From 10e961f6290f891d82535e3d4321ce6ee78deb38 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A9=20P=C3=B6nitz?= Date: Fri, 30 Nov 2007 22:47:02 +0000 Subject: [PATCH] unused git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@21889 a592a061-630c-0410-9148-cb99ea01b6c8 --- boost/boost/spirit/actor/assign_actor.hpp | 96 - boost/boost/spirit/actor/push_back_actor.hpp | 97 - .../spirit/actor/ref_const_ref_actor.hpp | 73 - boost/boost/spirit/actor/ref_value_actor.hpp | 65 - boost/boost/spirit/attribute.hpp | 38 - boost/boost/spirit/attribute/closure.hpp | 1079 ----- .../spirit/attribute/closure_context.hpp | 51 - boost/boost/spirit/attribute/parametric.hpp | 140 - boost/boost/spirit/core.hpp | 74 - boost/boost/spirit/core/assert.hpp | 39 - boost/boost/spirit/core/composite/actions.hpp | 123 - .../spirit/core/composite/alternative.hpp | 134 - .../boost/spirit/core/composite/composite.hpp | 138 - .../spirit/core/composite/difference.hpp | 137 - .../spirit/core/composite/directives.hpp | 603 --- boost/boost/spirit/core/composite/epsilon.hpp | 272 -- .../spirit/core/composite/exclusive_or.hpp | 138 - .../core/composite/impl/alternative.ipp | 86 - .../spirit/core/composite/impl/difference.ipp | 86 - .../spirit/core/composite/impl/directives.ipp | 370 -- .../core/composite/impl/exclusive_or.ipp | 86 - .../core/composite/impl/intersection.ipp | 86 - .../core/composite/impl/kleene_star.ipp | 30 - .../boost/spirit/core/composite/impl/list.ipp | 89 - .../spirit/core/composite/impl/optional.ipp | 30 - .../spirit/core/composite/impl/positive.ipp | 30 - .../spirit/core/composite/impl/sequence.ipp | 86 - .../core/composite/impl/sequential_and.ipp | 86 - .../core/composite/impl/sequential_or.ipp | 86 - .../spirit/core/composite/intersection.hpp | 138 - .../spirit/core/composite/kleene_star.hpp | 96 - boost/boost/spirit/core/composite/list.hpp | 69 - .../spirit/core/composite/no_actions.hpp | 163 - .../boost/spirit/core/composite/operators.hpp | 26 - .../boost/spirit/core/composite/optional.hpp | 90 - .../boost/spirit/core/composite/positive.hpp | 99 - .../boost/spirit/core/composite/sequence.hpp | 129 - .../spirit/core/composite/sequential_and.hpp | 72 - .../spirit/core/composite/sequential_or.hpp | 150 - boost/boost/spirit/core/config.hpp | 63 - boost/boost/spirit/core/impl/match.ipp | 109 - .../spirit/core/impl/match_attr_traits.ipp | 94 - boost/boost/spirit/core/impl/parser.ipp | 51 - boost/boost/spirit/core/match.hpp | 181 - boost/boost/spirit/core/nil.hpp | 19 - .../spirit/core/non_terminal/grammar.hpp | 81 - .../spirit/core/non_terminal/impl/grammar.ipp | 388 -- .../core/non_terminal/impl/object_with_id.ipp | 185 - .../spirit/core/non_terminal/impl/rule.ipp | 407 -- .../spirit/core/non_terminal/impl/subrule.ipp | 205 - .../core/non_terminal/parser_context.hpp | 147 - .../spirit/core/non_terminal/parser_id.hpp | 118 - boost/boost/spirit/core/non_terminal/rule.hpp | 168 - .../spirit/core/non_terminal/subrule.hpp | 296 -- boost/boost/spirit/core/parser.hpp | 219 - .../spirit/core/primitives/impl/numerics.ipp | 531 --- .../core/primitives/impl/primitives.ipp | 465 -- .../boost/spirit/core/primitives/numerics.hpp | 285 -- .../spirit/core/primitives/primitives.hpp | 645 --- boost/boost/spirit/core/safe_bool.hpp | 59 - .../spirit/core/scanner/impl/skipper.ipp | 177 - boost/boost/spirit/core/scanner/scanner.hpp | 320 -- boost/boost/spirit/core/scanner/skipper.hpp | 192 - boost/boost/spirit/debug.hpp | 146 - boost/boost/spirit/debug/minimal.hpp | 82 - boost/boost/spirit/dynamic/if.hpp | 225 - .../boost/spirit/dynamic/impl/conditions.ipp | 100 - boost/boost/spirit/error_handling.hpp | 22 - .../spirit/error_handling/exceptions.hpp | 361 -- .../spirit/error_handling/impl/exceptions.ipp | 85 - boost/boost/spirit/iterator.hpp | 26 - boost/boost/spirit/iterator/file_iterator.hpp | 225 - .../spirit/iterator/fixed_size_queue.hpp | 398 -- .../spirit/iterator/impl/file_iterator.ipp | 460 -- .../iterator/impl/position_iterator.ipp | 131 - boost/boost/spirit/iterator/multi_pass.hpp | 1295 ------ .../spirit/iterator/position_iterator.hpp | 429 -- boost/boost/spirit/meta.hpp | 27 - boost/boost/spirit/meta/as_parser.hpp | 109 - boost/boost/spirit/meta/fundamental.hpp | 52 - boost/boost/spirit/meta/impl/fundamental.ipp | 305 -- .../boost/spirit/meta/impl/parser_traits.ipp | 187 - boost/boost/spirit/meta/impl/refactoring.ipp | 447 -- boost/boost/spirit/meta/impl/traverse.ipp | 389 -- boost/boost/spirit/meta/parser_traits.hpp | 316 -- boost/boost/spirit/meta/refactoring.hpp | 274 -- boost/boost/spirit/meta/traverse.hpp | 218 - boost/boost/spirit/phoenix.hpp | 26 - boost/boost/spirit/phoenix/actor.hpp | 596 --- boost/boost/spirit/phoenix/binders.hpp | 4067 ----------------- boost/boost/spirit/phoenix/casts.hpp | 1471 ------ boost/boost/spirit/phoenix/closures.hpp | 440 -- boost/boost/spirit/phoenix/composite.hpp | 1423 ------ boost/boost/spirit/phoenix/functions.hpp | 761 --- boost/boost/spirit/phoenix/new.hpp | 1316 ------ boost/boost/spirit/phoenix/operators.hpp | 2203 --------- boost/boost/spirit/phoenix/primitives.hpp | 248 - boost/boost/spirit/phoenix/special_ops.hpp | 342 -- boost/boost/spirit/phoenix/statements.hpp | 444 -- boost/boost/spirit/phoenix/tuple_helpers.hpp | 1076 ----- boost/boost/spirit/phoenix/tuples.hpp | 1330 ------ boost/boost/spirit/symbols.hpp | 22 - boost/boost/spirit/symbols/impl/symbols.ipp | 114 - boost/boost/spirit/symbols/impl/tst.ipp | 277 -- boost/boost/spirit/symbols/symbols.hpp | 225 - boost/boost/spirit/utility.hpp | 41 - boost/boost/spirit/utility/chset.hpp | 183 - .../boost/spirit/utility/chset_operators.hpp | 398 -- boost/boost/spirit/utility/confix.hpp | 392 -- boost/boost/spirit/utility/distinct.hpp | 227 - boost/boost/spirit/utility/escape_char.hpp | 180 - .../boost/spirit/utility/flush_multi_pass.hpp | 73 - boost/boost/spirit/utility/functor_parser.hpp | 67 - boost/boost/spirit/utility/impl/chset.ipp | 362 -- .../spirit/utility/impl/chset/basic_chset.hpp | 102 - .../spirit/utility/impl/chset/basic_chset.ipp | 241 - .../spirit/utility/impl/chset/range_run.hpp | 118 - .../spirit/utility/impl/chset/range_run.ipp | 212 - .../spirit/utility/impl/chset_operators.ipp | 662 --- boost/boost/spirit/utility/impl/confix.ipp | 217 - .../boost/spirit/utility/impl/escape_char.ipp | 220 - boost/boost/spirit/utility/impl/lists.ipp | 164 - boost/boost/spirit/utility/lists.hpp | 336 -- boost/boost/spirit/utility/loops.hpp | 313 -- boost/boost/spirit/utility/scoped_lock.hpp | 108 - boost/boost/spirit/version.hpp | 31 - 126 files changed, 38222 deletions(-) delete mode 100644 boost/boost/spirit/actor/assign_actor.hpp delete mode 100644 boost/boost/spirit/actor/push_back_actor.hpp delete mode 100644 boost/boost/spirit/actor/ref_const_ref_actor.hpp delete mode 100644 boost/boost/spirit/actor/ref_value_actor.hpp delete mode 100644 boost/boost/spirit/attribute.hpp delete mode 100644 boost/boost/spirit/attribute/closure.hpp delete mode 100644 boost/boost/spirit/attribute/closure_context.hpp delete mode 100644 boost/boost/spirit/attribute/parametric.hpp delete mode 100644 boost/boost/spirit/core.hpp delete mode 100644 boost/boost/spirit/core/assert.hpp delete mode 100644 boost/boost/spirit/core/composite/actions.hpp delete mode 100644 boost/boost/spirit/core/composite/alternative.hpp delete mode 100644 boost/boost/spirit/core/composite/composite.hpp delete mode 100644 boost/boost/spirit/core/composite/difference.hpp delete mode 100644 boost/boost/spirit/core/composite/directives.hpp delete mode 100644 boost/boost/spirit/core/composite/epsilon.hpp delete mode 100644 boost/boost/spirit/core/composite/exclusive_or.hpp delete mode 100644 boost/boost/spirit/core/composite/impl/alternative.ipp delete mode 100644 boost/boost/spirit/core/composite/impl/difference.ipp delete mode 100644 boost/boost/spirit/core/composite/impl/directives.ipp delete mode 100644 boost/boost/spirit/core/composite/impl/exclusive_or.ipp delete mode 100644 boost/boost/spirit/core/composite/impl/intersection.ipp delete mode 100644 boost/boost/spirit/core/composite/impl/kleene_star.ipp delete mode 100644 boost/boost/spirit/core/composite/impl/list.ipp delete mode 100644 boost/boost/spirit/core/composite/impl/optional.ipp delete mode 100644 boost/boost/spirit/core/composite/impl/positive.ipp delete mode 100644 boost/boost/spirit/core/composite/impl/sequence.ipp delete mode 100644 boost/boost/spirit/core/composite/impl/sequential_and.ipp delete mode 100644 boost/boost/spirit/core/composite/impl/sequential_or.ipp delete mode 100644 boost/boost/spirit/core/composite/intersection.hpp delete mode 100644 boost/boost/spirit/core/composite/kleene_star.hpp delete mode 100644 boost/boost/spirit/core/composite/list.hpp delete mode 100644 boost/boost/spirit/core/composite/no_actions.hpp delete mode 100644 boost/boost/spirit/core/composite/operators.hpp delete mode 100644 boost/boost/spirit/core/composite/optional.hpp delete mode 100644 boost/boost/spirit/core/composite/positive.hpp delete mode 100644 boost/boost/spirit/core/composite/sequence.hpp delete mode 100644 boost/boost/spirit/core/composite/sequential_and.hpp delete mode 100644 boost/boost/spirit/core/composite/sequential_or.hpp delete mode 100644 boost/boost/spirit/core/config.hpp delete mode 100644 boost/boost/spirit/core/impl/match.ipp delete mode 100644 boost/boost/spirit/core/impl/match_attr_traits.ipp delete mode 100644 boost/boost/spirit/core/impl/parser.ipp delete mode 100644 boost/boost/spirit/core/match.hpp delete mode 100644 boost/boost/spirit/core/nil.hpp delete mode 100644 boost/boost/spirit/core/non_terminal/grammar.hpp delete mode 100644 boost/boost/spirit/core/non_terminal/impl/grammar.ipp delete mode 100644 boost/boost/spirit/core/non_terminal/impl/object_with_id.ipp delete mode 100644 boost/boost/spirit/core/non_terminal/impl/rule.ipp delete mode 100644 boost/boost/spirit/core/non_terminal/impl/subrule.ipp delete mode 100644 boost/boost/spirit/core/non_terminal/parser_context.hpp delete mode 100644 boost/boost/spirit/core/non_terminal/parser_id.hpp delete mode 100644 boost/boost/spirit/core/non_terminal/rule.hpp delete mode 100644 boost/boost/spirit/core/non_terminal/subrule.hpp delete mode 100644 boost/boost/spirit/core/parser.hpp delete mode 100644 boost/boost/spirit/core/primitives/impl/numerics.ipp delete mode 100644 boost/boost/spirit/core/primitives/impl/primitives.ipp delete mode 100644 boost/boost/spirit/core/primitives/numerics.hpp delete mode 100644 boost/boost/spirit/core/primitives/primitives.hpp delete mode 100644 boost/boost/spirit/core/safe_bool.hpp delete mode 100644 boost/boost/spirit/core/scanner/impl/skipper.ipp delete mode 100644 boost/boost/spirit/core/scanner/scanner.hpp delete mode 100644 boost/boost/spirit/core/scanner/skipper.hpp delete mode 100644 boost/boost/spirit/debug.hpp delete mode 100644 boost/boost/spirit/debug/minimal.hpp delete mode 100644 boost/boost/spirit/dynamic/if.hpp delete mode 100644 boost/boost/spirit/dynamic/impl/conditions.ipp delete mode 100644 boost/boost/spirit/error_handling.hpp delete mode 100644 boost/boost/spirit/error_handling/exceptions.hpp delete mode 100644 boost/boost/spirit/error_handling/impl/exceptions.ipp delete mode 100644 boost/boost/spirit/iterator.hpp delete mode 100644 boost/boost/spirit/iterator/file_iterator.hpp delete mode 100644 boost/boost/spirit/iterator/fixed_size_queue.hpp delete mode 100644 boost/boost/spirit/iterator/impl/file_iterator.ipp delete mode 100644 boost/boost/spirit/iterator/impl/position_iterator.ipp delete mode 100644 boost/boost/spirit/iterator/multi_pass.hpp delete mode 100644 boost/boost/spirit/iterator/position_iterator.hpp delete mode 100644 boost/boost/spirit/meta.hpp delete mode 100644 boost/boost/spirit/meta/as_parser.hpp delete mode 100644 boost/boost/spirit/meta/fundamental.hpp delete mode 100644 boost/boost/spirit/meta/impl/fundamental.ipp delete mode 100644 boost/boost/spirit/meta/impl/parser_traits.ipp delete mode 100644 boost/boost/spirit/meta/impl/refactoring.ipp delete mode 100644 boost/boost/spirit/meta/impl/traverse.ipp delete mode 100644 boost/boost/spirit/meta/parser_traits.hpp delete mode 100644 boost/boost/spirit/meta/refactoring.hpp delete mode 100644 boost/boost/spirit/meta/traverse.hpp delete mode 100644 boost/boost/spirit/phoenix.hpp delete mode 100644 boost/boost/spirit/phoenix/actor.hpp delete mode 100644 boost/boost/spirit/phoenix/binders.hpp delete mode 100644 boost/boost/spirit/phoenix/casts.hpp delete mode 100644 boost/boost/spirit/phoenix/closures.hpp delete mode 100644 boost/boost/spirit/phoenix/composite.hpp delete mode 100644 boost/boost/spirit/phoenix/functions.hpp delete mode 100644 boost/boost/spirit/phoenix/new.hpp delete mode 100644 boost/boost/spirit/phoenix/operators.hpp delete mode 100644 boost/boost/spirit/phoenix/primitives.hpp delete mode 100644 boost/boost/spirit/phoenix/special_ops.hpp delete mode 100644 boost/boost/spirit/phoenix/statements.hpp delete mode 100644 boost/boost/spirit/phoenix/tuple_helpers.hpp delete mode 100644 boost/boost/spirit/phoenix/tuples.hpp delete mode 100644 boost/boost/spirit/symbols.hpp delete mode 100644 boost/boost/spirit/symbols/impl/symbols.ipp delete mode 100644 boost/boost/spirit/symbols/impl/tst.ipp delete mode 100644 boost/boost/spirit/symbols/symbols.hpp delete mode 100644 boost/boost/spirit/utility.hpp delete mode 100644 boost/boost/spirit/utility/chset.hpp delete mode 100644 boost/boost/spirit/utility/chset_operators.hpp delete mode 100644 boost/boost/spirit/utility/confix.hpp delete mode 100644 boost/boost/spirit/utility/distinct.hpp delete mode 100644 boost/boost/spirit/utility/escape_char.hpp delete mode 100644 boost/boost/spirit/utility/flush_multi_pass.hpp delete mode 100644 boost/boost/spirit/utility/functor_parser.hpp delete mode 100644 boost/boost/spirit/utility/impl/chset.ipp delete mode 100644 boost/boost/spirit/utility/impl/chset/basic_chset.hpp delete mode 100644 boost/boost/spirit/utility/impl/chset/basic_chset.ipp delete mode 100644 boost/boost/spirit/utility/impl/chset/range_run.hpp delete mode 100644 boost/boost/spirit/utility/impl/chset/range_run.ipp delete mode 100644 boost/boost/spirit/utility/impl/chset_operators.ipp delete mode 100644 boost/boost/spirit/utility/impl/confix.ipp delete mode 100644 boost/boost/spirit/utility/impl/escape_char.ipp delete mode 100644 boost/boost/spirit/utility/impl/lists.ipp delete mode 100644 boost/boost/spirit/utility/lists.hpp delete mode 100644 boost/boost/spirit/utility/loops.hpp delete mode 100644 boost/boost/spirit/utility/scoped_lock.hpp delete mode 100644 boost/boost/spirit/version.hpp diff --git a/boost/boost/spirit/actor/assign_actor.hpp b/boost/boost/spirit/actor/assign_actor.hpp deleted file mode 100644 index 6eb58c9e20..0000000000 --- a/boost/boost/spirit/actor/assign_actor.hpp +++ /dev/null @@ -1,96 +0,0 @@ -/*============================================================================= - Copyright (c) 2003 Jonathan de Halleux (dehalleux@pelikhan.com) - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_ACTOR_ASSIGN_ACTOR_HPP -#define BOOST_SPIRIT_ACTOR_ASSIGN_ACTOR_HPP - -#include -#include - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // Summary: - // A semantic action policy that applies the assignement operator. - // (This doc uses convention available in actors.hpp) - // - // Actions (what it does): - // ref = value; - // ref = T(first,last); - // ref = value_ref; - // - // Policy name: - // assign_action - // - // Policy holder, corresponding helper method: - // ref_value_actor, assign_a( ref ); - // ref_const_ref_actor, assign_a( ref, value_ref ); - // - // () operators: both - // - // See also ref_value_actor and ref_const_ref_actor for more details. - /////////////////////////////////////////////////////////////////////////// - struct assign_action - { - template< - typename T, - typename ValueT - > - void act(T& ref_, ValueT const& value_) const - { - ref_ = value_; - } - template< - typename T, - typename IteratorT - > - void act( - T& ref_, - IteratorT const& first_, - IteratorT const& last_ - ) const - { - typedef T value_type; -#ifndef BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS - value_type value(first_,last_); -#else - value_type value; - std::copy(first_, last_, std::inserter(value, value.end())); -#endif - ref_ = value; - } - }; - - // Deprecated. Please use assign_a - template - inline ref_value_actor assign(T& ref_) - { - return ref_value_actor(ref_); - } - - template - inline ref_value_actor assign_a(T& ref_) - { - return ref_value_actor(ref_); - } - - template< - typename T, - typename ValueT - > - inline ref_const_ref_actor assign_a( - T& ref_, - ValueT const& value_ - ) - { - return ref_const_ref_actor(ref_,value_); - } - -}} - -#endif diff --git a/boost/boost/spirit/actor/push_back_actor.hpp b/boost/boost/spirit/actor/push_back_actor.hpp deleted file mode 100644 index 6fbd24f464..0000000000 --- a/boost/boost/spirit/actor/push_back_actor.hpp +++ /dev/null @@ -1,97 +0,0 @@ -/*============================================================================= - Copyright (c) 2003 Jonathan de Halleux (dehalleux@pelikhan.com) - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_ACTOR_PUSH_BACK_ACTOR_HPP -#define BOOST_SPIRIT_ACTOR_PUSH_BACK_ACTOR_HPP - -#include -#include - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // Summary: - // - // A semantic action policy that appends a value to the back of a - // container. - // (This doc uses convention available in actors.hpp) - // - // Actions (what it does and what ref, value_ref must support): - // ref.push_back( value ); - // ref.push_back( T::value_type(first,last) ); - // ref.push_back( value_ref ); - // - // Policy name: - // push_back_action - // - // Policy holder, corresponding helper method: - // ref_value_actor, push_back_a( ref ); - // ref_const_ref_actor, push_back_a( ref, value_ref ); - // - // () operators: both - // - // See also ref_value_actor and ref_const_ref_actor for more details. - /////////////////////////////////////////////////////////////////////////// - struct push_back_action - { - template< - typename T, - typename ValueT - > - void act(T& ref_, ValueT const& value_) const - { - ref_.push_back( value_ ); - } - template< - typename T, - typename IteratorT - > - void act( - T& ref_, - IteratorT const& first_, - IteratorT const& last_ - ) const - { - typedef typename T::value_type value_type; - value_type value(first_,last_); - - ref_.push_back( value ); - } - }; - -// Deprecated interface. Use push_back_a - template - inline ref_value_actor - append(T& ref_) - { - return ref_value_actor(ref_); - } - - template - inline ref_value_actor - push_back_a(T& ref_) - { - return ref_value_actor(ref_); - } - - template< - typename T, - typename ValueT - > - inline ref_const_ref_actor - push_back_a( - T& ref_, - ValueT const& value_ - ) - { - return ref_const_ref_actor(ref_,value_); - } - -}} - -#endif diff --git a/boost/boost/spirit/actor/ref_const_ref_actor.hpp b/boost/boost/spirit/actor/ref_const_ref_actor.hpp deleted file mode 100644 index 3691606810..0000000000 --- a/boost/boost/spirit/actor/ref_const_ref_actor.hpp +++ /dev/null @@ -1,73 +0,0 @@ -/*============================================================================= - Copyright (c) 2003 Jonathan de Halleux (dehalleux@pelikhan.com) - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_ACTOR_REF_CONST_REF_ACTOR_HPP -#define BOOST_SPIRIT_ACTOR_REF_CONST_REF_ACTOR_HPP - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // Summary: - // A semantic action policy holder. This holder stores a reference to ref - // and a const reference to value_ref. - // act methods are feed with ref and value_ref. The parse result is - // not used by this holder. - // - // (This doc uses convention available in actors.hpp) - // - // Constructor: - // ...(T& ref_, ValueT const& value_ref_); - // where ref_ and value_ref_ are stored in the holder. - // - // Action calls: - // act(ref, value_ref); - // - // () operators: both - // - /////////////////////////////////////////////////////////////////////////// - template< - typename T, - typename ValueT, - typename ActionT - > - class ref_const_ref_actor : public ActionT - { - private: - T& ref; - ValueT const& value_ref; - public: - ref_const_ref_actor( - T& ref_, - ValueT const& value_ref_ - ) - : - ref(ref_), - value_ref(value_ref_) - {} - - - template - void operator()(T2 const& /*val*/) const - { - this->act(ref,value_ref); // defined in ActionT - } - - - template - void operator()( - IteratorT const& /*first*/, - IteratorT const& /*last*/ - ) const - { - this->act(ref,value_ref); // defined in ActionT - } - }; - -}} - -#endif diff --git a/boost/boost/spirit/actor/ref_value_actor.hpp b/boost/boost/spirit/actor/ref_value_actor.hpp deleted file mode 100644 index cd21ab8bcb..0000000000 --- a/boost/boost/spirit/actor/ref_value_actor.hpp +++ /dev/null @@ -1,65 +0,0 @@ -/*============================================================================= - Copyright (c) 2003 Jonathan de Halleux (dehalleux@pelikhan.com) - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_ACTOR_REF_VALUE_ACTOR_HPP -#define BOOST_SPIRIT_ACTOR_REF_VALUE_ACTOR_HPP - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // Summary: - // A semantic action policy holder. This holder stores a reference to ref. - // act methods are feed with ref and the parse result. - // - // (This doc uses convention available in actors.hpp) - // - // Constructor: - // ...(T& ref_); - // where ref_ is stored. - // - // Action calls: - // act(ref, value); - // act(ref, first,last); - // - // () operators: both - // - /////////////////////////////////////////////////////////////////////////// - template< - typename T, - typename ActionT - > - class ref_value_actor : public ActionT - { - private: - T& ref; - public: - explicit - ref_value_actor(T& ref_) - : ref(ref_){} - - - template - void operator()(T2 const& val_) const - { - this->act(ref,val_); // defined in ActionT - } - - - template - void operator()( - IteratorT const& first_, - IteratorT const& last_ - ) const - { - this->act(ref,first_,last_); // defined in ActionT - } - }; - -}} - -#endif diff --git a/boost/boost/spirit/attribute.hpp b/boost/boost/spirit/attribute.hpp deleted file mode 100644 index 48e9a5dfc5..0000000000 --- a/boost/boost/spirit/attribute.hpp +++ /dev/null @@ -1,38 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - Copyright (c) 2002-2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_ATTRIBUTE_MAIN_HPP) -#define BOOST_SPIRIT_ATTRIBUTE_MAIN_HPP - -#include - -/////////////////////////////////////////////////////////////////////////////// -// -// Master header for Spirit.Attributes -// -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// -// Phoenix predefined maximum limit. This limit defines the maximum -// number of elements a tuple can hold. This number defaults to 3. The -// actual maximum is rounded up in multiples of 3. Thus, if this value -// is 4, the actual limit is 6. The ultimate maximum limit in this -// implementation is 15. -// -/////////////////////////////////////////////////////////////////////////////// -#if !defined(PHOENIX_LIMIT) -#define PHOENIX_LIMIT 3 -#endif // !defined(PHOENIX_LIMIT) - -/////////////////////////////////////////////////////////////////////////////// -#include -#include - -#endif // !defined(BOOST_SPIRIT_ATTRIBUTE_MAIN_HPP) diff --git a/boost/boost/spirit/attribute/closure.hpp b/boost/boost/spirit/attribute/closure.hpp deleted file mode 100644 index 0443791364..0000000000 --- a/boost/boost/spirit/attribute/closure.hpp +++ /dev/null @@ -1,1079 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - Copyright (c) 2002-2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_CLOSURE_HPP -#define BOOST_SPIRIT_CLOSURE_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include - -#include - -/////////////////////////////////////////////////////////////////////////////// -// -// Spirit predefined maximum closure limit. This limit defines the maximum -// number of elements a closure can hold. This number defaults to 3. The -// actual maximum is rounded up in multiples of 3. Thus, if this value -// is 4, the actual limit is 6. The ultimate maximum limit in this -// implementation is 15. -// -// It should NOT be greater than PHOENIX_LIMIT! -// -/////////////////////////////////////////////////////////////////////////////// - -#if !defined(BOOST_SPIRIT_CLOSURE_LIMIT) -#define BOOST_SPIRIT_CLOSURE_LIMIT PHOENIX_LIMIT -#endif - -/////////////////////////////////////////////////////////////////////////////// -// -// ensure BOOST_SPIRIT_CLOSURE_LIMIT <= PHOENIX_LIMIT and SPIRIT_CLOSURE_LIMIT <= 15 -// -/////////////////////////////////////////////////////////////////////////////// -BOOST_STATIC_ASSERT(BOOST_SPIRIT_CLOSURE_LIMIT <= PHOENIX_LIMIT); -BOOST_STATIC_ASSERT(BOOST_SPIRIT_CLOSURE_LIMIT <= 15); - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // closure_context class - // - /////////////////////////////////////////////////////////////////////////// - template - class closure_context : public parser_context_base - { - public: - - typedef typename phoenix::tuple_element<0, - typename ClosureT::tuple_t>::type attr_t; - typedef ClosureT base_t; - typedef closure_context_linker > - context_linker_t; - - closure_context(ClosureT const& clos) - : frame(clos) {} - - ~closure_context() {} - - template - void pre_parse(ParserT const&, ScannerT const&) {} - - template - ResultT& post_parse(ResultT& hit, ParserT const&, ScannerT const&) - { hit.value(frame[phoenix::tuple_index<0>()]); return hit; } - - private: - - phoenix::closure_frame frame; - }; - - /////////////////////////////////////////////////////////////////////////// - // - // init_closure_context class - // - // The init_closure_context class is a special parser context type - // which additionally initializes a closure contained in the derived - // parser with values from a given tuple. Please note, that this - // given tuple does not contain the required values directly, it - // contains phoenix::actor objects. These actors have to be - // dereferenced to gain the values to be used for initialization - // (this is done by the help of the phoenix::convert_actors<> - // template). - // - /////////////////////////////////////////////////////////////////////////// - - template - class init_closure_context : public parser_context_base - { - typedef typename ClosureT::tuple_t tuple_t; - typedef typename ClosureT::closure_t closure_t; - - public: - - init_closure_context(ClosureT const& clos) - : frame(clos.subject(), phoenix::convert_actors(clos.init)) {} - - ~init_closure_context() {} - - template - void pre_parse(ParserT const& /*p*/, ScannerT const&) {} - - template - ResultT& post_parse(ResultT& hit, ParserT const&, ScannerT const&) - { hit.value(frame[phoenix::tuple_index<0>()]); return hit; } - - private: - - phoenix::closure_frame frame; - }; - - /////////////////////////////////////////////////////////////////////////// - // - // init_closure_parser class - // - /////////////////////////////////////////////////////////////////////////// - template - struct init_closure_parser - : public unary > > - { - typedef init_closure_parser self_t; - typedef unary > base_t; - typedef typename ParserT::phoenix_closure_t closure_t; - typedef typename ParserT::tuple_t tuple_t; - typedef typename phoenix::tuple_element<0, tuple_t>::type attr_t; - - template - struct result - { - typedef typename match_result::type type; - }; - - init_closure_parser(ParserT const& p, ActorTupleT const& init_) - : base_t(p), init(init_) {} - - template - typename parser_result::type - parse_main(ScannerT const& scan) const - { - return this->subject().parse_main(scan); - } - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef init_closure_context init_context_t; - typedef parser_scanner_linker scanner_t; - typedef closure_context_linker context_t; - typedef typename parser_result::type result_t; - BOOST_SPIRIT_CONTEXT_PARSE( - scan, *this, scanner_t, context_t, result_t); - } - - ActorTupleT init; - }; - - /////////////////////////////////////////////////////////////////////////// - // - // closure class - // - /////////////////////////////////////////////////////////////////////////// - template < - typename DerivedT - , typename T0 - , typename T1 - , typename T2 - - #if BOOST_SPIRIT_CLOSURE_LIMIT > 3 - , typename T3 - , typename T4 - , typename T5 - - #if BOOST_SPIRIT_CLOSURE_LIMIT > 6 - , typename T6 - , typename T7 - , typename T8 - - #if BOOST_SPIRIT_CLOSURE_LIMIT > 9 - , typename T9 - , typename T10 - , typename T11 - - #if BOOST_SPIRIT_CLOSURE_LIMIT > 12 - , typename T12 - , typename T13 - , typename T14 - #endif - #endif - #endif - #endif - > - struct closure : - public phoenix::closure< - T0, T1, T2 - #if BOOST_SPIRIT_CLOSURE_LIMIT > 3 - , T3, T4, T5 - #if BOOST_SPIRIT_CLOSURE_LIMIT > 6 - , T6, T7, T8 - #if BOOST_SPIRIT_CLOSURE_LIMIT > 9 - , T9, T10, T11 - #if BOOST_SPIRIT_CLOSURE_LIMIT > 12 - , T12, T13, T14 - #endif - #endif - #endif - #endif - > - { - typedef phoenix::closure< - T0, T1, T2 - #if BOOST_SPIRIT_CLOSURE_LIMIT > 3 - , T3, T4, T5 - #if BOOST_SPIRIT_CLOSURE_LIMIT > 6 - , T6, T7, T8 - #if BOOST_SPIRIT_CLOSURE_LIMIT > 9 - , T9, T10, T11 - #if BOOST_SPIRIT_CLOSURE_LIMIT > 12 - , T12, T13, T14 - #endif - #endif - #endif - #endif - > phoenix_closure_t; - - typedef closure_context context_t; - - template - struct aux - { - DerivedT2& aux_derived() - { return *static_cast(this); } - - DerivedT2 const& aux_derived() const - { return *static_cast(this); } - - // initialization functions - template - init_closure_parser< - DerivedT2, - phoenix::tuple< - typename phoenix::as_actor::type - > - > - operator()(A const &a) const - { - typedef typename phoenix::as_actor::type a_t; - typedef phoenix::tuple actor_tuple_t; - - return init_closure_parser( - aux_derived(), - actor_tuple_t( - phoenix::as_actor::convert(a) - ) - ); - } - - template - init_closure_parser< - DerivedT2, - phoenix::tuple< - typename phoenix::as_actor::type, - typename phoenix::as_actor::type - > - > - operator()(A const &a, B const &b) const - { - typedef typename phoenix::as_actor::type a_t; - typedef typename phoenix::as_actor::type b_t; - typedef phoenix::tuple actor_tuple_t; - - return init_closure_parser( - aux_derived(), - actor_tuple_t( - phoenix::as_actor::convert(a), - phoenix::as_actor::convert(b) - ) - ); - } - - template - init_closure_parser< - DerivedT2, - phoenix::tuple< - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type - > - > - operator()(A const &a, B const &b, C const &c) const - { - typedef typename phoenix::as_actor::type a_t; - typedef typename phoenix::as_actor::type b_t; - typedef typename phoenix::as_actor::type c_t; - typedef phoenix::tuple actor_tuple_t; - - return init_closure_parser( - aux_derived(), - actor_tuple_t( - phoenix::as_actor::convert(a), - phoenix::as_actor::convert(b), - phoenix::as_actor::convert(c) - ) - ); - } - - #if BOOST_SPIRIT_CLOSURE_LIMIT > 3 - - template < - typename A, typename B, typename C, typename D - > - init_closure_parser< - DerivedT2, - phoenix::tuple< - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type - > - > - operator()( - A const &a, B const &b, C const &c, D const &d - ) const - { - typedef typename phoenix::as_actor::type a_t; - typedef typename phoenix::as_actor::type b_t; - typedef typename phoenix::as_actor::type c_t; - typedef typename phoenix::as_actor::type d_t; - typedef phoenix::tuple< - a_t, b_t, c_t, d_t - > actor_tuple_t; - - return init_closure_parser( - aux_derived(), - actor_tuple_t( - phoenix::as_actor::convert(a), - phoenix::as_actor::convert(b), - phoenix::as_actor::convert(c), - phoenix::as_actor::convert(d) - ) - ); - } - - template < - typename A, typename B, typename C, typename D, typename E - > - init_closure_parser< - DerivedT2, - phoenix::tuple< - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type - > - > - operator()( - A const &a, B const &b, C const &c, D const &d, E const &e - ) const - { - typedef typename phoenix::as_actor::type a_t; - typedef typename phoenix::as_actor::type b_t; - typedef typename phoenix::as_actor::type c_t; - typedef typename phoenix::as_actor::type d_t; - typedef typename phoenix::as_actor::type e_t; - typedef phoenix::tuple< - a_t, b_t, c_t, d_t, e_t - > actor_tuple_t; - - return init_closure_parser( - aux_derived(), - actor_tuple_t( - phoenix::as_actor::convert(a), - phoenix::as_actor::convert(b), - phoenix::as_actor::convert(c), - phoenix::as_actor::convert(d), - phoenix::as_actor::convert(e) - ) - ); - } - - template < - typename A, typename B, typename C, typename D, typename E, - typename F - > - init_closure_parser< - DerivedT2, - phoenix::tuple< - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type - > - > - operator()( - A const &a, B const &b, C const &c, D const &d, E const &e, - F const &f - ) const - { - typedef typename phoenix::as_actor::type a_t; - typedef typename phoenix::as_actor::type b_t; - typedef typename phoenix::as_actor::type c_t; - typedef typename phoenix::as_actor::type d_t; - typedef typename phoenix::as_actor::type e_t; - typedef typename phoenix::as_actor::type f_t; - typedef phoenix::tuple< - a_t, b_t, c_t, d_t, e_t, f_t - > actor_tuple_t; - - return init_closure_parser( - aux_derived(), - actor_tuple_t( - phoenix::as_actor::convert(a), - phoenix::as_actor::convert(b), - phoenix::as_actor::convert(c), - phoenix::as_actor::convert(d), - phoenix::as_actor::convert(e), - phoenix::as_actor::convert(f) - ) - ); - } - - #if BOOST_SPIRIT_CLOSURE_LIMIT > 6 - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G - > - init_closure_parser< - DerivedT2, - phoenix::tuple< - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type - > - > - operator()( - A const &a, B const &b, C const &c, D const &d, E const &e, - F const &f, G const &g - ) const - { - typedef typename phoenix::as_actor::type a_t; - typedef typename phoenix::as_actor::type b_t; - typedef typename phoenix::as_actor::type c_t; - typedef typename phoenix::as_actor::type d_t; - typedef typename phoenix::as_actor::type e_t; - typedef typename phoenix::as_actor::type f_t; - typedef typename phoenix::as_actor::type g_t; - typedef phoenix::tuple< - a_t, b_t, c_t, d_t, e_t, f_t, g_t - > actor_tuple_t; - - return init_closure_parser( - aux_derived(), - actor_tuple_t( - phoenix::as_actor::convert(a), - phoenix::as_actor::convert(b), - phoenix::as_actor::convert(c), - phoenix::as_actor::convert(d), - phoenix::as_actor::convert(e), - phoenix::as_actor::convert(f), - phoenix::as_actor::convert(g) - ) - ); - } - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H - > - init_closure_parser< - DerivedT2, - phoenix::tuple< - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type - > - > - operator()( - A const &a, B const &b, C const &c, D const &d, E const &e, - F const &f, G const &g, H const &h - ) const - { - typedef typename phoenix::as_actor::type a_t; - typedef typename phoenix::as_actor::type b_t; - typedef typename phoenix::as_actor::type c_t; - typedef typename phoenix::as_actor::type d_t; - typedef typename phoenix::as_actor::type e_t; - typedef typename phoenix::as_actor::type f_t; - typedef typename phoenix::as_actor::type g_t; - typedef typename phoenix::as_actor::type h_t; - typedef phoenix::tuple< - a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t - > actor_tuple_t; - - return init_closure_parser( - aux_derived(), - actor_tuple_t( - phoenix::as_actor::convert(a), - phoenix::as_actor::convert(b), - phoenix::as_actor::convert(c), - phoenix::as_actor::convert(d), - phoenix::as_actor::convert(e), - phoenix::as_actor::convert(f), - phoenix::as_actor::convert(g), - phoenix::as_actor::convert(h) - ) - ); - } - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I - > - init_closure_parser< - DerivedT2, - phoenix::tuple< - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type - > - > - operator()( - A const &a, B const &b, C const &c, D const &d, E const &e, - F const &f, G const &g, H const &h, I const &i - ) const - { - typedef typename phoenix::as_actor::type a_t; - typedef typename phoenix::as_actor::type b_t; - typedef typename phoenix::as_actor::type c_t; - typedef typename phoenix::as_actor::type d_t; - typedef typename phoenix::as_actor::type e_t; - typedef typename phoenix::as_actor::type f_t; - typedef typename phoenix::as_actor::type g_t; - typedef typename phoenix::as_actor::type h_t; - typedef typename phoenix::as_actor::type i_t; - typedef phoenix::tuple< - a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t - > actor_tuple_t; - - return init_closure_parser( - aux_derived(), - actor_tuple_t( - phoenix::as_actor::convert(a), - phoenix::as_actor::convert(b), - phoenix::as_actor::convert(c), - phoenix::as_actor::convert(d), - phoenix::as_actor::convert(e), - phoenix::as_actor::convert(f), - phoenix::as_actor::convert(g), - phoenix::as_actor::convert(h), - phoenix::as_actor::convert(i) - ) - ); - } - - #if BOOST_SPIRIT_CLOSURE_LIMIT > 9 - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J - > - init_closure_parser< - DerivedT2, - phoenix::tuple< - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type - > - > - operator()( - A const &a, B const &b, C const &c, D const &d, E const &e, - F const &f, G const &g, H const &h, I const &i, J const &j - ) const - { - typedef typename phoenix::as_actor::type a_t; - typedef typename phoenix::as_actor::type b_t; - typedef typename phoenix::as_actor::type c_t; - typedef typename phoenix::as_actor::type d_t; - typedef typename phoenix::as_actor::type e_t; - typedef typename phoenix::as_actor::type f_t; - typedef typename phoenix::as_actor::type g_t; - typedef typename phoenix::as_actor::type h_t; - typedef typename phoenix::as_actor::type i_t; - typedef typename phoenix::as_actor::type j_t; - typedef phoenix::tuple< - a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t - > actor_tuple_t; - - return init_closure_parser( - aux_derived(), - actor_tuple_t( - phoenix::as_actor::convert(a), - phoenix::as_actor::convert(b), - phoenix::as_actor::convert(c), - phoenix::as_actor::convert(d), - phoenix::as_actor::convert(e), - phoenix::as_actor::convert(f), - phoenix::as_actor::convert(g), - phoenix::as_actor::convert(h), - phoenix::as_actor::convert(i), - phoenix::as_actor::convert(j) - ) - ); - } - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K - > - init_closure_parser< - DerivedT2, - phoenix::tuple< - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type - > - > - operator()( - A const &a, B const &b, C const &c, D const &d, E const &e, - F const &f, G const &g, H const &h, I const &i, J const &j, - K const &k - ) const - { - typedef typename phoenix::as_actor::type a_t; - typedef typename phoenix::as_actor::type b_t; - typedef typename phoenix::as_actor::type c_t; - typedef typename phoenix::as_actor::type d_t; - typedef typename phoenix::as_actor::type e_t; - typedef typename phoenix::as_actor::type f_t; - typedef typename phoenix::as_actor::type g_t; - typedef typename phoenix::as_actor::type h_t; - typedef typename phoenix::as_actor::type i_t; - typedef typename phoenix::as_actor::type j_t; - typedef typename phoenix::as_actor::type k_t; - typedef phoenix::tuple< - a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t, - k_t - > actor_tuple_t; - - return init_closure_parser( - aux_derived(), - actor_tuple_t( - phoenix::as_actor::convert(a), - phoenix::as_actor::convert(b), - phoenix::as_actor::convert(c), - phoenix::as_actor::convert(d), - phoenix::as_actor::convert(e), - phoenix::as_actor::convert(f), - phoenix::as_actor::convert(g), - phoenix::as_actor::convert(h), - phoenix::as_actor::convert(i), - phoenix::as_actor::convert(j), - phoenix::as_actor::convert(k) - ) - ); - } - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L - > - init_closure_parser< - DerivedT2, - phoenix::tuple< - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type - > - > - operator()( - A const &a, B const &b, C const &c, D const &d, E const &e, - F const &f, G const &g, H const &h, I const &i, J const &j, - K const &k, L const &l - ) const - { - typedef typename phoenix::as_actor::type a_t; - typedef typename phoenix::as_actor::type b_t; - typedef typename phoenix::as_actor::type c_t; - typedef typename phoenix::as_actor::type d_t; - typedef typename phoenix::as_actor::type e_t; - typedef typename phoenix::as_actor::type f_t; - typedef typename phoenix::as_actor::type g_t; - typedef typename phoenix::as_actor::type h_t; - typedef typename phoenix::as_actor::type i_t; - typedef typename phoenix::as_actor::type j_t; - typedef typename phoenix::as_actor::type k_t; - typedef typename phoenix::as_actor::type l_t; - typedef phoenix::tuple< - a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t, - k_t, l_t - > actor_tuple_t; - - return init_closure_parser( - aux_derived(), - actor_tuple_t( - phoenix::as_actor::convert(a), - phoenix::as_actor::convert(b), - phoenix::as_actor::convert(c), - phoenix::as_actor::convert(d), - phoenix::as_actor::convert(e), - phoenix::as_actor::convert(f), - phoenix::as_actor::convert(g), - phoenix::as_actor::convert(h), - phoenix::as_actor::convert(i), - phoenix::as_actor::convert(j), - phoenix::as_actor::convert(k), - phoenix::as_actor::convert(l) - ) - ); - } - - #if BOOST_SPIRIT_CLOSURE_LIMIT > 12 - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M - > - init_closure_parser< - DerivedT2, - phoenix::tuple< - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type - > - > - operator()( - A const &a, B const &b, C const &c, D const &d, E const &e, - F const &f, G const &g, H const &h, I const &i, J const &j, - K const &k, L const &l, M const &m - ) const - { - typedef typename phoenix::as_actor::type a_t; - typedef typename phoenix::as_actor::type b_t; - typedef typename phoenix::as_actor::type c_t; - typedef typename phoenix::as_actor::type d_t; - typedef typename phoenix::as_actor::type e_t; - typedef typename phoenix::as_actor::type f_t; - typedef typename phoenix::as_actor::type g_t; - typedef typename phoenix::as_actor::type h_t; - typedef typename phoenix::as_actor::type i_t; - typedef typename phoenix::as_actor::type j_t; - typedef typename phoenix::as_actor::type k_t; - typedef typename phoenix::as_actor::type l_t; - typedef typename phoenix::as_actor::type m_t; - typedef phoenix::tuple< - a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t, - k_t, l_t, m_t - > actor_tuple_t; - - return init_closure_parser( - aux_derived(), - actor_tuple_t( - phoenix::as_actor::convert(a), - phoenix::as_actor::convert(b), - phoenix::as_actor::convert(c), - phoenix::as_actor::convert(d), - phoenix::as_actor::convert(e), - phoenix::as_actor::convert(f), - phoenix::as_actor::convert(g), - phoenix::as_actor::convert(h), - phoenix::as_actor::convert(i), - phoenix::as_actor::convert(j), - phoenix::as_actor::convert(k), - phoenix::as_actor::convert(l), - phoenix::as_actor::convert(m) - ) - ); - } - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M, typename N - > - init_closure_parser< - DerivedT2, - phoenix::tuple< - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type - > - > - operator()( - A const &a, B const &b, C const &c, D const &d, E const &e, - F const &f, G const &g, H const &h, I const &i, J const &j, - K const &k, L const &l, M const &m, N const &n - ) const - { - typedef typename phoenix::as_actor::type a_t; - typedef typename phoenix::as_actor::type b_t; - typedef typename phoenix::as_actor::type c_t; - typedef typename phoenix::as_actor::type d_t; - typedef typename phoenix::as_actor::type e_t; - typedef typename phoenix::as_actor::type f_t; - typedef typename phoenix::as_actor::type g_t; - typedef typename phoenix::as_actor::type h_t; - typedef typename phoenix::as_actor::type i_t; - typedef typename phoenix::as_actor::type j_t; - typedef typename phoenix::as_actor::type k_t; - typedef typename phoenix::as_actor::type l_t; - typedef typename phoenix::as_actor::type m_t; - typedef typename phoenix::as_actor::type n_t; - typedef phoenix::tuple< - a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t, - k_t, l_t, m_t, n_t - > actor_tuple_t; - - return init_closure_parser( - aux_derived(), - actor_tuple_t( - phoenix::as_actor::convert(a), - phoenix::as_actor::convert(b), - phoenix::as_actor::convert(c), - phoenix::as_actor::convert(d), - phoenix::as_actor::convert(e), - phoenix::as_actor::convert(f), - phoenix::as_actor::convert(g), - phoenix::as_actor::convert(h), - phoenix::as_actor::convert(i), - phoenix::as_actor::convert(j), - phoenix::as_actor::convert(k), - phoenix::as_actor::convert(l), - phoenix::as_actor::convert(m), - phoenix::as_actor::convert(n) - ) - ); - } - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M, typename N, typename O - > - init_closure_parser< - DerivedT2, - phoenix::tuple< - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type, - typename phoenix::as_actor::type - > - > - operator()( - A const &a, B const &b, C const &c, D const &d, E const &e, - F const &f, G const &g, H const &h, I const &i, J const &j, - K const &k, L const &l, M const &m, N const &n, O const &o - ) const - { - typedef typename phoenix::as_actor::type a_t; - typedef typename phoenix::as_actor::type b_t; - typedef typename phoenix::as_actor::type c_t; - typedef typename phoenix::as_actor::type d_t; - typedef typename phoenix::as_actor::type e_t; - typedef typename phoenix::as_actor::type f_t; - typedef typename phoenix::as_actor::type g_t; - typedef typename phoenix::as_actor::type h_t; - typedef typename phoenix::as_actor::type i_t; - typedef typename phoenix::as_actor::type j_t; - typedef typename phoenix::as_actor::type k_t; - typedef typename phoenix::as_actor::type l_t; - typedef typename phoenix::as_actor::type m_t; - typedef typename phoenix::as_actor::type n_t; - typedef typename phoenix::as_actor::type o_t; - typedef phoenix::tuple< - a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t, - k_t, l_t, m_t, n_t, o_t - > actor_tuple_t; - - return init_closure_parser( - aux_derived(), - actor_tuple_t( - phoenix::as_actor::convert(a), - phoenix::as_actor::convert(b), - phoenix::as_actor::convert(c), - phoenix::as_actor::convert(d), - phoenix::as_actor::convert(e), - phoenix::as_actor::convert(f), - phoenix::as_actor::convert(g), - phoenix::as_actor::convert(h), - phoenix::as_actor::convert(i), - phoenix::as_actor::convert(j), - phoenix::as_actor::convert(k), - phoenix::as_actor::convert(l), - phoenix::as_actor::convert(m), - phoenix::as_actor::convert(n), - phoenix::as_actor::convert(o) - ) - ); - } - - #endif - #endif - #endif - #endif - }; - - ~closure() {} - }; - - /////////////////////////////////////////////////////////////////////////// - // - // overloads for chseq_p and str_p taking in phoenix actors - // - /////////////////////////////////////////////////////////////////////////// - template - struct container_begin - { - typedef container_begin self_t; - - template - struct result - { - typedef typename phoenix::actor_result - ::plain_type::iterator type; - }; - - container_begin(ActorT actor_) - : actor(actor_) {} - - template - typename phoenix::actor_result::type - eval(TupleT const& /*args*/) const - { return actor().begin(); } - - ActorT actor; - }; - - template - struct container_end - { - typedef container_begin self_t; - - template - struct result - { - typedef typename phoenix::actor_result - ::plain_type::iterator type; - }; - - container_end(ActorT actor_) - : actor(actor_) {} - - template - typename phoenix::actor_result::type - eval(TupleT const& /*args*/) const - { return actor().end(); } - - ActorT actor; - }; - - template - inline f_chseq< - phoenix::actor > >, - phoenix::actor > > - > - f_chseq_p(phoenix::actor const& a) - { - typedef phoenix::actor > > - container_begin_t; - typedef phoenix::actor > > - container_end_t; - typedef f_chseq result_t; - - return result_t(container_begin_t(a), container_end_t(a)); - } - - template - inline f_strlit< - phoenix::actor > >, - phoenix::actor > > - > - f_str_p(phoenix::actor const& a) - { - typedef phoenix::actor > > - container_begin_t; - typedef phoenix::actor > > - container_end_t; - typedef f_strlit result_t; - - return result_t(container_begin_t(a), container_end_t(a)); - } - -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/attribute/closure_context.hpp b/boost/boost/spirit/attribute/closure_context.hpp deleted file mode 100644 index ff46228aca..0000000000 --- a/boost/boost/spirit/attribute/closure_context.hpp +++ /dev/null @@ -1,51 +0,0 @@ -/*============================================================================= - Copyright (c) 2002-2003 Joel de Guzman - Copyright (c) 2002-2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_CLOSURE_CONTEXT_HPP) -#define BOOST_SPIRIT_CLOSURE_CONTEXT_HPP - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -#if !defined(BOOST_SPIRIT_CLOSURE_CONTEXT_LINKER_DEFINED) -#define BOOST_SPIRIT_CLOSURE_CONTEXT_LINKER_DEFINED - -/////////////////////////////////////////////////////////////////////////////// -// -// closure_context_linker -// { helper template for the closure extendability } -// -// This classes can be 'overloaded' (defined elsewhere), to plug -// in additional functionality into the closure parsing process. -// -/////////////////////////////////////////////////////////////////////////////// - -template -struct closure_context_linker : public ContextT -{ - template - closure_context_linker(ParserT const& p) - : ContextT(p) {} - - template - void pre_parse(ParserT const& p, ScannerT const& scan) - { ContextT::pre_parse(p, scan); } - - template - ResultT& - post_parse(ResultT& hit, ParserT const& p, ScannerT const& scan) - { return ContextT::post_parse(hit, p, scan); } -}; - -#endif // !defined(BOOST_SPIRIT_CLOSURE_CONTEXT_LINKER_DEFINED) - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#endif // BOOST_SPIRIT_CLOSURE_CONTEXT_HPP diff --git a/boost/boost/spirit/attribute/parametric.hpp b/boost/boost/spirit/attribute/parametric.hpp deleted file mode 100644 index 2e2883bf2e..0000000000 --- a/boost/boost/spirit/attribute/parametric.hpp +++ /dev/null @@ -1,140 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_PARAMETRIC_HPP -#define BOOST_SPIRIT_PARAMETRIC_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include -#include -#include - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // f_chlit class [ functional version of chlit ] - // - /////////////////////////////////////////////////////////////////////////// - template - struct f_chlit : public char_parser > - { - f_chlit(ChGenT chgen_) - : chgen(chgen_) {} - - template - bool test(T ch) const - { return ch == chgen(); } - - ChGenT chgen; - }; - - template - inline f_chlit - f_ch_p(ChGenT chgen) - { return f_chlit(chgen); } - - /////////////////////////////////////////////////////////////////////////// - // - // f_range class [ functional version of range ] - // - /////////////////////////////////////////////////////////////////////////// - template - struct f_range : public char_parser > - { - f_range(ChGenAT first_, ChGenBT last_) - : first(first_), last(last_) - {} - - template - bool test(T ch) const - { - BOOST_SPIRIT_ASSERT(first() <= last()); - return (ch >= first()) && (ch <= last()); - } - - ChGenAT first; - ChGenBT last; - }; - - template - inline f_range - f_range_p(ChGenAT first, ChGenBT last) - { return f_range(first, last); } - - /////////////////////////////////////////////////////////////////////////// - // - // f_chseq class [ functional version of chseq ] - // - /////////////////////////////////////////////////////////////////////////// - template - class f_chseq : public parser > - { - public: - - typedef f_chseq self_t; - - f_chseq(IterGenAT first_, IterGenBT last_) - : first(first_), last(last_) {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - return impl::string_parser_parse(first(), last(), scan); - } - - private: - - IterGenAT first; - IterGenBT last; - }; - - template - inline f_chseq - f_chseq_p(IterGenAT first, IterGenBT last) - { return f_chseq(first, last); } - - /////////////////////////////////////////////////////////////////////////// - // - // f_strlit class [ functional version of strlit ] - // - /////////////////////////////////////////////////////////////////////////// - template - class f_strlit : public parser > - { - public: - - typedef f_strlit self_t; - - f_strlit(IterGenAT first, IterGenBT last) - : seq(first, last) {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - return impl::contiguous_parser_parse - (seq, scan, scan); - } - - private: - - f_chseq seq; - }; - - template - inline f_strlit - f_str_p(IterGenAT first, IterGenBT last) - { return f_strlit(first, last); } - -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/core.hpp b/boost/boost/spirit/core.hpp deleted file mode 100644 index 2bcba62fc5..0000000000 --- a/boost/boost/spirit/core.hpp +++ /dev/null @@ -1,74 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001-2003 Daniel Nuffer - Copyright (c) 2001-2003 Hartmut Kaiser - Copyright (c) 2002-2003 Martin Wille - Copyright (c) 2002 Raghavendra Satish - Copyright (c) 2001 Bruce Florman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_CORE_MAIN_HPP) -#define BOOST_SPIRIT_CORE_MAIN_HPP - -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -// -// Spirit.Core includes -// -/////////////////////////////////////////////////////////////////////////////// - -// Spirit.Core.Kernel -#include -#include -#include -#include - -// Spirit.Core.Primitives -#include -#include - -// Spirit.Core.Scanner -#include -#include - -// Spirit.Core.NonTerminal -#include -#include -#include - -// Spirit.Core.Composite -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -// Deprecated interface includes -#include -#include - -#if defined(BOOST_SPIRIT_DEBUG) - ////////////////////////////////// - #include - -#endif // BOOST_SPIRIT_DEBUG - -#endif // BOOST_SPIRIT_CORE_MAIN_HPP - diff --git a/boost/boost/spirit/core/assert.hpp b/boost/boost/spirit/core/assert.hpp deleted file mode 100644 index 11002442ee..0000000000 --- a/boost/boost/spirit/core/assert.hpp +++ /dev/null @@ -1,39 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - Copyright (c) 2002-2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_ASSERT_HPP) -#define BOOST_SPIRIT_ASSERT_HPP - -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -// -// BOOST_SPIRIT_ASSERT is used throughout the framework. It can be -// overridden by the user. If BOOST_SPIRIT_ASSERT_EXCEPTION is defined, -// then that will be thrown, otherwise, BOOST_SPIRIT_ASSERT simply turns -// into a plain assert() -// -/////////////////////////////////////////////////////////////////////////////// -#if !defined(BOOST_SPIRIT_ASSERT) -#if defined(NDEBUG) - #define BOOST_SPIRIT_ASSERT(x) -#elif defined (BOOST_SPIRIT_ASSERT_EXCEPTION) - #define BOOST_SPIRIT_ASSERT_AUX(f, l, x) BOOST_SPIRIT_ASSERT_AUX2(f, l, x) - #define BOOST_SPIRIT_ASSERT_AUX2(f, l, x) \ - do{ if (!(x)) boost::throw_exception( \ - BOOST_SPIRIT_ASSERT_EXCEPTION(f "(" #l "): " #x)); } while(0) - #define BOOST_SPIRIT_ASSERT(x) BOOST_SPIRIT_ASSERT_AUX(__FILE__, __LINE__, x) -#else - #include - #define BOOST_SPIRIT_ASSERT(x) assert(x) -#endif -#endif // !defined(BOOST_SPIRIT_ASSERT) - -#endif // BOOST_SPIRIT_ASSERT_HPP diff --git a/boost/boost/spirit/core/composite/actions.hpp b/boost/boost/spirit/core/composite/actions.hpp deleted file mode 100644 index 543faedc01..0000000000 --- a/boost/boost/spirit/core/composite/actions.hpp +++ /dev/null @@ -1,123 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_ACTIONS_HPP -#define BOOST_SPIRIT_ACTIONS_HPP - -#include -#include - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // action class - // - // The action class binds a parser with a user defined semantic - // action. Instances of action are never created manually. Instead, - // action objects are typically created indirectly through - // expression templates of the form: - // - // p[f] - // - // where p is a parser and f is a function or functor. The semantic - // action may be a function or a functor. When the parser is - // successful, the actor calls the scanner's action_policy policy - // (see scanner.hpp): - // - // scan.do_action(actor, attribute, first, last); - // - // passing in these information: - // - // actor: The action's function or functor - // attribute: The match (returned by the parser) object's - // attribute (see match.hpp) - // first: Iterator pointing to the start of the matching - // portion of the input - // last: Iterator pointing to one past the end of the - // matching portion of the input - // - // It is the responsibility of the scanner's action_policy policy to - // dispatch the function or functor as it sees fit. The expected - // function or functor signature depends on the parser being - // wrapped. In general, if the attribute type of the parser being - // wrapped is a nil_t, the function or functor expect the signature: - // - // void func(Iterator first, Iterator last); // functions - // - // struct ftor // functors - // { - // void func(Iterator first, Iterator last) const; - // }; - // - // where Iterator is the type of the iterator that is being used and - // first and last are the iterators pointing to the matching portion - // of the input. - // - // If the attribute type of the parser being wrapped is not a nil_t, - // the function or functor usually expect the signature: - // - // void func(T val); // functions - // - // struct ftor // functors - // { - // void func(T val) const; - // }; - // - // where T is the attribute type and val is the attribute value - // returned by the parser being wrapped. - // - /////////////////////////////////////////////////////////////////////////// - template - class action : public unary > > - { - public: - - typedef action self_t; - typedef action_parser_category parser_category_t; - typedef unary > base_t; - typedef ActionT predicate_t; - - template - struct result - { - typedef typename parser_result::type type; - }; - - action(ParserT const& p, ActionT const& a) - : base_t(p) - , actor(a) {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename ScannerT::iterator_t iterator_t; - typedef typename parser_result::type result_t; - - scan.at_end(); // allow skipper to take effect - iterator_t save = scan.first; - result_t hit = this->subject().parse(scan); - if (hit) - { - typename result_t::return_t val = hit.value(); - scan.do_action(actor, val, save, scan.first); - } - return hit; - } - - ActionT const& predicate() const { return actor; } - - private: - - ActionT actor; - }; - -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/core/composite/alternative.hpp b/boost/boost/spirit/core/composite/alternative.hpp deleted file mode 100644 index a587c20f2f..0000000000 --- a/boost/boost/spirit/core/composite/alternative.hpp +++ /dev/null @@ -1,134 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - Copyright (c) 2002 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_ALTERNATIVE_HPP) -#define BOOST_SPIRIT_ALTERNATIVE_HPP - -#include -#include -#include -#include - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // alternative class - // - // Handles expressions of the form: - // - // a | b - // - // where a and b are parsers. The expression returns a composite - // parser that matches a or b. One (not both) of the operands may - // be a literal char, wchar_t or a primitive string char const*, - // wchar_t const*. - // - // The expression is short circuit evaluated. b is never touched - // when a is returns a successful match. - // - /////////////////////////////////////////////////////////////////////////// - struct alternative_parser_gen; - - template - struct alternative - : public binary > > - { - typedef alternative self_t; - typedef binary_parser_category parser_category_t; - typedef alternative_parser_gen parser_generator_t; - typedef binary > base_t; - - alternative(A const& a, B const& b) - : base_t(a, b) {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - typedef typename ScannerT::iterator_t iterator_t; - { // scope for save - iterator_t save = scan.first; - if (result_t hit = this->left().parse(scan)) - return hit; - scan.first = save; - } - return this->right().parse(scan); - } - }; - - struct alternative_parser_gen - { - template - struct result - { - typedef - alternative< - typename as_parser::type - , typename as_parser::type - > - type; - }; - - template - static alternative< - typename as_parser::type - , typename as_parser::type - > - generate(A const& a, B const& b) - { - return alternative::type, - BOOST_DEDUCED_TYPENAME as_parser::type> - (as_parser::convert(a), as_parser::convert(b)); - } - }; - - template - alternative - operator|(parser const& a, parser const& b); - - template - alternative > - operator|(parser const& a, char b); - - template - alternative, B> - operator|(char a, parser const& b); - - template - alternative > - operator|(parser const& a, char const* b); - - template - alternative, B> - operator|(char const* a, parser const& b); - - template - alternative > - operator|(parser const& a, wchar_t b); - - template - alternative, B> - operator|(wchar_t a, parser const& b); - - template - alternative > - operator|(parser const& a, wchar_t const* b); - - template - alternative, B> - operator|(wchar_t const* a, parser const& b); - -}} // namespace boost::spirit - -#endif - -#include diff --git a/boost/boost/spirit/core/composite/composite.hpp b/boost/boost/spirit/core/composite/composite.hpp deleted file mode 100644 index 8e5ae3d26d..0000000000 --- a/boost/boost/spirit/core/composite/composite.hpp +++ /dev/null @@ -1,138 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_COMPOSITE_HPP) -#define BOOST_SPIRIT_COMPOSITE_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // unary class. - // - // Composite class composed of a single subject. This template class - // is parameterized by the subject type S and a base class to - // inherit from, BaseT. The unary class is meant to be a base class - // to inherit from. The inheritance structure, given the BaseT - // template parameter places the unary class in the middle of a - // linear, single parent hierarchy. For instance, given a class S - // and a base class B, a class D can derive from unary: - // - // struct D : public unary {...}; - // - // The inheritance structure is thus: - // - // B - // | - // unary (has S) - // | - // D - // - // The subject can be accessed from the derived class D as: - // this->subject(); - // - // Typically, the subject S is specified as typename S::embed_t. - // embed_t specifies how the subject is embedded in the composite - // (See parser.hpp for details). - // - /////////////////////////////////////////////////////////////////////////// - template - class unary : public BaseT - { - public: - - typedef BaseT base_t; - typedef typename boost::call_traits::param_type param_t; - typedef typename boost::call_traits::const_reference return_t; - typedef S subject_t; - typedef typename S::embed_t subject_embed_t; - - unary(param_t subj_) - : base_t(), subj(subj_) {} - - unary(BaseT const& base, param_t subj_) - : base_t(base), subj(subj_) {} - - return_t - subject() const - { return subj; } - - private: - - subject_embed_t subj; - }; - - /////////////////////////////////////////////////////////////////////////// - // - // binary class. - // - // Composite class composed of a pair (left and right). This - // template class is parameterized by the left and right subject - // types A and B and a base class to inherit from, BaseT. The binary - // class is meant to be a base class to inherit from. The - // inheritance structure, given the BaseT template parameter places - // the binary class in the middle of a linear, single parent - // hierarchy. For instance, given classes X and Y and a base class - // B, a class D can derive from binary: - // - // struct D : public binary {...}; - // - // The inheritance structure is thus: - // - // B - // | - // binary (has X and Y) - // | - // D - // - // The left and right subjects can be accessed from the derived - // class D as: this->left(); and this->right(); - // - // Typically, the pairs X and Y are specified as typename X::embed_t - // and typename Y::embed_t. embed_t specifies how the subject is - // embedded in the composite (See parser.hpp for details). - // - /////////////////////////////////////////////////////////////////////////////// - template - class binary : public BaseT - { - public: - - typedef BaseT base_t; - typedef typename boost::call_traits::param_type left_param_t; - typedef typename boost::call_traits::const_reference left_return_t; - typedef typename boost::call_traits::param_type right_param_t; - typedef typename boost::call_traits::const_reference right_return_t; - typedef A left_t; - typedef typename A::embed_t left_embed_t; - typedef B right_t; - typedef typename B::embed_t right_embed_t; - - binary(left_param_t a, right_param_t b) - : base_t(), subj(a, b) {} - - left_return_t - left() const - { return subj.first(); } - - right_return_t - right() const - { return subj.second(); } - - private: - - boost::compressed_pair subj; - }; - -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/core/composite/difference.hpp b/boost/boost/spirit/core/composite/difference.hpp deleted file mode 100644 index 51ad9e3c14..0000000000 --- a/boost/boost/spirit/core/composite/difference.hpp +++ /dev/null @@ -1,137 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - Copyright (c) 2002 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_DIFFERENCE_HPP) -#define BOOST_SPIRIT_DIFFERENCE_HPP - -#include -#include -#include -#include - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // difference: a - b; Matches a but not b - // - // Handles expressions of the form: - // - // a - b - // - // where a and b are parsers. The expression returns a composite - // parser that matches a but not b. One (not both) of the operands - // may be a literal char, wchar_t or a primitive string char const*, - // wchar_t const*. - // - /////////////////////////////////////////////////////////////////////////// - struct difference_parser_gen; - - template - struct difference - : public binary > > - { - typedef difference self_t; - typedef binary_parser_category parser_category_t; - typedef difference_parser_gen parser_generator_t; - typedef binary > base_t; - - difference(A const& a, B const& b) - : base_t(a, b) {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - typedef typename ScannerT::iterator_t iterator_t; - iterator_t save = scan.first; - if (result_t hl = this->left().parse(scan)) - { - std::swap(save, scan.first); - result_t hr = this->right().parse(scan); - if (!hr || (hr.length() < hl.length())) - { - scan.first = save; - return hl; - } - } - - return scan.no_match(); - } - }; - - struct difference_parser_gen - { - template - struct result - { - typedef - difference< - typename as_parser::type - , typename as_parser::type - > - type; - }; - - template - static difference< - typename as_parser::type - , typename as_parser::type - > - generate(A const& a, B const& b) - { - return difference::type, - BOOST_DEDUCED_TYPENAME as_parser::type> - (as_parser::convert(a), as_parser::convert(b)); - } - }; - - template - difference - operator-(parser const& a, parser const& b); - - template - difference > - operator-(parser const& a, char b); - - template - difference, B> - operator-(char a, parser const& b); - - template - difference > - operator-(parser const& a, char const* b); - - template - difference, B> - operator-(char const* a, parser const& b); - - template - difference > - operator-(parser const& a, wchar_t b); - - template - difference, B> - operator-(wchar_t a, parser const& b); - - template - difference > - operator-(parser const& a, wchar_t const* b); - - template - difference, B> - operator-(wchar_t const* a, parser const& b); - -}} // namespace boost::spirit - -#endif - -#include diff --git a/boost/boost/spirit/core/composite/directives.hpp b/boost/boost/spirit/core/composite/directives.hpp deleted file mode 100644 index 546382de58..0000000000 --- a/boost/boost/spirit/core/composite/directives.hpp +++ /dev/null @@ -1,603 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_DIRECTIVES_HPP) -#define BOOST_SPIRIT_DIRECTIVES_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include - -#include -#include -#include -#include -#include - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // contiguous class - // - /////////////////////////////////////////////////////////////////////////// - struct lexeme_parser_gen; - - template - struct contiguous - : public unary > > - { - typedef contiguous self_t; - typedef unary_parser_category parser_category_t; - typedef lexeme_parser_gen parser_generator_t; - typedef unary > base_t; - - template - struct result - { - typedef typename parser_result::type type; - }; - - contiguous(ParserT const& p) - : base_t(p) {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - return impl::contiguous_parser_parse - (this->subject(), scan, scan); - } - }; - - struct lexeme_parser_gen - { - template - struct result { - - typedef contiguous type; - }; - - template - static contiguous - generate(parser const& subject) - { - return contiguous(subject.derived()); - } - - template - contiguous - operator[](parser const& subject) const - { - return contiguous(subject.derived()); - } - }; - - ////////////////////////////////// - const lexeme_parser_gen lexeme_d = lexeme_parser_gen(); - - /////////////////////////////////////////////////////////////////////////// - // - // lexeme_scanner - // - // Given a Scanner, return the correct scanner type that - // the lexeme_d uses. Scanner is assumed to be a phrase - // level scanner (see skipper.hpp) - // - /////////////////////////////////////////////////////////////////////////// - template - struct lexeme_scanner - { - typedef scanner_policies< - no_skipper_iteration_policy< - typename ScannerT::iteration_policy_t>, - typename ScannerT::match_policy_t, - typename ScannerT::action_policy_t - > policies_t; - - typedef typename - rebind_scanner_policies::type type; - }; - - /////////////////////////////////////////////////////////////////////////// - // - // inhibit_case_iteration_policy class - // - /////////////////////////////////////////////////////////////////////////// - template - struct inhibit_case_iteration_policy : public BaseT - { - typedef BaseT base_t; - - inhibit_case_iteration_policy() - : BaseT() {} - - template - inhibit_case_iteration_policy(PolicyT const& other) - : BaseT(other) {} - - template - CharT filter(CharT ch) const - { return impl::tolower_(ch); } - }; - - /////////////////////////////////////////////////////////////////////////// - // - // inhibit_case class - // - /////////////////////////////////////////////////////////////////////////// - struct inhibit_case_parser_gen; - - template - struct inhibit_case - : public unary > > - { - typedef inhibit_case self_t; - typedef unary_parser_category parser_category_t; - typedef inhibit_case_parser_gen parser_generator_t; - typedef unary > base_t; - - template - struct result - { - typedef typename parser_result::type type; - }; - - inhibit_case(ParserT const& p) - : base_t(p) {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - return impl::inhibit_case_parser_parse - (this->subject(), scan, scan); - } - }; - - template - struct inhibit_case_parser_gen_base - { - // This hack is needed to make borland happy. - // If these member operators were defined in the - // inhibit_case_parser_gen class, or if this class - // is non-templated, borland ICEs. - - static inhibit_case > - generate(char const* str) - { return inhibit_case >(str); } - - static inhibit_case > - generate(wchar_t const* str) - { return inhibit_case >(str); } - - static inhibit_case > - generate(char ch) - { return inhibit_case >(ch); } - - static inhibit_case > - generate(wchar_t ch) - { return inhibit_case >(ch); } - - template - static inhibit_case - generate(parser const& subject) - { return inhibit_case(subject.derived()); } - - inhibit_case > - operator[](char const* str) const - { return inhibit_case >(str); } - - inhibit_case > - operator[](wchar_t const* str) const - { return inhibit_case >(str); } - - inhibit_case > - operator[](char ch) const - { return inhibit_case >(ch); } - - inhibit_case > - operator[](wchar_t ch) const - { return inhibit_case >(ch); } - - template - inhibit_case - operator[](parser const& subject) const - { return inhibit_case(subject.derived()); } - }; - - ////////////////////////////////// - struct inhibit_case_parser_gen : public inhibit_case_parser_gen_base<0> - { - inhibit_case_parser_gen() {} - }; - - ////////////////////////////////// - // Depracated - const inhibit_case_parser_gen nocase_d = inhibit_case_parser_gen(); - - // Preferred syntax - const inhibit_case_parser_gen as_lower_d = inhibit_case_parser_gen(); - - /////////////////////////////////////////////////////////////////////////// - // - // as_lower_scanner - // - // Given a Scanner, return the correct scanner type that - // the as_lower_d uses. Scanner is assumed to be a scanner - // with an inhibit_case_iteration_policy. - // - /////////////////////////////////////////////////////////////////////////// - template - struct as_lower_scanner - { - typedef scanner_policies< - inhibit_case_iteration_policy< - typename ScannerT::iteration_policy_t>, - typename ScannerT::match_policy_t, - typename ScannerT::action_policy_t - > policies_t; - - typedef typename - rebind_scanner_policies::type type; - }; - - /////////////////////////////////////////////////////////////////////////// - // - // longest_alternative class - // - /////////////////////////////////////////////////////////////////////////// - struct longest_parser_gen; - - template - struct longest_alternative - : public binary > > - { - typedef longest_alternative self_t; - typedef binary_parser_category parser_category_t; - typedef longest_parser_gen parser_generator_t; - typedef binary > base_t; - - longest_alternative(A const& a, B const& b) - : base_t(a, b) {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - typename ScannerT::iterator_t save = scan.first; - result_t l = this->left().parse(scan); - std::swap(scan.first, save); - result_t r = this->right().parse(scan); - - if (l || r) - { - if (l.length() > r.length()) - { - scan.first = save; - return l; - } - return r; - } - - return scan.no_match(); - } - }; - - struct longest_parser_gen - { - template - struct result { - - typedef typename - impl::to_longest_alternative >::result_t - type; - }; - - template - static typename - impl::to_longest_alternative >::result_t - generate(alternative const& alt) - { - return impl::to_longest_alternative >:: - convert(alt); - } - - //'generate' for binary composite - template - static - longest_alternative - generate(A const &left, B const &right) - { - return longest_alternative(left, right); - } - - template - typename impl::to_longest_alternative >::result_t - operator[](alternative const& alt) const - { - return impl::to_longest_alternative >:: - convert(alt); - } - }; - - const longest_parser_gen longest_d = longest_parser_gen(); - - /////////////////////////////////////////////////////////////////////////// - // - // shortest_alternative class - // - /////////////////////////////////////////////////////////////////////////// - struct shortest_parser_gen; - - template - struct shortest_alternative - : public binary > > - { - typedef shortest_alternative self_t; - typedef binary_parser_category parser_category_t; - typedef shortest_parser_gen parser_generator_t; - typedef binary > base_t; - - shortest_alternative(A const& a, B const& b) - : base_t(a, b) {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - typename ScannerT::iterator_t save = scan.first; - result_t l = this->left().parse(scan); - std::swap(scan.first, save); - result_t r = this->right().parse(scan); - - if (l || r) - { - if (l.length() < r.length() && l || !r) - { - scan.first = save; - return l; - } - return r; - } - - return scan.no_match(); - } - }; - - struct shortest_parser_gen - { - template - struct result { - - typedef typename - impl::to_shortest_alternative >::result_t - type; - }; - - template - static typename - impl::to_shortest_alternative >::result_t - generate(alternative const& alt) - { - return impl::to_shortest_alternative >:: - convert(alt); - } - - //'generate' for binary composite - template - static - shortest_alternative - generate(A const &left, B const &right) - { - return shortest_alternative(left, right); - } - - template - typename impl::to_shortest_alternative >::result_t - operator[](alternative const& alt) const - { - return impl::to_shortest_alternative >:: - convert(alt); - } - }; - - const shortest_parser_gen shortest_d = shortest_parser_gen(); - - /////////////////////////////////////////////////////////////////////////// - // - // min_bounded class - // - /////////////////////////////////////////////////////////////////////////// - template - struct min_bounded_gen; - - template - struct min_bounded - : public unary > > - { - typedef min_bounded self_t; - typedef unary_parser_category parser_category_t; - typedef min_bounded_gen parser_generator_t; - typedef unary > base_t; - - template - struct result - { - typedef typename parser_result::type type; - }; - - min_bounded(ParserT const& p, BoundsT const& min__) - : base_t(p) - , min_(min__) {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - result_t hit = this->subject().parse(scan); - if (hit.has_valid_attribute() && hit.value() < min_) - return scan.no_match(); - return hit; - } - - BoundsT min_; - }; - - template - struct min_bounded_gen - { - min_bounded_gen(BoundsT const& min__) - : min_(min__) {} - - template - min_bounded - operator[](parser const& p) const - { return min_bounded(p.derived(), min_); } - - BoundsT min_; - }; - - template - inline min_bounded_gen - min_limit_d(BoundsT const& min_) - { return min_bounded_gen(min_); } - - /////////////////////////////////////////////////////////////////////////// - // - // max_bounded class - // - /////////////////////////////////////////////////////////////////////////// - template - struct max_bounded_gen; - - template - struct max_bounded - : public unary > > - { - typedef max_bounded self_t; - typedef unary_parser_category parser_category_t; - typedef max_bounded_gen parser_generator_t; - typedef unary > base_t; - - template - struct result - { - typedef typename parser_result::type type; - }; - - max_bounded(ParserT const& p, BoundsT const& max__) - : base_t(p) - , max_(max__) {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - result_t hit = this->subject().parse(scan); - if (hit.has_valid_attribute() && hit.value() > max_) - return scan.no_match(); - return hit; - } - - BoundsT max_; - }; - - template - struct max_bounded_gen - { - max_bounded_gen(BoundsT const& max__) - : max_(max__) {} - - template - max_bounded - operator[](parser const& p) const - { return max_bounded(p.derived(), max_); } - - BoundsT max_; - }; - - ////////////////////////////////// - template - inline max_bounded_gen - max_limit_d(BoundsT const& max_) - { return max_bounded_gen(max_); } - - /////////////////////////////////////////////////////////////////////////// - // - // bounded class - // - /////////////////////////////////////////////////////////////////////////// - template - struct bounded_gen; - - template - struct bounded - : public unary > > - { - typedef bounded self_t; - typedef unary_parser_category parser_category_t; - typedef bounded_gen parser_generator_t; - typedef unary > base_t; - - template - struct result - { - typedef typename parser_result::type type; - }; - - bounded(ParserT const& p, BoundsT const& min__, BoundsT const& max__) - : base_t(p) - , min_(min__) - , max_(max__) {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - result_t hit = this->subject().parse(scan); - if (hit.has_valid_attribute() && - (hit.value() < min_ || hit.value() > max_)) - return scan.no_match(); - return hit; - } - - BoundsT min_, max_; - }; - - template - struct bounded_gen - { - bounded_gen(BoundsT const& min__, BoundsT const& max__) - : min_(min__) - , max_(max__) {} - - template - bounded - operator[](parser const& p) const - { return bounded(p.derived(), min_, max_); } - - BoundsT min_, max_; - }; - - template - inline bounded_gen - limit_d(BoundsT const& min_, BoundsT const& max_) - { return bounded_gen(min_, max_); } - -}} // namespace boost::spirit - -#endif - diff --git a/boost/boost/spirit/core/composite/epsilon.hpp b/boost/boost/spirit/core/composite/epsilon.hpp deleted file mode 100644 index 71d962e136..0000000000 --- a/boost/boost/spirit/core/composite/epsilon.hpp +++ /dev/null @@ -1,272 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2002-2003 Martin Wille - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_EPSILON_HPP -#define BOOST_SPIRIT_EPSILON_HPP - -//////////////////////////////////////////////////////////////////////////////// -#include -#include -#include -#include - -//////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -/////////////////////////////////////////////////////////////////////////////// -// -// condition_parser class -// -// handles expresions of the form -// -// epsilon_p(cond) -// -// where cond is a function or a functor that returns a value suitable -// to be used in boolean context. The expression returns a parser that -// returns an empty match when the condition evaluates to true. -// -/////////////////////////////////////////////////////////////////////////////// - template - struct condition_parser : parser > - { - typedef condition_parser self_t; - - // not explicit! (needed for implementation of if_p et al.) - condition_parser(CondT const& cond_) : cond(cond_) {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - if (positive_ == bool(cond())) // allow cond to return int - return scan.empty_match(); - else - return scan.no_match(); - } - - condition_parser - negate() const - { return condition_parser(cond); } - - private: - - CondT cond; - }; - -#if BOOST_WORKAROUND(BOOST_MSVC, == 1310) || \ - BOOST_WORKAROUND(BOOST_MSVC, == 1400) || \ - BOOST_WORKAROUND(__SUNPRO_CC, <= 0x580) -// VC 7.1, VC8 and Sun CC <= 5.8 do not support general -// expressions of non-type template parameters in instantiations - template - inline condition_parser - operator~(condition_parser const& p) - { return p.negate(); } - - template - inline condition_parser - operator~(condition_parser const& p) - { return p.negate(); } -#else // BOOST_WORKAROUND(BOOST_MSVC, == 1310) || == 1400 - template - inline condition_parser - operator~(condition_parser const& p) - { return p.negate(); } -#endif // BOOST_WORKAROUND(BOOST_MSVC, == 1310) || == 1400 - -/////////////////////////////////////////////////////////////////////////////// -// -// empty_match_parser class -// -// handles expressions of the form -// epsilon_p(subject) -// where subject is a parser. The expresion returns a composite -// parser that returns an empty match if the subject parser matches. -// -/////////////////////////////////////////////////////////////////////////////// - struct empty_match_parser_gen; - struct negated_empty_match_parser_gen; - - template - struct negated_empty_match_parser; // Forward declaration - - template - struct empty_match_parser - : unary > > - { - typedef empty_match_parser self_t; - typedef unary > base_t; - typedef unary_parser_category parser_category_t; - typedef empty_match_parser_gen parser_genererator_t; - typedef self_t embed_t; - - explicit empty_match_parser(SubjectT const& p) : base_t(p) {} - - template - struct result - { typedef typename match_result::type type; }; - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typename ScannerT::iterator_t save(scan.first); - - typedef typename no_actions_scanner::policies_t - policies_t; - - bool matches = this->subject().parse( - scan.change_policies(policies_t(scan))); - if (matches) - { - scan.first = save; // reset the position - return scan.empty_match(); - } - else - { - return scan.no_match(); - } - } - - negated_empty_match_parser - negate() const - { return negated_empty_match_parser(this->subject()); } - }; - - template - struct negated_empty_match_parser - : public unary > > - { - typedef negated_empty_match_parser self_t; - typedef unary > base_t; - typedef unary_parser_category parser_category_t; - typedef negated_empty_match_parser_gen parser_genererator_t; - - explicit negated_empty_match_parser(SubjectT const& p) : base_t(p) {} - - template - struct result - { typedef typename match_result::type type; }; - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typename ScannerT::iterator_t save(scan.first); - - typedef typename no_actions_scanner::policies_t - policies_t; - - bool matches = this->subject().parse( - scan.change_policies(policies_t(scan))); - if (!matches) - { - scan.first = save; // reset the position - return scan.empty_match(); - } - else - { - return scan.no_match(); - } - } - - empty_match_parser - negate() const - { return empty_match_parser(this->subject()); } - }; - - struct empty_match_parser_gen - { - template - struct result - { typedef empty_match_parser type; }; - - template - static empty_match_parser - generate(parser const& subject) - { return empty_match_parser(subject.derived()); } - }; - - struct negated_empty_match_parser_gen - { - template - struct result - { typedef negated_empty_match_parser type; }; - - template - static negated_empty_match_parser - generate(parser const& subject) - { return negated_empty_match_parser(subject.derived()); } - }; - - ////////////////////////////// - template - inline negated_empty_match_parser - operator~(empty_match_parser const& p) - { return p.negate(); } - - template - inline empty_match_parser - operator~(negated_empty_match_parser const& p) - { return p.negate(); } - -/////////////////////////////////////////////////////////////////////////////// -// -// epsilon_ parser and parser generator class -// -// Operates as primitive parser that always matches an empty sequence. -// -// Also operates as a parser generator. According to the type of the -// argument an instance of empty_match_parser<> (when the argument is -// a parser) or condition_parser<> (when the argument is not a parser) -// is returned by operator(). -// -/////////////////////////////////////////////////////////////////////////////// - namespace impl - { - template - struct epsilon_selector - { - typedef typename as_parser::type subject_t; - typedef typename - mpl::if_< - is_parser - ,empty_match_parser - ,condition_parser - >::type type; - }; - } - - struct epsilon_parser : public parser - { - typedef epsilon_parser self_t; - - epsilon_parser() {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { return scan.empty_match(); } - - template - typename impl::epsilon_selector::type - operator()(SubjectT const& subject) const - { - typedef typename impl::epsilon_selector::type result_t; - return result_t(subject); - } - }; - - epsilon_parser const epsilon_p = epsilon_parser(); - epsilon_parser const eps_p = epsilon_parser(); - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/core/composite/exclusive_or.hpp b/boost/boost/spirit/core/composite/exclusive_or.hpp deleted file mode 100644 index e7af4530d1..0000000000 --- a/boost/boost/spirit/core/composite/exclusive_or.hpp +++ /dev/null @@ -1,138 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - Copyright (c) 2002 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_EXCLUSIVE_OR_HPP) -#define BOOST_SPIRIT_EXCLUSIVE_OR_HPP - -#include -#include -#include -#include - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // exclusive_or class - // - // Handles expressions of the form: - // - // a ^ b - // - // where a and b are parsers. The expression returns a composite - // parser that matches a or b but not both. One (not both) of the - // operands may be a literal char, wchar_t or a primitive string - // char const*, wchar_t const*. - // - /////////////////////////////////////////////////////////////////////////// - struct exclusive_or_parser_gen; - - template - struct exclusive_or - : public binary > > - { - typedef exclusive_or self_t; - typedef binary_parser_category parser_category_t; - typedef exclusive_or_parser_gen parser_generator_t; - typedef binary > base_t; - - exclusive_or(A const& a, B const& b) - : base_t(a, b) {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - typedef typename ScannerT::iterator_t iterator_t; - - iterator_t save = scan.first; - result_t l = this->left().parse(scan); - std::swap(save, scan.first); - result_t r = this->right().parse(scan); - - if (l ? !bool(r) : bool(r)) - { - if (l) - scan.first = save; - return l ? l : r; - } - - return scan.no_match(); - } - }; - - struct exclusive_or_parser_gen - { - template - struct result - { - typedef - exclusive_or< - typename as_parser::type - , typename as_parser::type - > - type; - }; - - template - static exclusive_or< - typename as_parser::type - , typename as_parser::type - > - generate(A const& a, B const& b) - { - return exclusive_or::type, - BOOST_DEDUCED_TYPENAME as_parser::type> - (as_parser::convert(a), as_parser::convert(b)); - } - }; - - template - exclusive_or - operator^(parser const& a, parser const& b); - - template - exclusive_or > - operator^(parser const& a, char b); - - template - exclusive_or, B> - operator^(char a, parser const& b); - - template - exclusive_or > - operator^(parser const& a, char const* b); - - template - exclusive_or, B> - operator^(char const* a, parser const& b); - - template - exclusive_or > - operator^(parser const& a, wchar_t b); - - template - exclusive_or, B> - operator^(wchar_t a, parser const& b); - - template - exclusive_or > - operator^(parser const& a, wchar_t const* b); - - template - exclusive_or, B> - operator^(wchar_t const* a, parser const& b); - -}} // namespace boost::spirit - -#endif - -#include diff --git a/boost/boost/spirit/core/composite/impl/alternative.ipp b/boost/boost/spirit/core/composite/impl/alternative.ipp deleted file mode 100644 index d03901cde2..0000000000 --- a/boost/boost/spirit/core/composite/impl/alternative.ipp +++ /dev/null @@ -1,86 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - Copyright (c) 2002 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_ALTERNATIVE_IPP) -#define BOOST_SPIRIT_ALTERNATIVE_IPP - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // alternative class implementation - // - /////////////////////////////////////////////////////////////////////////// - template - inline alternative - operator|(parser const& a, parser const& b) - { - return alternative(a.derived(), b.derived()); - } - - template - inline alternative > - operator|(parser const& a, char b) - { - return alternative >(a.derived(), b); - } - - template - inline alternative, B> - operator|(char a, parser const& b) - { - return alternative, B>(a, b.derived()); - } - - template - inline alternative > - operator|(parser const& a, char const* b) - { - return alternative >(a.derived(), b); - } - - template - inline alternative, B> - operator|(char const* a, parser const& b) - { - return alternative, B>(a, b.derived()); - } - - template - inline alternative > - operator|(parser const& a, wchar_t b) - { - return alternative >(a.derived(), b); - } - - template - inline alternative, B> - operator|(wchar_t a, parser const& b) - { - return alternative, B>(a, b.derived()); - } - - template - inline alternative > - operator|(parser const& a, wchar_t const* b) - { - return alternative >(a.derived(), b); - } - - template - inline alternative, B> - operator|(wchar_t const* a, parser const& b) - { - return alternative, B>(a, b.derived()); - } - -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/core/composite/impl/difference.ipp b/boost/boost/spirit/core/composite/impl/difference.ipp deleted file mode 100644 index 533ec343e5..0000000000 --- a/boost/boost/spirit/core/composite/impl/difference.ipp +++ /dev/null @@ -1,86 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - Copyright (c) 2002 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_DIFFERENCE_IPP) -#define BOOST_SPIRIT_DIFFERENCE_IPP - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // difference class implementation - // - /////////////////////////////////////////////////////////////////////////// - template - inline difference - operator-(parser const& a, parser const& b) - { - return difference(a.derived(), b.derived()); - } - - template - inline difference > - operator-(parser const& a, char b) - { - return difference >(a.derived(), b); - } - - template - inline difference, B> - operator-(char a, parser const& b) - { - return difference, B>(a, b.derived()); - } - - template - inline difference > - operator-(parser const& a, char const* b) - { - return difference >(a.derived(), b); - } - - template - inline difference, B> - operator-(char const* a, parser const& b) - { - return difference, B>(a, b.derived()); - } - - template - inline difference > - operator-(parser const& a, wchar_t b) - { - return difference >(a.derived(), b); - } - - template - inline difference, B> - operator-(wchar_t a, parser const& b) - { - return difference, B>(a, b.derived()); - } - - template - inline difference > - operator-(parser const& a, wchar_t const* b) - { - return difference >(a.derived(), b); - } - - template - inline difference, B> - operator-(wchar_t const* a, parser const& b) - { - return difference, B>(a, b.derived()); - } - -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/core/composite/impl/directives.ipp b/boost/boost/spirit/core/composite/impl/directives.ipp deleted file mode 100644 index 48cc1d10ed..0000000000 --- a/boost/boost/spirit/core/composite/impl/directives.ipp +++ /dev/null @@ -1,370 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - Copyright (c) 2001 Bruce Florman - Copyright (c) 2002 Raghavendra Satish - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_DIRECTIVES_IPP) -#define BOOST_SPIRIT_DIRECTIVES_IPP - -/////////////////////////////////////////////////////////////////////////////// -#include - -namespace boost { namespace spirit { - - template - struct no_skipper_iteration_policy; - - template - struct inhibit_case_iteration_policy; - - template - struct alternative; - - template - struct longest_alternative; - - template - struct shortest_alternative; - - namespace impl - { - template - inline RT - contiguous_parser_parse( - ST const& s, - ScannerT const& scan, - skipper_iteration_policy const&) - { - typedef scanner_policies< - no_skipper_iteration_policy< - BOOST_DEDUCED_TYPENAME ScannerT::iteration_policy_t>, - BOOST_DEDUCED_TYPENAME ScannerT::match_policy_t, - BOOST_DEDUCED_TYPENAME ScannerT::action_policy_t - > policies_t; - - scan.skip(scan); - RT hit = s.parse(scan.change_policies(policies_t(scan))); - // We will not do a post skip!!! - return hit; - } - - template - inline RT - contiguous_parser_parse( - ST const& s, - ScannerT const& scan, - no_skipper_iteration_policy const&) - { - return s.parse(scan); - } - - template - inline RT - contiguous_parser_parse( - ST const& s, - ScannerT const& scan, - iteration_policy const&) - { - return s.parse(scan); - } - - template < - typename RT, - typename ParserT, - typename ScannerT, - typename BaseT> - inline RT - implicit_lexeme_parse( - ParserT const& p, - ScannerT const& scan, - skipper_iteration_policy const&) - { - typedef scanner_policies< - no_skipper_iteration_policy< - BOOST_DEDUCED_TYPENAME ScannerT::iteration_policy_t>, - BOOST_DEDUCED_TYPENAME ScannerT::match_policy_t, - BOOST_DEDUCED_TYPENAME ScannerT::action_policy_t - > policies_t; - - scan.skip(scan); - RT hit = p.parse_main(scan.change_policies(policies_t(scan))); - // We will not do a post skip!!! - return hit; - } - - template < - typename RT, - typename ParserT, - typename ScannerT, - typename BaseT> - inline RT - implicit_lexeme_parse( - ParserT const& p, - ScannerT const& scan, - no_skipper_iteration_policy const&) - { - return p.parse_main(scan); - } - - template - inline RT - implicit_lexeme_parse( - ParserT const& p, - ScannerT const& scan, - iteration_policy const&) - { - return p.parse_main(scan); - } - - template - inline RT - inhibit_case_parser_parse( - ST const& s, - ScannerT const& scan, - iteration_policy const&) - { - typedef scanner_policies< - inhibit_case_iteration_policy< - BOOST_DEDUCED_TYPENAME ScannerT::iteration_policy_t>, - BOOST_DEDUCED_TYPENAME ScannerT::match_policy_t, - BOOST_DEDUCED_TYPENAME ScannerT::action_policy_t - > policies_t; - - return s.parse(scan.change_policies(policies_t(scan))); - } - - template - inline RT - inhibit_case_parser_parse( - ST const& s, - ScannerT const& scan, - inhibit_case_iteration_policy const&) - { - return s.parse(scan); - } - -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - - /////////////////////////////////////////////////////////////////////// - // - // from spirit 1.1 (copyright (c) 2001 Bruce Florman) - // various workarounds to support longest and shortest directives - // - /////////////////////////////////////////////////////////////////////// - template - struct is_alternative - { - // Determine at compile time (without partial specialization) - // whether a given type is an instance of the alternative - - static T t(); - template - static char test_(alternative const&); // no implementation - static int test_(...); // no implementation - enum { r = sizeof(char) == sizeof(test_(t())) }; - typedef mpl::bool_ value; - }; - - template struct select_to_longest; - - template - struct to_longest_alternative - { - typedef typename select_to_longest::result_t result_t; - typedef typename select_to_longest::plain_t plain_t; - typedef typename select_to_longest::choose_t choose_t; - static result_t convert(T const& a); - }; - - template - struct to_longest_generic - { - typedef T const& result_t; - typedef T plain_t; - typedef mpl::false_ choose_t; - }; - - template - inline T const& - to_longest_convert(T const& a, mpl::false_) - { return a; } - - template - struct to_longest_recursive - { - typedef typename to_longest_alternative< - typename T::left_t>::plain_t a_t; - typedef typename to_longest_alternative< - typename T::right_t>::plain_t b_t; - - typedef longest_alternative result_t; - - typedef result_t plain_t; - typedef mpl::true_ choose_t; - }; - - template - inline typename to_longest_alternative >::result_t - to_longest_convert(alternative const& alt, mpl::true_) - { - typedef typename to_longest_alternative< - alternative >::result_t result_t; - return result_t( - to_longest_alternative::convert(alt.left()), - to_longest_alternative::convert(alt.right())); - } - - template - inline typename to_longest_alternative::result_t - to_longest_alternative::convert(T const& a) - { - return to_longest_convert( - a, to_longest_alternative::choose_t()); - } - - template - struct select_to_longest - { - typedef typename mpl::if_< - is_alternative // IF - , to_longest_recursive // THEN - , to_longest_generic // ELSE - >::type type; - - typedef typename select_to_longest::type::result_t result_t; - typedef typename select_to_longest::type::plain_t plain_t; - typedef typename select_to_longest::type::choose_t choose_t; - }; - - template struct select_to_shortest; - - template - struct to_shortest_alternative - { - typedef typename select_to_shortest::result_t result_t; - typedef typename select_to_shortest::plain_t plain_t; - typedef typename select_to_shortest::choose_t choose_t; - static result_t convert(T const& a); - }; - - template - struct to_shortest_generic - { - typedef T const& result_t; - typedef T plain_t; - typedef mpl::false_ choose_t; - }; - - template - inline T const& - to_shortest_convert(T const& a, mpl::false_) { return a; } - - template - struct to_shortest_recursive - { - typedef typename to_shortest_alternative< - typename T::left_t>::plain_t a_t; - typedef typename to_shortest_alternative< - typename T::right_t>::plain_t b_t; - - typedef shortest_alternative result_t; - - typedef result_t plain_t; - typedef mpl::true_ choose_t; - }; - - template - inline typename to_shortest_alternative >::result_t - to_shortest_convert(alternative const& alt, mpl::true_) - { - typedef typename to_shortest_alternative< - alternative >::result_t result_t; - return result_t( - to_shortest_alternative::convert(alt.left()), - to_shortest_alternative::convert(alt.right())); - } - - template - inline typename to_shortest_alternative::result_t - to_shortest_alternative::convert(T const& a) - { - return to_shortest_convert( - a, to_shortest_alternative::choose_t()); - } - - template - struct select_to_shortest - { - typedef typename mpl::if_< - is_alternative // IF - , to_shortest_recursive // THEN - , to_shortest_generic // ELSE - >::type type; - - typedef typename select_to_shortest::type::result_t result_t; - typedef typename select_to_shortest::type::plain_t plain_t; - typedef typename select_to_shortest::type::choose_t choose_t; - }; -#else - template - struct to_longest_alternative - { - typedef T result_t; - static result_t const& - convert(T const& a) // Special (end) case - { return a; } - }; - - template - struct to_longest_alternative > - { - typedef typename to_longest_alternative::result_t a_t; - typedef typename to_longest_alternative::result_t b_t; - typedef longest_alternative result_t; - - static result_t - convert(alternative const& alt) // Recursive case - { - return result_t( - to_longest_alternative::convert(alt.left()), - to_longest_alternative::convert(alt.right())); - } - }; - - template - struct to_shortest_alternative - { - typedef T result_t; - static result_t const& - convert(T const& a) // Special (end) case - { return a; } - }; - - template - struct to_shortest_alternative > - { - typedef typename to_shortest_alternative::result_t a_t; - typedef typename to_shortest_alternative::result_t b_t; - typedef shortest_alternative result_t; - - static result_t - convert(alternative const& alt) // Recursive case - { - return result_t( - to_shortest_alternative::convert(alt.left()), - to_shortest_alternative::convert(alt.right())); - } - }; -#endif - } - -}} // namespace boost::spirit - -#endif - diff --git a/boost/boost/spirit/core/composite/impl/exclusive_or.ipp b/boost/boost/spirit/core/composite/impl/exclusive_or.ipp deleted file mode 100644 index 79a607dce1..0000000000 --- a/boost/boost/spirit/core/composite/impl/exclusive_or.ipp +++ /dev/null @@ -1,86 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - Copyright (c) 2002 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_EXCLUSIVE_OR_IPP) -#define BOOST_SPIRIT_EXCLUSIVE_OR_IPP - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // exclusive_or class implementation - // - /////////////////////////////////////////////////////////////////////////// - template - inline exclusive_or - operator^(parser const& a, parser const& b) - { - return exclusive_or(a.derived(), b.derived()); - } - - template - inline exclusive_or > - operator^(parser const& a, char b) - { - return exclusive_or >(a.derived(), b); - } - - template - inline exclusive_or, B> - operator^(char a, parser const& b) - { - return exclusive_or, B>(a, b.derived()); - } - - template - inline exclusive_or > - operator^(parser const& a, char const* b) - { - return exclusive_or >(a.derived(), b); - } - - template - inline exclusive_or, B> - operator^(char const* a, parser const& b) - { - return exclusive_or, B>(a, b.derived()); - } - - template - inline exclusive_or > - operator^(parser const& a, wchar_t b) - { - return exclusive_or >(a.derived(), b); - } - - template - inline exclusive_or, B> - operator^(wchar_t a, parser const& b) - { - return exclusive_or, B>(a, b.derived()); - } - - template - inline exclusive_or > - operator^(parser const& a, wchar_t const* b) - { - return exclusive_or >(a.derived(), b); - } - - template - inline exclusive_or, B> - operator^(wchar_t const* a, parser const& b) - { - return exclusive_or, B>(a, b.derived()); - } - -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/core/composite/impl/intersection.ipp b/boost/boost/spirit/core/composite/impl/intersection.ipp deleted file mode 100644 index 5f1f51b283..0000000000 --- a/boost/boost/spirit/core/composite/impl/intersection.ipp +++ /dev/null @@ -1,86 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - Copyright (c) 2002 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_INTERSECTION_IPP) -#define BOOST_SPIRIT_INTERSECTION_IPP - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // intersection class implementation - // - /////////////////////////////////////////////////////////////////////////// - template - inline intersection - operator&(parser const& a, parser const& b) - { - return intersection(a.derived(), b.derived()); - } - - template - inline intersection > - operator&(parser const& a, char b) - { - return intersection >(a.derived(), b); - } - - template - inline intersection, B> - operator&(char a, parser const& b) - { - return intersection, B>(a, b.derived()); - } - - template - inline intersection > - operator&(parser const& a, char const* b) - { - return intersection >(a.derived(), b); - } - - template - inline intersection, B> - operator&(char const* a, parser const& b) - { - return intersection, B>(a, b.derived()); - } - - template - inline intersection > - operator&(parser const& a, wchar_t b) - { - return intersection >(a.derived(), b); - } - - template - inline intersection, B> - operator&(wchar_t a, parser const& b) - { - return intersection, B>(a, b.derived()); - } - - template - inline intersection > - operator&(parser const& a, wchar_t const* b) - { - return intersection >(a.derived(), b); - } - - template - inline intersection, B> - operator&(wchar_t const* a, parser const& b) - { - return intersection, B>(a, b.derived()); - } - -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/core/composite/impl/kleene_star.ipp b/boost/boost/spirit/core/composite/impl/kleene_star.ipp deleted file mode 100644 index 1ed639fb0c..0000000000 --- a/boost/boost/spirit/core/composite/impl/kleene_star.ipp +++ /dev/null @@ -1,30 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - Copyright (c) 2002 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_KLEENE_STAR_IPP) -#define BOOST_SPIRIT_KLEENE_STAR_IPP - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // kleene_star class implementation - // - /////////////////////////////////////////////////////////////////////////// - template - inline kleene_star - operator*(parser const& a) - { - return kleene_star(a.derived()); - } - -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/core/composite/impl/list.ipp b/boost/boost/spirit/core/composite/impl/list.ipp deleted file mode 100644 index 36ecbc56fe..0000000000 --- a/boost/boost/spirit/core/composite/impl/list.ipp +++ /dev/null @@ -1,89 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - Copyright (c) 2002 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_LIST_IPP) -#define BOOST_SPIRIT_LIST_IPP - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // operator% is defined as: - // a % b ---> a >> *(b >> a) - // - /////////////////////////////////////////////////////////////////////////// - template - inline sequence > > - operator%(parser const& a, parser const& b) - { - return a.derived() >> *(b.derived() >> a.derived()); - } - - template - inline sequence, A> > > - operator%(parser const& a, char b) - { - return a.derived() >> *(b >> a.derived()); - } - - template - inline sequence, kleene_star > > > - operator%(char a, parser const& b) - { - return a >> *(b.derived() >> a); - } - - template - inline sequence, A> > > - operator%(parser const& a, char const* b) - { - return a.derived() >> *(b >> a.derived()); - } - - template - inline sequence, - kleene_star > > > - operator%(char const* a, parser const& b) - { - return a >> *(b.derived() >> a); - } - - template - inline sequence, A> > > - operator%(parser const& a, wchar_t b) - { - return a.derived() >> *(b >> a.derived()); - } - - template - inline sequence, kleene_star > > > - operator%(wchar_t a, parser const& b) - { - return a >> *(b.derived() >> a); - } - - template - inline sequence, A> > > - operator%(parser const& a, wchar_t const* b) - { - return a.derived() >> *(b >> a.derived()); - } - - template - inline sequence, - kleene_star > > > - operator%(wchar_t const* a, parser const& b) - { - return a >> *(b.derived() >> a); - } - -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/core/composite/impl/optional.ipp b/boost/boost/spirit/core/composite/impl/optional.ipp deleted file mode 100644 index 7bbe6b4065..0000000000 --- a/boost/boost/spirit/core/composite/impl/optional.ipp +++ /dev/null @@ -1,30 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - Copyright (c) 2002 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_OPTIONAL_IPP) -#define BOOST_SPIRIT_OPTIONAL_IPP - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // optional class implementation - // - /////////////////////////////////////////////////////////////////////////// - template - optional - operator!(parser const& a) - { - return optional(a.derived()); - } - -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/core/composite/impl/positive.ipp b/boost/boost/spirit/core/composite/impl/positive.ipp deleted file mode 100644 index cce8dc9746..0000000000 --- a/boost/boost/spirit/core/composite/impl/positive.ipp +++ /dev/null @@ -1,30 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - Copyright (c) 2002 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_POSITIVE_IPP) -#define BOOST_SPIRIT_POSITIVE_IPP - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // positive class implementation - // - /////////////////////////////////////////////////////////////////////////// - template - inline positive - operator+(parser const& a) - { - return positive(a.derived()); - } - -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/core/composite/impl/sequence.ipp b/boost/boost/spirit/core/composite/impl/sequence.ipp deleted file mode 100644 index 041dff0888..0000000000 --- a/boost/boost/spirit/core/composite/impl/sequence.ipp +++ /dev/null @@ -1,86 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - Copyright (c) 2002 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_SEQUENCE_IPP) -#define BOOST_SPIRIT_SEQUENCE_IPP - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // sequence class implementation - // - /////////////////////////////////////////////////////////////////////////// - template - inline sequence - operator>>(parser const& a, parser const& b) - { - return sequence(a.derived(), b.derived()); - } - - template - inline sequence > - operator>>(parser const& a, char b) - { - return sequence >(a.derived(), b); - } - - template - inline sequence, B> - operator>>(char a, parser const& b) - { - return sequence, B>(a, b.derived()); - } - - template - inline sequence > - operator>>(parser const& a, char const* b) - { - return sequence >(a.derived(), b); - } - - template - inline sequence, B> - operator>>(char const* a, parser const& b) - { - return sequence, B>(a, b.derived()); - } - - template - inline sequence > - operator>>(parser const& a, wchar_t b) - { - return sequence >(a.derived(), b); - } - - template - inline sequence, B> - operator>>(wchar_t a, parser const& b) - { - return sequence, B>(a, b.derived()); - } - - template - inline sequence > - operator>>(parser const& a, wchar_t const* b) - { - return sequence >(a.derived(), b); - } - - template - inline sequence, B> - operator>>(wchar_t const* a, parser const& b) - { - return sequence, B>(a, b.derived()); - } - -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/core/composite/impl/sequential_and.ipp b/boost/boost/spirit/core/composite/impl/sequential_and.ipp deleted file mode 100644 index 03b0904ed3..0000000000 --- a/boost/boost/spirit/core/composite/impl/sequential_and.ipp +++ /dev/null @@ -1,86 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - Copyright (c) 2002 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_SEQUENTIAL_AND_IPP) -#define BOOST_SPIRIT_SEQUENTIAL_AND_IPP - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // sequential-and operators implementation - // - /////////////////////////////////////////////////////////////////////////// - template - inline sequence - operator&&(parser const& a, parser const& b) - { - return sequence(a.derived(), b.derived()); - } - - template - inline sequence > - operator&&(parser const& a, char b) - { - return sequence >(a.derived(), b); - } - - template - inline sequence, B> - operator&&(char a, parser const& b) - { - return sequence, B>(a, b.derived()); - } - - template - inline sequence > - operator&&(parser const& a, char const* b) - { - return sequence >(a.derived(), b); - } - - template - inline sequence, B> - operator&&(char const* a, parser const& b) - { - return sequence, B>(a, b.derived()); - } - - template - inline sequence > - operator&&(parser const& a, wchar_t b) - { - return sequence >(a.derived(), b); - } - - template - inline sequence, B> - operator&&(wchar_t a, parser const& b) - { - return sequence, B>(a, b.derived()); - } - - template - inline sequence > - operator&&(parser const& a, wchar_t const* b) - { - return sequence >(a.derived(), b); - } - - template - inline sequence, B> - operator&&(wchar_t const* a, parser const& b) - { - return sequence, B>(a, b.derived()); - } - -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/core/composite/impl/sequential_or.ipp b/boost/boost/spirit/core/composite/impl/sequential_or.ipp deleted file mode 100644 index f5a41f3d39..0000000000 --- a/boost/boost/spirit/core/composite/impl/sequential_or.ipp +++ /dev/null @@ -1,86 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - Copyright (c) 2002 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_SEQUENTIAL_OR_IPP) -#define BOOST_SPIRIT_SEQUENTIAL_OR_IPP - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // sequential-or class implementation - // - /////////////////////////////////////////////////////////////////////////// - template - inline sequential_or - operator||(parser const& a, parser const& b) - { - return sequential_or(a.derived(), b.derived()); - } - - template - inline sequential_or > - operator||(parser const& a, char b) - { - return sequential_or >(a.derived(), b); - } - - template - inline sequential_or, B> - operator||(char a, parser const& b) - { - return sequential_or, B>(a, b.derived()); - } - - template - inline sequential_or > - operator||(parser const& a, char const* b) - { - return sequential_or >(a.derived(), b); - } - - template - inline sequential_or, B> - operator||(char const* a, parser const& b) - { - return sequential_or, B>(a, b.derived()); - } - - template - inline sequential_or > - operator||(parser const& a, wchar_t b) - { - return sequential_or >(a.derived(), b); - } - - template - inline sequential_or, B> - operator||(wchar_t a, parser const& b) - { - return sequential_or, B>(a, b.derived()); - } - - template - inline sequential_or > - operator||(parser const& a, wchar_t const* b) - { - return sequential_or >(a.derived(), b); - } - - template - inline sequential_or, B> - operator||(wchar_t const* a, parser const& b) - { - return sequential_or, B>(a, b.derived()); - } - -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/core/composite/intersection.hpp b/boost/boost/spirit/core/composite/intersection.hpp deleted file mode 100644 index 07fb38484c..0000000000 --- a/boost/boost/spirit/core/composite/intersection.hpp +++ /dev/null @@ -1,138 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - Copyright (c) 2002 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_INTERSECTION_HPP) -#define BOOST_SPIRIT_INTERSECTION_HPP - -#include -#include -#include -#include - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // intersection class - // - // Handles expressions of the form: - // - // a & b - // - // where a and b are parsers. The expression returns a composite - // parser that matches a and b. One (not both) of the operands may - // be a literal char, wchar_t or a primitive string char const*, - // wchar_t const*. - // - // The expression is short circuit evaluated. b is never touched - // when a is returns a no-match. - // - /////////////////////////////////////////////////////////////////////////// - struct intersection_parser_gen; - - template - struct intersection - : public binary > > - { - typedef intersection self_t; - typedef binary_parser_category parser_category_t; - typedef intersection_parser_gen parser_generator_t; - typedef binary > base_t; - - intersection(A const& a, B const& b) - : base_t(a, b) {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - typedef typename ScannerT::iterator_t iterator_t; - iterator_t save = scan.first; - if (result_t hl = this->left().parse(scan)) - { - ScannerT bscan(scan.first, scan.first, scan); - scan.first = save; - result_t hr = this->right().parse(bscan); - if (hl.length() == hr.length()) - return hl; - } - - return scan.no_match(); - } - }; - - struct intersection_parser_gen - { - template - struct result - { - typedef - intersection< - typename as_parser::type - , typename as_parser::type - > - type; - }; - - template - static intersection< - typename as_parser::type - , typename as_parser::type - > - generate(A const& a, B const& b) - { - return intersection::type, - BOOST_DEDUCED_TYPENAME as_parser::type> - (as_parser::convert(a), as_parser::convert(b)); - } - }; - - template - intersection - operator&(parser const& a, parser const& b); - - template - intersection > - operator&(parser const& a, char b); - - template - intersection, B> - operator&(char a, parser const& b); - - template - intersection > - operator&(parser const& a, char const* b); - - template - intersection, B> - operator&(char const* a, parser const& b); - - template - intersection > - operator&(parser const& a, wchar_t b); - - template - intersection, B> - operator&(wchar_t a, parser const& b); - - template - intersection > - operator&(parser const& a, wchar_t const* b); - - template - intersection, B> - operator&(wchar_t const* a, parser const& b); - -}} // namespace boost::spirit - -#endif - -#include diff --git a/boost/boost/spirit/core/composite/kleene_star.hpp b/boost/boost/spirit/core/composite/kleene_star.hpp deleted file mode 100644 index 0dc3ac5a44..0000000000 --- a/boost/boost/spirit/core/composite/kleene_star.hpp +++ /dev/null @@ -1,96 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - Copyright (c) 2002 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_KLEENE_STAR_HPP) -#define BOOST_SPIRIT_KLEENE_STAR_HPP - -#include -#include -#include -#include - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // kleene_star class - // - // Handles expressions of the form: - // - // *a - // - // where a is a parser. The expression returns a composite - // parser that matches its subject zero (0) or more times. - // - /////////////////////////////////////////////////////////////////////////// - struct kleene_star_parser_gen; - - template - struct kleene_star - : public unary > > - { - typedef kleene_star self_t; - typedef unary_parser_category parser_category_t; - typedef kleene_star_parser_gen parser_generator_t; - typedef unary > base_t; - - kleene_star(S const& a) - : base_t(a) {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - typedef typename ScannerT::iterator_t iterator_t; - result_t hit = scan.empty_match(); - - for (;;) - { - iterator_t save = scan.first; - if (result_t next = this->subject().parse(scan)) - { - scan.concat_match(hit, next); - } - else - { - scan.first = save; - return hit; - } - } - } - }; - - struct kleene_star_parser_gen - { - template - struct result - { - typedef kleene_star type; - }; - - template - static kleene_star - generate(parser const& a) - { - return kleene_star(a.derived()); - } - }; - - ////////////////////////////////// - template - kleene_star - operator*(parser const& a); - -}} // namespace boost::spirit - -#endif - -#include diff --git a/boost/boost/spirit/core/composite/list.hpp b/boost/boost/spirit/core/composite/list.hpp deleted file mode 100644 index 7e94ea0245..0000000000 --- a/boost/boost/spirit/core/composite/list.hpp +++ /dev/null @@ -1,69 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - Copyright (c) 2002 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_LIST_HPP) -#define BOOST_SPIRIT_LIST_HPP - -#include -#include -#include -#include - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // operator% is defined as: - // a % b ---> a >> *(b >> a) - // - /////////////////////////////////////////////////////////////////////////// - template - sequence > > - operator%(parser const& a, parser const& b); - - template - sequence, A> > > - operator%(parser const& a, char b); - - template - sequence, kleene_star > > > - operator%(char a, parser const& b); - - template - sequence, A> > > - operator%(parser const& a, char const* b); - - template - sequence, - kleene_star > > > - operator%(char const* a, parser const& b); - - template - sequence, A> > > - operator%(parser const& a, wchar_t b); - - template - sequence, kleene_star > > > - operator%(wchar_t a, parser const& b); - - template - sequence, A> > > - operator%(parser const& a, wchar_t const* b); - - template - sequence, - kleene_star > > > - operator%(wchar_t const* a, parser const& b); - -}} // namespace boost::spirit - -#endif - -#include diff --git a/boost/boost/spirit/core/composite/no_actions.hpp b/boost/boost/spirit/core/composite/no_actions.hpp deleted file mode 100644 index 4b5f6bc949..0000000000 --- a/boost/boost/spirit/core/composite/no_actions.hpp +++ /dev/null @@ -1,163 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2003 Vaclav Vesely - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_NO_ACTIONS_HPP) -#define BOOST_SPIRIT_NO_ACTIONS_HPP - -#include -#include -#include - -namespace boost { -namespace spirit { -//----------------------------------------------------------------------------- -// no_actions_action_policy - -template -struct no_actions_action_policy: - public BaseT -{ - typedef BaseT base_t; - - no_actions_action_policy(): - BaseT() - {} - - template - no_actions_action_policy(PolicyT const& other): - BaseT(other) - {} - - template - void - do_action( - ActorT const& actor, - AttrT& val, - IteratorT const& first, - IteratorT const& last) const - {} -}; - -//----------------------------------------------------------------------------- -// no_actions_scanner - - -namespace detail -{ - template - struct compute_no_actions_action_policy - { - typedef no_actions_action_policy type; - }; - - template - struct compute_no_actions_action_policy > - { - typedef no_actions_action_policy type; - }; -} - -template > -struct no_actions_scanner -{ - typedef scanner_policies< - typename ScannerT::iteration_policy_t, - typename ScannerT::match_policy_t, - typename detail::compute_no_actions_action_policy::type - > policies_t; - - typedef typename - rebind_scanner_policies::type type; -}; - -#if BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT > 1 - -template > -struct no_actions_scanner_list -{ - typedef - scanner_list< - ScannerT, - typename no_actions_scanner::type - > - type; -}; - -#endif // BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT > 1 - -//----------------------------------------------------------------------------- -// no_actions_parser - -struct no_actions_parser_gen; - -template -struct no_actions_parser: - public unary > > -{ - typedef no_actions_parser self_t; - typedef unary_parser_category parser_category_t; - typedef no_actions_parser_gen parser_generator_t; - typedef unary > base_t; - - template - struct result - { - typedef typename parser_result::type type; - }; - - no_actions_parser(ParserT const& p) - : base_t(p) - {} - - template - typename result::type - parse(ScannerT const& scan) const - { - typedef typename no_actions_scanner::policies_t policies_t; - - return this->subject().parse(scan.change_policies(policies_t(scan))); - } -}; - -//----------------------------------------------------------------------------- -// no_actions_parser_gen - -struct no_actions_parser_gen -{ - template - struct result - { - typedef no_actions_parser type; - }; - - template - static no_actions_parser - generate(parser const& subject) - { - return no_actions_parser(subject.derived()); - } - - template - no_actions_parser - operator[](parser const& subject) const - { - return no_actions_parser(subject.derived()); - } -}; - -//----------------------------------------------------------------------------- -// no_actions_d - -const no_actions_parser_gen no_actions_d = no_actions_parser_gen(); - -//----------------------------------------------------------------------------- -} // namespace spirit -} // namespace boost - -#endif // !defined(BOOST_SPIRIT_NO_ACTIONS_HPP) diff --git a/boost/boost/spirit/core/composite/operators.hpp b/boost/boost/spirit/core/composite/operators.hpp deleted file mode 100644 index a6563fe8e5..0000000000 --- a/boost/boost/spirit/core/composite/operators.hpp +++ /dev/null @@ -1,26 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - Copyright (c) 2002 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_OPERATORS_HPP) -#define BOOST_SPIRIT_OPERATORS_HPP - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#endif diff --git a/boost/boost/spirit/core/composite/optional.hpp b/boost/boost/spirit/core/composite/optional.hpp deleted file mode 100644 index 5018551a2e..0000000000 --- a/boost/boost/spirit/core/composite/optional.hpp +++ /dev/null @@ -1,90 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - Copyright (c) 2002 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_OPTIONAL_HPP) -#define BOOST_SPIRIT_OPTIONAL_HPP - -#include -#include -#include -#include - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // optional class - // - // Handles expressions of the form: - // - // !a - // - // where a is a parser. The expression returns a composite - // parser that matches its subject zero (0) or one (1) time. - // - /////////////////////////////////////////////////////////////////////////// - struct optional_parser_gen; - - template - struct optional - : public unary > > - { - typedef optional self_t; - typedef unary_parser_category parser_category_t; - typedef optional_parser_gen parser_generator_t; - typedef unary > base_t; - - optional(S const& a) - : base_t(a) {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - typedef typename ScannerT::iterator_t iterator_t; - iterator_t save = scan.first; - if (result_t r = this->subject().parse(scan)) - { - return r; - } - else - { - scan.first = save; - return scan.empty_match(); - } - } - }; - - struct optional_parser_gen - { - template - struct result - { - typedef optional type; - }; - - template - static optional - generate(parser const& a) - { - return optional(a.derived()); - } - }; - - template - optional - operator!(parser const& a); - -}} // namespace boost::spirit - -#endif - -#include diff --git a/boost/boost/spirit/core/composite/positive.hpp b/boost/boost/spirit/core/composite/positive.hpp deleted file mode 100644 index f108037a1c..0000000000 --- a/boost/boost/spirit/core/composite/positive.hpp +++ /dev/null @@ -1,99 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - Copyright (c) 2002 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_POSITIVE_HPP) -#define BOOST_SPIRIT_POSITIVE_HPP - -#include -#include -#include -#include - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // positive class - // - // Handles expressions of the form: - // - // +a - // - // where a is a parser. The expression returns a composite - // parser that matches its subject one (1) or more times. - // - /////////////////////////////////////////////////////////////////////////// - struct positive_parser_gen; - - template - struct positive - : public unary > > - { - typedef positive self_t; - typedef unary_parser_category parser_category_t; - typedef positive_parser_gen parser_generator_t; - typedef unary > base_t; - - positive(S const& a) - : base_t(a) {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - typedef typename ScannerT::iterator_t iterator_t; - result_t hit = this->subject().parse(scan); - - if (hit) - { - for (;;) - { - iterator_t save = scan.first; - if (result_t next = this->subject().parse(scan)) - { - scan.concat_match(hit, next); - } - else - { - scan.first = save; - break; - } - } - } - return hit; - } - }; - - struct positive_parser_gen - { - template - struct result - { - typedef positive type; - }; - - template - static positive - generate(parser const& a) - { - return positive(a.derived()); - } - }; - - template - inline positive - operator+(parser const& a); - -}} // namespace boost::spirit - -#endif - -#include diff --git a/boost/boost/spirit/core/composite/sequence.hpp b/boost/boost/spirit/core/composite/sequence.hpp deleted file mode 100644 index e600957c79..0000000000 --- a/boost/boost/spirit/core/composite/sequence.hpp +++ /dev/null @@ -1,129 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - Copyright (c) 2002 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_SEQUENCE_HPP) -#define BOOST_SPIRIT_SEQUENCE_HPP - -#include -#include -#include -#include - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // sequence class - // - // Handles expressions of the form: - // - // a >> b - // - // where a and b are parsers. The expression returns a composite - // parser that matches a and b in sequence. One (not both) of the - // operands may be a literal char, wchar_t or a primitive string - // char const*, wchar_t const*. - // - ////////////////////////////////////////////////////////////////////////// - struct sequence_parser_gen; - - template - struct sequence : public binary > > - { - typedef sequence self_t; - typedef binary_parser_category parser_category_t; - typedef sequence_parser_gen parser_generator_t; - typedef binary > base_t; - - sequence(A const& a, B const& b) - : base_t(a, b) {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - if (result_t ma = this->left().parse(scan)) - if (result_t mb = this->right().parse(scan)) - { - scan.concat_match(ma, mb); - return ma; - } - return scan.no_match(); - } - }; - - struct sequence_parser_gen - { - template - struct result - { - typedef - sequence< - typename as_parser::type - , typename as_parser::type - > - type; - }; - - template - static sequence< - typename as_parser::type - , typename as_parser::type - > - generate(A const& a, B const& b) - { - return sequence::type, - BOOST_DEDUCED_TYPENAME as_parser::type> - (as_parser::convert(a), as_parser::convert(b)); - } - }; - - template - sequence - operator>>(parser const& a, parser const& b); - - template - sequence > - operator>>(parser const& a, char b); - - template - sequence, B> - operator>>(char a, parser const& b); - - template - sequence > - operator>>(parser const& a, char const* b); - - template - sequence, B> - operator>>(char const* a, parser const& b); - - template - sequence > - operator>>(parser const& a, wchar_t b); - - template - sequence, B> - operator>>(wchar_t a, parser const& b); - - template - sequence > - operator>>(parser const& a, wchar_t const* b); - - template - sequence, B> - operator>>(wchar_t const* a, parser const& b); - -}} // namespace boost::spirit - -#endif - -#include diff --git a/boost/boost/spirit/core/composite/sequential_and.hpp b/boost/boost/spirit/core/composite/sequential_and.hpp deleted file mode 100644 index aa900e00db..0000000000 --- a/boost/boost/spirit/core/composite/sequential_and.hpp +++ /dev/null @@ -1,72 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - Copyright (c) 2002 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_SEQUENTIAL_AND_HPP) -#define BOOST_SPIRIT_SEQUENTIAL_AND_HPP - -#include -#include -#include -#include - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // sequential-and operators - // - // Handles expressions of the form: - // - // a && b - // - // Same as a >> b. - // - /////////////////////////////////////////////////////////////////////////// - template - sequence - operator&&(parser const& a, parser const& b); - - template - sequence > - operator&&(parser const& a, char b); - - template - sequence, B> - operator&&(char a, parser const& b); - - template - sequence > - operator&&(parser const& a, char const* b); - - template - sequence, B> - operator&&(char const* a, parser const& b); - - template - sequence > - operator&&(parser const& a, wchar_t b); - - template - sequence, B> - operator&&(wchar_t a, parser const& b); - - template - sequence > - operator&&(parser const& a, wchar_t const* b); - - template - sequence, B> - operator&&(wchar_t const* a, parser const& b); - -}} // namespace boost::spirit - -#endif - -#include diff --git a/boost/boost/spirit/core/composite/sequential_or.hpp b/boost/boost/spirit/core/composite/sequential_or.hpp deleted file mode 100644 index f4ba9f13d2..0000000000 --- a/boost/boost/spirit/core/composite/sequential_or.hpp +++ /dev/null @@ -1,150 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - Copyright (c) 2002 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_SEQUENTIAL_OR_HPP) -#define BOOST_SPIRIT_SEQUENTIAL_OR_HPP - -#include -#include -#include -#include - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // sequential-or class - // - // Handles expressions of the form: - // - // a || b - // - // Equivalent to - // - // a | b | a >> b; - // - // where a and b are parsers. The expression returns a composite - // parser that matches matches a or b in sequence. One (not both) of - // the operands may be a literal char, wchar_t or a primitive string - // char const*, wchar_t const*. - // - /////////////////////////////////////////////////////////////////////////// - struct sequential_or_parser_gen; - - template - struct sequential_or : public binary > > - { - typedef sequential_or self_t; - typedef binary_parser_category parser_category_t; - typedef sequential_or_parser_gen parser_generator_t; - typedef binary > base_t; - - sequential_or(A const& a, B const& b) - : base_t(a, b) {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - typedef typename ScannerT::iterator_t iterator_t; - { // scope for save - iterator_t save = scan.first; - if (result_t ma = this->left().parse(scan)) - { - save = scan.first; - if (result_t mb = this->right().parse(scan)) - { - // matched a b - scan.concat_match(ma, mb); - return ma; - } - else - { - // matched a - scan.first = save; - return ma; - } - } - scan.first = save; - } - - // matched b - return this->right().parse(scan); - } - }; - - struct sequential_or_parser_gen - { - template - struct result - { - typedef - sequential_or< - typename as_parser::type - , typename as_parser::type - > - type; - }; - - template - static sequential_or< - typename as_parser::type - , typename as_parser::type - > - generate(A const& a, B const& b) - { - return sequential_or::type, - BOOST_DEDUCED_TYPENAME as_parser::type> - (as_parser::convert(a), as_parser::convert(b)); - } - }; - - template - sequential_or - operator||(parser const& a, parser const& b); - - template - sequential_or > - operator||(parser const& a, char b); - - template - sequential_or, B> - operator||(char a, parser const& b); - - template - sequential_or > - operator||(parser const& a, char const* b); - - template - sequential_or, B> - operator||(char const* a, parser const& b); - - template - sequential_or > - operator||(parser const& a, wchar_t b); - - template - sequential_or, B> - operator||(wchar_t a, parser const& b); - - template - sequential_or > - operator||(parser const& a, wchar_t const* b); - - template - sequential_or, B> - operator||(wchar_t const* a, parser const& b); - -}} // namespace boost::spirit - -#endif - -#include diff --git a/boost/boost/spirit/core/config.hpp b/boost/boost/spirit/core/config.hpp deleted file mode 100644 index 62a98412e7..0000000000 --- a/boost/boost/spirit/core/config.hpp +++ /dev/null @@ -1,63 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_CONFIG_HPP) -#define BOOST_SPIRIT_CONFIG_HPP - -#include - -/////////////////////////////////////////////////////////////////////////////// -// -// Compiler check: -// -// Historically, Spirit supported a lot of compilers, including (to some -// extent) poorly conforming compilers such as VC6. Spirit v1.6.x will be -// the last release that will support older poorly conforming compilers. -// Starting from Spirit v1.8.0, ill conforming compilers will not be -// supported. If you are still using one of these older compilers, you can -// still use Spirit v1.6.x. -// -// The reason why Spirit v1.6.x worked on old non-conforming compilers is -// that the authors laboriously took the trouble of searching for -// workarounds to make these compilers happy. The process takes a lot of -// time and energy, especially when one encounters the dreaded ICE or -// "Internal Compiler Error". Sometimes searching for a single workaround -// takes days or even weeks. Sometimes, there are no known workarounds. This -// stifles progress a lot. And, as the library gets more progressive and -// takes on more advanced C++ techniques, the difficulty is escalated to -// even new heights. -// -// Spirit v1.6.x will still be supported. Maintenance and bug fixes will -// still be applied. There will still be active development for the back- -// porting of new features introduced in Spirit v1.8.0 (and Spirit 1.9.0) -// to lesser able compilers; hopefully, fueled by contributions from the -// community. For instance, there is already a working AST tree back-port -// for VC6 and VC7 by Peder Holt. -// -// If you got here somehow, your compiler is known to be poorly conforming -// WRT ANSI/ISO C++ standard. Library implementers get a bad reputation when -// someone attempts to compile the code on a non-conforming compiler. She'll -// be confronted with tons of compiler errors when she tries to compile the -// library. Such errors will somehow make less informed users conclude that -// the code is poorly written. It's better for the user to see a message -// "sorry, this code has not been ported to your compiler yet", than to see -// pages and pages of compiler error messages. -// -///////////////////////////////////////////////////////////////////////////////// -#if (defined(BOOST_MSVC) && (BOOST_MSVC < 1310)) \ - || (defined(__BORLANDC__) && (__BORLANDC__ <= 0x570)) \ - || (defined(__GNUC__) && (__GNUC__ < 3)) \ - || (defined(__GNUC__) && (__GNUC__ == 3) && (__GNUC_MINOR__ < 1)) -# error "Compiler not supported. See note in " -#else -// Pass... Compiler supported. -#endif - -#endif - - diff --git a/boost/boost/spirit/core/impl/match.ipp b/boost/boost/spirit/core/impl/match.ipp deleted file mode 100644 index f30f9f83e9..0000000000 --- a/boost/boost/spirit/core/impl/match.ipp +++ /dev/null @@ -1,109 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_MATCH_IPP) -#define BOOST_SPIRIT_MATCH_IPP -#include - -namespace boost { namespace spirit -{ - template - inline match::match() - : len(-1), val() {} - - template - inline match::match(std::size_t length) - : len(length), val() {} - - template - inline match::match(std::size_t length, ctor_param_t val_) - : len(length), val(val_) {} - - template - inline bool - match::operator!() const - { - return len < 0; - } - - template - inline std::ptrdiff_t - match::length() const - { - return len; - } - - template - inline bool - match::has_valid_attribute() const - { - return val.is_initialized(); - } - - template - inline typename match::return_t - match::value() const - { - BOOST_SPIRIT_ASSERT(val.is_initialized()); - return *val; - } - - template - inline void - match::swap(match& other) - { - std::swap(len, other.len); - std::swap(val, other.val); - } - - inline match::match() - : len(-1) {} - - inline match::match(std::size_t length) - : len(length) {} - - inline match::match(std::size_t length, nil_t) - : len(length) {} - - inline bool - match::operator!() const - { - return len < 0; - } - - inline bool - match::has_valid_attribute() const - { - return false; - } - - inline std::ptrdiff_t - match::length() const - { - return len; - } - - inline nil_t - match::value() const - { - return nil_t(); - } - - inline void - match::value(nil_t) {} - - inline void - match::swap(match& other) - { - std::swap(len, other.len); - } - -}} // namespace boost::spirit - -#endif - diff --git a/boost/boost/spirit/core/impl/match_attr_traits.ipp b/boost/boost/spirit/core/impl/match_attr_traits.ipp deleted file mode 100644 index c6398b5664..0000000000 --- a/boost/boost/spirit/core/impl/match_attr_traits.ipp +++ /dev/null @@ -1,94 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_MATCH_ATTR_TRAITS_IPP) -#define BOOST_SPIRIT_MATCH_ATTR_TRAITS_IPP - -#include -#include -#include -#include -#include - -namespace boost { namespace spirit { namespace impl -{ - template - struct match_attr_traits - { - typedef typename - boost::optional::reference_const_type - const_reference; - - // case where src *IS* convertible to T (dest) - template - static void - convert(boost::optional& dest, T2 const& src, mpl::true_) - { - dest.reset(src); - } - - // case where src *IS NOT* convertible to T (dest) - template - static void - convert(boost::optional& dest, T2 const& /*src*/, mpl::false_) - { - dest.reset(); - } - - static void - convert(boost::optional& dest, nil_t/*src*/) - { - dest.reset(); - } - - template - static void - convert(boost::optional& dest, T2 const& src) - { - convert(dest, src, is_convertible()); - } - - template - static void - copy(boost::optional& dest, OtherMatchT const& src) - { - if (src.has_valid_attribute()) - convert(dest, src.value()); - } - - template - static void - assign(boost::optional& dest, OtherMatchT const& src) - { - if (src.has_valid_attribute()) - convert(dest, src.value()); - else - dest.reset(); - } - - // T is not reference - template - static void - set_value(boost::optional& dest, ValueT const& val, mpl::false_) - { - dest.reset(val); - } - - // T is a reference - template - static void - set_value(boost::optional& dest, ValueT const& val, mpl::true_) - { - dest.get() = val; - } - }; - -}}} // namespace boost::spirit::impl - -#endif - diff --git a/boost/boost/spirit/core/impl/parser.ipp b/boost/boost/spirit/core/impl/parser.ipp deleted file mode 100644 index 3f5a372243..0000000000 --- a/boost/boost/spirit/core/impl/parser.ipp +++ /dev/null @@ -1,51 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_PARSER_IPP) -#define BOOST_SPIRIT_PARSER_IPP - -namespace boost { namespace spirit -{ - /////////////////////////////////////////////////////////////////////////// - // - // Generic parse function implementation - // - /////////////////////////////////////////////////////////////////////////// - template - inline parse_info - parse( - IteratorT const& first_ - , IteratorT const& last - , parser const& p) - { - IteratorT first = first_; - scanner > scan(first, last); - match hit = p.derived().parse(scan); - return parse_info( - first, hit, hit && (first == last), hit.length()); - } - - /////////////////////////////////////////////////////////////////////////// - // - // Parse function for null terminated strings implementation - // - /////////////////////////////////////////////////////////////////////////// - template - inline parse_info - parse(CharT const* str, parser const& p) - { - CharT const* last = str; - while (*last) - last++; - return parse(str, last, p); - } - -}} // namespace boost::spirit - -#endif - diff --git a/boost/boost/spirit/core/match.hpp b/boost/boost/spirit/core/match.hpp deleted file mode 100644 index 741cc025d4..0000000000 --- a/boost/boost/spirit/core/match.hpp +++ /dev/null @@ -1,181 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_MATCH_HPP) -#define BOOST_SPIRIT_MATCH_HPP - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -namespace boost { namespace spirit -{ - /////////////////////////////////////////////////////////////////////////// - // - // match class - // - // The match holds the result of a parser. A match object evaluates - // to true when a successful match is found, otherwise false. The - // length of the match is the number of characters (or tokens) that - // is successfully matched. This can be queried through its length() - // member function. A negative value means that the match is - // unsucessful. - // - // Each parser may have an associated attribute. This attribute is - // also returned back to the client on a successful parse through - // the match object. The match's value() member function returns the - // match's attribute. - // - // A match attribute is valid: - // - // * on a successful match - // * when its value is set through the value(val) member function - // * if it is assigned or copied from a compatible match object - // (e.g. match from match) with a valid attribute. - // - // The match attribute is undefined: - // - // * on an unsuccessful match - // * when an attempt to copy or assign from another match object - // with an incompatible attribute type (e.g. match - // from match). - // - // The member function has_valid_attribute() can be queried to know if - // it is safe to get the match's attribute. The attribute may be set - // through the member function value(v) where v is the new attribute - // value. - // - /////////////////////////////////////////////////////////////////////////// - template - class match : public safe_bool > - { - - public: - - typedef typename boost::optional optional_type; - typedef typename optional_type::argument_type ctor_param_t; - typedef typename optional_type::reference_const_type return_t; - typedef T attr_t; - - match(); - explicit match(std::size_t length); - match(std::size_t length, ctor_param_t val); - - bool operator!() const; - std::ptrdiff_t length() const; - bool has_valid_attribute() const; - return_t value() const; - void swap(match& other); - - template - match(match const& other) - : len(other.length()), val() - { - impl::match_attr_traits::copy(val, other); - } - - template - match& - operator=(match const& other) - { - impl::match_attr_traits::assign(val, other); - len = other.length(); - return *this; - } - - template - void - concat(MatchT const& other) - { - BOOST_SPIRIT_ASSERT(*this && other); - len += other.length(); - } - - template - void - value(ValueT const& val_) - { - impl::match_attr_traits::set_value(val, val_, is_reference()); - } - - bool operator_bool() const - { - return len >= 0; - } - - private: - - std::ptrdiff_t len; - optional_type val; - }; - - /////////////////////////////////////////////////////////////////////////// - // - // match class specialization for nil_t values - // - /////////////////////////////////////////////////////////////////////////// - template <> - class match : public safe_bool > - { - public: - - typedef nil_t attr_t; - typedef nil_t return_t; - - match(); - explicit match(std::size_t length); - match(std::size_t length, nil_t); - - bool operator!() const; - bool has_valid_attribute() const; - std::ptrdiff_t length() const; - nil_t value() const; - void value(nil_t); - void swap(match& other); - - template - match(match const& other) - : len(other.length()) {} - - template - match<>& - operator=(match const& other) - { - len = other.length(); - return *this; - } - - template - void - concat(match const& other) - { - BOOST_SPIRIT_ASSERT(*this && other); - len += other.length(); - } - - bool operator_bool() const - { - return len >= 0; - } - - private: - - std::ptrdiff_t len; - }; - -}} // namespace boost::spirit - -#endif -#include - diff --git a/boost/boost/spirit/core/nil.hpp b/boost/boost/spirit/core/nil.hpp deleted file mode 100644 index 2b61851a15..0000000000 --- a/boost/boost/spirit/core/nil.hpp +++ /dev/null @@ -1,19 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_NIL_HPP) -#define BOOST_SPIRIT_NIL_HPP - -namespace boost { namespace spirit -{ - struct nil_t {}; -}} - -#endif - - diff --git a/boost/boost/spirit/core/non_terminal/grammar.hpp b/boost/boost/spirit/core/non_terminal/grammar.hpp deleted file mode 100644 index a43382d04d..0000000000 --- a/boost/boost/spirit/core/non_terminal/grammar.hpp +++ /dev/null @@ -1,81 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - Copyright (c) 2002-2003 Martin Wille - Copyright (c) 2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_GRAMMAR_HPP) -#define BOOST_SPIRIT_GRAMMAR_HPP - -/////////////////////////////////////////////////////////////////////////////// -#if defined(BOOST_SPIRIT_THREADSAFE) && defined(BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE) -#undef BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE -#endif - -#include -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -/////////////////////////////////////////////////////////////////////////////// -// -// grammar class -// -/////////////////////////////////////////////////////////////////////////////// -template > -struct grammar - : public parser - , public ContextT::base_t - , public context_aux - BOOST_SPIRIT_GRAMMAR_ID -{ - typedef grammar self_t; - typedef DerivedT const& embed_t; - typedef typename ContextT::context_linker_t context_t; - typedef typename context_t::attr_t attr_t; - - template - struct result - { - typedef typename match_result::type type; - }; - - grammar() {} - ~grammar() { impl::grammar_destruct(this); } - - template - typename parser_result::type - parse_main(ScannerT const& scan) const - { return impl::grammar_parser_parse<0>(this, scan); } - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - typedef parser_scanner_linker scanner_t; - BOOST_SPIRIT_CONTEXT_PARSE(scan, *this, scanner_t, context_t, result_t) - } - - template - impl::entry_grammar - use_parser() const - { return impl::entry_grammar( this->derived()); } - - BOOST_SPIRIT_GRAMMAR_STATE -}; - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#undef BOOST_SPIRIT_GRAMMAR_ID -#undef BOOST_SPIRIT_GRAMMAR_ACCESS -#undef BOOST_SPIRIT_GRAMMAR_STATE -#endif - diff --git a/boost/boost/spirit/core/non_terminal/impl/grammar.ipp b/boost/boost/spirit/core/non_terminal/impl/grammar.ipp deleted file mode 100644 index 6811260661..0000000000 --- a/boost/boost/spirit/core/non_terminal/impl/grammar.ipp +++ /dev/null @@ -1,388 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - Copyright (c) 2002-2003 Martin Wille - Copyright (c) 2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined BOOST_SPIRIT_GRAMMAR_IPP -#define BOOST_SPIRIT_GRAMMAR_IPP - -#if !defined(BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE) -#include -#include -#include -#include // for std::auto_ptr -#include -#endif - -#ifdef BOOST_SPIRIT_THREADSAFE -#include -#include -#endif - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -template -struct grammar; - -#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300) - -BOOST_SPIRIT_DEPENDENT_TEMPLATE_WRAPPER(grammar_definition_wrapper, definition); - -////////////////////////////////// -template -struct grammar_definition -{ - typedef typename impl::grammar_definition_wrapper - ::template result_::param_t type; -}; - -#else - -////////////////////////////////// -template -struct grammar_definition -{ - typedef typename GrammarT::template definition type; -}; - -#endif - - namespace impl - { - -#if !defined(BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE) - struct grammar_tag {}; - - ////////////////////////////////// - template - struct grammar_helper_base - { - virtual int undefine(GrammarT *) = 0; - virtual ~grammar_helper_base() {} - }; - - ////////////////////////////////// - template - struct grammar_helper_list - { - typedef GrammarT grammar_t; - typedef grammar_helper_base helper_t; - typedef std::vector vector_t; - - grammar_helper_list() {} - grammar_helper_list(grammar_helper_list const& /*x*/) - { // Does _not_ copy the helpers member ! - } - - grammar_helper_list& operator=(grammar_helper_list const& x) - { // Does _not_ copy the helpers member ! - return *this; - } - - void push_back(helper_t *helper) - { helpers.push_back(helper); } - - void pop_back() - { helpers.pop_back(); } - - typename vector_t::size_type - size() const - { return helpers.size(); } - - typename vector_t::reverse_iterator - rbegin() - { return helpers.rbegin(); } - - typename vector_t::reverse_iterator - rend() - { return helpers.rend(); } - -#ifdef BOOST_SPIRIT_THREADSAFE - boost::mutex & mutex() - { return m; } -#endif - - private: - - vector_t helpers; -#ifdef BOOST_SPIRIT_THREADSAFE - boost::mutex m; -#endif - }; - - ////////////////////////////////// - struct grammartract_helper_list; - -#if !defined(BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE) \ - && (!defined(__GNUC__) || (__GNUC__ > 2)) - - struct grammartract_helper_list - { - template - static grammar_helper_list& - do_(GrammarT const* g) - { - return g->helpers; - } - }; - -#endif - - ////////////////////////////////// - template - struct grammar_helper : private grammar_helper_base - { - typedef GrammarT grammar_t; - typedef ScannerT scanner_t; - typedef DerivedT derived_t; - typedef typename grammar_definition::type definition_t; - - typedef grammar_helper helper_t; - typedef boost::shared_ptr helper_ptr_t; - typedef boost::weak_ptr helper_weak_ptr_t; - - grammar_helper* - this_() { return this; } - - grammar_helper(helper_weak_ptr_t& p) - : definitions_cnt(0) - , self(this_()) - { p = self; } - - definition_t& - define(grammar_t const* target_grammar) - { - grammar_helper_list &helpers = -#if !defined(__GNUC__) || (__GNUC__ > 2) - grammartract_helper_list::do_(target_grammar); -#else - target_grammar->helpers; -#endif - typename grammar_t::object_id id = target_grammar->get_object_id(); - - if (definitions.size()<=id) - definitions.resize(id*3/2+1); - if (definitions[id]!=0) - return *definitions[id]; - - std::auto_ptr - result(new definition_t(target_grammar->derived())); - -#ifdef BOOST_SPIRIT_THREADSAFE - boost::mutex::scoped_lock lock(helpers.mutex()); -#endif - helpers.push_back(this); - - ++definitions_cnt; - definitions[id] = result.get(); - return *(result.release()); - } - - int - undefine(grammar_t* target_grammar) - { - typename grammar_t::object_id id = target_grammar->get_object_id(); - - if (definitions.size()<=id) - return 0; - delete definitions[id]; - definitions[id] = 0; - if (--definitions_cnt==0) - self.reset(); - return 0; - } - - private: - - std::vector definitions; - unsigned long definitions_cnt; - helper_ptr_t self; - }; - -#endif /* defined(BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE) */ - - template - inline typename DerivedT::template definition & - get_definition(grammar const* self) - { -#if defined(BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE) - - typedef typename DerivedT::template definition definition_t; - static definition_t def(self->derived()); - return def; -#else - typedef grammar self_t; - typedef impl::grammar_helper helper_t; - typedef typename helper_t::helper_weak_ptr_t ptr_t; - -# ifdef BOOST_SPIRIT_THREADSAFE - static boost::thread_specific_ptr tld_helper; - if (!tld_helper.get()) - tld_helper.reset(new ptr_t); - ptr_t &helper = *tld_helper; -# else - static ptr_t helper; -# endif - if (!boost::make_shared(helper).get()) - new helper_t(helper); - return boost::make_shared(helper)->define(self); -#endif - } - -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - template - struct call_helper { - - template - static void - do_ (RT &result, DefinitionT &def, ScannerT const &scan) - { - result = def.template get_start_parser()->parse(scan); - } - }; -#else - // The grammar_def stuff isn't supported for compilers, which do not - // support partial template specialization - template struct call_helper; -#endif - - template <> - struct call_helper<0> { - - template - static void - do_ (RT &result, DefinitionT &def, ScannerT const &scan) - { - result = def.start().parse(scan); - } - }; - - ////////////////////////////////// - template - inline typename parser_result, ScannerT>::type - grammar_parser_parse( - grammar const* self, - ScannerT const &scan) - { - typedef - typename parser_result, ScannerT>::type - result_t; - typedef typename DerivedT::template definition definition_t; - - result_t result; - definition_t &def = get_definition(self); - - call_helper::do_(result, def, scan); - return result; - } - - ////////////////////////////////// - template - inline void - grammar_destruct(GrammarT* self) - { -#if !defined(BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE) - typedef impl::grammar_helper_base helper_base_t; - typedef grammar_helper_list helper_list_t; - typedef typename helper_list_t::vector_t::reverse_iterator iterator_t; - - helper_list_t& helpers = -# if !defined(__GNUC__) || (__GNUC__ > 2) - grammartract_helper_list::do_(self); -# else - self->helpers; -# endif - -# if (defined(BOOST_MSVC) && (BOOST_MSVC < 1300)) \ - || defined(BOOST_INTEL_CXX_VERSION) - for (iterator_t i = helpers.rbegin(); i != helpers.rend(); ++i) - (*i)->undefine(self); -# else - std::for_each(helpers.rbegin(), helpers.rend(), - std::bind2nd(std::mem_fun(&helper_base_t::undefine), self)); -# endif - -#else - (void)self; -#endif - } - - /////////////////////////////////////////////////////////////////////////// - // - // entry_grammar class - // - /////////////////////////////////////////////////////////////////////////// - template - class entry_grammar - : public parser > - { - - public: - typedef entry_grammar self_t; - typedef self_t embed_t; - typedef typename ContextT::context_linker_t context_t; - typedef typename context_t::attr_t attr_t; - - template - struct result - { - typedef typename match_result::type type; - }; - - entry_grammar(DerivedT const &p) : target_grammar(p) {} - - template - typename parser_result::type - parse_main(ScannerT const& scan) const - { return impl::grammar_parser_parse(&target_grammar, scan); } - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - typedef parser_scanner_linker scanner_t; - BOOST_SPIRIT_CONTEXT_PARSE(scan, target_grammar, scanner_t, - context_t, result_t) - } - - private: - DerivedT const &target_grammar; - }; - - } // namespace impl - -/////////////////////////////////////// -#if !defined(BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE) -#define BOOST_SPIRIT_GRAMMAR_ID , public impl::object_with_id -#else -#define BOOST_SPIRIT_GRAMMAR_ID -#endif - -/////////////////////////////////////// -#if !defined(__GNUC__) || (__GNUC__ > 2) -#define BOOST_SPIRIT_GRAMMAR_ACCESS private: -#else -#define BOOST_SPIRIT_GRAMMAR_ACCESS -#endif - -/////////////////////////////////////// -#if !defined(BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE) -#define BOOST_SPIRIT_GRAMMAR_STATE \ - BOOST_SPIRIT_GRAMMAR_ACCESS \ - friend struct impl::grammartract_helper_list; \ - mutable impl::grammar_helper_list helpers; -#else -#define BOOST_SPIRIT_GRAMMAR_STATE -#endif - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/core/non_terminal/impl/object_with_id.ipp b/boost/boost/spirit/core/non_terminal/impl/object_with_id.ipp deleted file mode 100644 index e3624f0fd0..0000000000 --- a/boost/boost/spirit/core/non_terminal/impl/object_with_id.ipp +++ /dev/null @@ -1,185 +0,0 @@ -/*============================================================================= - Copyright (c) 2002-2003 Joel de Guzman - Copyright (c) 2002-2003 Martin Wille - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined BOOST_SPIRIT_OBJECT_WITH_ID_IPP -#define BOOST_SPIRIT_OBJECT_WITH_ID_IPP - -#include -#include - -#ifdef BOOST_SPIRIT_THREADSAFE -#include -#include -#endif - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - - namespace impl { - - ////////////////////////////////// - template - struct object_with_id_base_supply - { - typedef IdT object_id; - typedef std::vector id_vector; - - object_with_id_base_supply() : max_id(object_id()) {} - -#ifdef BOOST_SPIRIT_THREADSAFE - boost::mutex mutex; -#endif - object_id max_id; - id_vector free_ids; - - object_id acquire(); - void release(object_id); - }; - - ////////////////////////////////// - template - struct object_with_id_base - { - typedef TagT tag_t; - typedef IdT object_id; - - protected: - - object_id acquire_object_id(); - void release_object_id(object_id); - - private: -#ifdef BOOST_SPIRIT_THREADSAFE - static boost::mutex &mutex_instance(); - static void mutex_init(); -#endif - - boost::shared_ptr > id_supply; - }; - - ////////////////////////////////// - template - struct object_with_id : private object_with_id_base - { - typedef object_with_id self_t; - typedef object_with_id_base base_t; - typedef IdT object_id; - - object_with_id() : id(base_t::acquire_object_id()) {} - object_with_id(self_t const &other) - : base_t(other) - , id(base_t::acquire_object_id()) - {} // don't copy id - self_t &operator = (self_t const &other) - { // don't assign id - base_t::operator=(other); - return *this; - } - ~object_with_id() { base_t::release_object_id(id); } - object_id get_object_id() const { return id; } - - private: - - object_id const id; - }; - - ////////////////////////////////// - template - inline IdT - object_with_id_base_supply::acquire() - { -#ifdef BOOST_SPIRIT_THREADSAFE - boost::mutex::scoped_lock lock(mutex); -#endif - if (free_ids.size()) - { - object_id id = *free_ids.rbegin(); - free_ids.pop_back(); - return id; - } - else - { - if (free_ids.capacity()<=max_id) - free_ids.reserve(max_id*3/2+1); - return ++max_id; - } - } - - ////////////////////////////////// - template - inline void - object_with_id_base_supply::release(IdT id) - { -#ifdef BOOST_SPIRIT_THREADSAFE - boost::mutex::scoped_lock lock(mutex); -#endif - if (max_id == id) - max_id--; - else - free_ids.push_back(id); // doesn't throw - } - - ////////////////////////////////// - template - inline IdT - object_with_id_base::acquire_object_id() - { - { -#ifdef BOOST_SPIRIT_THREADSAFE - static boost::once_flag been_here = BOOST_ONCE_INIT; - boost::call_once(mutex_init, been_here); - boost::mutex &mutex = mutex_instance(); - boost::mutex::scoped_lock lock(mutex); -#endif - static boost::shared_ptr > - static_supply; - - if (!static_supply.get()) - static_supply.reset(new object_with_id_base_supply()); - id_supply = static_supply; - } - - return id_supply->acquire(); - } - - ////////////////////////////////// - template - inline void - object_with_id_base::release_object_id(IdT id) - { - id_supply->release(id); - } - - ////////////////////////////////// -#ifdef BOOST_SPIRIT_THREADSAFE - template - inline boost::mutex & - object_with_id_base::mutex_instance() - { - static boost::mutex mutex; - return mutex; - } -#endif - - ////////////////////////////////// -#ifdef BOOST_SPIRIT_THREADSAFE - template - inline void - object_with_id_base::mutex_init() - { - mutex_instance(); - } -#endif - - } // namespace impl - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/core/non_terminal/impl/rule.ipp b/boost/boost/spirit/core/non_terminal/impl/rule.ipp deleted file mode 100644 index ee9ed2c154..0000000000 --- a/boost/boost/spirit/core/non_terminal/impl/rule.ipp +++ /dev/null @@ -1,407 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_RULE_IPP) -#define BOOST_SPIRIT_RULE_IPP - -#if BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT > 1 -#include -#include -#include -#include -#include -#include -#include -#endif - -#include -#include -#include -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -#if BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT > 1 - - template < - BOOST_PP_ENUM_BINARY_PARAMS( - BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT, - typename ScannerT, = mpl::void_ BOOST_PP_INTERCEPT - ) - > - struct scanner_list; - -#endif // BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT > 1 - - /////////////////////////////////////////////////////////////////////////// - namespace impl - { - template - struct get_param - { - typedef typename mpl::if_< - is_base_and_derived - , T0 - , typename mpl::if_< - is_base_and_derived - , T1 - , typename mpl::if_< - is_base_and_derived - , T2 - , DefaultT - >::type - >::type - >::type type; - }; - - template - struct get_context - { - typedef typename get_param< - parser_context_base, parser_context<>, T0, T1, T2>::type - type; - }; - - template - struct get_tag - { - typedef typename get_param< - parser_tag_base, parser_address_tag, T0, T1, T2>::type - type; - }; - - template - struct get_scanner - { - typedef typename get_param< - scanner_base, scanner<>, T0, T1, T2>::type - type; - }; - - /////////////////////////////////////////////////////////////////////// - // - // rule_base class - // - // The rule_base class implements the basic plumbing for rules - // minus the storage mechanism. It is up to the derived class - // to actually store the definition somewhere. The rule_base - // class assumes that the derived class provides a get() function - // that will return a pointer to a parser. The get() function - // may return NULL. See rule below for details. - // - // <<< For framework use only. Not for public consumption. >>> - // - /////////////////////////////////////////////////////////////////////// - template < - typename DerivedT // derived class - , typename EmbedT // how derived class is embedded - , typename T0 = nil_t // see rule class - , typename T1 = nil_t // see rule class - , typename T2 = nil_t // see rule class - > - class rule_base; // forward declaration - - class rule_base_access - { -#if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) \ - || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551)) - public: // YUCK! -#else - template < - typename DerivedT - , typename EmbedT - , typename T0 - , typename T1 - , typename T2 - > - friend class rule_base; -#endif - template - static typename RuleT::abstract_parser_t* - get(RuleT const& r) - { - return r.get(); - } - }; - - template < - typename DerivedT // derived class - , typename EmbedT // how derived class is embedded - , typename T0 // see rule class - , typename T1 // see rule class - , typename T2 // see rule class - > - class rule_base - : public parser - , public impl::get_context::type::base_t - , public context_aux< - typename impl::get_context::type, DerivedT> - , public impl::get_tag::type - { - public: - - typedef typename impl::get_scanner::type scanner_t; - typedef typename impl::get_context::type context_t; - typedef typename impl::get_tag::type tag_t; - - typedef EmbedT embed_t; - typedef typename context_t::context_linker_t linked_context_t; - typedef typename linked_context_t::attr_t attr_t; - - template - struct result - { - typedef typename match_result::type type; - }; - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef parser_scanner_linker linked_scanner_t; - typedef typename parser_result::type result_t; - BOOST_SPIRIT_CONTEXT_PARSE( - scan, *this, linked_scanner_t, linked_context_t, result_t); - } - - template - typename parser_result::type - parse_main(ScannerT const& scan) const - { - typename parser_result::type hit; - - // MWCW 8.3 needs this cast to be done through a pointer, - // not a reference. Otherwise, it will silently construct - // a temporary, causing an infinite runtime recursion. - DerivedT const* derived_this = static_cast(this); - - if (rule_base_access::get(*derived_this)) - { - typename ScannerT::iterator_t s(scan.first); - hit = rule_base_access::get(*derived_this) - ->do_parse_virtual(scan); - scan.group_match(hit, this->id(), s, scan.first); - } - else - { - hit = scan.no_match(); - } - return hit; - } - }; - - /////////////////////////////////////////////////////////////////////// - // - // abstract_parser class - // - /////////////////////////////////////////////////////////////////////// - template - struct abstract_parser - { - abstract_parser() {} - virtual ~abstract_parser() {} - - virtual typename match_result::type - do_parse_virtual(ScannerT const& scan) const = 0; - - virtual abstract_parser* - clone() const = 0; - }; - - /////////////////////////////////////////////////////////////////////// - // - // concrete_parser class - // - /////////////////////////////////////////////////////////////////////// - template - struct concrete_parser : abstract_parser - { - concrete_parser(ParserT const& p) : p(p) {} - virtual ~concrete_parser() {} - - virtual typename match_result::type - do_parse_virtual(ScannerT const& scan) const - { - return p.parse(scan); - } - - virtual abstract_parser* - clone() const - { - return new concrete_parser(p); - } - - typename ParserT::embed_t p; - }; - -#if BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT > 1 - - /////////////////////////////////////////////////////////////////////// - // - // This generates partial specializations for the class - // - // abstract_parser - // - // with an increasing number of different ScannerT template parameters - // and corresponding do_parse_virtual function declarations for each - // of the different required scanner types: - // - // template - // struct abstract_parser, AttrT> - // { - // abstract_parser() {} - // virtual ~abstract_parser() {} - // - // virtual typename match_result::type - // do_parse_virtual(ScannerT0 const &scan) const = 0; - // - // virtual abstract_parser* - // clone() const = 0; - // - // ... - // }; - // - /////////////////////////////////////////////////////////////////////// - #define BOOST_SPIRIT_RULE_ENUM_DOPARSE_A(z, N, _) \ - virtual typename match_result< \ - BOOST_PP_CAT(ScannerT, N), AttrT \ - >::type \ - do_parse_virtual( \ - BOOST_PP_CAT(ScannerT, N) const& scan) const = 0; \ - - #define BOOST_SPIRIT_ENUM_ABSTRACT_PARSERS(z, N, _) \ - template < \ - BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_INC(N), typename ScannerT), \ - typename AttrT \ - > \ - struct abstract_parser< \ - scanner_list< \ - BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_INC(N), ScannerT) \ - >, \ - AttrT \ - > \ - { \ - abstract_parser() {} \ - virtual ~abstract_parser() {} \ - \ - BOOST_PP_REPEAT_ ## z( \ - BOOST_PP_INC(N), BOOST_SPIRIT_RULE_ENUM_DOPARSE_A, _) \ - \ - virtual abstract_parser* \ - clone() const = 0; \ - }; \ - - BOOST_PP_REPEAT_FROM_TO(1, BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT, - BOOST_SPIRIT_ENUM_ABSTRACT_PARSERS, _) - - #undef BOOST_SPIRIT_RULE_ENUM_DOPARSE_A - #undef BOOST_SPIRIT_ENUM_ABSTRACT_PARSERS - /////////////////////////////////////////////////////////////////////// - - /////////////////////////////////////////////////////////////////////// - // - // This generates partial specializations for the class - // - // concrete_parser - // - // with an increasing number of different ScannerT template parameters - // and corresponding do_parse_virtual function declarations for each - // of the different required scanner types: - // - // template < - // typename ParserT, typename ScannerT0, ..., typename AttrT - // > - // struct concrete_parser< - // ParserT, scanner_list, AttrT - // > - // : public abstract_parser, AttrT> - // { - // concrete_parser(ParserT const& p_) : p(p_) {} - // virtual ~concrete_parser() {} - // - // virtual typename match_result::type - // do_parse_virtual(ScannerT0 const &scan) const - // { return p.parse(scan); } - // - // virtual abstract_parser, AttrT>* - // clone() const - // { - // return new concrete_parser(p); - // } - // - // ... - // - // typename ParserT::embed_t p; - // }; - // - /////////////////////////////////////////////////////////////////////// - #define BOOST_SPIRIT_RULE_ENUM_DOPARSE_C(z, N, _) \ - virtual typename match_result< \ - BOOST_PP_CAT(ScannerT, N), AttrT \ - >::type \ - do_parse_virtual( \ - BOOST_PP_CAT(ScannerT, N) const& scan) const \ - { return p.parse(scan); } \ - - #define BOOST_SPIRIT_ENUM_CONCRETE_PARSERS(z, N, _) \ - template < \ - typename ParserT, \ - BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_INC(N), typename ScannerT), \ - typename AttrT \ - > \ - struct concrete_parser< \ - ParserT, \ - scanner_list< \ - BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_INC(N), ScannerT) \ - >, \ - AttrT \ - > \ - : abstract_parser< \ - scanner_list< \ - BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_INC(N), ScannerT) \ - >, \ - AttrT \ - > \ - { \ - concrete_parser(ParserT const& p_) : p(p_) {} \ - virtual ~concrete_parser() {} \ - \ - BOOST_PP_REPEAT_ ## z( \ - BOOST_PP_INC(N), BOOST_SPIRIT_RULE_ENUM_DOPARSE_C, _) \ - \ - virtual abstract_parser< \ - scanner_list< \ - BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_INC(N), ScannerT) \ - >, \ - AttrT \ - >* \ - clone() const \ - { \ - return new concrete_parser(p); \ - } \ - \ - typename ParserT::embed_t p; \ - }; \ - - BOOST_PP_REPEAT_FROM_TO(1, BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT, - BOOST_SPIRIT_ENUM_CONCRETE_PARSERS, _) - - #undef BOOST_SPIRIT_ENUM_CONCRETE_PARSERS - #undef BOOST_SPIRIT_RULE_ENUM_DOPARSE_C - /////////////////////////////////////////////////////////////////////// - -#endif // BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT > 1 - - } // namespace impl - -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/core/non_terminal/impl/subrule.ipp b/boost/boost/spirit/core/non_terminal/impl/subrule.ipp deleted file mode 100644 index a194d4fbae..0000000000 --- a/boost/boost/spirit/core/non_terminal/impl/subrule.ipp +++ /dev/null @@ -1,205 +0,0 @@ -/*============================================================================= - Copyright (c) 2002-2003 Joel de Guzman - Copyright (c) 2002-2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_SUBRULE_IPP) -#define BOOST_SPIRIT_SUBRULE_IPP - -namespace boost { namespace spirit { - - template - struct subrule_list; - - template - struct subrule_parser; - - namespace impl { - - #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - - template - struct get_subrule; - - template - struct get_subrule_chooser - { - static ListT t(); - static char test(nil_t); - static int test(...); - - // Set value to - // 0: ListT is empty - // 1: ListT's first item has same ID - // 2: ListT's first item has a different ID - - enum - { - id = ListT::first_t::id, - is_same_id = N == id, - is_nil_t = sizeof(char) == sizeof(test(t())), - value = is_nil_t ? 0 : (is_same_id ? 1 : 2) - }; - }; - - template - struct subrule_chooser; - - template <> - struct subrule_chooser<0> - { - // First case. ListT is empty - - template - struct result - { typedef nil_t type; }; - }; - - template <> - struct subrule_chooser<1> - { - // Second case. ListT is non-empty and the list's - // first item has the ID we are looking for. - - template - struct result - { typedef typename ListT::first_t::def_t type; }; - }; - - template <> - struct subrule_chooser<2> - { - // Third case. ListT is non-empty but the list's - // first item does not have the ID we are looking for. - - template - struct result - { typedef typename get_subrule::type type; }; - }; - - template - struct get_subrule - { - enum { n = get_subrule_chooser::value }; - typedef typename subrule_chooser::template - result::type type; - }; - - #else - - template - struct get_subrule - { - // First case. ListT is non-empty but the list's - // first item does not have the ID we are looking for. - - typedef typename get_subrule::type type; - }; - - template - struct get_subrule< - ID, - subrule_list< - subrule_parser, - RestT> > - { - // Second case. ListT is non-empty and the list's - // first item has the ID we are looking for. - - typedef DefT type; - }; - - template - struct get_subrule - { - // Third case. ListT is empty - typedef nil_t type; - }; - - #endif - - template - struct get_result_t { - - // If the result type dictated by the context is nil_t (no closures - // present), then the whole subrule_parser return type is equal to - // the return type of the right hand side of this subrule_parser, - // otherwise it is equal to the dictated return value. - - typedef typename mpl::if_< - boost::is_same, T2, T1 - >::type type; - }; - - template - struct get_subrule_result - { - typedef typename - impl::get_subrule::type - parser_t; - - typedef typename parser_result::type - def_result_t; - - typedef typename match_result::type - context_result_t; - - typedef typename get_result_t::type - type; - }; - - template - struct get_subrule_parser_result - { - typedef typename parser_result::type - def_result_t; - - typedef typename match_result::type - context_result_t; - - typedef typename get_result_t::type - type; - }; - - template - struct same_subrule_id - { - BOOST_STATIC_CONSTANT(bool, value = (SubruleT::id == ID)); - }; - - template - struct parse_subrule - { - template - static void - do_parse(RT& r, ScannerT const& scan, ListT const& list, mpl::true_) - { - r = list.first.rhs.parse(scan); - } - - template - static void - do_parse(RT& r, ScannerT const& scan, ListT const& list, mpl::false_) - { - typedef typename ListT::rest_t::first_t subrule_t; - mpl::bool_::value> same_id; - do_parse(r, scan, list.rest, same_id); - } - - static void - do_(RT& r, ScannerT const& scan) - { - typedef typename ScannerT::list_t::first_t subrule_t; - mpl::bool_::value> same_id; - do_parse(r, scan, scan.list, same_id); - } - }; - -}}} // namespace boost::spirit::impl - -#endif - diff --git a/boost/boost/spirit/core/non_terminal/parser_context.hpp b/boost/boost/spirit/core/non_terminal/parser_context.hpp deleted file mode 100644 index 4c9662fc77..0000000000 --- a/boost/boost/spirit/core/non_terminal/parser_context.hpp +++ /dev/null @@ -1,147 +0,0 @@ -/*============================================================================= - Copyright (c) 2002-2003 Joel de Guzman - Copyright (c) 2002-2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_PARSER_CONTEXT_HPP) -#define BOOST_SPIRIT_PARSER_CONTEXT_HPP - -/////////////////////////////////////////////////////////////////////////////// -namespace boost -{ - namespace spirit - { - - /////////////////////////////////////////////////////////////////////////// - // - // default_parser_context_base class { default context base } - // - /////////////////////////////////////////////////////////////////////////// - struct default_parser_context_base - { - template - struct aux {}; - }; - - /////////////////////////////////////////////////////////////////////////// - // - // parser_context_base class { base class of all context classes } - // - /////////////////////////////////////////////////////////////////////////// - struct parser_context_base {}; - - /////////////////////////////////////////////////////////////////////////// - // - // parser_context class { default context } - // - /////////////////////////////////////////////////////////////////////////// - struct nil_t; - template struct parser_context_linker; - - template - struct parser_context : parser_context_base - { - typedef AttrT attr_t; - typedef default_parser_context_base base_t; - typedef parser_context_linker > context_linker_t; - - template - parser_context(ParserT const&) {} - - template - void - pre_parse(ParserT const&, ScannerT const&) {} - - template - ResultT& - post_parse(ResultT& hit, ParserT const&, ScannerT const&) - { return hit; } - }; - - /////////////////////////////////////////////////////////////////////////// - // - // context_aux class - // - // context_aux is a class derived from the - // ContextT's nested base_t::base template class. (see - // default_parser_context_base::aux for an example). - // - // Basically, this class provides ContextT dependent optional - // functionality to the derived class DerivedT through the CRTP - // idiom (Curiously recurring template pattern). - // - /////////////////////////////////////////////////////////////////////////// - template - struct context_aux : public ContextT::base_t::template aux {}; - - /////////////////////////////////////////////////////////////////////////// - // - // parser_scanner_linker and parser_scanner_linker classes - // { helper templates for the rule extensibility } - // - // This classes can be 'overloaded' (defined elsewhere), to plug - // in additional functionality into the non-terminal parsing process. - // - /////////////////////////////////////////////////////////////////////////// - #if !defined(BOOST_SPIRIT_PARSER_SCANNER_LINKER_DEFINED) - #define BOOST_SPIRIT_PARSER_SCANNER_LINKER_DEFINED - - template - struct parser_scanner_linker : public ScannerT - { - parser_scanner_linker(ScannerT const scan_) : ScannerT(scan_) {} - }; - - #endif // !defined(BOOST_SPIRIT_PARSER_SCANNER_LINKER_DEFINED) - - ////////////////////////////////// - #if !defined(BOOST_SPIRIT_PARSER_CONTEXT_LINKER_DEFINED) - #define BOOST_SPIRIT_PARSER_CONTEXT_LINKER_DEFINED - - template - struct parser_context_linker : public ContextT - { - template - parser_context_linker(ParserT const& p) - : ContextT(p) {} - - template - void pre_parse(ParserT const& p, ScannerT const& scan) - { ContextT::pre_parse(p, scan); } - - template - ResultT& - post_parse(ResultT& hit, ParserT const& p, ScannerT const& scan) - { return ContextT::post_parse(hit, p, scan); } - }; - - #endif // !defined(BOOST_SPIRIT_PARSER_CONTEXT_LINKER_DEFINED) - - /////////////////////////////////////////////////////////////////////////// - // - // BOOST_SPIRIT_CONTEXT_PARSE helper macro - // - // The original implementation uses a template class. However, we - // need to lessen the template instantiation depth to help inferior - // compilers that sometimes choke on deep template instantiations. - // The objective is to avoid code redundancy. A macro, in this case - // is an obvious solution. Sigh! - // - // WARNING: INTERNAL USE ONLY. NOT FOR PUBLIC CONSUMPTION. - // - /////////////////////////////////////////////////////////////////////////// - #define BOOST_SPIRIT_CONTEXT_PARSE(scan, this_, scanner_t, context_t, result_t) \ - scanner_t scan_wrap(scan); \ - context_t context_wrap(this_); \ - context_wrap.pre_parse(this_, scan_wrap); \ - result_t hit = parse_main(scan); \ - return context_wrap.post_parse(hit, this_, scan_wrap); - - } // namespace spirit -} // namespace boost - -#endif diff --git a/boost/boost/spirit/core/non_terminal/parser_id.hpp b/boost/boost/spirit/core/non_terminal/parser_id.hpp deleted file mode 100644 index 25bccb848c..0000000000 --- a/boost/boost/spirit/core/non_terminal/parser_id.hpp +++ /dev/null @@ -1,118 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - Copyright (c) 2001 Daniel Nuffer - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_PARSER_ID_HPP) -#define BOOST_SPIRIT_PARSER_ID_HPP - -#if defined(BOOST_SPIRIT_DEBUG) -# include -#endif - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // parser_id class - // - /////////////////////////////////////////////////////////////////////////// - class parser_id - { - public: - parser_id() : p(0) {} - explicit parser_id(void const* prule) : p(prule) {} - parser_id(std::size_t l_) : l(l_) {} - - bool operator==(parser_id const& x) const { return p == x.p; } - bool operator!=(parser_id const& x) const { return !(*this == x); } - bool operator<(parser_id const& x) const { return p < x.p; } - std::size_t to_long() const { return l; } - - private: - - union - { - void const* p; - std::size_t l; - }; - }; - - #if defined(BOOST_SPIRIT_DEBUG) - inline std::ostream& - operator<<(std::ostream& out, parser_id const& rid) - { - out << rid.to_long(); - return out; - } - #endif - - /////////////////////////////////////////////////////////////////////////// - // - // parser_tag_base class: base class of all parser tags - // - /////////////////////////////////////////////////////////////////////////// - struct parser_tag_base {}; - - /////////////////////////////////////////////////////////////////////////// - // - // parser_address_tag class: tags a parser with its address - // - /////////////////////////////////////////////////////////////////////////// - struct parser_address_tag : parser_tag_base - { - parser_id id() const - { return parser_id(reinterpret_cast(this)); } - }; - - /////////////////////////////////////////////////////////////////////////// - // - // parser_tag class: tags a parser with an integer ID - // - /////////////////////////////////////////////////////////////////////////// - template - struct parser_tag : parser_tag_base - { - static parser_id id() - { return parser_id(std::size_t(N)); } - }; - - /////////////////////////////////////////////////////////////////////////// - // - // dynamic_parser_tag class: tags a parser with a dynamically changeable - // integer ID - // - /////////////////////////////////////////////////////////////////////////// - class dynamic_parser_tag : public parser_tag_base - { - public: - - dynamic_parser_tag() - : tag(std::size_t(0)) {} - - parser_id - id() const - { - return - tag.to_long() - ? tag - : parser_id(reinterpret_cast(this)); - } - - void set_id(parser_id id) { tag = id; } - - private: - - parser_id tag; - }; - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#endif - diff --git a/boost/boost/spirit/core/non_terminal/rule.hpp b/boost/boost/spirit/core/non_terminal/rule.hpp deleted file mode 100644 index 001e5cd3bf..0000000000 --- a/boost/boost/spirit/core/non_terminal/rule.hpp +++ /dev/null @@ -1,168 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_RULE_HPP) -#define BOOST_SPIRIT_RULE_HPP - -#include - -/////////////////////////////////////////////////////////////////////////////// -// -// Spirit predefined maximum number of simultaneously usable different -// scanner types. -// -// This limit defines the maximum number of of possible different scanner -// types for which a specific rule<> may be used. If this isn't defined, a -// rule<> may be used with one scanner type only (multiple scanner support -// is disabled). -// -/////////////////////////////////////////////////////////////////////////////// -#if !defined(BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT) -# define BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT 1 -#endif - -// Ensure a meaningful maximum number of simultaneously usable scanner types -BOOST_STATIC_ASSERT(BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT > 0); - -#include -#include - -#if BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT > 1 -# include -#endif - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -#if BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT > 1 - - /////////////////////////////////////////////////////////////////////////// - // - // scanner_list (a fake scanner) - // - // Typically, rules are tied to a specific scanner type and - // a particular rule cannot be used with anything else. Sometimes - // there's a need for rules that can accept more than one scanner - // type. The scanner_list can be used as a template - // parameter to the rule class to specify up to the number of - // scanner types defined by the BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT - // constant. Example: - // - // rule > r; - // - // *** This feature is available only to compilers that support - // partial template specialization. *** - // - /////////////////////////////////////////////////////////////////////////// - template < - BOOST_PP_ENUM_PARAMS( - BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT, - typename ScannerT - ) - > - struct scanner_list : scanner_base {}; - -#endif - - /////////////////////////////////////////////////////////////////////////// - // - // rule class - // - // The rule is a polymorphic parser that acts as a named place- - // holder capturing the behavior of an EBNF expression assigned to - // it. - // - // The rule is a template class parameterized by: - // - // 1) scanner (scanner_t, see scanner.hpp), - // 2) the rule's context (context_t, see parser_context.hpp) - // 3) an arbitrary tag (tag_t, see parser_id.hpp) that allows - // a rule to be tagged for identification. - // - // These template parameters may be specified in any order. The - // scanner will default to scanner<> when it is not specified. - // The context will default to parser_context when not specified. - // The tag will default to parser_address_tag when not specified. - // - // The definition of the rule (its right hand side, RHS) held by - // the rule through a scoped_ptr. When a rule is seen in the RHS - // of an assignment or copy construction EBNF expression, the rule - // is held by the LHS rule by reference. - // - /////////////////////////////////////////////////////////////////////////// - template < - typename T0 = nil_t - , typename T1 = nil_t - , typename T2 = nil_t - > - class rule - : public impl::rule_base< - rule - , rule const& - , T0, T1, T2> - { - public: - - typedef rule self_t; - typedef impl::rule_base< - self_t - , self_t const& - , T0, T1, T2> - base_t; - - typedef typename base_t::scanner_t scanner_t; - typedef typename base_t::attr_t attr_t; - typedef impl::abstract_parser abstract_parser_t; - - rule() : ptr() {} - ~rule() {} - - rule(rule const& r) - : ptr(new impl::concrete_parser(r)) {} - - template - rule(ParserT const& p) - : ptr(new impl::concrete_parser(p)) {} - - template - rule& operator=(ParserT const& p) - { - ptr.reset(new impl::concrete_parser(p)); - return *this; - } - - rule& operator=(rule const& r) - { - ptr.reset(new impl::concrete_parser(r)); - return *this; - } - - rule - copy() const - { - return rule(ptr.get() ? ptr->clone() : 0); - } - - private: - friend class impl::rule_base_access; - - abstract_parser_t* - get() const - { - return ptr.get(); - } - - rule(abstract_parser_t const* ptr) - : ptr(ptr) {} - - scoped_ptr ptr; - }; - -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/core/non_terminal/subrule.hpp b/boost/boost/spirit/core/non_terminal/subrule.hpp deleted file mode 100644 index 7509d204e9..0000000000 --- a/boost/boost/spirit/core/non_terminal/subrule.hpp +++ /dev/null @@ -1,296 +0,0 @@ -/*============================================================================= - Copyright (c) 2002-2003 Joel de Guzman - Copyright (c) 2002-2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_SUBRULE_HPP) -#define BOOST_SPIRIT_SUBRULE_HPP - -#include -#include - -#include -#include - -#include -#include - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // subrules_scanner class - // - /////////////////////////////////////////////////////////////////////////// - template - struct subrules_scanner : public ScannerT - { - typedef ScannerT scanner_t; - typedef ListT list_t; - typedef subrules_scanner self_t; - - subrules_scanner(ScannerT const& scan, ListT const& list_) - : ScannerT(scan), list(list_) {} - - template - struct rebind_policies - { - typedef typename rebind_scanner_policies::type - rebind_scanner; - typedef subrules_scanner type; - }; - - template - subrules_scanner< - typename rebind_scanner_policies::type, - ListT> - change_policies(PoliciesT const& policies) const - { - typedef subrules_scanner< - BOOST_DEDUCED_TYPENAME - rebind_scanner_policies::type, - ListT> - subrules_scanner_t; - - return subrules_scanner_t( - ScannerT::change_policies(policies), - list); - } - - template - struct rebind_iterator - { - typedef typename rebind_scanner_iterator::type - rebind_scanner; - typedef subrules_scanner type; - }; - - template - subrules_scanner< - typename rebind_scanner_iterator::type, - ListT> - change_iterator(IteratorT const& first, IteratorT const &last) const - { - typedef subrules_scanner< - BOOST_DEDUCED_TYPENAME - rebind_scanner_iterator::type, - ListT> - subrules_scanner_t; - - return subrules_scanner_t( - ScannerT::change_iterator(first, last), - list); - } - - ListT const& list; - }; - - /////////////////////////////////////////////////////////////////////////// - // - // subrule_scanner type computer class - // - // This computer ensures that the scanner will not be recursively - // instantiated if it's not needed. - // - /////////////////////////////////////////////////////////////////////////// - template - struct subrules_scanner_finder - { - typedef subrules_scanner type; - }; - - template - struct subrules_scanner_finder, ListT> - { - typedef subrules_scanner type; - }; - - /////////////////////////////////////////////////////////////////////////// - // - // subrule_list class - // - /////////////////////////////////////////////////////////////////////////// - template - struct subrule_list : public parser > - { - typedef subrule_list self_t; - typedef FirstT first_t; - typedef RestT rest_t; - - subrule_list(FirstT const& first_, RestT const& rest_) - : first(first_), rest(rest_) {} - - template - struct result - { - typedef typename parser_result::type type; - }; - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename subrules_scanner_finder::type - subrules_scanner_t; - subrules_scanner_t g_arg(scan, *this); - return first.start.parse(g_arg); - } - - template - subrule_list< - FirstT, - subrule_list< - subrule_parser, - RestT> > - operator,(subrule_parser const& rhs) - { - return subrule_list< - FirstT, - subrule_list< - subrule_parser, - RestT> >( - first, - subrule_list< - subrule_parser, - RestT>(rhs, rest)); - } - - FirstT first; - RestT rest; - }; - - /////////////////////////////////////////////////////////////////////////// - // - // subrule_parser class - // - /////////////////////////////////////////////////////////////////////////// - template - struct subrule_parser - : public parser > - { - typedef subrule_parser self_t; - typedef subrule subrule_t; - typedef DefT def_t; - - BOOST_STATIC_CONSTANT(int, id = ID); - - template - struct result - { - typedef typename - impl::get_subrule_parser_result< - DefT, ScannerT, typename subrule_t::attr_t>::type type; - }; - - subrule_parser(subrule_t const& start_, DefT const& rhs_) - : rhs(rhs_), start(start_) {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - // This will only be called when parsing single subrules. - typedef subrule_list list_t; - typedef subrules_scanner scanner_t; - - list_t list(*this, nil_t()); - scanner_t g_arg(scan, list); - return start.parse(g_arg); - } - - template - inline subrule_list< - self_t, - subrule_list< - subrule_parser, - nil_t> > - operator,(subrule_parser const& rhs) const - { - return subrule_list< - self_t, - subrule_list< - subrule_parser, - nil_t> >( - *this, - subrule_list< - subrule_parser, nil_t>( - rhs, nil_t())); - } - - typename DefT::embed_t rhs; - subrule_t const& start; - }; - - /////////////////////////////////////////////////////////////////////////// - // - // subrule class - // - /////////////////////////////////////////////////////////////////////////// - template - struct subrule - : public parser > - , public ContextT::base_t - , public context_aux > - { - typedef subrule self_t; - typedef subrule const& embed_t; - - typedef typename ContextT::context_linker_t context_t; - typedef typename context_t::attr_t attr_t; - - BOOST_STATIC_CONSTANT(int, id = ID); - - template - struct result - { - typedef typename - impl::get_subrule_result::type type; - }; - - template - typename parser_result::type - parse_main(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - result_t result; - impl::parse_subrule:: - do_(result, scan); - return result; - } - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - typedef parser_scanner_linker scanner_t; - BOOST_SPIRIT_CONTEXT_PARSE( - scan, *this, scanner_t, context_t, result_t); - } - - template - subrule_parser - operator=(parser const& rhs) const - { - return subrule_parser(*this, rhs.derived()); - } - - private: - - // assignment of subrules is not allowed. Use subrules - // with identical IDs if you want to have aliases. - - subrule& operator=(subrule const&); - - template - subrule& operator=(subrule const&); - }; - -}} // namespace boost::spirit - -#endif - diff --git a/boost/boost/spirit/core/parser.hpp b/boost/boost/spirit/core/parser.hpp deleted file mode 100644 index 6b0a616b39..0000000000 --- a/boost/boost/spirit/core/parser.hpp +++ /dev/null @@ -1,219 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_PARSER_HPP) -#define BOOST_SPIRIT_PARSER_HPP - -#include -#include -#include -#include - -namespace boost { namespace spirit -{ - template - class action; // forward declaration - - /////////////////////////////////////////////////////////////////////////// - // - // Parser categories - // - // Helper template classes to distinguish different types of - // parsers. The following categories are the most generic. More - // specific types may inherit from these. Each parser has a typedef - // parser_category_t that defines its category. By default, if one - // is not specified, it will inherit from the base parser class - // which typedefs its parser_category_t as plain_parser_category. - // - // - plain parser has nothing special - // - binary parser has subject a and b (e.g. alternative) - // - unary parser has single subject (e.g. kleene star) - // - action parser has an attached action parser - // - /////////////////////////////////////////////////////////////////////////// - struct plain_parser_category {}; - struct binary_parser_category : plain_parser_category {}; - struct unary_parser_category : plain_parser_category {}; - struct action_parser_category : unary_parser_category {}; - - /////////////////////////////////////////////////////////////////////////// - // - // parser_result metafunction - // - // Given a scanner type ScannerT and a parser type ParserT, the - // parser_result metafunction provides the actual result of the - // parser. - // - // Usage: - // - // typename parser_result::type - // - /////////////////////////////////////////////////////////////////////////// - template - struct parser_result - { - typedef typename boost::remove_reference::type parser_type; - typedef typename parser_type::template result::type type; - }; - - /////////////////////////////////////////////////////////////////////////// - // - // parser class - // - // This class is a protocol base class for all parsers. This is - // essentially an interface contract. The parser class does not - // really know how to parse anything but instead relies on the - // template parameter DerivedT (which obviously is assumed to be a - // subclass) to do the actual parsing. - // - // Concrete sub-classes inheriting from parser must have a - // corresponding member function parse(...) compatible with the - // conceptual Interface: - // - // template - // RT parse(ScannerT const& scan) const; - // - // where RT is the desired return type of the parser and ScannerT - // scan is the scanner (see scanner.hpp). - // - // Concrete sub-classes inheriting from parser in most cases need to - // have a nested meta-function result that returns the result type - // of the parser's parse member function, given a scanner type. The - // meta-function has the form: - // - // template - // struct result - // { - // typedef RT type; - // }; - // - // where RT is the desired return type of the parser. This is - // usually, but not always, dependent on the template parameter - // ScannerT. If a parser does not supply a result metafunction, a - // default is provided by the base parser class. - // - // The parser's derived() member function returns a reference to the - // parser as its derived object. - // - // An operator[] is provided. The operator returns a semantic action - // handler (see actions.hpp). - // - // Each parser has a typedef embed_t. This typedef specifies how a - // parser is embedded in a composite (see composite.hpp). By - // default, if one is not specified, the parser will be embedded by - // value. That is, a copy of the parser is placed as a member - // variable of the composite. Most parsers are embedded by value. In - // certain situations however, this is not desirable or possible. - // - /////////////////////////////////////////////////////////////////////////// - template - struct parser - { - typedef DerivedT embed_t; - typedef DerivedT derived_t; - typedef plain_parser_category parser_category_t; - - template - struct result - { - typedef typename match_result::type type; - }; - - DerivedT& derived() - { - return *static_cast(this); - } - - DerivedT const& derived() const - { - return *static_cast(this); - } - - template - action - operator[](ActionT const& actor) const - { - return action(derived(), actor); - } - }; - - /////////////////////////////////////////////////////////////////////////// - // - // parse_info - // - // Results returned by the free parse functions: - // - // stop: points to the final parse position (i.e parsing - // processed the input up to this point). - // - // hit: true if parsing is successful. This may be full: - // the parser consumed all the input, or partial: - // the parser consumed only a portion of the input. - // - // full: true when we have a full hit (i.e the parser - // consumed all the input. - // - // length: The number of characters consumed by the parser. - // This is valid only if we have a successful hit - // (either partial or full). - // - /////////////////////////////////////////////////////////////////////////// - template - struct parse_info - { - IteratorT stop; - bool hit; - bool full; - std::size_t length; - - parse_info( - IteratorT const& stop_ = IteratorT(), - bool hit_ = false, - bool full_ = false, - std::size_t length_ = 0) - : stop(stop_) - , hit(hit_) - , full(full_) - , length(length_) {} - - template - parse_info(ParseInfoT const& pi) - : stop(pi.stop) - , hit(pi.hit) - , full(pi.full) - , length(pi.length) {} - }; - - /////////////////////////////////////////////////////////////////////////// - // - // Generic parse function - // - /////////////////////////////////////////////////////////////////////////// - template - parse_info - parse( - IteratorT const& first, - IteratorT const& last, - parser const& p); - - /////////////////////////////////////////////////////////////////////////// - // - // Parse function for null terminated strings - // - /////////////////////////////////////////////////////////////////////////// - template - parse_info - parse( - CharT const* str, - parser const& p); - -}} // namespace boost::spirit - -#endif - -#include diff --git a/boost/boost/spirit/core/primitives/impl/numerics.ipp b/boost/boost/spirit/core/primitives/impl/numerics.ipp deleted file mode 100644 index 144011f4f0..0000000000 --- a/boost/boost/spirit/core/primitives/impl/numerics.ipp +++ /dev/null @@ -1,531 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001-2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_NUMERICS_IPP -#define BOOST_SPIRIT_NUMERICS_IPP - -#include - -#if defined(BOOST_NO_STDC_NAMESPACE) -# define BOOST_SPIRIT_IMPL_STD_NS -#else -# define BOOST_SPIRIT_IMPL_STD_NS std -#endif - -namespace boost { namespace spirit { - - struct sign_parser; // forward declaration only - - namespace impl - { - /////////////////////////////////////////////////////////////////////// - // - // Extract the prefix sign (- or +) - // - /////////////////////////////////////////////////////////////////////// - template - bool - extract_sign(ScannerT const& scan, std::size_t& count) - { - // Extract the sign - count = 0; - bool neg = *scan == '-'; - if (neg || (*scan == '+')) - { - ++scan; - ++count; - return neg; - } - - return false; - } - - /////////////////////////////////////////////////////////////////////// - // - // Traits class for radix specific number conversion - // - // Test the validity of a single character: - // - // template static bool is_valid(CharT ch); - // - // Convert a digit from character representation to binary - // representation: - // - // template static int digit(CharT ch); - // - /////////////////////////////////////////////////////////////////////// - template - struct radix_traits; - - ////////////////////////////////// Binary - template<> - struct radix_traits<2> - { - template - static bool is_valid(CharT ch) - { - return ('0' == ch || '1' == ch); - } - - template - static int digit(CharT ch) - { - return ch - '0'; - } - }; - - ////////////////////////////////// Octal - template<> - struct radix_traits<8> - { - template - static bool is_valid(CharT ch) - { - return ('0' <= ch && ch <= '7'); - } - - template - static int digit(CharT ch) - { - return ch - '0'; - } - }; - - ////////////////////////////////// Decimal - template<> - struct radix_traits<10> - { - template - static bool is_valid(CharT ch) - { - return impl::isdigit_(ch); - } - - template - static int digit(CharT ch) - { - return ch - '0'; - } - }; - - ////////////////////////////////// Hexadecimal - template<> - struct radix_traits<16> - { - template - static bool is_valid(CharT ch) - { - return impl::isxdigit_(ch); - } - - template - static int digit(CharT ch) - { - if (impl::isdigit_(ch)) - return ch - '0'; - return impl::tolower_(ch) - 'a' + 10; - } - }; - - /////////////////////////////////////////////////////////////////////// - // - // Helper templates for encapsulation of radix specific - // conversion of an input string to an integral value. - // - // main entry point: - // - // extract_int - // ::f(first, last, n, count); - // - // The template parameter Radix represents the radix of the - // number contained in the parsed string. The template - // parameter MinDigits specifies the minimum digits to - // accept. The template parameter MaxDigits specifies the - // maximum digits to parse. A -1 value for MaxDigits will - // make it parse an arbitrarilly large number as long as the - // numeric type can hold it. Accumulate is either - // positive_accumulate (default) for parsing positive - // numbers or negative_accumulate otherwise. - // - // scan.first and scan.last are iterators as usual (i.e. - // first is mutable and is moved forward when a match is - // found), n is a variable that holds the number (passed by - // reference). The number of parsed characters is added to - // count (also passed by reference) - // - // NOTE: - // Returns a non-match, if the number to parse - // overflows (or underflows) the used integral type. - // Overflow (or underflow) is detected when an - // operation wraps a value from its maximum to its - // minimum (or vice-versa). For example, overflow - // occurs when the result of the expression n * x is - // less than n (assuming n is positive and x is - // greater than 1). - // - // BEWARE: - // the parameters 'n' and 'count' should be properly - // initialized before calling this function. - // - /////////////////////////////////////////////////////////////////////// - template - struct positive_accumulate - { - // Use this accumulator if number is positive - - template - static bool check(T const& n, T const& prev) - { - return n < prev; - } - - template - static void add(T& n, CharT ch) - { - n += radix_traits::digit(ch); - } - }; - - template - struct negative_accumulate - { - // Use this accumulator if number is negative - - template - static bool check(T const& n, T const& prev) - { - return n > prev; - } - - template - static void add(T& n, CharT ch) - { - n -= radix_traits::digit(ch); - } - }; - - template - struct extract_int_base - { - // Common code for extract_int specializations - template - static bool - f(ScannerT& scan, T& n) - { - T prev = n; - n *= Radix; - if (Accumulate::check(n, prev)) - return false; // over/underflow! - prev = n; - Accumulate::add(n, *scan); - if (Accumulate::check(n, prev)) - return false; // over/underflow! - return true; - } - }; - - template - struct extract_int_ - { - template < - int Radix, - unsigned MinDigits, - int MaxDigits, - typename Accumulate - > - struct apply - { - typedef extract_int_base base; - typedef radix_traits check; - - template - static bool - f(ScannerT& scan, T& n, std::size_t& count) - { - std::size_t i = 0; - for (; (i < MaxDigits) && !scan.at_end() - && check::is_valid(*scan); - ++i, ++scan, ++count) - { - if (!base::f(scan, n)) - return false; // over/underflow! - } - return i >= MinDigits; - } - }; - }; - - template <> - struct extract_int_ - { - template < - int Radix, - unsigned MinDigits, - int MaxDigits, - typename Accumulate - > - struct apply - { - typedef extract_int_base base; - typedef radix_traits check; - - template - static bool - f(ScannerT& scan, T& n, std::size_t& count) - { - std::size_t i = 0; - for (; !scan.at_end() && check::is_valid(*scan); - ++i, ++scan, ++count) - { - if (!base::f(scan, n)) - return false; // over/underflow! - } - return i >= MinDigits; - } - }; - }; - - ////////////////////////////////// - template < - int Radix, unsigned MinDigits, int MaxDigits, - typename Accumulate = positive_accumulate - > - struct extract_int - { - template - static bool - f(ScannerT& scan, T& n, std::size_t& count) - { - typedef typename extract_int_<(MaxDigits >= 0)>::template - apply extractor; - return extractor::f(scan, n, count); - } - }; - - /////////////////////////////////////////////////////////////////////// - // - // uint_parser_impl class - // - /////////////////////////////////////////////////////////////////////// - template < - typename T = unsigned, - int Radix = 10, - unsigned MinDigits = 1, - int MaxDigits = -1 - > - struct uint_parser_impl - : parser > - { - typedef uint_parser_impl self_t; - - template - struct result - { - typedef typename match_result::type type; - }; - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - if (!scan.at_end()) - { - T n = 0; - std::size_t count = 0; - typename ScannerT::iterator_t save = scan.first; - if (extract_int:: - f(scan, n, count)) - { - return scan.create_match(count, n, save, scan.first); - } - // return no-match if number overflows - } - return scan.no_match(); - } - }; - - /////////////////////////////////////////////////////////////////////// - // - // int_parser_impl class - // - /////////////////////////////////////////////////////////////////////// - template < - typename T = unsigned, - int Radix = 10, - unsigned MinDigits = 1, - int MaxDigits = -1 - > - struct int_parser_impl - : parser > - { - typedef int_parser_impl self_t; - - template - struct result - { - typedef typename match_result::type type; - }; - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef extract_int > extract_int_neg_t; - typedef extract_int - extract_int_pos_t; - - if (!scan.at_end()) - { - T n = 0; - std::size_t count = 0; - typename ScannerT::iterator_t save = scan.first; - - bool hit = impl::extract_sign(scan, count); - - if (hit) - hit = extract_int_neg_t::f(scan, n, count); - else - hit = extract_int_pos_t::f(scan, n, count); - - if (hit) - return scan.create_match(count, n, save, scan.first); - else - scan.first = save; - // return no-match if number overflows or underflows - } - return scan.no_match(); - } - }; - - /////////////////////////////////////////////////////////////////////// - // - // real_parser_impl class - // - /////////////////////////////////////////////////////////////////////// -#if (defined(BOOST_MSVC) && (BOOST_MSVC <= 1310)) -#pragma warning(push) -#pragma warning(disable:4127) -#endif - - template - struct real_parser_impl - { - typedef real_parser_impl self_t; - - template - RT parse_main(ScannerT const& scan) const - { - if (scan.at_end()) - return scan.no_match(); - typename ScannerT::iterator_t save = scan.first; - - typedef typename parser_result::type - sign_match_t; - typedef typename parser_result, ScannerT>::type - exp_match_t; - - sign_match_t sign_match = RealPoliciesT::parse_sign(scan); - std::size_t count = sign_match ? sign_match.length() : 0; - bool neg = sign_match.has_valid_attribute() ? - sign_match.value() : false; - - RT n_match = RealPoliciesT::parse_n(scan); - T n = n_match.has_valid_attribute() ? - n_match.value() : T(0); - bool got_a_number = n_match; - exp_match_t e_hit; - - if (!got_a_number && !RealPoliciesT::allow_leading_dot) - return scan.no_match(); - else - count += n_match.length(); - - if (neg) - n = -n; - - if (RealPoliciesT::parse_dot(scan)) - { - // We got the decimal point. Now we will try to parse - // the fraction if it is there. If not, it defaults - // to zero (0) only if we already got a number. - - if (RT hit = RealPoliciesT::parse_frac_n(scan)) - { - hit.value(hit.value() - * BOOST_SPIRIT_IMPL_STD_NS:: - pow(T(10), T(-hit.length()))); - if (neg) - n -= hit.value(); - else - n += hit.value(); - count += hit.length() + 1; - - } - - else if (!got_a_number || - !RealPoliciesT::allow_trailing_dot) - return scan.no_match(); - - e_hit = RealPoliciesT::parse_exp(scan); - } - else - { - // We have reached a point where we - // still haven't seen a number at all. - // We return early with a no-match. - if (!got_a_number) - return scan.no_match(); - - // If we must expect a dot and we didn't see - // an exponent, return early with a no-match. - e_hit = RealPoliciesT::parse_exp(scan); - if (RealPoliciesT::expect_dot && !e_hit) - return scan.no_match(); - } - - if (e_hit) - { - // We got the exponent prefix. Now we will try to parse the - // actual exponent. It is an error if it is not there. - if (RT e_n_hit = RealPoliciesT::parse_exp_n(scan)) - { - n *= BOOST_SPIRIT_IMPL_STD_NS:: - pow(T(10), T(e_n_hit.value())); - count += e_n_hit.length() + e_hit.length(); - } - else - { - // Oops, no exponent, return a no-match - return scan.no_match(); - } - } - - return scan.create_match(count, n, save, scan.first); - } - - template - static RT parse(ScannerT const& scan) - { - static self_t this_; - return impl::implicit_lexeme_parse(this_, scan, scan); - } - }; - -#if (defined(BOOST_MSVC) && (BOOST_MSVC <= 1310)) -#pragma warning(pop) -#endif - - } // namespace impl - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#endif -#undef BOOST_SPIRIT_IMPL_STD_NS diff --git a/boost/boost/spirit/core/primitives/impl/primitives.ipp b/boost/boost/spirit/core/primitives/impl/primitives.ipp deleted file mode 100644 index 17ff2ce029..0000000000 --- a/boost/boost/spirit/core/primitives/impl/primitives.ipp +++ /dev/null @@ -1,465 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2003 Martin Wille - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_PRIMITIVES_IPP) -#define BOOST_SPIRIT_PRIMITIVES_IPP - -// This should eventually go to a config file. -#if defined(__GNUC__) && (__GNUC__ < 3) && !defined(_STLPORT_VERSION) -# ifndef BOOST_SPIRIT_NO_CHAR_TRAITS -# define BOOST_SPIRIT_NO_CHAR_TRAITS -# endif -#endif - -#include -#if !defined(BOOST_NO_CWCTYPE) -#include -#endif - -#ifndef BOOST_SPIRIT_NO_CHAR_TRAITS -# include // char_traits -#endif - -#if defined(BOOST_MSVC) -# pragma warning(disable:4800) -#endif - -namespace boost { namespace spirit { - - template struct char_parser; - - namespace impl - { - template - inline IteratorT - get_last(IteratorT first) - { - while (*first) - first++; - return first; - } - - template< - typename RT, - typename IteratorT, - typename ScannerT> - inline RT - string_parser_parse( - IteratorT str_first, - IteratorT str_last, - ScannerT& scan) - { - typedef typename ScannerT::iterator_t iterator_t; - iterator_t saved = scan.first; - std::size_t slen = str_last - str_first; - - while (str_first != str_last) - { - if (scan.at_end() || (*str_first != *scan)) - return scan.no_match(); - ++str_first; - ++scan; - } - - return scan.create_match(slen, nil_t(), saved, scan.first); - } - - /////////////////////////////////////////////////////////////////////////// - // - // Conversion from char_type to int_type - // - /////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_SPIRIT_NO_CHAR_TRAITS -# define BOOST_SPIRIT_CHAR_TRAITS_NAMESPACE std -#else - - template - struct char_traits - { - typedef CharT int_type; - typedef CharT char_type; - }; - - template<> - struct char_traits - { - typedef int int_type; - typedef char char_type; - - static char_type - to_char_type(int_type c) - { - return static_cast(c); - } - - static int - to_int_type(char c) - { - return static_cast(c); - } - }; - - template<> - struct char_traits - { - typedef int int_type; - typedef unsigned char char_type; - - static char_type - to_char_type(int_type c) - { - return static_cast(c); - } - - static int - to_int_type(unsigned char c) - { - return c; - } - }; - -# define BOOST_SPIRIT_CHAR_TRAITS_NAMESPACE impl -# ifndef BOOST_NO_CWCTYPE - - template<> - struct char_traits - { - typedef wint_t int_type; - typedef wchar_t char_type; - - static char_type - to_char_type(int_type c) - { - return static_cast(c); - } - - static wint_t - to_int_type(wchar_t c) - { - return c; - } - }; - -# endif -#endif // BOOST_SPIRIT_NO_CHAR_TRAITS - - // Use char_traits for char and wchar_t only, as these are the only - // specializations provided in the standard. Other types are on their - // own. - // - // For UDT, one may override: - // - // isalnum - // isalpha - // iscntrl - // isdigit - // isgraph - // islower - // isprint - // ispunct - // isspace - // isupper - // isxdigit - // isblank - // isupper - // tolower - // toupper - // - // in a namespace suitable for Argument Dependent lookup or in - // namespace std (disallowed by the standard). - - template - struct char_type_char_traits_helper - { - typedef CharT char_type; - typedef typename BOOST_SPIRIT_CHAR_TRAITS_NAMESPACE - ::char_traits::int_type int_type; - - static int_type to_int_type(CharT c) - { - return BOOST_SPIRIT_CHAR_TRAITS_NAMESPACE - ::char_traits::to_int_type(c); - } - - static char_type to_char_type(int_type i) - { - return BOOST_SPIRIT_CHAR_TRAITS_NAMESPACE - ::char_traits::to_char_type(i); - } - }; - - template - struct char_traits_helper - { - typedef CharT char_type; - typedef CharT int_type; - - static CharT & to_int_type(CharT & c) - { - return c; - } - - static CharT & to_char_type(CharT & c) - { - return c; - } - }; - - template <> - struct char_traits_helper - : char_type_char_traits_helper - { - }; - -#if !defined(BOOST_NO_CWCTYPE) - - template <> - struct char_traits_helper - : char_type_char_traits_helper - { - }; - -#endif - - template - inline typename char_traits_helper::int_type - to_int_type(CharT c) - { - return char_traits_helper::to_int_type(c); - } - - template - inline CharT - to_char_type(typename char_traits_helper::int_type c) - { - return char_traits_helper::to_char_type(c); - } - - /////////////////////////////////////////////////////////////////////// - // - // Convenience functions - // - /////////////////////////////////////////////////////////////////////// - - template - inline bool - isalnum_(CharT c) - { - using namespace std; - return isalnum(to_int_type(c)) ? true : false; - } - - template - inline bool - isalpha_(CharT c) - { - using namespace std; - return isalpha(to_int_type(c)) ? true : false; - } - - template - inline bool - iscntrl_(CharT c) - { - using namespace std; - return iscntrl(to_int_type(c)) ? true : false; - } - - template - inline bool - isdigit_(CharT c) - { - using namespace std; - return isdigit(to_int_type(c)) ? true : false; - } - - template - inline bool - isgraph_(CharT c) - { - using namespace std; - return isgraph(to_int_type(c)) ? true : false; - } - - template - inline bool - islower_(CharT c) - { - using namespace std; - return islower(to_int_type(c)) ? true : false; - } - - template - inline bool - isprint_(CharT c) - { - using namespace std; - return isprint(to_int_type(c)) ? true : false; - } - - template - inline bool - ispunct_(CharT c) - { - using namespace std; - return ispunct(to_int_type(c)) ? true : false; - } - - template - inline bool - isspace_(CharT c) - { - using namespace std; - return isspace(to_int_type(c)) ? true : false; - } - - template - inline bool - isupper_(CharT c) - { - using namespace std; - return isupper(to_int_type(c)) ? true : false; - } - - template - inline bool - isxdigit_(CharT c) - { - using namespace std; - return isxdigit(to_int_type(c)) ? true : false; - } - - template - inline bool - isblank_(CharT c) - { - return (c == ' ' || c == '\t'); - } - - template - inline CharT - tolower_(CharT c) - { - using namespace std; - return to_char_type(tolower(to_int_type(c))); - } - - template - inline CharT - toupper_(CharT c) - { - using namespace std; - return to_char_type(toupper(to_int_type(c))); - } - -#if !defined(BOOST_NO_CWCTYPE) - - inline bool - isalnum_(wchar_t c) - { - using namespace std; - return iswalnum(to_int_type(c)) ? true : false; - } - - inline bool - isalpha_(wchar_t c) - { - using namespace std; - return iswalpha(to_int_type(c)) ? true : false; - } - - inline bool - iscntrl_(wchar_t c) - { - using namespace std; - return iswcntrl(to_int_type(c)) ? true : false; - } - - inline bool - isdigit_(wchar_t c) - { - using namespace std; - return iswdigit(to_int_type(c)) ? true : false; - } - - inline bool - isgraph_(wchar_t c) - { - using namespace std; - return iswgraph(to_int_type(c)) ? true : false; - } - - inline bool - islower_(wchar_t c) - { - using namespace std; - return iswlower(to_int_type(c)) ? true : false; - } - - inline bool - isprint_(wchar_t c) - { - using namespace std; - return iswprint(to_int_type(c)) ? true : false; - } - - inline bool - ispunct_(wchar_t c) - { - using namespace std; - return iswpunct(to_int_type(c)) ? true : false; - } - - inline bool - isspace_(wchar_t c) - { - using namespace std; - return iswspace(to_int_type(c)) ? true : false; - } - - inline bool - isupper_(wchar_t c) - { - using namespace std; - return iswupper(to_int_type(c)) ? true : false; - } - - inline bool - isxdigit_(wchar_t c) - { - using namespace std; - return iswxdigit(to_int_type(c)) ? true : false; - } - - inline bool - isblank_(wchar_t c) - { - return (c == L' ' || c == L'\t'); - } - - inline wchar_t - tolower_(wchar_t c) - { - using namespace std; - return to_char_type(towlower(to_int_type(c))); - } - - inline wchar_t - toupper_(wchar_t c) - { - using namespace std; - return to_char_type(towupper(to_int_type(c))); - } - -#endif // !defined(BOOST_NO_CWCTYPE) - -}}} // namespace boost::spirit::impl - -#endif diff --git a/boost/boost/spirit/core/primitives/numerics.hpp b/boost/boost/spirit/core/primitives/numerics.hpp deleted file mode 100644 index 58e552aaba..0000000000 --- a/boost/boost/spirit/core/primitives/numerics.hpp +++ /dev/null @@ -1,285 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001-2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_NUMERICS_HPP -#define BOOST_SPIRIT_NUMERICS_HPP - -#include -#include -#include - -#include -#include - -namespace boost { namespace spirit -{ - /////////////////////////////////////////////////////////////////////////// - // - // uint_parser class - // - /////////////////////////////////////////////////////////////////////////// - template < - typename T, - int Radix, - unsigned MinDigits, - int MaxDigits - > - struct uint_parser : parser > - { - typedef uint_parser self_t; - - template - struct result - { - typedef typename match_result::type type; - }; - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef impl::uint_parser_impl impl_t; - typedef typename parser_result::type result_t; - return impl::contiguous_parser_parse(impl_t(), scan, scan); - } - }; - - /////////////////////////////////////////////////////////////////////////// - // - // int_parser class - // - /////////////////////////////////////////////////////////////////////////// - template < - typename T, - int Radix, - unsigned MinDigits, - int MaxDigits - > - struct int_parser : parser > - { - typedef int_parser self_t; - - template - struct result - { - typedef typename match_result::type type; - }; - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef impl::int_parser_impl impl_t; - typedef typename parser_result::type result_t; - return impl::contiguous_parser_parse(impl_t(), scan, scan); - } - }; - - /////////////////////////////////////////////////////////////////////////// - // - // uint_parser/int_parser instantiations - // - /////////////////////////////////////////////////////////////////////////// - int_parser const - int_p = int_parser(); - - uint_parser const - uint_p = uint_parser(); - - uint_parser const - bin_p = uint_parser(); - - uint_parser const - oct_p = uint_parser(); - - uint_parser const - hex_p = uint_parser(); - - /////////////////////////////////////////////////////////////////////////// - // - // sign_parser class - // - /////////////////////////////////////////////////////////////////////////// - namespace impl - { - // Utility to extract the prefix sign ('-' | '+') - template - bool extract_sign(ScannerT const& scan, std::size_t& count); - } - - struct sign_parser : public parser - { - typedef sign_parser self_t; - - template - struct result - { - typedef typename match_result::type type; - }; - - sign_parser() {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - if (!scan.at_end()) - { - std::size_t length; - typename ScannerT::iterator_t save(scan.first); - bool neg = impl::extract_sign(scan, length); - if (length) - return scan.create_match(1, neg, save, scan.first); - } - return scan.no_match(); - } - }; - - sign_parser const sign_p = sign_parser(); - - /////////////////////////////////////////////////////////////////////////// - // - // default real number policies - // - /////////////////////////////////////////////////////////////////////////// - template - struct ureal_parser_policies - { - // trailing dot policy suggested suggested by Gustavo Guerra - BOOST_STATIC_CONSTANT(bool, allow_leading_dot = true); - BOOST_STATIC_CONSTANT(bool, allow_trailing_dot = true); - BOOST_STATIC_CONSTANT(bool, expect_dot = false); - - typedef uint_parser uint_parser_t; - typedef int_parser int_parser_t; - - template - static typename match_result::type - parse_sign(ScannerT& scan) - { - return scan.no_match(); - } - - template - static typename parser_result::type - parse_n(ScannerT& scan) - { - return uint_parser_t().parse(scan); - } - - template - static typename parser_result, ScannerT>::type - parse_dot(ScannerT& scan) - { - return ch_p('.').parse(scan); - } - - template - static typename parser_result::type - parse_frac_n(ScannerT& scan) - { - return uint_parser_t().parse(scan); - } - - template - static typename parser_result, ScannerT>::type - parse_exp(ScannerT& scan) - { - return as_lower_d['e'].parse(scan); - } - - template - static typename parser_result::type - parse_exp_n(ScannerT& scan) - { - return int_parser_t().parse(scan); - } - }; - - template - struct real_parser_policies : public ureal_parser_policies - { - template - static typename parser_result::type - parse_sign(ScannerT& scan) - { - return sign_p.parse(scan); - } - }; - - /////////////////////////////////////////////////////////////////////////// - // - // real_parser class - // - /////////////////////////////////////////////////////////////////////////// - template < - typename T, - typename RealPoliciesT - > - struct real_parser - : public parser > - { - typedef real_parser self_t; - - template - struct result - { - typedef typename match_result::type type; - }; - - real_parser() {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - return impl::real_parser_impl::parse(scan); - } - }; - - /////////////////////////////////////////////////////////////////////////// - // - // real_parser instantiations - // - /////////////////////////////////////////////////////////////////////////// - real_parser > const - ureal_p = real_parser >(); - - real_parser > const - real_p = real_parser >(); - - /////////////////////////////////////////////////////////////////////////// - // - // strict reals (do not allow plain integers (no decimal point)) - // - /////////////////////////////////////////////////////////////////////////// - template - struct strict_ureal_parser_policies : public ureal_parser_policies - { - BOOST_STATIC_CONSTANT(bool, expect_dot = true); - }; - - template - struct strict_real_parser_policies : public real_parser_policies - { - BOOST_STATIC_CONSTANT(bool, expect_dot = true); - }; - - real_parser > const - strict_ureal_p - = real_parser >(); - - real_parser > const - strict_real_p - = real_parser >(); - -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/core/primitives/primitives.hpp b/boost/boost/spirit/core/primitives/primitives.hpp deleted file mode 100644 index 89be6ccf1a..0000000000 --- a/boost/boost/spirit/core/primitives/primitives.hpp +++ /dev/null @@ -1,645 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2003 Martin Wille - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_PRIMITIVES_HPP) -#define BOOST_SPIRIT_PRIMITIVES_HPP - -#include -#include -#include -#include -#include - -#ifdef BOOST_MSVC -#pragma warning(disable : 4512) -#endif - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // char_parser class - // - /////////////////////////////////////////////////////////////////////////// - template - struct char_parser : public parser - { - typedef DerivedT self_t; - template - struct result - { - typedef typename match_result< - ScannerT, - typename ScannerT::value_t - >::type type; - }; - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - typedef typename ScannerT::value_t value_t; - typedef typename ScannerT::iterator_t iterator_t; - - if (!scan.at_end()) - { - value_t ch = *scan; - if (this->derived().test(ch)) - { - iterator_t save(scan.first); - ++scan.first; - return scan.create_match(1, ch, save, scan.first); - } - } - return scan.no_match(); - } - }; - - /////////////////////////////////////////////////////////////////////////// - // - // negation of char_parsers - // - /////////////////////////////////////////////////////////////////////////// - template - struct negated_char_parser - : public char_parser > - { - typedef negated_char_parser self_t; - typedef PositiveT positive_t; - - negated_char_parser(positive_t const& p) - : positive(p.derived()) {} - - template - bool test(T ch) const - { - return !positive.test(ch); - } - - positive_t const positive; - }; - - template - inline negated_char_parser - operator~(char_parser const& p) - { - return negated_char_parser(p.derived()); - } - - template - inline ParserT - operator~(negated_char_parser const& n) - { - return n.positive; - } - - /////////////////////////////////////////////////////////////////////////// - // - // chlit class - // - /////////////////////////////////////////////////////////////////////////// - template - struct chlit : public char_parser > - { - chlit(CharT ch_) - : ch(ch_) {} - - template - bool test(T ch_) const - { - return ch_ == ch; - } - - CharT ch; - }; - - template - inline chlit - ch_p(CharT ch) - { - return chlit(ch); - } - - // This should take care of ch_p("a") "bugs" - template - inline chlit - ch_p(CharT const (& str)[N]) - { - // ch_p's argument should be a single character or a null-terminated - // string with a single character - BOOST_STATIC_ASSERT(N < 3); - return chlit(str[0]); - } - - /////////////////////////////////////////////////////////////////////////// - // - // range class - // - /////////////////////////////////////////////////////////////////////////// - template - struct range : public char_parser > - { - range(CharT first_, CharT last_) - : first(first_), last(last_) - { - BOOST_SPIRIT_ASSERT(!(last < first)); - } - - template - bool test(T ch) const - { - return !(CharT(ch) < first) && !(last < CharT(ch)); - } - - CharT first; - CharT last; - }; - - template - inline range - range_p(CharT first, CharT last) - { - return range(first, last); - } - - /////////////////////////////////////////////////////////////////////////// - // - // chseq class - // - /////////////////////////////////////////////////////////////////////////// - template - class chseq : public parser > - { - public: - - typedef chseq self_t; - - chseq(IteratorT first_, IteratorT last_) - : first(first_), last(last_) {} - - chseq(IteratorT first_) - : first(first_), last(impl::get_last(first_)) {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename boost::unwrap_reference::type striter_t; - typedef typename parser_result::type result_t; - return impl::string_parser_parse( - striter_t(first), - striter_t(last), - scan); - } - - private: - - IteratorT first; - IteratorT last; - }; - - template - inline chseq - chseq_p(CharT const* str) - { - return chseq(str); - } - - template - inline chseq - chseq_p(IteratorT first, IteratorT last) - { - return chseq(first, last); - } - - /////////////////////////////////////////////////////////////////////////// - // - // strlit class - // - /////////////////////////////////////////////////////////////////////////// - template - class strlit : public parser > - { - public: - - typedef strlit self_t; - - strlit(IteratorT first, IteratorT last) - : seq(first, last) {} - - strlit(IteratorT first) - : seq(first) {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - return impl::contiguous_parser_parse - (seq, scan, scan); - } - - private: - - chseq seq; - }; - - template - inline strlit - str_p(CharT const* str) - { - return strlit(str); - } - - template - inline strlit - str_p(CharT * str) - { - return strlit(str); - } - - template - inline strlit - str_p(IteratorT first, IteratorT last) - { - return strlit(first, last); - } - - // This should take care of str_p('a') "bugs" - template - inline chlit - str_p(CharT ch) - { - return chlit(ch); - } - - /////////////////////////////////////////////////////////////////////////// - // - // nothing_parser class - // - /////////////////////////////////////////////////////////////////////////// - struct nothing_parser : public parser - { - typedef nothing_parser self_t; - - nothing_parser() {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - return scan.no_match(); - } - }; - - nothing_parser const nothing_p = nothing_parser(); - - /////////////////////////////////////////////////////////////////////////// - // - // anychar_parser class - // - /////////////////////////////////////////////////////////////////////////// - struct anychar_parser : public char_parser - { - typedef anychar_parser self_t; - - anychar_parser() {} - - template - bool test(CharT) const - { - return true; - } - }; - - anychar_parser const anychar_p = anychar_parser(); - - inline nothing_parser - operator~(anychar_parser) - { - return nothing_p; - } - - /////////////////////////////////////////////////////////////////////////// - // - // alnum_parser class - // - /////////////////////////////////////////////////////////////////////////// - struct alnum_parser : public char_parser - { - typedef alnum_parser self_t; - - alnum_parser() {} - - template - bool test(CharT ch) const - { - return impl::isalnum_(ch); - } - }; - - alnum_parser const alnum_p = alnum_parser(); - - /////////////////////////////////////////////////////////////////////////// - // - // alpha_parser class - // - /////////////////////////////////////////////////////////////////////////// - struct alpha_parser : public char_parser - { - typedef alpha_parser self_t; - - alpha_parser() {} - - template - bool test(CharT ch) const - { - return impl::isalpha_(ch); - } - }; - - alpha_parser const alpha_p = alpha_parser(); - - /////////////////////////////////////////////////////////////////////////// - // - // cntrl_parser class - // - /////////////////////////////////////////////////////////////////////////// - struct cntrl_parser : public char_parser - { - typedef cntrl_parser self_t; - - cntrl_parser() {} - - template - bool test(CharT ch) const - { - return impl::iscntrl_(ch); - } - }; - - cntrl_parser const cntrl_p = cntrl_parser(); - - /////////////////////////////////////////////////////////////////////////// - // - // digit_parser class - // - /////////////////////////////////////////////////////////////////////////// - struct digit_parser : public char_parser - { - typedef digit_parser self_t; - - digit_parser() {} - - template - bool test(CharT ch) const - { - return impl::isdigit_(ch); - } - }; - - digit_parser const digit_p = digit_parser(); - - /////////////////////////////////////////////////////////////////////////// - // - // graph_parser class - // - /////////////////////////////////////////////////////////////////////////// - struct graph_parser : public char_parser - { - typedef graph_parser self_t; - - graph_parser() {} - - template - bool test(CharT ch) const - { - return impl::isgraph_(ch); - } - }; - - graph_parser const graph_p = graph_parser(); - - /////////////////////////////////////////////////////////////////////////// - // - // lower_parser class - // - /////////////////////////////////////////////////////////////////////////// - struct lower_parser : public char_parser - { - typedef lower_parser self_t; - - lower_parser() {} - - template - bool test(CharT ch) const - { - return impl::islower_(ch); - } - }; - - lower_parser const lower_p = lower_parser(); - - /////////////////////////////////////////////////////////////////////////// - // - // print_parser class - // - /////////////////////////////////////////////////////////////////////////// - struct print_parser : public char_parser - { - typedef print_parser self_t; - - print_parser() {} - - template - bool test(CharT ch) const - { - return impl::isprint_(ch); - } - }; - - print_parser const print_p = print_parser(); - - /////////////////////////////////////////////////////////////////////////// - // - // punct_parser class - // - /////////////////////////////////////////////////////////////////////////// - struct punct_parser : public char_parser - { - typedef punct_parser self_t; - - punct_parser() {} - - template - bool test(CharT ch) const - { - return impl::ispunct_(ch); - } - }; - - punct_parser const punct_p = punct_parser(); - - /////////////////////////////////////////////////////////////////////////// - // - // blank_parser class - // - /////////////////////////////////////////////////////////////////////////// - struct blank_parser : public char_parser - { - typedef blank_parser self_t; - - blank_parser() {} - - template - bool test(CharT ch) const - { - return impl::isblank_(ch); - } - }; - - blank_parser const blank_p = blank_parser(); - - /////////////////////////////////////////////////////////////////////////// - // - // space_parser class - // - /////////////////////////////////////////////////////////////////////////// - struct space_parser : public char_parser - { - typedef space_parser self_t; - - space_parser() {} - - template - bool test(CharT ch) const - { - return impl::isspace_(ch); - } - }; - - space_parser const space_p = space_parser(); - - /////////////////////////////////////////////////////////////////////////// - // - // upper_parser class - // - /////////////////////////////////////////////////////////////////////////// - struct upper_parser : public char_parser - { - typedef upper_parser self_t; - - upper_parser() {} - - template - bool test(CharT ch) const - { - return impl::isupper_(ch); - } - }; - - upper_parser const upper_p = upper_parser(); - - /////////////////////////////////////////////////////////////////////////// - // - // xdigit_parser class - // - /////////////////////////////////////////////////////////////////////////// - struct xdigit_parser : public char_parser - { - typedef xdigit_parser self_t; - - xdigit_parser() {} - - template - bool test(CharT ch) const - { - return impl::isxdigit_(ch); - } - }; - - xdigit_parser const xdigit_p = xdigit_parser(); - - /////////////////////////////////////////////////////////////////////////// - // - // eol_parser class (contributed by Martin Wille) - // - /////////////////////////////////////////////////////////////////////////// - struct eol_parser : public parser - { - typedef eol_parser self_t; - - eol_parser() {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typename ScannerT::iterator_t save = scan.first; - std::size_t len = 0; - - if (!scan.at_end() && *scan == '\r') // CR - { - ++scan.first; - ++len; - } - - // Don't call skipper here - if (scan.first != scan.last && *scan == '\n') // LF - { - ++scan.first; - ++len; - } - - if (len) - return scan.create_match(len, nil_t(), save, scan.first); - return scan.no_match(); - } - }; - - eol_parser const eol_p = eol_parser(); - - /////////////////////////////////////////////////////////////////////////// - // - // end_parser class (suggested by Markus Schöpflin) - // - /////////////////////////////////////////////////////////////////////////// - struct end_parser : public parser - { - typedef end_parser self_t; - - end_parser() {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - if (scan.at_end()) - return scan.empty_match(); - return scan.no_match(); - } - }; - - end_parser const end_p = end_parser(); - - /////////////////////////////////////////////////////////////////////////// - // - // the pizza_p parser :-) - // - /////////////////////////////////////////////////////////////////////////// - inline strlit const - pizza_p(char const* your_favorite_pizza) - { - return your_favorite_pizza; - } - -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/core/safe_bool.hpp b/boost/boost/spirit/core/safe_bool.hpp deleted file mode 100644 index 5a2631aac0..0000000000 --- a/boost/boost/spirit/core/safe_bool.hpp +++ /dev/null @@ -1,59 +0,0 @@ -/*============================================================================= - Copyright (c) 2003 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_SAFE_BOOL_HPP) -#define BOOST_SPIRIT_SAFE_BOOL_HPP - -#include -#include - -namespace boost { namespace spirit -{ - namespace impl - { - template - struct no_base {}; - - template - struct safe_bool_impl - { -#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) - void stub(T*) {}; - typedef void (safe_bool_impl::*type)(T*); -#else - typedef T* TP; // workaround to make parsing easier - TP stub; - typedef TP safe_bool_impl::*type; -#endif - }; - } - - template > - struct safe_bool : BaseT - { - private: - typedef impl::safe_bool_impl impl_t; - typedef typename impl_t::type bool_type; - - public: - operator bool_type() const - { - return static_cast(this)->operator_bool() ? - &impl_t::stub : 0; - } - - operator bool_type() - { - return static_cast(this)->operator_bool() ? - &impl_t::stub : 0; - } - }; -}} - -#endif - diff --git a/boost/boost/spirit/core/scanner/impl/skipper.ipp b/boost/boost/spirit/core/scanner/impl/skipper.ipp deleted file mode 100644 index b809e64cb1..0000000000 --- a/boost/boost/spirit/core/scanner/impl/skipper.ipp +++ /dev/null @@ -1,177 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -============================================================================*/ -#if !defined(BOOST_SPIRIT_SKIPPER_IPP) -#define BOOST_SPIRIT_SKIPPER_IPP - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - - struct space_parser; - template - struct no_skipper_iteration_policy; - - namespace impl - { - template - inline void - skipper_skip( - ST const& s, - ScannerT const& scan, - skipper_iteration_policy const&) - { - typedef scanner_policies< - no_skipper_iteration_policy< - BOOST_DEDUCED_TYPENAME ScannerT::iteration_policy_t>, - BOOST_DEDUCED_TYPENAME ScannerT::match_policy_t, - BOOST_DEDUCED_TYPENAME ScannerT::action_policy_t - > policies_t; - - scanner - scan2(scan.first, scan.last, policies_t(scan)); - typedef typename ScannerT::iterator_t iterator_t; - - for (;;) - { - iterator_t save = scan.first; - if (!s.parse(scan2)) - { - scan.first = save; - break; - } - } - } - - template - inline void - skipper_skip( - ST const& s, - ScannerT const& scan, - no_skipper_iteration_policy const&) - { - for (;;) - { - typedef typename ScannerT::iterator_t iterator_t; - iterator_t save = scan.first; - if (!s.parse(scan)) - { - scan.first = save; - break; - } - } - } - - template - inline void - skipper_skip( - ST const& s, - ScannerT const& scan, - iteration_policy const&) - { - for (;;) - { - typedef typename ScannerT::iterator_t iterator_t; - iterator_t save = scan.first; - if (!s.parse(scan)) - { - scan.first = save; - break; - } - } - } - - template - struct phrase_parser - { - template - static parse_info - parse( - IteratorT const& first_, - IteratorT const& last, - ParserT const& p, - SkipT const& skip) - { - typedef skip_parser_iteration_policy iter_policy_t; - typedef scanner_policies scanner_policies_t; - typedef scanner scanner_t; - - iter_policy_t iter_policy(skip); - scanner_policies_t policies(iter_policy); - IteratorT first = first_; - scanner_t scan(first, last, policies); - match hit = p.parse(scan); - return parse_info( - first, hit, hit && (first == last), - hit.length()); - } - }; - - template <> - struct phrase_parser - { - template - static parse_info - parse( - IteratorT const& first_, - IteratorT const& last, - ParserT const& p, - space_parser const&) - { - typedef skipper_iteration_policy<> iter_policy_t; - typedef scanner_policies scanner_policies_t; - typedef scanner scanner_t; - - IteratorT first = first_; - scanner_t scan(first, last); - match hit = p.parse(scan); - return parse_info( - first, hit, hit && (first == last), - hit.length()); - } - }; - } - - /////////////////////////////////////////////////////////////////////////// - // - // Free parse functions using the skippers - // - /////////////////////////////////////////////////////////////////////////// - template - inline parse_info - parse( - IteratorT const& first, - IteratorT const& last, - parser const& p, - parser const& skip) - { - return impl::phrase_parser:: - parse(first, last, p.derived(), skip.derived()); - } - - /////////////////////////////////////////////////////////////////////////// - // - // Parse function for null terminated strings using the skippers - // - /////////////////////////////////////////////////////////////////////////// - template - inline parse_info - parse( - CharT const* str, - parser const& p, - parser const& skip) - { - CharT const* last = str; - while (*last) - last++; - return parse(str, last, p, skip); - } - -}} // namespace boost::spirit - -#endif - diff --git a/boost/boost/spirit/core/scanner/scanner.hpp b/boost/boost/spirit/core/scanner/scanner.hpp deleted file mode 100644 index e369dc4eb8..0000000000 --- a/boost/boost/spirit/core/scanner/scanner.hpp +++ /dev/null @@ -1,320 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2002 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_SCANNER_HPP) -#define BOOST_SPIRIT_SCANNER_HPP - -#include -#include -#include -#include -#include // for boost::detail::iterator_traits - -#include - -namespace boost { namespace spirit -{ - /////////////////////////////////////////////////////////////////////////// - // - // iteration_policy class - // - /////////////////////////////////////////////////////////////////////////// - struct iteration_policy - { - template - void - advance(ScannerT const& scan) const - { - ++scan.first; - } - - template - bool at_end(ScannerT const& scan) const - { - return scan.first == scan.last; - } - - template - T filter(T ch) const - { - return ch; - } - - template - typename ScannerT::ref_t - get(ScannerT const& scan) const - { - return *scan.first; - } - }; - - /////////////////////////////////////////////////////////////////////////// - // - // match_policy class - // - /////////////////////////////////////////////////////////////////////////// - struct match_policy - { - template - struct result { typedef match type; }; - - const match - no_match() const - { - return match(); - } - - const match - empty_match() const - { - return match(0, nil_t()); - } - - template - match - create_match( - std::size_t length, - AttrT const& val, - IteratorT const& /*first*/, - IteratorT const& /*last*/) const - { - return match(length, val); - } - - template - void group_match( - MatchT& /*m*/, - parser_id const& /*id*/, - IteratorT const& /*first*/, - IteratorT const& /*last*/) const {} - - template - void concat_match(Match1T& l, Match2T const& r) const - { - l.concat(r); - } - }; - - /////////////////////////////////////////////////////////////////////////// - // - // match_result class - // - /////////////////////////////////////////////////////////////////////////// - template - struct match_result - { - typedef typename MatchPolicyT::template result::type type; - }; - - /////////////////////////////////////////////////////////////////////////// - // - // action_policy class - // - /////////////////////////////////////////////////////////////////////////// - template - struct attributed_action_policy - { - template - static void - call( - ActorT const& actor, - AttrT& val, - IteratorT const&, - IteratorT const&) - { - actor(val); - } - }; - - ////////////////////////////////// - template <> - struct attributed_action_policy - { - template - static void - call( - ActorT const& actor, - nil_t, - IteratorT const& first, - IteratorT const& last) - { - actor(first, last); - } - }; - - ////////////////////////////////// - struct action_policy - { - template - void - do_action( - ActorT const& actor, - AttrT& val, - IteratorT const& first, - IteratorT const& last) const - { - attributed_action_policy::call(actor, val, first, last); - } - }; - - /////////////////////////////////////////////////////////////////////////// - // - // scanner_policies class - // - /////////////////////////////////////////////////////////////////////////// - template < - typename IterationPolicyT, - typename MatchPolicyT, - typename ActionPolicyT> - struct scanner_policies : - public IterationPolicyT, - public MatchPolicyT, - public ActionPolicyT - { - typedef IterationPolicyT iteration_policy_t; - typedef MatchPolicyT match_policy_t; - typedef ActionPolicyT action_policy_t; - - scanner_policies( - IterationPolicyT const& i_policy = IterationPolicyT(), - MatchPolicyT const& m_policy = MatchPolicyT(), - ActionPolicyT const& a_policy = ActionPolicyT()) - : IterationPolicyT(i_policy) - , MatchPolicyT(m_policy) - , ActionPolicyT(a_policy) {} - - template - scanner_policies(ScannerPoliciesT const& policies) - : IterationPolicyT(policies) - , MatchPolicyT(policies) - , ActionPolicyT(policies) {} - }; - - /////////////////////////////////////////////////////////////////////////// - // - // scanner_policies_base class: the base class of all scanners - // - /////////////////////////////////////////////////////////////////////////// - struct scanner_base {}; - - /////////////////////////////////////////////////////////////////////////// - // - // scanner class - // - /////////////////////////////////////////////////////////////////////////// - template < - typename IteratorT, - typename PoliciesT> - class scanner : public PoliciesT, public scanner_base - { - public: - - typedef IteratorT iterator_t; - typedef PoliciesT policies_t; - - typedef typename boost::detail:: - iterator_traits::value_type value_t; - typedef typename boost::detail:: - iterator_traits::reference ref_t; - typedef typename boost:: - call_traits::param_type iter_param_t; - - scanner( - IteratorT& first_, - iter_param_t last_, - PoliciesT const& policies = PoliciesT()) - : PoliciesT(policies), first(first_), last(last_) - { - at_end(); - } - - scanner(scanner const& other) - : PoliciesT(other), first(other.first), last(other.last) {} - - scanner(scanner const& other, IteratorT& first_) - : PoliciesT(other), first(first_), last(other.last) {} - - bool - at_end() const - { - typedef typename PoliciesT::iteration_policy_t iteration_policy_t; - return iteration_policy_t::at_end(*this); - } - - value_t - operator*() const - { - typedef typename PoliciesT::iteration_policy_t iteration_policy_t; - return iteration_policy_t::filter(iteration_policy_t::get(*this)); - } - - scanner const& - operator++() const - { - typedef typename PoliciesT::iteration_policy_t iteration_policy_t; - iteration_policy_t::advance(*this); - return *this; - } - - template - struct rebind_policies - { - typedef scanner type; - }; - - template - scanner - change_policies(PoliciesT2 const& policies) const - { - return scanner(first, last, policies); - } - - template - struct rebind_iterator - { - typedef scanner type; - }; - - template - scanner - change_iterator(IteratorT2 const& first_, IteratorT2 const &last_) const - { - return scanner(first_, last_, *this); - } - - IteratorT& first; - IteratorT const last; - - private: - - scanner& - operator=(scanner const& other); - }; - - /////////////////////////////////////////////////////////////////////////// - // - // rebind_scanner_policies class - // - /////////////////////////////////////////////////////////////////////////// - template - struct rebind_scanner_policies - { - typedef typename ScannerT::template - rebind_policies::type type; - }; - - ////////////////////////////////// - template - struct rebind_scanner_iterator - { - typedef typename ScannerT::template - rebind_iterator::type type; - }; -}} - -#endif diff --git a/boost/boost/spirit/core/scanner/skipper.hpp b/boost/boost/spirit/core/scanner/skipper.hpp deleted file mode 100644 index 9fe2a73ead..0000000000 --- a/boost/boost/spirit/core/scanner/skipper.hpp +++ /dev/null @@ -1,192 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_SKIPPER_HPP) -#define BOOST_SPIRIT_SKIPPER_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include - -#include -#include - -#include - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // skipper_iteration_policy class - // - /////////////////////////////////////////////////////////////////////////// - template - struct skipper_iteration_policy : public BaseT - { - typedef BaseT base_t; - - skipper_iteration_policy() - : BaseT() {} - - template - skipper_iteration_policy(PolicyT const& other) - : BaseT(other) {} - - template - void - advance(ScannerT const& scan) const - { - BaseT::advance(scan); - scan.skip(scan); - } - - template - bool - at_end(ScannerT const& scan) const - { - scan.skip(scan); - return BaseT::at_end(scan); - } - - template - void - skip(ScannerT const& scan) const - { - while (!BaseT::at_end(scan) && impl::isspace_(BaseT::get(scan))) - BaseT::advance(scan); - } - }; - - /////////////////////////////////////////////////////////////////////////// - // - // no_skipper_iteration_policy class - // - /////////////////////////////////////////////////////////////////////////// - template - struct no_skipper_iteration_policy : public BaseT - { - typedef BaseT base_t; - - no_skipper_iteration_policy() - : BaseT() {} - - template - no_skipper_iteration_policy(PolicyT const& other) - : BaseT(other) {} - - template - void - skip(ScannerT const& /*scan*/) const {} - }; - - /////////////////////////////////////////////////////////////////////////// - // - // skip_parser_iteration_policy class - // - /////////////////////////////////////////////////////////////////////////// - namespace impl - { - template - void - skipper_skip( - ST const& s, - ScannerT const& scan, - skipper_iteration_policy const&); - - template - void - skipper_skip( - ST const& s, - ScannerT const& scan, - no_skipper_iteration_policy const&); - - template - void - skipper_skip( - ST const& s, - ScannerT const& scan, - iteration_policy const&); - } - - template - class skip_parser_iteration_policy : public skipper_iteration_policy - { - public: - - typedef skipper_iteration_policy base_t; - - skip_parser_iteration_policy( - ParserT const& skip_parser, - base_t const& base = base_t()) - : base_t(base), subject(skip_parser) {} - - template - skip_parser_iteration_policy(PolicyT const& other) - : base_t(other), subject(other.skipper()) {} - - template - void - skip(ScannerT const& scan) const - { - impl::skipper_skip(subject, scan, scan); - } - - ParserT const& - skipper() const - { - return subject; - } - - private: - - ParserT const& subject; - }; - - /////////////////////////////////////////////////////////////////////////////// - // - // Free parse functions using the skippers - // - /////////////////////////////////////////////////////////////////////////////// - template - parse_info - parse( - IteratorT const& first, - IteratorT const& last, - parser const& p, - parser const& skip); - - /////////////////////////////////////////////////////////////////////////////// - // - // Parse function for null terminated strings using the skippers - // - /////////////////////////////////////////////////////////////////////////////// - template - parse_info - parse( - CharT const* str, - parser const& p, - parser const& skip); - - /////////////////////////////////////////////////////////////////////////////// - // - // phrase_scanner_t and wide_phrase_scanner_t - // - // The most common scanners. Use these typedefs when you need - // a scanner that skips white spaces. - // - /////////////////////////////////////////////////////////////////////////////// - typedef skipper_iteration_policy<> iter_policy_t; - typedef scanner_policies scanner_policies_t; - typedef scanner phrase_scanner_t; - typedef scanner wide_phrase_scanner_t; - - /////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#include -#endif - diff --git a/boost/boost/spirit/debug.hpp b/boost/boost/spirit/debug.hpp deleted file mode 100644 index 8b97edeadf..0000000000 --- a/boost/boost/spirit/debug.hpp +++ /dev/null @@ -1,146 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - Copyright (c) 2002-2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_DEBUG_MAIN_HPP) -#define BOOST_SPIRIT_DEBUG_MAIN_HPP - -/////////////////////////////////////////////////////////////////////////// -#if defined(BOOST_SPIRIT_DEBUG) - -#include - -/////////////////////////////////////////////////////////////////////////////// -// -// Spirit.Debug includes and defines -// -/////////////////////////////////////////////////////////////////////////////// - - #include - - /////////////////////////////////////////////////////////////////////////// - // - // The BOOST_SPIRIT_DEBUG_OUT defines the stream object, which should be used - // for debug diagnostics. This defaults to std::cout. - // - /////////////////////////////////////////////////////////////////////////// - #if !defined(BOOST_SPIRIT_DEBUG_OUT) - #define BOOST_SPIRIT_DEBUG_OUT std::cout - #endif - - /////////////////////////////////////////////////////////////////////////// - // - // The BOOST_SPIRIT_DEBUG_PRINT_SOME constant defines the number of characters - // from the stream to be printed for diagnosis. This defaults to the first - // 20 characters. - // - /////////////////////////////////////////////////////////////////////////// - #if !defined(BOOST_SPIRIT_DEBUG_PRINT_SOME) - #define BOOST_SPIRIT_DEBUG_PRINT_SOME 20 - #endif - - /////////////////////////////////////////////////////////////////////////// - // - // Additional BOOST_SPIRIT_DEBUG_FLAGS control the level of diagnostics printed - // Basic constants are defined in debug/minimal.hpp. - // - /////////////////////////////////////////////////////////////////////////// - #define BOOST_SPIRIT_DEBUG_FLAGS_NODES 0x0001 // node diagnostics - #define BOOST_SPIRIT_DEBUG_FLAGS_ESCAPE_CHAR 0x0002 // escape_char_parse diagnostics - #define BOOST_SPIRIT_DEBUG_FLAGS_TREES 0x0004 // parse tree/ast diagnostics - #define BOOST_SPIRIT_DEBUG_FLAGS_CLOSURES 0x0008 // closure diagnostics - #define BOOST_SPIRIT_DEBUG_FLAGS_SLEX 0x8000 // slex diagnostics - - #define BOOST_SPIRIT_DEBUG_FLAGS_MAX 0xFFFF // print maximal diagnostics - - #if !defined(BOOST_SPIRIT_DEBUG_FLAGS) - #define BOOST_SPIRIT_DEBUG_FLAGS BOOST_SPIRIT_DEBUG_FLAGS_MAX - #endif - - /////////////////////////////////////////////////////////////////////////// - // - // By default all nodes are traced (even those, not registered with - // BOOST_SPIRIT_DEBUG_RULE et.al. - see below). The following constant may be - // used to redefine this default. - // - /////////////////////////////////////////////////////////////////////////// - #if !defined(BOOST_SPIRIT_DEBUG_TRACENODE) - #define BOOST_SPIRIT_DEBUG_TRACENODE (true) - #endif // !defined(BOOST_SPIRIT_DEBUG_TRACENODE) - - /////////////////////////////////////////////////////////////////////////// - // - // Helper macros for giving rules and subrules a name accessible through - // parser_name() functions (see parser_names.hpp). - // - // Additionally, the macros BOOST_SPIRIT_DEBUG_RULE, SPIRIT_DEBUG_NODE and - // BOOST_SPIRIT_DEBUG_GRAMMAR enable/disable the tracing of the - // correspondingnode accordingly to the PP constant - // BOOST_SPIRIT_DEBUG_TRACENODE. - // - // The macros BOOST_SPIRIT_DEBUG_TRACE_RULE, BOOST_SPIRIT_DEBUG_TRACE_NODE - // and BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR allow to specify a flag to define, - // whether the corresponding node is to be traced or not. - // - /////////////////////////////////////////////////////////////////////////// - #if !defined(BOOST_SPIRIT_DEBUG_RULE) - #define BOOST_SPIRIT_DEBUG_RULE(r) \ - ::boost::spirit::impl::get_node_registry().register_node(&r, #r, BOOST_SPIRIT_DEBUG_TRACENODE) - #endif // !defined(BOOST_SPIRIT_DEBUG_RULE) - - #if !defined(BOOST_SPIRIT_DEBUG_NODE) - #define BOOST_SPIRIT_DEBUG_NODE(r) \ - ::boost::spirit::impl::get_node_registry().register_node(&r, #r, BOOST_SPIRIT_DEBUG_TRACENODE) - #endif // !defined(BOOST_SPIRIT_DEBUG_NODE) - - #if !defined(BOOST_SPIRIT_DEBUG_GRAMMAR) - #define BOOST_SPIRIT_DEBUG_GRAMMAR(r) \ - ::boost::spirit::impl::get_node_registry().register_node(&r, #r, BOOST_SPIRIT_DEBUG_TRACENODE) - #endif // !defined(BOOST_SPIRIT_DEBUG_GRAMMAR) - - #if !defined(BOOST_SPIRIT_DEBUG_TRACE_RULE) - #define BOOST_SPIRIT_DEBUG_TRACE_RULE(r, t) \ - ::boost::spirit::impl::get_node_registry().register_node(&r, #r, (t)) - #endif // !defined(BOOST_SPIRIT_TRACE_RULE) - - #if !defined(BOOST_SPIRIT_DEBUG_TRACE_NODE) - #define BOOST_SPIRIT_DEBUG_TRACE_NODE(r, t) \ - ::boost::spirit::impl::get_node_registry().register_node(&r, #r, (t)) - #endif // !defined(BOOST_SPIRIT_DEBUG_TRACE_NODE) - - #if !defined(BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR) - #define BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR(r, t) \ - ::boost::spirit::impl::get_node_registry().register_node(&r, #r, (t)) - #endif // !defined(BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR) - - #if !defined(BOOST_SPIRIT_DEBUG_TRACE_RULE_NAME) - #define BOOST_SPIRIT_DEBUG_TRACE_RULE_NAME(r, n, t) \ - ::boost::spirit::impl::get_node_registry().register_node(&r, (n), (t)) - #endif // !defined(BOOST_SPIRIT_DEBUG_TRACE_RULE_NAME) - - #if !defined(BOOST_SPIRIT_DEBUG_TRACE_NODE_NAME) - #define BOOST_SPIRIT_DEBUG_TRACE_NODE_NAME(r, n, t) \ - ::boost::spirit::impl::get_node_registry().register_node(&r, (n), (t)) - #endif // !defined(BOOST_SPIRIT_DEBUG_TRACE_NODE_NAME) - - #if !defined(BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR_NAME) - #define BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR_NAME(r, n, t) \ - ::boost::spirit::impl::get_node_registry().register_node(&r, (n), (t)) - #endif // !defined(BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR_NAME) - - ////////////////////////////////// - #include - -#else - ////////////////////////////////// - #include - -#endif // BOOST_SPIRIT_DEBUG - -#endif - diff --git a/boost/boost/spirit/debug/minimal.hpp b/boost/boost/spirit/debug/minimal.hpp deleted file mode 100644 index 47b6c781eb..0000000000 --- a/boost/boost/spirit/debug/minimal.hpp +++ /dev/null @@ -1,82 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - Copyright (c) 2002-2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_MINIMAL_DEBUG_HPP) -#define BOOST_SPIRIT_MINIMAL_DEBUG_HPP - -#if !defined(BOOST_SPIRIT_DEBUG_MAIN_HPP) -#error "You must include boost/spirit/debug.hpp, not boost/spirit/debug/minimal.hpp" -#endif -/////////////////////////////////////////////////////////////////////////////// -// -// Minimum debugging tools support -// -/////////////////////////////////////////////////////////////////////////////// -#if !defined(BOOST_SPIRIT_DEBUG_OUT) -#define BOOST_SPIRIT_DEBUG_OUT std::cout -#endif - -/////////////////////////////////////////////////////////////////////////// -// -// BOOST_SPIRIT_DEBUG_FLAGS controls the level of diagnostics printed -// -/////////////////////////////////////////////////////////////////////////// -#if !defined(BOOST_SPIRIT_DEBUG_FLAGS_NONE) -#define BOOST_SPIRIT_DEBUG_FLAGS_NONE 0x0000 // no diagnostics at all -#endif - -#if !defined(BOOST_SPIRIT_DEBUG_FLAGS_MAX) -#define BOOST_SPIRIT_DEBUG_FLAGS_MAX 0xFFFF // print maximal diagnostics -#endif - -#if !defined(BOOST_SPIRIT_DEBUG_FLAGS) -#define BOOST_SPIRIT_DEBUG_FLAGS SPIRIT_DEBUG_FLAGS_MAX -#endif - -#if !defined(BOOST_SPIRIT_DEBUG_PRINT_SOME) -#define BOOST_SPIRIT_DEBUG_PRINT_SOME 20 -#endif - -#if !defined(BOOST_SPIRIT_DEBUG_RULE) -#define BOOST_SPIRIT_DEBUG_RULE(r) -#endif // !defined(BOOST_SPIRIT_DEBUG_RULE) - -#if !defined(BOOST_SPIRIT_DEBUG_NODE) -#define BOOST_SPIRIT_DEBUG_NODE(r) -#endif // !defined(BOOST_SPIRIT_DEBUG_NODE) - -#if !defined(BOOST_SPIRIT_DEBUG_GRAMMAR) -#define BOOST_SPIRIT_DEBUG_GRAMMAR(r) -#endif // !defined(BOOST_SPIRIT_DEBUG_GRAMMAR) - -#if !defined(BOOST_SPIRIT_DEBUG_TRACE_RULE) -#define BOOST_SPIRIT_DEBUG_TRACE_RULE(r, t) -#endif // !defined(BOOST_SPIRIT_DEBUG_TRACE_RULE) - -#if !defined(BOOST_SPIRIT_DEBUG_TRACE_NODE) -#define BOOST_SPIRIT_DEBUG_TRACE_NODE(r, t) -#endif // !defined(BOOST_SPIRIT_DEBUG_TRACE_NODE) - -#if !defined(BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR) -#define BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR(r, t) -#endif // !defined(BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR) - -#if !defined(BOOST_SPIRIT_DEBUG_TRACE_RULE_NAME) -#define BOOST_SPIRIT_DEBUG_TRACE_RULE_NAME(r, n, t) -#endif // !defined(BOOST_SPIRIT_DEBUG_TRACE_RULE_NAME) - -#if !defined(BOOST_SPIRIT_DEBUG_TRACE_NODE_NAME) -#define BOOST_SPIRIT_DEBUG_TRACE_NODE_NAME(r, n, t) -#endif // !defined(BOOST_SPIRIT_DEBUG_TRACE_NODE_NAME) - -#if !defined(BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR_NAME) -#define BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR_NAME(r, n, t) -#endif // !defined(BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR_NAME) - -#endif // !defined(BOOST_SPIRIT_MINIMAL_DEBUG_HPP) diff --git a/boost/boost/spirit/dynamic/if.hpp b/boost/boost/spirit/dynamic/if.hpp deleted file mode 100644 index 81cc4c1b16..0000000000 --- a/boost/boost/spirit/dynamic/if.hpp +++ /dev/null @@ -1,225 +0,0 @@ -/*============================================================================= - Copyright (c) 2002-2003 Joel de Guzman - Copyright (c) 2002 Juan Carlos Arevalo-Baeza - Copyright (c) 2002-2003 Martin Wille - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_IF_HPP -#define BOOST_SPIRIT_IF_HPP - -#include -#include -#include - -namespace boost { namespace spirit { - - namespace impl { - - ////////////////////////////////// - // if-else-parser, holds two alternative parsers and a conditional functor - // that selects between them. - template - struct if_else_parser - : public condition_evaluator::type> - , public binary - < - typename as_parser::type, - typename as_parser::type, - parser< if_else_parser > - > - { - typedef if_else_parser self_t; - - typedef as_parser as_parser_true_t; - typedef as_parser as_parser_false_t; - typedef typename as_parser_true_t::type parser_true_t; - typedef typename as_parser_false_t::type parser_false_t; - typedef as_parser cond_as_parser_t; - typedef typename cond_as_parser_t::type condition_t; - - typedef binary > base_t; - typedef condition_evaluator eval_t; - - if_else_parser - ( - ParsableTrueT const& p_true, - ParsableFalseT const& p_false, - CondT const& cond_ - ) - : eval_t(cond_as_parser_t::convert(cond_)) - , base_t - ( - as_parser_true_t::convert(p_true), - as_parser_false_t::convert(p_false) - ) - { } - - template - struct result - { - typedef typename match_result::type type; - }; - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result - ::type then_result_t; - typedef typename parser_result - ::type else_result_t; - - typename ScannerT::iterator_t const save(scan.first); - - std::ptrdiff_t length = this->evaluate(scan); - if (length >= 0) - { - then_result_t then_result(this->left().parse(scan)); - if (then_result) - { - length += then_result.length(); - return scan.create_match(std::size_t(length), nil_t(), save, scan.first); - } - } - else - { - else_result_t else_result(this->right().parse(scan)); - if (else_result) - { - length = else_result.length(); - return scan.create_match(std::size_t(length), nil_t(), save, scan.first); - } - } - return scan.no_match(); - } - }; - - ////////////////////////////////// - // if-else-parser generator, takes the false-parser in brackets - // and returns the if-else-parser. - template - struct if_else_parser_gen - { - if_else_parser_gen(ParsableTrueT const& p_true_, CondT const& cond_) - : p_true(p_true_) - , cond(cond_) {} - - template - if_else_parser - < - ParsableTrueT, - ParsableFalseT, - CondT - > - operator[](ParsableFalseT const& p_false) const - { - return if_else_parser - ( - p_true, - p_false, - cond - ); - } - - ParsableTrueT const &p_true; - CondT const &cond; - }; - - ////////////////////////////////// - // if-parser, conditionally runs a parser is a functor condition is true. - // If the condition is fales, it fails the parse. - // It can optionally become an if-else-parser through the member else_p. - template - struct if_parser - : public condition_evaluator::type> - , public unary - < - typename as_parser::type, - parser > > - { - typedef if_parser self_t; - typedef as_parser as_parser_t; - typedef typename as_parser_t::type parser_t; - - typedef as_parser cond_as_parser_t; - typedef typename cond_as_parser_t::type condition_t; - typedef condition_evaluator eval_t; - typedef unary > base_t; - - if_parser(ParsableT const& p, CondT const& cond_) - : eval_t(cond_as_parser_t::convert(cond_)) - , base_t(as_parser_t::convert(p)) - , else_p(p, cond_) - {} - - template - struct result - { - typedef typename match_result::type type; - }; - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type t_result_t; - typename ScannerT::iterator_t const save(scan.first); - - std::ptrdiff_t length = this->evaluate(scan); - if (length >= 0) - { - t_result_t then_result(this->subject().parse(scan)); - if (then_result) - { - length += then_result.length(); - return scan.create_match(std::size_t(length), nil_t(), save, scan.first); - } - return scan.no_match(); - } - return scan.empty_match(); - } - - if_else_parser_gen else_p; - }; - - ////////////////////////////////// - // if-parser generator, takes the true-parser in brackets and returns the - // if-parser. - template - struct if_parser_gen - { - if_parser_gen(CondT const& cond_) : cond(cond_) {} - - template - if_parser - < - ParsableT, - CondT - > - operator[](ParsableT const& subject) const - { - return if_parser(subject, cond); - } - - CondT const &cond; - }; - -} // namespace impl - -////////////////////////////////// -// if_p function, returns "if" parser generator - -template -impl::if_parser_gen -if_p(CondT const& cond) -{ - return impl::if_parser_gen(cond); -} - -}} // namespace boost::spirit - -#endif // BOOST_SPIRIT_IF_HPP diff --git a/boost/boost/spirit/dynamic/impl/conditions.ipp b/boost/boost/spirit/dynamic/impl/conditions.ipp deleted file mode 100644 index a2fd032728..0000000000 --- a/boost/boost/spirit/dynamic/impl/conditions.ipp +++ /dev/null @@ -1,100 +0,0 @@ -/*============================================================================= - Copyright (c) 2002-2003 Martin Wille - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_CONDITIONS_IPP -#define BOOST_SPIRIT_CONDITIONS_IPP - -/////////////////////////////////////////////////////////////////////////////// -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - - namespace impl { - -/////////////////////////////////////////////////////////////////////////////// -// -// condition evaluation -// -/////////////////////////////////////////////////////////////////////////////// - ////////////////////////////////// - // condition_parser_selector, decides which parser to use for a condition - // If the template argument is a parser then that parser is used. - // If the template argument is a functor then a condition parser using - // the functor is chosen - - template struct embed_t_accessor - { - typedef typename T::embed_t type; - }; - -#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 - template <> struct embed_t_accessor - { - typedef int type; - }; -#endif - - template - struct condition_parser_selector - { - typedef - typename mpl::if_< - is_parser, - ConditionT, - condition_parser - >::type - type; - - typedef typename embed_t_accessor::type embed_t; - }; - - ////////////////////////////////// - // condition_evaluator, uses a parser to check wether a condition is met - // takes a parser or a functor that can be evaluated in boolean context - // as template parameter. - - // JDG 4-15-03 refactored - template - struct condition_evaluator - { - typedef condition_parser_selector selector_t; - typedef typename selector_t::type selected_t; - typedef typename selector_t::embed_t cond_embed_t; - - typedef typename boost::call_traits::param_type - param_t; - - condition_evaluator(param_t s) : cond(s) {} - - ///////////////////////////// - // evaluate, checks wether condition is met - // returns length of a match or a negative number for no-match - template - std::ptrdiff_t - evaluate(ScannerT const &scan) const - { - typedef typename ScannerT::iterator_t iterator_t; - typedef typename parser_result::type cres_t; - iterator_t save(scan.first); - cres_t result = cond.parse(scan); - if (!result) // reset the position if evaluation - scan.first = save; // fails. - return result.length(); - } - - cond_embed_t cond; - }; - -/////////////////////////////////////////////////////////////////////////////// - } // namespace impl - -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/error_handling.hpp b/boost/boost/spirit/error_handling.hpp deleted file mode 100644 index 3d94ca40b2..0000000000 --- a/boost/boost/spirit/error_handling.hpp +++ /dev/null @@ -1,22 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_ERROR_HANDLING_MAIN_HPP) -#define BOOST_SPIRIT_ERROR_HANDLING_MAIN_HPP - -#include - -/////////////////////////////////////////////////////////////////////////////// -// -// Master header for Spirit.ErrorHandling -// -/////////////////////////////////////////////////////////////////////////////// - -#include - -#endif // !defined(BOOST_SPIRIT_ERROR_HANDLING_MAIN_HPP) diff --git a/boost/boost/spirit/error_handling/exceptions.hpp b/boost/boost/spirit/error_handling/exceptions.hpp deleted file mode 100644 index a848a0f231..0000000000 --- a/boost/boost/spirit/error_handling/exceptions.hpp +++ /dev/null @@ -1,361 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_EXCEPTIONS_HPP -#define BOOST_SPIRIT_EXCEPTIONS_HPP - -#include -#include -#include -#include -#include - -#include - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // parser_error_base class - // - // This is the base class of parser_error (see below). This may be - // used to catch any type of parser error. - // - // This exception shouldn't propagate outside the parser. However to - // avoid quirks of many platforms/implementations which fall outside - // the C++ standard, we derive parser_error_base from std::exception - // to allow a single catch handler to catch all exceptions. - // - /////////////////////////////////////////////////////////////////////////// - class parser_error_base : public std::exception - { - protected: - - parser_error_base() {} - virtual ~parser_error_base() throw() {} - - public: - - parser_error_base(parser_error_base const& rhs) - : std::exception(rhs) {} - parser_error_base& operator=(parser_error_base const&) - { - return *this; - } - }; - - /////////////////////////////////////////////////////////////////////////// - // - // parser_error class - // - // Generic parser exception class. This is the base class for all - // parser exceptions. The exception holds the iterator position - // where the error was encountered in its member variable "where". - // The parser_error also holds information regarding the error - // (error descriptor) in its member variable "descriptor". - // - // The throw_ function creates and throws a parser_error given - // an iterator and an error descriptor. - // - /////////////////////////////////////////////////////////////////////////// - template - struct parser_error : public parser_error_base - { - typedef ErrorDescrT error_descr_t; - typedef IteratorT iterator_t; - - parser_error(IteratorT where_, ErrorDescrT descriptor_) - : where(where_), descriptor(descriptor_) {} - - parser_error(parser_error const& rhs) - : parser_error_base(rhs) - , where(rhs.where), descriptor(rhs.descriptor) {} - - parser_error& - operator=(parser_error const& rhs) - { - where = rhs.where; - descriptor = rhs.descriptor; - return *this; - } - - virtual - ~parser_error() throw() {} - - virtual const char* - what() const throw() - { - return "boost::spirit::parser_error"; - } - - IteratorT where; - ErrorDescrT descriptor; - }; - - ////////////////////////////////// - template - inline void - throw_(IteratorT where, ErrorDescrT descriptor) - { - boost::throw_exception( - parser_error(where, descriptor)); - } - - /////////////////////////////////////////////////////////////////////////// - // - // assertive_parser class - // - // An assertive_parser class is a parser that throws an exception - // in response to a parsing failure. The assertive_parser throws a - // parser_error exception rather than returning an unsuccessful - // match to signal that the parser failed to match the input. - // - /////////////////////////////////////////////////////////////////////////// - template - struct assertive_parser - : public unary > > - { - typedef assertive_parser self_t; - typedef unary > base_t; - typedef unary_parser_category parser_category_t; - - assertive_parser(ParserT const& parser, ErrorDescrT descriptor) - : base_t(parser), descriptor(descriptor) {} - - template - struct result - { - typedef typename parser_result::type type; - }; - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - typedef typename ScannerT::iterator_t iterator_t; - - result_t hit = this->subject().parse(scan); - if (!hit) - { - throw_(scan.first, descriptor); - } - return hit; - } - - ErrorDescrT descriptor; - }; - - /////////////////////////////////////////////////////////////////////////// - // - // assertion class - // - // assertive_parsers are never instantiated directly. The assertion - // class is used to indirectly create an assertive_parser object. - // Before declaring the grammar, we declare some assertion objects. - // Examples: - // - // enum Errors - // { - // program_expected, begin_expected, end_expected - // }; - // - // assertion expect_program(program_expected); - // assertion expect_begin(begin_expected); - // assertion expect_end(end_expected); - // - // Now, we can use these assertions as wrappers around parsers: - // - // expect_end(str_p("end")) - // - // Take note that although the example uses enums to hold the - // information regarding the error (error desccriptor), we are free - // to use other types such as integers and strings. Enums are - // convenient for error handlers to easily catch since C++ treats - // enums as unique types. - // - /////////////////////////////////////////////////////////////////////////// - template - struct assertion - { - assertion(ErrorDescrT descriptor_) - : descriptor(descriptor_) {} - - template - assertive_parser - operator()(ParserT const& parser) const - { - return assertive_parser(parser, descriptor); - } - - ErrorDescrT descriptor; - }; - - /////////////////////////////////////////////////////////////////////////// - // - // error_status - // - // Where T is an attribute type compatible with the match attribute - // of the fallback_parser's subject (defaults to nil_t). The class - // error_status reports the result of an error handler (see - // fallback_parser). result can be one of: - // - // fail: quit and fail (return a no_match) - // retry: attempt error recovery, possibly moving the scanner - // accept: force success returning a matching length, moving - // the scanner appropriately and returning an attribute - // value - // rethrow: rethrows the error. - // - /////////////////////////////////////////////////////////////////////////// - template - struct error_status - { - enum result_t { fail, retry, accept, rethrow }; - - error_status( - result_t result_ = fail, - std::ptrdiff_t length = -1, - T const& value_ = T()) - : result(result_), length(length), value(value_) {} - - result_t result; - std::ptrdiff_t length; - T value; - }; - - /////////////////////////////////////////////////////////////////////////// - // - // fallback_parser class - // - // Handles exceptions of type parser_error - // thrown somewhere inside its embedded ParserT object. The class - // sets up a try block before delegating parsing to its subject. - // When an exception is caught, the catch block then calls the - // HandlerT object. HandlerT may be a function or a functor (with - // an operator() member function) compatible with the interface: - // - // error_status - // handler(ScannerT const& scan, ErrorT error); - // - // Where scan points to the scanner state prior to parsing and error - // is the error that arose (see parser_error). The handler must - // return an error_status object (see above). - // - /////////////////////////////////////////////////////////////////////////// - namespace impl - { - template - RT fallback_parser_parse(ParserT const& p, ScannerT const& scan); - } - - template - struct fallback_parser - : public unary > > - { - typedef fallback_parser - self_t; - typedef ErrorDescrT - error_descr_t; - typedef unary > - base_t; - typedef unary_parser_category - parser_category_t; - - fallback_parser(ParserT const& parser, HandlerT const& handler_) - : base_t(parser), handler(handler_) {} - - template - struct result - { - typedef typename parser_result::type type; - }; - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - return impl::fallback_parser_parse(*this, scan); - } - - HandlerT handler; - }; - - /////////////////////////////////////////////////////////////////////////// - // - // guard class - // - // fallback_parser objects are not instantiated directly. The guard - // class is used to indirectly create a fallback_parser object. - // guards are typically predeclared just like assertions (see the - // assertion class above; the example extends the previous example - // introduced in the assertion class above): - // - // guard my_guard; - // - // Errors, in this example is the error descriptor type we want to - // detect; This is essentially the ErrorDescrT template parameter - // of the fallback_parser class. - // - // my_guard may now be used in a grammar declaration as: - // - // my_guard(p)[h] - // - // where p is a parser, h is a function or functor compatible with - // fallback_parser's HandlerT (see above). - // - /////////////////////////////////////////////////////////////////////////// - template - struct guard_gen : public unary - { - typedef guard parser_generator_t; - typedef unary_parser_category parser_category_t; - - guard_gen(ParserT const& p) - : unary(p) {} - - template - fallback_parser - operator[](HandlerT const& handler) const - { - return fallback_parser - (this->subject(), handler); - } - }; - - template - struct guard - { - template - struct result - { - typedef guard_gen type; - }; - - template - static guard_gen - generate(ParserT const& parser) - { - return guard_gen(parser); - } - - template - guard_gen - operator()(ParserT const& parser) const - { - return guard_gen(parser); - } - }; - -}} // namespace boost::spirit - -#include -#endif - diff --git a/boost/boost/spirit/error_handling/impl/exceptions.ipp b/boost/boost/spirit/error_handling/impl/exceptions.ipp deleted file mode 100644 index e1a871b0c9..0000000000 --- a/boost/boost/spirit/error_handling/impl/exceptions.ipp +++ /dev/null @@ -1,85 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_EXCEPTIONS_IPP -#define BOOST_SPIRIT_EXCEPTIONS_IPP - -namespace boost { namespace spirit { namespace impl { - -#ifdef __BORLANDC__ - template - typename parser_result::type - fallback_parser_helper(ParserT const& subject, ScannerT const& scan); -#endif - - template - RT fallback_parser_parse(ParserT const& p, ScannerT const& scan) - { - typedef typename ScannerT::iterator_t iterator_t; - typedef typename RT::attr_t attr_t; - typedef error_status error_status_t; - typedef typename ParserT::error_descr_t error_descr_t; - - iterator_t save = scan.first; - error_status_t hr(error_status_t::retry); - - while (hr.result == error_status_t::retry) - { - try - { - #ifndef __BORLANDC__ - return p.subject().parse(scan); - #else - return impl::fallback_parser_helper(p, scan); - #endif - } - - catch (parser_error& error) - { - scan.first = save; - hr = p.handler(scan, error); - switch (hr.result) - { - case error_status_t::fail: - return scan.no_match(); - case error_status_t::accept: - return scan.create_match - (std::size_t(hr.length), hr.value, save, scan.first); - case error_status_t::rethrow: - boost::throw_exception(error); - default: - continue; - } - } - } - return scan.no_match(); - } - -/////////////////////////////////////////////////////////////////////////// -// -// Borland does not like calling the subject directly in the try block. -// Removing the #ifdef __BORLANDC__ code makes Borland complain that -// some variables and types cannot be found in the catch block. Weird! -// -/////////////////////////////////////////////////////////////////////////// -#ifdef __BORLANDC__ - - template - typename parser_result::type - fallback_parser_helper(ParserT const& p, ScannerT const& scan) - { - return p.subject().parse(scan); - } - -#endif - -}}} // namespace boost::spirit::impl - -/////////////////////////////////////////////////////////////////////////////// -#endif - diff --git a/boost/boost/spirit/iterator.hpp b/boost/boost/spirit/iterator.hpp deleted file mode 100644 index b0719c13b0..0000000000 --- a/boost/boost/spirit/iterator.hpp +++ /dev/null @@ -1,26 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Daniel Nuffer - Copyright (c) 2003 Giovanni Bajo - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_ITERATOR_MAIN_HPP) -#define BOOST_SPIRIT_ITERATOR_MAIN_HPP - -#include - -/////////////////////////////////////////////////////////////////////////////// -// -// Master header for Spirit.Iterators -// -/////////////////////////////////////////////////////////////////////////////// - -#include -#include -#include -#include - -#endif // !defined(BOOST_SPIRIT_ITERATOR_MAIN_HPP) diff --git a/boost/boost/spirit/iterator/file_iterator.hpp b/boost/boost/spirit/iterator/file_iterator.hpp deleted file mode 100644 index 3edd0c072f..0000000000 --- a/boost/boost/spirit/iterator/file_iterator.hpp +++ /dev/null @@ -1,225 +0,0 @@ -/*============================================================================= - Copyright (c) 2003 Giovanni Bajo - Copyright (c) 2003 Thomas Witt - Copyright (c) 2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ - -/////////////////////////////////////////////////////////////////////////////// -// -// File Iterator structure -// -// The new structure is designed on layers. The top class (used by the user) -// is file_iterator, which implements a full random access iterator through -// the file, and some specific member functions (constructor that opens -// the file, make_end() to generate the end iterator, operator bool to check -// if the file was opened correctly). -// -// file_iterator implements the random access iterator interface by the means -// of boost::iterator_adaptor, that is inhering an object created with it. -// iterator_adaptor gets a low-level file iterator implementation (with just -// a few member functions) and a policy (that basically describes to it how -// the low-level file iterator interface is). The advantage is that -// with boost::iterator_adaptor only 5 functions are needed to implement -// a fully conformant random access iterator, instead of dozens of functions -// and operators. -// -// There are two low-level file iterators implemented in this module. The -// first (std_file_iterator) uses cstdio stream functions (fopen/fread), which -// support full buffering, and is available everywhere (it's standard C++). -// The second (mmap_file_iterator) is currently available only on Windows -// platforms, and uses memory mapped files, which gives a decent speed boost. -// -/////////////////////////////////////////////////////////////////////////////// -// -// TODO LIST: -// -// - In the Win32 mmap iterator, we could check if keeping a handle to the -// opened file is really required. If it's not, we can just store the file -// length (for make_end()) and save performance. Notice that this should be -// tested under different Windows versions, the behaviour might change. -// - Add some error support (by the means of some exceptions) in case of -// low-level I/O failure. -// -/////////////////////////////////////////////////////////////////////////////// - -#ifndef BOOST_SPIRIT_FILE_ITERATOR_HPP -#define BOOST_SPIRIT_FILE_ITERATOR_HPP - -#include -#include -#include -#include - -#include - -#if !defined(BOOST_SPIRIT_FILEITERATOR_STD) -# if (defined(WIN32) || defined(_WIN32) || defined(__WIN32__)) \ - && !defined(BOOST_DISABLE_WIN32) -# define BOOST_SPIRIT_FILEITERATOR_WINDOWS -# elif defined(BOOST_HAS_UNISTD_H) -extern "C" -{ -# include -} -# ifdef _POSIX_MAPPED_FILES -# define BOOST_SPIRIT_FILEITERATOR_POSIX -# endif // _POSIX_MAPPED_FILES -# endif // BOOST_HAS_UNISTD_H - -# if !defined(BOOST_SPIRIT_FILEITERATOR_WINDOWS) && \ - !defined(BOOST_SPIRIT_FILEITERATOR_POSIX) -# define BOOST_SPIRIT_FILEITERATOR_STD -# endif -#endif // BOOST_SPIRIT_FILEITERATOR_STD - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -template < - typename CharT = char, - typename BaseIterator = -#ifdef BOOST_SPIRIT_FILEITERATOR_STD - fileiter_impl::std_file_iterator -#else - fileiter_impl::mmap_file_iterator -#endif -> class file_iterator; - -/////////////////////////////////////////////////////////////////////////////// -namespace fileiter_impl { - - ///////////////////////////////////////////////////////////////////////// - // - // file_iter_generator - // - // Template meta-function to invoke boost::iterator_adaptor - // NOTE: This cannot be moved into the implementation file because of - // a bug of MSVC 7.0 and previous versions (base classes types are - // looked up at compilation time, not instantion types, and - // file_iterator would break). - // - ///////////////////////////////////////////////////////////////////////// - -#if !defined(BOOST_ITERATOR_ADAPTORS_VERSION) || \ - BOOST_ITERATOR_ADAPTORS_VERSION < 0x0200 -#error "Please use at least Boost V1.31.0 while compiling the file_iterator class!" -#else // BOOST_ITERATOR_ADAPTORS_VERSION < 0x0200 - - template - struct file_iter_generator - { - public: - typedef BaseIteratorT adapted_t; - typedef typename adapted_t::value_type value_type; - - typedef boost::iterator_adaptor < - file_iterator, - adapted_t, - value_type const, - std::random_access_iterator_tag, - boost::use_default, - std::ptrdiff_t - > type; - }; - -#endif // BOOST_ITERATOR_ADAPTORS_VERSION < 0x0200 - -/////////////////////////////////////////////////////////////////////////////// -} /* namespace impl */ - - -/////////////////////////////////////////////////////////////////////////////// -// -// file_iterator -// -// Iterates through an opened file. -// -// The main iterator interface is implemented by the iterator_adaptors -// library, which wraps a conforming iterator interface around the -// impl::BaseIterator class. This class merely derives the iterator_adaptors -// generated class to implement the custom constructors and make_end() -// member function. -// -/////////////////////////////////////////////////////////////////////////////// - -template -class file_iterator - : public fileiter_impl::file_iter_generator::type, - public safe_bool > -{ -private: - typedef typename - fileiter_impl::file_iter_generator::type - base_t; - typedef typename - fileiter_impl::file_iter_generator::adapted_t - adapted_t; - -public: - file_iterator() - {} - - file_iterator(std::string fileName) - : base_t(adapted_t(fileName)) - {} - - file_iterator(const base_t& iter) - : base_t(iter) - {} - - inline file_iterator& operator=(const base_t& iter); - file_iterator make_end(void); - - // operator bool. This borrows a trick from boost::shared_ptr to avoid - // to interfere with arithmetic operations. - bool operator_bool(void) const - { return this->base(); } - -private: - friend class ::boost::iterator_core_access; - - typename base_t::reference dereference() const - { - return this->base_reference().get_cur_char(); - } - - void increment() - { - this->base_reference().next_char(); - } - - void decrement() - { - this->base_reference().prev_char(); - } - - void advance(typename base_t::difference_type n) - { - this->base_reference().advance(n); - } - - template < - typename OtherDerivedT, typename OtherIteratorT, - typename V, typename C, typename R, typename D - > - typename base_t::difference_type distance_to( - iterator_adaptor - const &x) const - { - return x.base().distance(this->base_reference()); - } -}; - -/////////////////////////////////////////////////////////////////////////////// -}} /* namespace boost::spirit */ - -/////////////////////////////////////////////////////////////////////////////// -#include /* implementation */ - -#endif /* BOOST_SPIRIT_FILE_ITERATOR_HPP */ - diff --git a/boost/boost/spirit/iterator/fixed_size_queue.hpp b/boost/boost/spirit/iterator/fixed_size_queue.hpp deleted file mode 100644 index 9f18b42288..0000000000 --- a/boost/boost/spirit/iterator/fixed_size_queue.hpp +++ /dev/null @@ -1,398 +0,0 @@ -/*============================================================================= - Copyright (c) 2001, Daniel C. Nuffer - Copyright (c) 2003, Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef FIXED_SIZE_QUEUE -#define FIXED_SIZE_QUEUE - -#include -#include -#include - -#include // for BOOST_SPIRIT_ASSERT - -// FIXES for broken compilers -#include -#include - -#define BOOST_SPIRIT_ASSERT_FSQ_SIZE \ - BOOST_SPIRIT_ASSERT(((m_tail + N + 1) - m_head) % (N+1) == m_size % (N+1)) \ - /**/ - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -/////////////////////////////////////////////////////////////////////////////// -namespace impl { - -#if !defined(BOOST_ITERATOR_ADAPTORS_VERSION) || \ - BOOST_ITERATOR_ADAPTORS_VERSION < 0x0200 -#error "Please use at least Boost V1.31.0 while compiling the fixed_size_queue class!" -#else // BOOST_ITERATOR_ADAPTORS_VERSION < 0x0200 - -template -class fsq_iterator -: public boost::iterator_adaptor< - fsq_iterator, - PointerT, - T, - std::random_access_iterator_tag - > -{ -public: - typedef typename QueueT::position_t position; - typedef boost::iterator_adaptor< - fsq_iterator, PointerT, T, - std::random_access_iterator_tag - > base_t; - - fsq_iterator() {} - fsq_iterator(position const &p_) : p(p_) {} - - position const &get_position() const { return p; } - -private: - friend class boost::iterator_core_access; - - typename base_t::reference dereference() const - { - return p.self->m_queue[p.pos]; - } - - void increment() - { - ++p.pos; - if (p.pos == QueueT::MAX_SIZE+1) - p.pos = 0; - } - - void decrement() - { - if (p.pos == 0) - p.pos = QueueT::MAX_SIZE; - else - --p.pos; - } - - template < - typename OtherDerivedT, typename OtherIteratorT, - typename V, typename C, typename R, typename D - > - bool equal(iterator_adaptor - const &x) const - { - position const &rhs_pos = - static_cast(x).get_position(); - return (p.self == rhs_pos.self) && (p.pos == rhs_pos.pos); - } - - template < - typename OtherDerivedT, typename OtherIteratorT, - typename V, typename C, typename R, typename D - > - typename base_t::difference_type distance_to( - iterator_adaptor - const &x) const - { - typedef typename base_t::difference_type diff_t; - - position const &p2 = - static_cast(x).get_position(); - std::size_t pos1 = p.pos; - std::size_t pos2 = p2.pos; - - // Undefined behaviour if the iterators come from different - // containers - BOOST_SPIRIT_ASSERT(p.self == p2.self); - - if (pos1 < p.self->m_head) - pos1 += QueueT::MAX_SIZE; - if (pos2 < p2.self->m_head) - pos2 += QueueT::MAX_SIZE; - - if (pos2 > pos1) - return diff_t(pos2 - pos1); - else - return -diff_t(pos1 - pos2); - } - - void advance(typename base_t::difference_type n) - { - // Notice that we don't care values of n that can - // wrap around more than one time, since it would - // be undefined behaviour anyway (going outside - // the begin/end range). Negative wrapping is a bit - // cumbersome because we don't want to case p.pos - // to signed. - if (n < 0) - { - n = -n; - if (p.pos < (std::size_t)n) - p.pos = QueueT::MAX_SIZE+1 - (n - p.pos); - else - p.pos -= n; - } - else - { - p.pos += n; - if (p.pos >= QueueT::MAX_SIZE+1) - p.pos -= QueueT::MAX_SIZE+1; - } - } - -private: - position p; -}; - -#endif // BOOST_ITERATOR_ADAPTORS_VERSION < 0x0200 - -/////////////////////////////////////////////////////////////////////////////// -} /* namespace impl */ - -template -class fixed_size_queue -{ -private: - struct position - { - fixed_size_queue* self; - std::size_t pos; - - position() : self(0), pos(0) {} - - // The const_cast here is just to avoid to have two different - // position structures for the const and non-const case. - // The const semantic is guaranteed by the iterator itself - position(const fixed_size_queue* s, std::size_t p) - : self(const_cast(s)), pos(p) - {} - }; - -public: - // Declare the iterators - typedef impl::fsq_iterator, T, T*> iterator; - typedef impl::fsq_iterator, T const, T const*> - const_iterator; - typedef position position_t; - - friend class impl::fsq_iterator, T, T*>; - friend class impl::fsq_iterator, T const, T const*>; - - fixed_size_queue(); - fixed_size_queue(const fixed_size_queue& x); - fixed_size_queue& operator=(const fixed_size_queue& x); - ~fixed_size_queue(); - - void push_back(const T& e); - void push_front(const T& e); - void serve(T& e); - void pop_front(); - - bool empty() const - { - return m_size == 0; - } - - bool full() const - { - return m_size == N; - } - - iterator begin() - { - return iterator(position(this, m_head)); - } - - const_iterator begin() const - { - return const_iterator(position(this, m_head)); - } - - iterator end() - { - return iterator(position(this, m_tail)); - } - - const_iterator end() const - { - return const_iterator(position(this, m_tail)); - } - - std::size_t size() const - { - return m_size; - } - - T& front() - { - return m_queue[m_head]; - } - - const T& front() const - { - return m_queue[m_head]; - } - -private: - // Redefine the template parameters to avoid using partial template - // specialization on the iterator policy to extract N. - BOOST_STATIC_CONSTANT(std::size_t, MAX_SIZE = N); - - std::size_t m_head; - std::size_t m_tail; - std::size_t m_size; - T m_queue[N+1]; -}; - -template -inline -fixed_size_queue::fixed_size_queue() - : m_head(0) - , m_tail(0) - , m_size(0) -{ - BOOST_SPIRIT_ASSERT(m_size <= N+1); - BOOST_SPIRIT_ASSERT_FSQ_SIZE; - BOOST_SPIRIT_ASSERT(m_head <= N+1); - BOOST_SPIRIT_ASSERT(m_tail <= N+1); -} - -template -inline -fixed_size_queue::fixed_size_queue(const fixed_size_queue& x) - : m_head(x.m_head) - , m_tail(x.m_tail) - , m_size(x.m_size) -{ - copy(x.begin(), x.end(), begin()); - BOOST_SPIRIT_ASSERT(m_size <= N+1); - BOOST_SPIRIT_ASSERT_FSQ_SIZE; - BOOST_SPIRIT_ASSERT(m_head <= N+1); - BOOST_SPIRIT_ASSERT(m_tail <= N+1); -} - -template -inline fixed_size_queue& -fixed_size_queue::operator=(const fixed_size_queue& x) -{ - if (this != &x) - { - m_head = x.m_head; - m_tail = x.m_tail; - m_size = x.m_size; - copy(x.begin(), x.end(), begin()); - } - BOOST_SPIRIT_ASSERT(m_size <= N+1); - BOOST_SPIRIT_ASSERT_FSQ_SIZE; - BOOST_SPIRIT_ASSERT(m_head <= N+1); - BOOST_SPIRIT_ASSERT(m_tail <= N+1); - - return *this; -} - -template -inline -fixed_size_queue::~fixed_size_queue() -{ - BOOST_SPIRIT_ASSERT(m_size <= N+1); - BOOST_SPIRIT_ASSERT_FSQ_SIZE; - BOOST_SPIRIT_ASSERT(m_head <= N+1); - BOOST_SPIRIT_ASSERT(m_tail <= N+1); -} - -template -inline void -fixed_size_queue::push_back(const T& e) -{ - BOOST_SPIRIT_ASSERT(m_size <= N+1); - BOOST_SPIRIT_ASSERT_FSQ_SIZE; - BOOST_SPIRIT_ASSERT(m_head <= N+1); - BOOST_SPIRIT_ASSERT(m_tail <= N+1); - - BOOST_SPIRIT_ASSERT(!full()); - - m_queue[m_tail] = e; - ++m_size; - ++m_tail; - if (m_tail == N+1) - m_tail = 0; - - - BOOST_SPIRIT_ASSERT(m_size <= N+1); - BOOST_SPIRIT_ASSERT_FSQ_SIZE; - BOOST_SPIRIT_ASSERT(m_head <= N+1); - BOOST_SPIRIT_ASSERT(m_tail <= N+1); -} - -template -inline void -fixed_size_queue::push_front(const T& e) -{ - BOOST_SPIRIT_ASSERT(m_size <= N+1); - BOOST_SPIRIT_ASSERT_FSQ_SIZE; - BOOST_SPIRIT_ASSERT(m_head <= N+1); - BOOST_SPIRIT_ASSERT(m_tail <= N+1); - - BOOST_SPIRIT_ASSERT(!full()); - - if (m_head == 0) - m_head = N; - else - --m_head; - - m_queue[m_head] = e; - ++m_size; - - BOOST_SPIRIT_ASSERT(m_size <= N+1); - BOOST_SPIRIT_ASSERT_FSQ_SIZE; - BOOST_SPIRIT_ASSERT(m_head <= N+1); - BOOST_SPIRIT_ASSERT(m_tail <= N+1); -} - - -template -inline void -fixed_size_queue::serve(T& e) -{ - BOOST_SPIRIT_ASSERT(m_size <= N+1); - BOOST_SPIRIT_ASSERT_FSQ_SIZE; - BOOST_SPIRIT_ASSERT(m_head <= N+1); - BOOST_SPIRIT_ASSERT(m_tail <= N+1); - - e = m_queue[m_head]; - pop_front(); -} - - - -template -inline void -fixed_size_queue::pop_front() -{ - BOOST_SPIRIT_ASSERT(m_size <= N+1); - BOOST_SPIRIT_ASSERT_FSQ_SIZE; - BOOST_SPIRIT_ASSERT(m_head <= N+1); - BOOST_SPIRIT_ASSERT(m_tail <= N+1); - - ++m_head; - if (m_head == N+1) - m_head = 0; - --m_size; - - BOOST_SPIRIT_ASSERT(m_size <= N+1); - BOOST_SPIRIT_ASSERT_FSQ_SIZE; - BOOST_SPIRIT_ASSERT(m_head <= N+1); - BOOST_SPIRIT_ASSERT(m_tail <= N+1); -} - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#undef BOOST_SPIRIT_ASSERT_FSQ_SIZE - -#endif diff --git a/boost/boost/spirit/iterator/impl/file_iterator.ipp b/boost/boost/spirit/iterator/impl/file_iterator.ipp deleted file mode 100644 index 8d22b04b5a..0000000000 --- a/boost/boost/spirit/iterator/impl/file_iterator.ipp +++ /dev/null @@ -1,460 +0,0 @@ -/*============================================================================= - Copyright (c) 2003 Giovanni Bajo - Copyright (c) 2003 Martin Wille - Copyright (c) 2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ - -#ifndef BOOST_SPIRIT_FILE_ITERATOR_IPP -#define BOOST_SPIRIT_FILE_ITERATOR_IPP - -#ifdef BOOST_SPIRIT_FILEITERATOR_WINDOWS -# define WIN32_LEAN_AND_MEAN -# include -#endif - -#include -#include - -#ifdef BOOST_SPIRIT_FILEITERATOR_WINDOWS -# include -#endif - -#ifdef BOOST_SPIRIT_FILEITERATOR_POSIX -# include // open, stat, mmap, munmap -# include // stat -# include // open -# include // stat, mmap, munmap -# include // mmap, mmunmap -#endif - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -/////////////////////////////////////////////////////////////////////////////// -namespace fileiter_impl { - -/////////////////////////////////////////////////////////////////////////////// -// -// std_file_iterator -// -// Base class that implements iteration through a file using standard C -// stream library (fopen and friends). This class and the following are -// the base components on which the iterator is built (through the -// iterator adaptor library). -// -// The opened file stream (FILE) is held with a shared_ptr<>, whose -// custom deleter invokes fcose(). This makes the syntax of the class -// very easy, especially everything related to copying. -// -/////////////////////////////////////////////////////////////////////////////// - -template -class std_file_iterator -{ -public: - typedef CharT value_type; - - std_file_iterator() - {} - - explicit std_file_iterator(std::string fileName) - { - using namespace std; - FILE* f = fopen(fileName.c_str(), "rb"); - - // If the file was opened, store it into - // the smart pointer. - if (f) - { - m_file.reset(f, fclose); - m_pos = 0; - m_eof = false; - update_char(); - } - } - - std_file_iterator(const std_file_iterator& iter) - { *this = iter; } - - std_file_iterator& operator=(const std_file_iterator& iter) - { - m_file = iter.m_file; - m_curChar = iter.m_curChar; - m_eof = iter.m_eof; - m_pos = iter.m_pos; - - return *this; - } - - // Nasty bug in Comeau up to 4.3.0.1, we need explicit boolean context - // for shared_ptr to evaluate correctly - operator bool() const - { return m_file ? true : false; } - - bool operator==(const std_file_iterator& iter) const - { - return (m_file == iter.m_file) && (m_eof == iter.m_eof) && - (m_pos == iter.m_pos); - } - - const CharT& get_cur_char(void) const - { - return m_curChar; - } - - void prev_char(void) - { - m_pos -= sizeof(CharT); - update_char(); - } - - void next_char(void) - { - m_pos += sizeof(CharT); - update_char(); - } - - void seek_end(void) - { - using namespace std; - fseek(m_file.get(), 0, SEEK_END); - m_pos = ftell(m_file.get()) / sizeof(CharT); - m_eof = true; - } - - void advance(std::ptrdiff_t n) - { - m_pos += n * sizeof(CharT); - update_char(); - } - - std::ptrdiff_t distance(const std_file_iterator& iter) const - { - return (std::ptrdiff_t)(m_pos - iter.m_pos) / sizeof(CharT); - } - -private: - boost::shared_ptr m_file; - std::size_t m_pos; - CharT m_curChar; - bool m_eof; - - void update_char(void) - { - using namespace std; - if ((std::size_t)ftell(m_file.get()) != m_pos) - fseek(m_file.get(), m_pos, SEEK_SET); - - m_eof = (fread(&m_curChar, sizeof(CharT), 1, m_file.get()) < 1); - } -}; - - -/////////////////////////////////////////////////////////////////////////////// -// -// mmap_file_iterator -// -// File iterator for memory mapped files, for now implemented on Windows and -// POSIX platforms. This class has the same interface of std_file_iterator, -// and can be used in its place (in fact, it's the default for Windows and -// POSIX). -// -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// mmap_file_iterator, Windows version -#ifdef BOOST_SPIRIT_FILEITERATOR_WINDOWS -template -class mmap_file_iterator -{ -public: - typedef CharT value_type; - - mmap_file_iterator() - {} - - explicit mmap_file_iterator(std::string fileName) - { - HANDLE hFile = ::CreateFileA( - fileName.c_str(), - GENERIC_READ, - FILE_SHARE_READ, - NULL, - OPEN_EXISTING, - FILE_FLAG_SEQUENTIAL_SCAN, - NULL - ); - - if (hFile == INVALID_HANDLE_VALUE) - return; - - // Store the size of the file, it's used to construct - // the end iterator - m_filesize = ::GetFileSize(hFile, NULL); - - HANDLE hMap = ::CreateFileMapping( - hFile, - NULL, - PAGE_READONLY, - 0, 0, - NULL - ); - - if (hMap == NULL) - { - ::CloseHandle(hFile); - return; - } - - LPVOID pMem = ::MapViewOfFile( - hMap, - FILE_MAP_READ, - 0, 0, 0 - ); - - if (pMem == NULL) - { - ::CloseHandle(hMap); - ::CloseHandle(hFile); - return; - } - - // We hold both the file handle and the memory pointer. - // We can close the hMap handle now because Windows holds internally - // a reference to it since there is a view mapped. - ::CloseHandle(hMap); - - // It seems like we can close the file handle as well (because - // a reference is hold by the filemap object). - ::CloseHandle(hFile); - - // Store the handles inside the shared_ptr (with the custom destructors) - m_mem.reset(static_cast(pMem), ::UnmapViewOfFile); - - // Start of the file - m_curChar = m_mem.get(); - } - - mmap_file_iterator(const mmap_file_iterator& iter) - { *this = iter; } - - mmap_file_iterator& operator=(const mmap_file_iterator& iter) - { - m_curChar = iter.m_curChar; - m_mem = iter.m_mem; - m_filesize = iter.m_filesize; - - return *this; - } - - // Nasty bug in Comeau up to 4.3.0.1, we need explicit boolean context - // for shared_ptr to evaluate correctly - operator bool() const - { return m_mem ? true : false; } - - bool operator==(const mmap_file_iterator& iter) const - { return m_curChar == iter.m_curChar; } - - const CharT& get_cur_char(void) const - { return *m_curChar; } - - void next_char(void) - { m_curChar++; } - - void prev_char(void) - { m_curChar--; } - - void advance(std::ptrdiff_t n) - { m_curChar += n; } - - std::ptrdiff_t distance(const mmap_file_iterator& iter) const - { return m_curChar - iter.m_curChar; } - - void seek_end(void) - { - m_curChar = m_mem.get() + - (m_filesize / sizeof(CharT)); - } - -private: -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - typedef boost::remove_pointer::type handle_t; -#else - typedef void handle_t; -#endif - - boost::shared_ptr m_mem; - std::size_t m_filesize; - CharT* m_curChar; -}; - -#endif // BOOST_SPIRIT_FILEITERATOR_WINDOWS - -/////////////////////////////////////////////////////////////////////////////// -// mmap_file_iterator, POSIX version -#ifdef BOOST_SPIRIT_FILEITERATOR_POSIX -template -class mmap_file_iterator -{ -private: - struct mapping - { - mapping(void *p, off_t len) - : data(p) - , size(len) - { } - - CharT const *begin() const - { - return static_cast(data); - } - - CharT const *end() const - { - return static_cast(data) + size/sizeof(CharT); - } - - ~mapping() - { - munmap(data, size); - } - - private: - void *data; - off_t size; - }; - -public: - typedef CharT value_type; - - mmap_file_iterator() - {} - - explicit mmap_file_iterator(std::string file_name) - { - // open the file - int fd = open(file_name.c_str(), -#ifdef O_NOCTTY - O_NOCTTY | // if stdin was closed then opening a file - // would cause the file to become the controlling - // terminal if the filename refers to a tty. Setting - // O_NOCTTY inhibits this. -#endif - O_RDONLY); - - if (fd == -1) - return; - - // call fstat to find get information about the file just - // opened (size and file type) - struct stat stat_buf; - if ((fstat(fd, &stat_buf) != 0) || !S_ISREG(stat_buf.st_mode)) - { // if fstat returns an error or if the file isn't a - // regular file we give up. - close(fd); - return; - } - - // perform the actual mapping - void *p = mmap(0, stat_buf.st_size, PROT_READ, MAP_SHARED, fd, 0); - // it is safe to close() here. POSIX requires that the OS keeps a - // second handle to the file while the file is mmapped. - close(fd); - - if (p == MAP_FAILED) - return; - - mapping *m = 0; - try - { - m = new mapping(p, stat_buf.st_size); - } - catch(...) - { - munmap(p, stat_buf.st_size); - throw; - } - - m_mem.reset(m); - - // Start of the file - m_curChar = m_mem->begin(); - } - - mmap_file_iterator(const mmap_file_iterator& iter) - { *this = iter; } - - mmap_file_iterator& operator=(const mmap_file_iterator& iter) - { - m_curChar = iter.m_curChar; - m_mem = iter.m_mem; - - return *this; - } - - // Nasty bug in Comeau up to 4.3.0.1, we need explicit boolean context - // for shared_ptr to evaluate correctly - operator bool() const - { return m_mem ? true : false; } - - bool operator==(const mmap_file_iterator& iter) const - { return m_curChar == iter.m_curChar; } - - const CharT& get_cur_char(void) const - { return *m_curChar; } - - void next_char(void) - { m_curChar++; } - - void prev_char(void) - { m_curChar--; } - - void advance(signed long n) - { m_curChar += n; } - - long distance(const mmap_file_iterator& iter) const - { return m_curChar - iter.m_curChar; } - - void seek_end(void) - { - m_curChar = m_mem->end(); - } - -private: - - boost::shared_ptr m_mem; - CharT const* m_curChar; -}; - -#endif // BOOST_SPIRIT_FILEITERATOR_POSIX - -/////////////////////////////////////////////////////////////////////////////// -} /* namespace boost::spirit::fileiter_impl */ - -template -file_iterator -file_iterator::make_end(void) -{ - file_iterator iter(*this); - iter.base_reference().seek_end(); - return iter; -} - -template -file_iterator& -file_iterator::operator=(const base_t& iter) -{ - base_t::operator=(iter); - return *this; -} - -/////////////////////////////////////////////////////////////////////////////// -}} /* namespace boost::spirit */ - - -#endif /* BOOST_SPIRIT_FILE_ITERATOR_IPP */ diff --git a/boost/boost/spirit/iterator/impl/position_iterator.ipp b/boost/boost/spirit/iterator/impl/position_iterator.ipp deleted file mode 100644 index fd97041b2a..0000000000 --- a/boost/boost/spirit/iterator/impl/position_iterator.ipp +++ /dev/null @@ -1,131 +0,0 @@ -/*============================================================================= - Copyright (c) 2002 Juan Carlos Arevalo-Baeza - Copyright (c) 2002-2006 Hartmut Kaiser - Copyright (c) 2003 Giovanni Bajo - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef POSITION_ITERATOR_IPP -#define POSITION_ITERATOR_IPP - -#include -#include -#include -#include -#include -#include // for nil_t -#include // for boost::detail::iterator_traits - -namespace boost { namespace spirit { - -/////////////////////////////////////////////////////////////////////////////// -// -// position_policy -// -// Specialization to handle file_position_without_column. Only take care of -// newlines since no column tracking is needed. -// -/////////////////////////////////////////////////////////////////////////////// -template -class position_policy > { - -public: - void next_line(file_position_without_column_base& pos) - { - ++pos.line; - } - - void set_tab_chars(unsigned int /*chars*/){} - void next_char(file_position_without_column_base& /*pos*/) {} - void tabulation(file_position_without_column_base& /*pos*/) {} -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// position_policy -// -// Specialization to handle file_position. Track characters and tabulation -// to compute the current column correctly. -// -// Default tab size is 4. You can change this with the set_tabchars member -// of position_iterator. -// -/////////////////////////////////////////////////////////////////////////////// -template -class position_policy > { - -public: - position_policy() - : m_CharsPerTab(4) - {} - - void next_line(file_position_base& pos) - { - ++pos.line; - pos.column = 1; - } - - void set_tab_chars(unsigned int chars) - { - m_CharsPerTab = chars; - } - - void next_char(file_position_base& pos) - { - ++pos.column; - } - - void tabulation(file_position_base& pos) - { - pos.column += m_CharsPerTab - (pos.column - 1) % m_CharsPerTab; - } - -private: - unsigned int m_CharsPerTab; -}; - -/* namespace boost::spirit { */ namespace iterator_ { namespace impl { - -/////////////////////////////////////////////////////////////////////////////// -// -// position_iterator_base_generator -// -// Metafunction to generate the iterator type using boost::iterator_adaptors, -// hiding all the metaprogramming thunking code in it. It is used -// mainly to keep the public interface (position_iterator) cleanear. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct position_iterator_base_generator -{ -private: - typedef boost::detail::iterator_traits traits; - typedef typename traits::value_type value_type; - typedef typename traits::iterator_category iter_category_t; - - // Position iterator is always a non-mutable iterator - typedef typename boost::add_const::type const_value_type; - -public: - // Check if the MainIterT is nil. If it's nil, it means that the actual - // self type is position_iterator. Otherwise, it's a real type we - // must use - typedef typename boost::mpl::if_< - typename boost::is_same::type, - position_iterator, - MainIterT - >::type main_iter_t; - - typedef boost::iterator_adaptor< - main_iter_t, - ForwardIterT, - const_value_type - > type; -}; - -}}}} /* namespace boost::spirit::iterator_::impl */ - -#endif diff --git a/boost/boost/spirit/iterator/multi_pass.hpp b/boost/boost/spirit/iterator/multi_pass.hpp deleted file mode 100644 index 437044f9e6..0000000000 --- a/boost/boost/spirit/iterator/multi_pass.hpp +++ /dev/null @@ -1,1295 +0,0 @@ -/*============================================================================= - Copyright (c) 2001, Daniel C. Nuffer - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_ITERATOR_MULTI_PASS_HPP -#define BOOST_SPIRIT_ITERATOR_MULTI_PASS_HPP - -#include -#include -#include -#include -#include -#include // for std::swap -#include // for std::exception -#include -#include - -#include // for BOOST_SPIRIT_ASSERT -#include -#include // for boost::detail::iterator_traits - -#include - -namespace boost { namespace spirit { - -namespace impl { - template - inline void mp_swap(T& t1, T& t2); -} - -namespace multi_pass_policies -{ - -/////////////////////////////////////////////////////////////////////////////// -// class ref_counted -// Implementation of an OwnershipPolicy used by multi_pass. -// -// Implementation modified from RefCounted class from the Loki library by -// Andrei Alexandrescu -/////////////////////////////////////////////////////////////////////////////// -class ref_counted -{ - protected: - ref_counted() - : count(new std::size_t(1)) - {} - - ref_counted(ref_counted const& x) - : count(x.count) - {} - - // clone is called when a copy of the iterator is made, so increment - // the ref-count. - void clone() - { - ++*count; - } - - // called when a copy is deleted. Decrement the ref-count. Return - // value of true indicates that the last copy has been released. - bool release() - { - if (!--*count) - { - delete count; - count = 0; - return true; - } - return false; - } - - void swap(ref_counted& x) - { - impl::mp_swap(count, x.count); - } - - public: - // returns true if there is only one iterator in existence. - // std_deque StoragePolicy will free it's buffered data if this - // returns true. - bool unique() const - { - return *count == 1; - } - - private: - std::size_t* count; -}; - -/////////////////////////////////////////////////////////////////////////////// -// class first_owner -// Implementation of an OwnershipPolicy used by multi_pass -// This ownership policy dictates that the first iterator created will -// determine the lifespan of the shared components. This works well for -// spirit, since no dynamic allocation of iterators is done, and all copies -// are make on the stack. -// -// There is a caveat about using this policy together with the std_deque -// StoragePolicy. Since first_owner always returns false from unique(), -// std_deque will only release the queued data if clear_queue() is called. -/////////////////////////////////////////////////////////////////////////////// -class first_owner -{ - protected: - first_owner() - : first(true) - {} - - first_owner(first_owner const&) - : first(false) - {} - - void clone() - { - } - - // return true to indicate deletion of resources - bool release() - { - return first; - } - - void swap(first_owner&) - { - // if we're the first, we still remain the first, even if assigned - // to, so don't swap first_. swap is only called from operator= - } - - public: - bool unique() const - { - return false; // no way to know, so always return false - } - - private: - bool first; -}; - -/////////////////////////////////////////////////////////////////////////////// -// class illegal_backtracking -// thrown by buf_id_check CheckingPolicy if an instance of an iterator is -// used after another one has invalidated the queue -/////////////////////////////////////////////////////////////////////////////// -class illegal_backtracking : public std::exception -{ -public: - - illegal_backtracking() throw() {} - ~illegal_backtracking() throw() {} - - virtual const char* - what() const throw() - { return "boost::spirit::illegal_backtracking"; } -}; - -/////////////////////////////////////////////////////////////////////////////// -// class buf_id_check -// Implementation of the CheckingPolicy used by multi_pass -// This policy is most effective when used together with the std_deque -// StoragePolicy. -// If used with the fixed_size_queue StoragePolicy, it will not detect -// iterator derefereces that are out of the range of the queue. -/////////////////////////////////////////////////////////////////////////////// -class buf_id_check -{ - protected: - buf_id_check() - : shared_buf_id(new unsigned long(0)) - , buf_id(0) - {} - - buf_id_check(buf_id_check const& x) - : shared_buf_id(x.shared_buf_id) - , buf_id(x.buf_id) - {} - - // will be called from the destructor of the last iterator. - void destroy() - { - delete shared_buf_id; - shared_buf_id = 0; - } - - void swap(buf_id_check& x) - { - impl::mp_swap(shared_buf_id, x.shared_buf_id); - impl::mp_swap(buf_id, x.buf_id); - } - - // called to verify that everything is okay. - void check() const - { - if (buf_id != *shared_buf_id) - { - boost::throw_exception(illegal_backtracking()); - } - } - - // called from multi_pass::clear_queue, so we can increment the count - void clear_queue() - { - ++*shared_buf_id; - ++buf_id; - } - - private: - unsigned long* shared_buf_id; - unsigned long buf_id; -}; - -/////////////////////////////////////////////////////////////////////////////// -// class no_check -// Implementation of the CheckingPolicy used by multi_pass -// It does not do anything :-) -/////////////////////////////////////////////////////////////////////////////// -class no_check -{ - protected: - no_check() {} - no_check(no_check const&) {} - void destroy() {} - void swap(no_check&) {} - void check() const {} - void clear_queue() {} -}; - -/////////////////////////////////////////////////////////////////////////////// -// class std_deque -// Implementation of the StoragePolicy used by multi_pass -// This stores all data in a std::deque, and keeps an offset to the current -// position. It stores all the data unless there is only one -// iterator using the queue. -// Note: a position is used instead of an iterator, because a push_back on -// a deque can invalidate any iterators. -/////////////////////////////////////////////////////////////////////////////// -class std_deque -{ - public: - -template -class inner -{ - private: - - typedef std::deque queue_type; - queue_type* queuedElements; - mutable typename queue_type::size_type queuePosition; - - protected: - inner() - : queuedElements(new queue_type) - , queuePosition(0) - {} - - inner(inner const& x) - : queuedElements(x.queuedElements) - , queuePosition(x.queuePosition) - {} - - // will be called from the destructor of the last iterator. - void destroy() - { - BOOST_SPIRIT_ASSERT(NULL != queuedElements); - delete queuedElements; - queuedElements = 0; - } - - void swap(inner& x) - { - impl::mp_swap(queuedElements, x.queuedElements); - impl::mp_swap(queuePosition, x.queuePosition); - } - - // This is called when the iterator is dereferenced. It's a template - // method so we can recover the type of the multi_pass iterator - // and call unique and access the m_input data member. - template - static typename MultiPassT::reference dereference(MultiPassT const& mp) - { - if (mp.queuePosition == mp.queuedElements->size()) - { - // check if this is the only iterator - if (mp.unique()) - { - // free up the memory used by the queue. - if (mp.queuedElements->size() > 0) - { - mp.queuedElements->clear(); - mp.queuePosition = 0; - } - } - return mp.get_input(); - } - else - { - return (*mp.queuedElements)[mp.queuePosition]; - } - } - - // This is called when the iterator is incremented. It's a template - // method so we can recover the type of the multi_pass iterator - // and call unique and access the m_input data member. - template - static void increment(MultiPassT& mp) - { - if (mp.queuePosition == mp.queuedElements->size()) - { - // check if this is the only iterator - if (mp.unique()) - { - // free up the memory used by the queue. - if (mp.queuedElements->size() > 0) - { - mp.queuedElements->clear(); - mp.queuePosition = 0; - } - } - else - { - mp.queuedElements->push_back(mp.get_input()); - ++mp.queuePosition; - } - mp.advance_input(); - } - else - { - ++mp.queuePosition; - } - - } - - // called to forcibly clear the queue - void clear_queue() - { - queuedElements->clear(); - queuePosition = 0; - } - - // called to determine whether the iterator is an eof iterator - template - static bool is_eof(MultiPassT const& mp) - { - return mp.queuePosition == mp.queuedElements->size() && - mp.input_at_eof(); - } - - // called by operator== - bool equal_to(inner const& x) const - { - return queuePosition == x.queuePosition; - } - - // called by operator< - bool less_than(inner const& x) const - { - return queuePosition < x.queuePosition; - } -}; // class inner - -}; // class std_deque - - -/////////////////////////////////////////////////////////////////////////////// -// class fixed_size_queue -// Implementation of the StoragePolicy used by multi_pass -// fixed_size_queue keeps a circular buffer (implemented by -// boost::spirit::fixed_size_queue class) that is size N+1 and stores N elements. -// It is up to the user to ensure that there is enough look ahead for their -// grammar. Currently there is no way to tell if an iterator is pointing -// to forgotten data. The leading iterator will put an item in the queue -// and remove one when it is incremented. No dynamic allocation is done, -// except on creation of the queue (fixed_size_queue constructor). -/////////////////////////////////////////////////////////////////////////////// -template < std::size_t N> -class fixed_size_queue -{ - public: - -template -class inner -{ - private: - - typedef boost::spirit::fixed_size_queue queue_type; - queue_type * queuedElements; - mutable typename queue_type::iterator queuePosition; - - protected: - inner() - : queuedElements(new queue_type) - , queuePosition(queuedElements->begin()) - {} - - inner(inner const& x) - : queuedElements(x.queuedElements) - , queuePosition(x.queuePosition) - {} - - // will be called from the destructor of the last iterator. - void destroy() - { - BOOST_SPIRIT_ASSERT(NULL != queuedElements); - delete queuedElements; - queuedElements = 0; - } - - void swap(inner& x) - { - impl::mp_swap(queuedElements, x.queuedElements); - impl::mp_swap(queuePosition, x.queuePosition); - } - - // This is called when the iterator is dereferenced. It's a template - // method so we can recover the type of the multi_pass iterator - // and access the m_input data member. - template - static typename MultiPassT::reference dereference(MultiPassT const& mp) - { - if (mp.queuePosition == mp.queuedElements->end()) - { - return mp.get_input(); - } - else - { - return *mp.queuePosition; - } - } - - // This is called when the iterator is incremented. It's a template - // method so we can recover the type of the multi_pass iterator - // and access the m_input data member. - template - static void increment(MultiPassT& mp) - { - if (mp.queuePosition == mp.queuedElements->end()) - { - // don't let the queue get larger than N - if (mp.queuedElements->size() >= N) - mp.queuedElements->pop_front(); - - mp.queuedElements->push_back(mp.get_input()); - mp.advance_input(); - } - ++mp.queuePosition; - } - - // no-op - void clear_queue() - {} - - // called to determine whether the iterator is an eof iterator - template - static bool is_eof(MultiPassT const& mp) - { - return mp.queuePosition == mp.queuedElements->end() && - mp.input_at_eof(); - } - - // called by operator== - bool equal_to(inner const& x) const - { - return queuePosition == x.queuePosition; - } - - // called by operator< - bool less_than(inner const& x) const - { - return queuePosition < x.queuePosition; - } -}; // class inner - -}; // class fixed_size_queue - - -/////////////////////////////////////////////////////////////////////////////// -// class input_iterator -// Implementation of the InputPolicy used by multi_pass -// input_iterator encapsulates an input iterator of type InputT -/////////////////////////////////////////////////////////////////////////////// -class input_iterator -{ - public: - -template -class inner -{ - typedef - typename boost::detail::iterator_traits::value_type - result_type; - - struct Data { - Data(InputT const &input_) - : input(input_), was_initialized(false) - {} - - InputT input; - result_type curtok; - bool was_initialized; - }; - - // Needed by compilers not implementing the resolution to DR45. For - // reference, see - // http://www.open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html#45. - - friend struct Data; - - public: - typedef result_type value_type; - typedef - typename boost::detail::iterator_traits::difference_type - difference_type; - typedef - typename boost::detail::iterator_traits::pointer - pointer; - typedef - typename boost::detail::iterator_traits::reference - reference; - - protected: - inner() - : data(0) - {} - - inner(InputT x) - : data(new Data(x)) - {} - - inner(inner const& x) - : data(x.data) - {} - - void destroy() - { - delete data; - data = 0; - } - - bool same_input(inner const& x) const - { - return data == x.data; - } - - typedef - typename boost::detail::iterator_traits::value_type - value_t; - void swap(inner& x) - { - impl::mp_swap(data, x.data); - } - - void ensure_initialized() const - { - if (data && !data->was_initialized) { - data->curtok = *data->input; // get the first token - data->was_initialized = true; - } - } - - public: - reference get_input() const - { - BOOST_SPIRIT_ASSERT(NULL != data); - ensure_initialized(); - return data->curtok; - } - - void advance_input() - { - BOOST_SPIRIT_ASSERT(NULL != data); - data->was_initialized = false; // should get the next token - ++data->input; - } - - bool input_at_eof() const - { - return !data || data->input == InputT(); - } - - private: - Data *data; -}; - -}; - -/////////////////////////////////////////////////////////////////////////////// -// class lex_input -// Implementation of the InputPolicy used by multi_pass -// lex_input gets tokens (ints) from yylex() -/////////////////////////////////////////////////////////////////////////////// -class lex_input -{ - public: - -template -class inner -{ - public: - typedef int value_type; - typedef std::ptrdiff_t difference_type; - typedef int* pointer; - typedef int& reference; - - protected: - inner() - : curtok(new int(0)) - {} - - inner(InputT x) - : curtok(new int(x)) - {} - - inner(inner const& x) - : curtok(x.curtok) - {} - - void destroy() - { - delete curtok; - curtok = 0; - } - - bool same_input(inner const& x) const - { - return curtok == x.curtok; - } - - void swap(inner& x) - { - impl::mp_swap(curtok, x.curtok); - } - - public: - reference get_input() const - { - return *curtok; - } - - void advance_input() - { - extern int yylex(); - *curtok = yylex(); - } - - bool input_at_eof() const - { - return *curtok == 0; - } - - private: - int* curtok; - -}; - -}; - -/////////////////////////////////////////////////////////////////////////////// -// class functor_input -// Implementation of the InputPolicy used by multi_pass -// functor_input gets tokens from a functor -// Note: the functor must have a typedef for result_type -// It also must have a static variable of type result_type defined to -// represent eof that is called eof. -/////////////////////////////////////////////////////////////////////////////// -class functor_input -{ - public: - -template -class inner -{ - typedef typename FunctorT::result_type result_type; - public: - typedef result_type value_type; - typedef std::ptrdiff_t difference_type; - typedef result_type* pointer; - typedef result_type& reference; - - protected: - inner() - : ftor(0) - , curtok(0) - {} - - inner(FunctorT const& x) - : ftor(new FunctorT(x)) - , curtok(new result_type((*ftor)())) - {} - - inner(inner const& x) - : ftor(x.ftor) - , curtok(x.curtok) - {} - - void destroy() - { - delete ftor; - ftor = 0; - delete curtok; - curtok = 0; - } - - bool same_input(inner const& x) const - { - return ftor == x.ftor; - } - - void swap(inner& x) - { - impl::mp_swap(curtok, x.curtok); - impl::mp_swap(ftor, x.ftor); - } - - public: - reference get_input() const - { - return *curtok; - } - - void advance_input() - { - if (curtok) { - *curtok = (*ftor)(); - } - } - - bool input_at_eof() const - { - return !curtok || *curtok == ftor->eof; - } - - FunctorT& get_functor() const - { - return *ftor; - } - - - private: - FunctorT* ftor; - result_type* curtok; - -}; - -}; - -} // namespace multi_pass_policies - -/////////////////////////////////////////////////////////////////////////////// -// iterator_base_creator -/////////////////////////////////////////////////////////////////////////////// - -namespace iterator_ { namespace impl { - -// Meta-function to generate a std::iterator<> base class for multi_pass. This -// is used mainly to improve conformance of compilers not supporting PTS -// and thus relying on inheritance to recognize an iterator. -// We are using boost::iterator<> because it offers an automatic workaround -// for broken std::iterator<> implementations. -template -struct iterator_base_creator -{ - typedef typename InputPolicyT::BOOST_NESTED_TEMPLATE inner input_t; - - typedef boost::iterator - < - std::forward_iterator_tag, - typename input_t::value_type, - typename input_t::difference_type, - typename input_t::pointer, - typename input_t::reference - > type; -}; - -}} - -/////////////////////////////////////////////////////////////////////////////// -// class template multi_pass -/////////////////////////////////////////////////////////////////////////////// - -// The default multi_pass instantiation uses a ref-counted std_deque scheme. -template -< - typename InputT, - typename InputPolicy, - typename OwnershipPolicy, - typename CheckingPolicy, - typename StoragePolicy -> -class multi_pass - : public OwnershipPolicy - , public CheckingPolicy - , public StoragePolicy::template inner< - typename InputPolicy::template inner::value_type> - , public InputPolicy::template inner - , public iterator_::impl::iterator_base_creator::type -{ - typedef OwnershipPolicy OP; - typedef CheckingPolicy CHP; - typedef typename StoragePolicy::template inner< - typename InputPolicy::template inner::value_type> SP; - typedef typename InputPolicy::template inner IP; - typedef typename - iterator_::impl::iterator_base_creator::type - IB; - - public: - typedef typename IB::value_type value_type; - typedef typename IB::difference_type difference_type; - typedef typename IB::reference reference; - typedef typename IB::pointer pointer; - typedef InputT iterator_type; - - multi_pass(); - explicit multi_pass(InputT input); - -#if BOOST_WORKAROUND(__GLIBCPP__, == 20020514) - multi_pass(int); -#endif // BOOST_WORKAROUND(__GLIBCPP__, == 20020514) - - ~multi_pass(); - - multi_pass(multi_pass const&); - multi_pass& operator=(multi_pass const&); - - void swap(multi_pass& x); - - reference operator*() const; - pointer operator->() const; - multi_pass& operator++(); - multi_pass operator++(int); - - void clear_queue(); - - bool operator==(const multi_pass& y) const; - bool operator<(const multi_pass& y) const; - - private: // helper functions - bool is_eof() const; -}; - -template -< - typename InputT, - typename InputPolicy, - typename OwnershipPolicy, - typename CheckingPolicy, - typename StoragePolicy -> -inline -multi_pass:: -multi_pass() - : OP() - , CHP() - , SP() - , IP() -{ -} - -template -< - typename InputT, - typename InputPolicy, - typename OwnershipPolicy, - typename CheckingPolicy, - typename StoragePolicy -> -inline -multi_pass:: -multi_pass(InputT input) - : OP() - , CHP() - , SP() - , IP(input) -{ -} - -#if BOOST_WORKAROUND(__GLIBCPP__, == 20020514) - // The standard library shipped with gcc-3.1 has a bug in - // bits/basic_string.tcc. It tries to use iter::iter(0) to - // construct an iterator. Ironically, this happens in sanity - // checking code that isn't required by the standard. - // The workaround is to provide an additional constructor that - // ignores its int argument and behaves like the default constructor. -template -< - typename InputT, - typename InputPolicy, - typename OwnershipPolicy, - typename CheckingPolicy, - typename StoragePolicy -> -inline -multi_pass:: -multi_pass(int) - : OP() - , CHP() - , SP() - , IP() -{ -} -#endif // BOOST_WORKAROUND(__GLIBCPP__, == 20020514) - -template -< - typename InputT, - typename InputPolicy, - typename OwnershipPolicy, - typename CheckingPolicy, - typename StoragePolicy -> -inline -multi_pass:: -~multi_pass() -{ - if (OP::release()) - { - CHP::destroy(); - SP::destroy(); - IP::destroy(); - } -} - -template -< - typename InputT, - typename InputPolicy, - typename OwnershipPolicy, - typename CheckingPolicy, - typename StoragePolicy -> -inline -multi_pass:: -multi_pass( - multi_pass const& x) - : OP(x) - , CHP(x) - , SP(x) - , IP(x) -{ - OP::clone(); -} - -template -< - typename InputT, - typename InputPolicy, - typename OwnershipPolicy, - typename CheckingPolicy, - typename StoragePolicy -> -inline -multi_pass& -multi_pass:: -operator=( - multi_pass const& x) -{ - multi_pass temp(x); - temp.swap(*this); - return *this; -} - -template -< - typename InputT, - typename InputPolicy, - typename OwnershipPolicy, - typename CheckingPolicy, - typename StoragePolicy -> -inline void -multi_pass:: -swap(multi_pass& x) -{ - OP::swap(x); - CHP::swap(x); - SP::swap(x); - IP::swap(x); -} - -template -< - typename InputT, - typename InputPolicy, - typename OwnershipPolicy, - typename CheckingPolicy, - typename StoragePolicy -> -inline -typename multi_pass:: -reference -multi_pass:: -operator*() const -{ - CHP::check(); - return SP::dereference(*this); -} - -template -< - typename InputT, - typename InputPolicy, - typename OwnershipPolicy, - typename CheckingPolicy, - typename StoragePolicy -> -inline -typename multi_pass:: -pointer -multi_pass:: -operator->() const -{ - return &(operator*()); -} - -template -< - typename InputT, - typename InputPolicy, - typename OwnershipPolicy, - typename CheckingPolicy, - typename StoragePolicy -> -inline -multi_pass& -multi_pass:: -operator++() -{ - CHP::check(); - SP::increment(*this); - return *this; -} - -template -< - typename InputT, - typename InputPolicy, - typename OwnershipPolicy, - typename CheckingPolicy, - typename StoragePolicy -> -inline -multi_pass -multi_pass:: -operator++(int) -{ - multi_pass - < - InputT, - InputPolicy, - OwnershipPolicy, - CheckingPolicy, - StoragePolicy - > tmp(*this); - - ++*this; - - return tmp; -} - -template -< - typename InputT, - typename InputPolicy, - typename OwnershipPolicy, - typename CheckingPolicy, - typename StoragePolicy -> -inline void -multi_pass:: -clear_queue() -{ - SP::clear_queue(); - CHP::clear_queue(); -} - -template -< - typename InputT, - typename InputPolicy, - typename OwnershipPolicy, - typename CheckingPolicy, - typename StoragePolicy -> -inline bool -multi_pass:: -is_eof() const -{ - return SP::is_eof(*this); -} - -///// Comparisons -template -< - typename InputT, - typename InputPolicy, - typename OwnershipPolicy, - typename CheckingPolicy, - typename StoragePolicy -> -inline bool -multi_pass:: -operator==(const multi_pass& y) const -{ - bool is_eof_ = SP::is_eof(*this); - bool y_is_eof_ = SP::is_eof(y); - - if (is_eof_ && y_is_eof_) - { - return true; // both are EOF - } - else if (is_eof_ ^ y_is_eof_) - { - return false; // one is EOF, one isn't - } - else if (!IP::same_input(y)) - { - return false; - } - else - { - return SP::equal_to(y); - } -} - -template -< - typename InputT, - typename InputPolicy, - typename OwnershipPolicy, - typename CheckingPolicy, - typename StoragePolicy -> -inline bool -multi_pass:: -operator<(const multi_pass& y) const -{ - return SP::less_than(y); -} - -template -< - typename InputT, - typename InputPolicy, - typename OwnershipPolicy, - typename CheckingPolicy, - typename StoragePolicy -> -inline -bool operator!=( - const multi_pass& x, - const multi_pass& y) -{ - return !(x == y); -} - -template -< - typename InputT, - typename InputPolicy, - typename OwnershipPolicy, - typename CheckingPolicy, - typename StoragePolicy -> -inline -bool operator>( - const multi_pass& x, - const multi_pass& y) -{ - return y < x; -} - -template -< - typename InputT, - typename InputPolicy, - typename OwnershipPolicy, - typename CheckingPolicy, - typename StoragePolicy -> -inline -bool operator>=( - const multi_pass& x, - const multi_pass& y) -{ - return !(x < y); -} - -template -< - typename InputT, - typename InputPolicy, - typename OwnershipPolicy, - typename CheckingPolicy, - typename StoragePolicy -> -inline -bool operator<=( - const multi_pass& x, - const multi_pass& y) -{ - return !(y < x); -} - -///// Generator function -template -inline multi_pass -make_multi_pass(InputT i) -{ - return multi_pass(i); -} - -// this could be a template typedef, since such a thing doesn't -// exist in C++, we'll use inheritance to accomplish the same thing. - -template -class look_ahead : - public multi_pass< - InputT, - multi_pass_policies::input_iterator, - multi_pass_policies::first_owner, - multi_pass_policies::no_check, - multi_pass_policies::fixed_size_queue > -{ - typedef multi_pass< - InputT, - multi_pass_policies::input_iterator, - multi_pass_policies::first_owner, - multi_pass_policies::no_check, - multi_pass_policies::fixed_size_queue > base_t; - public: - look_ahead() - : base_t() {} - - explicit look_ahead(InputT x) - : base_t(x) {} - - look_ahead(look_ahead const& x) - : base_t(x) {} - -#if BOOST_WORKAROUND(__GLIBCPP__, == 20020514) - look_ahead(int) // workaround for a bug in the library - : base_t() {} // shipped with gcc 3.1 -#endif // BOOST_WORKAROUND(__GLIBCPP__, == 20020514) - - // default generated operators destructor and assignment operator are okay. -}; - -template -< - typename InputT, - typename InputPolicy, - typename OwnershipPolicy, - typename CheckingPolicy, - typename StoragePolicy -> -void swap( - multi_pass< - InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy - > &x, - multi_pass< - InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy - > &y) -{ - x.swap(y); -} - -namespace impl { - - template - inline void mp_swap(T& t1, T& t2) - { - using std::swap; - using boost::spirit::swap; - swap(t1, t2); - } -} - -}} // namespace boost::spirit - -#endif // BOOST_SPIRIT_ITERATOR_MULTI_PASS_HPP - - diff --git a/boost/boost/spirit/iterator/position_iterator.hpp b/boost/boost/spirit/iterator/position_iterator.hpp deleted file mode 100644 index 19cf316bd7..0000000000 --- a/boost/boost/spirit/iterator/position_iterator.hpp +++ /dev/null @@ -1,429 +0,0 @@ -/*============================================================================= - Copyright (c) 2002 Juan Carlos Arevalo-Baeza - Copyright (c) 2002-2006 Hartmut Kaiser - Copyright (c) 2003 Giovanni Bajo - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_POSITION_ITERATOR_HPP -#define BOOST_SPIRIT_POSITION_ITERATOR_HPP - -#include -#include -#include - -#include - -namespace boost { namespace spirit { - -/////////////////////////////////////////////////////////////////////////////// -// -// file_position_without_column -// -// A structure to hold positional information. This includes the file, -// and the line number -// -/////////////////////////////////////////////////////////////////////////////// -template -struct file_position_without_column_base { - String file; - int line; - - file_position_without_column_base(String const& file_ = String(), - int line_ = 1): - file (file_), - line (line_) - {} - - bool operator==(const file_position_without_column_base& fp) const - { return line == fp.line && file == fp.file; } -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// file_position -// -// This structure holds complete file position, including file name, -// line and column number -// -/////////////////////////////////////////////////////////////////////////////// -template -struct file_position_base : public file_position_without_column_base { - int column; - - file_position_base(String const& file_ = String(), - int line_ = 1, int column_ = 1): - file_position_without_column_base (file_, line_), - column (column_) - {} - - bool operator==(const file_position_base& fp) const - { return column == fp.column && this->line == fp.line && this->file == fp.file; } -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// position_policy<> -// -// This template is the policy to handle the file position. It is specialized -// on the position type. Providing a custom file_position also requires -// providing a specialization of this class. -// -// Policy interface: -// -// Default constructor of the custom position class must be accessible. -// set_tab_chars(unsigned int chars) - Set the tabstop width -// next_char(PositionT& pos) - Notify that a new character has been -// processed -// tabulation(PositionT& pos) - Notify that a tab character has been -// processed -// next_line(PositionT& pos) - Notify that a new line delimiter has -// been reached. -// -/////////////////////////////////////////////////////////////////////////////// -template class position_policy; - -/////////////////////////////////////////////////////////////////////////////// -}} /* namespace boost::spirit */ - - -// This must be included here for full compatibility with old MSVC -#include "boost/spirit/iterator/impl/position_iterator.ipp" - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -/////////////////////////////////////////////////////////////////////////////// -// -// position_iterator -// -// It wraps an iterator, and keeps track of the current position in the input, -// as it gets incremented. -// -// The wrapped iterator must be at least a Forward iterator. The position -// iterator itself will always be a non-mutable Forward iterator. -// -// In order to have begin/end iterators constructed, the end iterator must be -// empty constructed. Similar to what happens with stream iterators. The begin -// iterator must be constructed from both, the begin and end iterators of the -// wrapped iterator type. This is necessary to implement the lookahead of -// characters necessary to parse CRLF sequences. -// -// In order to extract the current positional data from the iterator, you may -// use the get_position member function. -// -// You can also use the set_position member function to reset the current -// position to something new. -// -// The structure that holds the current position can be customized through a -// template parameter, and the class position_policy must be specialized -// on the new type to define how to handle it. Currently, it's possible -// to choose between the file_position and file_position_without_column -// (which saves some overhead if managing current column is not required). -// -/////////////////////////////////////////////////////////////////////////////// - -#if !defined(BOOST_ITERATOR_ADAPTORS_VERSION) || \ - BOOST_ITERATOR_ADAPTORS_VERSION < 0x0200 -#error "Please use at least Boost V1.31.0 while compiling the position_iterator class!" -#else // BOOST_ITERATOR_ADAPTORS_VERSION < 0x0200 - -/////////////////////////////////////////////////////////////////////////////// -// -// Uses the newer iterator_adaptor version (should be released with -// Boost V1.31.0) -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename ForwardIteratorT, - typename PositionT, - typename SelfT -> -class position_iterator -: public iterator_::impl::position_iterator_base_generator< - SelfT, - ForwardIteratorT, - PositionT - >::type, - public position_policy -{ -private: - - typedef position_policy position_policy_t; - typedef typename iterator_::impl::position_iterator_base_generator< - SelfT, - ForwardIteratorT, - PositionT - >::type base_t; - typedef typename iterator_::impl::position_iterator_base_generator< - SelfT, - ForwardIteratorT, - PositionT - >::main_iter_t main_iter_t; - -public: - - typedef PositionT position_t; - - position_iterator() - : _isend(true) - {} - - position_iterator( - const ForwardIteratorT& begin, - const ForwardIteratorT& end) - : base_t(begin), _end(end), _pos(PositionT()), _isend(begin == end) - {} - - template - position_iterator( - const ForwardIteratorT& begin, - const ForwardIteratorT& end, - FileNameT fileName) - : base_t(begin), _end(end), _pos(PositionT(fileName)), - _isend(begin == end) - {} - - template - position_iterator( - const ForwardIteratorT& begin, - const ForwardIteratorT& end, - FileNameT fileName, LineT line) - : base_t(begin), _end(end), _pos(PositionT(fileName, line)), - _isend(begin == end) - {} - - template - position_iterator( - const ForwardIteratorT& begin, - const ForwardIteratorT& end, - FileNameT fileName, LineT line, ColumnT column) - : base_t(begin), _end(end), _pos(PositionT(fileName, line, column)), - _isend(begin == end) - {} - - position_iterator( - const ForwardIteratorT& begin, - const ForwardIteratorT& end, - const PositionT& pos) - : base_t(begin), _end(end), _pos(pos), _isend(begin == end) - {} - - position_iterator(const position_iterator& iter) - : base_t(iter.base()), position_policy_t(iter), - _end(iter._end), _pos(iter._pos), _isend(iter._isend) - {} - - position_iterator& operator=(const position_iterator& iter) - { - base_t::operator=(iter); - position_policy_t::operator=(iter); - _end = iter._end; - _pos = iter._pos; - _isend = iter._isend; - return *this; - } - - void set_position(PositionT const& newpos) { _pos = newpos; } - PositionT& get_position() { return _pos; } - PositionT const& get_position() const { return _pos; } - - void set_tabchars(unsigned int chars) - { - // This function (which comes from the position_policy) has a - // different name on purpose, to avoid messing with using - // declarations or qualified calls to access the base template - // function, which might break some compilers. - this->position_policy_t::set_tab_chars(chars); - } - -private: - friend class boost::iterator_core_access; - - void increment() - { - typename base_t::reference val = *(this->base()); - if (val == '\n' || val == '\r') { - ++this->base_reference(); - if (this->base_reference() != _end) { - typename base_t::reference val2 = *(this->base()); - if ((val == '\n' && val2 == '\r') - || (val == '\r' && val2 == '\n')) - { - ++this->base_reference(); - } - } - this->next_line(_pos); - static_cast(*this).newline(); - } - else if (val == '\t') { - this->tabulation(_pos); - ++this->base_reference(); - } - else { - this->next_char(_pos); - ++this->base_reference(); - } - - // The iterator is at the end only if it's the same - // of the - _isend = (this->base_reference() == _end); - } - - template < - typename OtherDerivedT, typename OtherIteratorT, - typename V, typename C, typename R, typename D - > - bool equal(iterator_adaptor - const &x) const - { - OtherDerivedT const &rhs = static_cast(x); - bool x_is_end = rhs._isend; - - return (_isend && x_is_end) || - (!_isend && !x_is_end && this->base() == rhs.base()); - } - -protected: - - void newline(void) - {} - - ForwardIteratorT _end; - PositionT _pos; - bool _isend; -}; - -#endif // BOOST_ITERATOR_ADAPTORS_VERSION < 0x0200 - -/////////////////////////////////////////////////////////////////////////////// -// -// position_iterator2 -// -// Equivalent to position_iterator, but it is able to extract the current -// line into a string. This is very handy for error reports. -// -// Notice that the footprint of this class is higher than position_iterator, -// (how much depends on how bulky the underlying iterator is), so it should -// be used only if necessary. -// -/////////////////////////////////////////////////////////////////////////////// - -template -< - typename ForwardIteratorT, - typename PositionT -> -class position_iterator2 - : public position_iterator - < - ForwardIteratorT, - PositionT, - position_iterator2 - > -{ - typedef position_iterator - < - ForwardIteratorT, - PositionT, - position_iterator2 // JDG 4-15-03 - > base_t; - -public: - typedef typename base_t::value_type value_type; - typedef PositionT position_t; - - position_iterator2() - {} - - position_iterator2( - const ForwardIteratorT& begin, - const ForwardIteratorT& end): - base_t(begin, end), - _startline(begin) - {} - - template - position_iterator2( - const ForwardIteratorT& begin, - const ForwardIteratorT& end, - FileNameT file): - base_t(begin, end, file), - _startline(begin) - {} - - template - position_iterator2( - const ForwardIteratorT& begin, - const ForwardIteratorT& end, - FileNameT file, LineT line): - base_t(begin, end, file, line), - _startline(begin) - {} - - template - position_iterator2( - const ForwardIteratorT& begin, - const ForwardIteratorT& end, - FileNameT file, LineT line, ColumnT column): - base_t(begin, end, file, line, column), - _startline(begin) - {} - - position_iterator2( - const ForwardIteratorT& begin, - const ForwardIteratorT& end, - const PositionT& pos): - base_t(begin, end, pos), - _startline(begin) - {} - - position_iterator2(const position_iterator2& iter) - : base_t(iter), _startline(iter._startline) - {} - - position_iterator2& operator=(const position_iterator2& iter) - { - base_t::operator=(iter); - _startline = iter._startline; - return *this; - } - - ForwardIteratorT get_currentline_begin(void) const - { return _startline; } - - ForwardIteratorT get_currentline_end(void) const - { return get_endline(); } - - std::basic_string get_currentline(void) const - { - return std::basic_string - (get_currentline_begin(), get_currentline_end()); - } - -protected: - ForwardIteratorT _startline; - - friend class position_iterator >; - - ForwardIteratorT get_endline() const - { - ForwardIteratorT endline = _startline; - while (endline != this->_end && *endline != '\r' && *endline != '\n') - { - ++endline; - } - return endline; - } - - void newline(void) - { _startline = this->base(); } -}; - -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/meta.hpp b/boost/boost/spirit/meta.hpp deleted file mode 100644 index 85876f39b5..0000000000 --- a/boost/boost/spirit/meta.hpp +++ /dev/null @@ -1,27 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001-2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_META_MAIN_HPP) -#define BOOST_SPIRIT_META_MAIN_HPP - -#include - -/////////////////////////////////////////////////////////////////////////////// -// -// Master header for Spirit.Meta -// -/////////////////////////////////////////////////////////////////////////////// - -#include -#include -#include -#include - -#endif // BOOST_SPIRIT_CORE_MAIN_HPP - diff --git a/boost/boost/spirit/meta/as_parser.hpp b/boost/boost/spirit/meta/as_parser.hpp deleted file mode 100644 index 53d58775ca..0000000000 --- a/boost/boost/spirit/meta/as_parser.hpp +++ /dev/null @@ -1,109 +0,0 @@ -/*============================================================================= - Copyright (c) 2002-2003 Joel de Guzman - Copyright (c) 2002-2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_AS_PARSER_HPP) -#define BOOST_SPIRIT_AS_PARSER_HPP - -#include - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // Helper templates to derive the parser type from an auxilliary type - // and to generate an object of the required parser type given an - // auxilliary object. Supported types to convert are parsers, - // single characters and character strings. - // - /////////////////////////////////////////////////////////////////////////// - namespace impl - { - template - struct default_as_parser - { - typedef T type; - static type const& convert(type const& p) - { - return p; - } - }; - - struct char_as_parser - { - typedef chlit type; - static type convert(char ch) - { - return type(ch); - } - }; - - struct wchar_as_parser - { - typedef chlit type; - static type convert(wchar_t ch) - { - return type(ch); - } - }; - - struct string_as_parser - { - typedef strlit type; - static type convert(char const* str) - { - return type(str); - } - }; - - struct wstring_as_parser - { - typedef strlit type; - static type convert(wchar_t const* str) - { - return type(str); - } - }; - } - - template - struct as_parser : impl::default_as_parser {}; - - template<> - struct as_parser : impl::char_as_parser {}; - - template<> - struct as_parser : impl::wchar_as_parser {}; - - template<> - struct as_parser : impl::string_as_parser {}; - - template<> - struct as_parser : impl::string_as_parser {}; - - template<> - struct as_parser : impl::wstring_as_parser {}; - - template<> - struct as_parser : impl::wstring_as_parser {}; - - template - struct as_parser : impl::string_as_parser {}; - - template - struct as_parser : impl::wstring_as_parser {}; - - template - struct as_parser : impl::string_as_parser {}; - - template - struct as_parser : impl::wstring_as_parser {}; - -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/meta/fundamental.hpp b/boost/boost/spirit/meta/fundamental.hpp deleted file mode 100644 index cb0986cbc0..0000000000 --- a/boost/boost/spirit/meta/fundamental.hpp +++ /dev/null @@ -1,52 +0,0 @@ -/*============================================================================= - Copyright (c) 2002-2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_FUNDAMENTAL_HPP) -#define BOOST_SPIRIT_FUNDAMENTAL_HPP - -#include - -namespace boost { namespace spirit -{ - /////////////////////////////////////////////////////////////////////////// - // - // Helper template for counting the number of nodes contained in a - // given parser type. - // All parser_category type parsers are counted as nodes. - // - /////////////////////////////////////////////////////////////////////////// - template - struct node_count { - - typedef typename ParserT::parser_category_t parser_category_t; - typedef typename impl::nodes - ::template count > count_t; - - BOOST_STATIC_CONSTANT(int, value = count_t::value); - }; - - /////////////////////////////////////////////////////////////////////////// - // - // Helper template for counting the number of leaf nodes contained in a - // given parser type. - // Only plain_parser_category type parsers are counted as leaf nodes. - // - /////////////////////////////////////////////////////////////////////////// - template - struct leaf_count { - - typedef typename ParserT::parser_category_t parser_category_t; - typedef typename impl::leafs - ::template count > count_t; - - BOOST_STATIC_CONSTANT(int, value = count_t::value); - }; - -}} // namespace boost::spirit - -#endif // !defined(BOOST_SPIRIT_FUNDAMENTAL_HPP) diff --git a/boost/boost/spirit/meta/impl/fundamental.ipp b/boost/boost/spirit/meta/impl/fundamental.ipp deleted file mode 100644 index f0b16ca45a..0000000000 --- a/boost/boost/spirit/meta/impl/fundamental.ipp +++ /dev/null @@ -1,305 +0,0 @@ -/*============================================================================= - Copyright (c) 2002-2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_FUNDAMENTAL_IPP) -#define BOOST_SPIRIT_FUNDAMENTAL_IPP - -#include - -namespace boost { namespace spirit { - -#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300) - BOOST_SPIRIT_DEPENDENT_TEMPLATE_WRAPPER2(count_wrapper, count); -#endif // defined(BOOST_MSVC) && (BOOST_MSVC <= 1300) - -namespace impl -{ - /////////////////////////////////////////////////////////////////////////// - // - // Helper template for counting the number of nodes contained in a - // given parser type. - // All parser_category type parsers are counted as nodes. - // - /////////////////////////////////////////////////////////////////////////// - template - struct nodes; - - template <> - struct nodes { - - template - struct count { - - // __BORLANDC__ == 0x0561 isn't happy with BOOST_STATIC_CONSTANT - enum { value = (LeafCountT::value + 1) }; - }; - }; - -#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300) - - template <> - struct nodes { - - template - struct count { - - typedef typename ParserT::subject_t subject_t; - typedef typename subject_t::parser_category_t subject_category_t; - - typedef nodes nodes_t; - typedef typename count_wrapper - ::template result_ count_t; - - BOOST_STATIC_CONSTANT(int, value = count_t::value + 1); - }; - }; - - template <> - struct nodes { - - template - struct count { - - typedef typename ParserT::subject_t subject_t; - typedef typename subject_t::parser_category_t subject_category_t; - - typedef nodes nodes_t; - typedef typename count_wrapper - ::template result_ count_t; - - BOOST_STATIC_CONSTANT(int, value = count_t::value + 1); - }; - }; - - template <> - struct nodes { - - template - struct count { - - typedef typename ParserT::left_t left_t; - typedef typename ParserT::right_t right_t; - typedef typename left_t::parser_category_t left_category_t; - typedef typename right_t::parser_category_t right_category_t; - - typedef nodes left_nodes_t; - typedef typename count_wrapper - ::template result_ left_count_t; - - typedef nodes right_nodes_t; - typedef typename count_wrapper - ::template result_ right_count_t; - - BOOST_STATIC_CONSTANT(int, - value = (left_count_t::value + right_count_t::value + 1)); - }; - }; - -#else - - template <> - struct nodes { - - template - struct count { - - typedef typename ParserT::subject_t subject_t; - typedef typename subject_t::parser_category_t subject_category_t; - - // __BORLANDC__ == 0x0561 isn't happy with BOOST_STATIC_CONSTANT - enum { value = (nodes - ::template count::value + 1) }; - }; - }; - - template <> - struct nodes { - - template - struct count { - - typedef typename ParserT::subject_t subject_t; - typedef typename subject_t::parser_category_t subject_category_t; - - // __BORLANDC__ == 0x0561 isn't happy with BOOST_STATIC_CONSTANT - enum { value = (nodes - ::template count::value + 1) }; - }; - }; - - template <> - struct nodes { - - template - struct count { - - typedef typename ParserT::left_t left_t; - typedef typename ParserT::right_t right_t; - typedef typename left_t::parser_category_t left_category_t; - typedef typename right_t::parser_category_t right_category_t; - - typedef count self_t; - - // __BORLANDC__ == 0x0561 isn't happy with BOOST_STATIC_CONSTANT - enum { - leftcount = (nodes - ::template count::value), - rightcount = (nodes - ::template count::value), - value = ((self_t::leftcount) + (self_t::rightcount) + 1) - }; - }; - }; - -#endif - - /////////////////////////////////////////////////////////////////////////// - // - // Helper template for counting the number of leaf nodes contained in a - // given parser type. - // Only plain_parser_category type parsers are counted as leaf nodes. - // - /////////////////////////////////////////////////////////////////////////// - template - struct leafs; - - template <> - struct leafs { - - template - struct count { - - // __BORLANDC__ == 0x0561 isn't happy with BOOST_STATIC_CONSTANT - enum { value = (LeafCountT::value + 1) }; - }; - }; - -#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300) - - template <> - struct leafs { - - template - struct count { - - typedef typename ParserT::subject_t subject_t; - typedef typename subject_t::parser_category_t subject_category_t; - - typedef leafs nodes_t; - typedef typename count_wrapper - ::template result_ count_t; - - BOOST_STATIC_CONSTANT(int, value = count_t::value); - }; - }; - - template <> - struct leafs { - - template - struct count { - - typedef typename ParserT::subject_t subject_t; - typedef typename subject_t::parser_category_t subject_category_t; - - typedef leafs nodes_t; - typedef typename count_wrapper - ::template result_ count_t; - - BOOST_STATIC_CONSTANT(int, value = count_t::value); - }; - }; - - template <> - struct leafs { - - template - struct count { - - typedef typename ParserT::left_t left_t; - typedef typename ParserT::right_t right_t; - typedef typename left_t::parser_category_t left_category_t; - typedef typename right_t::parser_category_t right_category_t; - - typedef leafs left_nodes_t; - typedef typename count_wrapper - ::template result_ left_count_t; - - typedef leafs right_nodes_t; - typedef typename count_wrapper - ::template result_ right_count_t; - - BOOST_STATIC_CONSTANT(int, - value = (left_count_t::value + right_count_t::value)); - }; - }; - -#else - - template <> - struct leafs { - - template - struct count { - - typedef typename ParserT::subject_t subject_t; - typedef typename subject_t::parser_category_t subject_category_t; - - // __BORLANDC__ == 0x0561 isn't happy with BOOST_STATIC_CONSTANT - enum { value = (leafs - ::template count::value) }; - }; - }; - - template <> - struct leafs { - - template - struct count { - - typedef typename ParserT::subject_t subject_t; - typedef typename subject_t::parser_category_t subject_category_t; - - // __BORLANDC__ == 0x0561 isn't happy with BOOST_STATIC_CONSTANT - enum { value = (leafs - ::template count::value) }; - }; - }; - - template <> - struct leafs { - - template - struct count { - - typedef typename ParserT::left_t left_t; - typedef typename ParserT::right_t right_t; - typedef typename left_t::parser_category_t left_category_t; - typedef typename right_t::parser_category_t right_category_t; - - typedef count self_t; - - // __BORLANDC__ == 0x0561 isn't happy with BOOST_STATIC_CONSTANT - enum { - leftcount = (leafs - ::template count::value), - rightcount = (leafs - ::template count::value), - value = (self_t::leftcount + self_t::rightcount) - }; - }; - }; - -#endif - -} // namespace impl - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#endif // !defined(BOOST_SPIRIT_FUNDAMENTAL_IPP) diff --git a/boost/boost/spirit/meta/impl/parser_traits.ipp b/boost/boost/spirit/meta/impl/parser_traits.ipp deleted file mode 100644 index af210f177a..0000000000 --- a/boost/boost/spirit/meta/impl/parser_traits.ipp +++ /dev/null @@ -1,187 +0,0 @@ -/*============================================================================= - Copyright (c) 2002-2003 Joel de Guzman - Copyright (c) 2002-2003 Hartmut Kaiser - Copyright (c) 2003 Martin Wille - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_PARSER_TRAITS_IPP) -#define BOOST_SPIRIT_PARSER_TRAITS_IPP - -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -namespace impl -{ - -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - - /////////////////////////////////////////////////////////////////////////// - // - // from spirit 1.1 (copyright (c) 2001 Bruce Florman) - // various workarounds to support compile time decisions without partial - // template specialization whether a given type is an instance of a - // concrete parser type. - // - /////////////////////////////////////////////////////////////////////////// - - /////////////////////////////////////////////////////////////////////////// - template - struct parser_type_traits - { - // Determine at compile time (without partial specialization) - // whether a given type is an instance of the alternative - - static T t(); - - typedef struct { char dummy[1]; } size1_t; - typedef struct { char dummy[2]; } size2_t; - typedef struct { char dummy[3]; } size3_t; - typedef struct { char dummy[4]; } size4_t; - typedef struct { char dummy[5]; } size5_t; - typedef struct { char dummy[6]; } size6_t; - typedef struct { char dummy[7]; } size7_t; - typedef struct { char dummy[8]; } size8_t; - typedef struct { char dummy[9]; } size9_t; - typedef struct { char dummy[10]; } size10_t; - - // the following functions need no implementation - template - static size1_t test_(alternative const&); - template - static size2_t test_(sequence const&); - template - static size3_t test_(sequential_or const&); - template - static size4_t test_(intersection const&); - template - static size5_t test_(difference const&); - template - static size6_t test_(exclusive_or const&); - template - static size7_t test_(optional const&); - template - static size8_t test_(kleene_star const&); - template - static size9_t test_(positive const&); - - static size10_t test_(...); - - BOOST_STATIC_CONSTANT(bool, - is_alternative = (sizeof(size1_t) == sizeof(test_(t()))) ); - BOOST_STATIC_CONSTANT(bool, - is_sequence = (sizeof(size2_t) == sizeof(test_(t()))) ); - BOOST_STATIC_CONSTANT(bool, - is_sequential_or = (sizeof(size3_t) == sizeof(test_(t()))) ); - BOOST_STATIC_CONSTANT(bool, - is_intersection = (sizeof(size4_t) == sizeof(test_(t()))) ); - BOOST_STATIC_CONSTANT(bool, - is_difference = (sizeof(size5_t) == sizeof(test_(t()))) ); - BOOST_STATIC_CONSTANT(bool, - is_exclusive_or = (sizeof(size6_t) == sizeof(test_(t()))) ); - BOOST_STATIC_CONSTANT(bool, - is_optional = (sizeof(size7_t) == sizeof(test_(t()))) ); - BOOST_STATIC_CONSTANT(bool, - is_kleene_star = (sizeof(size8_t) == sizeof(test_(t()))) ); - BOOST_STATIC_CONSTANT(bool, - is_positive = (sizeof(size9_t) == sizeof(test_(t()))) ); - }; - -#else - - /////////////////////////////////////////////////////////////////////////// - struct parser_type_traits_base { - - BOOST_STATIC_CONSTANT(bool, is_alternative = false); - BOOST_STATIC_CONSTANT(bool, is_sequence = false); - BOOST_STATIC_CONSTANT(bool, is_sequential_or = false); - BOOST_STATIC_CONSTANT(bool, is_intersection = false); - BOOST_STATIC_CONSTANT(bool, is_difference = false); - BOOST_STATIC_CONSTANT(bool, is_exclusive_or = false); - BOOST_STATIC_CONSTANT(bool, is_optional = false); - BOOST_STATIC_CONSTANT(bool, is_kleene_star = false); - BOOST_STATIC_CONSTANT(bool, is_positive = false); - }; - - template - struct parser_type_traits : public parser_type_traits_base { - - // no definition here, fallback for all not explicitly mentioned parser - // types - }; - - template - struct parser_type_traits > - : public parser_type_traits_base { - - BOOST_STATIC_CONSTANT(bool, is_alternative = true); - }; - - template - struct parser_type_traits > - : public parser_type_traits_base { - - BOOST_STATIC_CONSTANT(bool, is_sequence = true); - }; - - template - struct parser_type_traits > - : public parser_type_traits_base { - - BOOST_STATIC_CONSTANT(bool, is_sequential_or = true); - }; - - template - struct parser_type_traits > - : public parser_type_traits_base { - - BOOST_STATIC_CONSTANT(bool, is_intersection = true); - }; - - template - struct parser_type_traits > - : public parser_type_traits_base { - - BOOST_STATIC_CONSTANT(bool, is_difference = true); - }; - - template - struct parser_type_traits > - : public parser_type_traits_base { - - BOOST_STATIC_CONSTANT(bool, is_exclusive_or = true); - }; - - template - struct parser_type_traits > - : public parser_type_traits_base { - - BOOST_STATIC_CONSTANT(bool, is_optional = true); - }; - - template - struct parser_type_traits > - : public parser_type_traits_base { - - BOOST_STATIC_CONSTANT(bool, is_kleene_star = true); - }; - - template - struct parser_type_traits > - : public parser_type_traits_base { - - BOOST_STATIC_CONSTANT(bool, is_positive = true); - }; - -#endif // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) -} // namespace impl - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#endif // !defined(BOOST_SPIRIT_PARSER_TRAITS_IPP) diff --git a/boost/boost/spirit/meta/impl/refactoring.ipp b/boost/boost/spirit/meta/impl/refactoring.ipp deleted file mode 100644 index c63a8c07c3..0000000000 --- a/boost/boost/spirit/meta/impl/refactoring.ipp +++ /dev/null @@ -1,447 +0,0 @@ -/*============================================================================= - Copyright (c) 2002-2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_REFACTORING_IPP -#define BOOST_SPIRIT_REFACTORING_IPP - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -/////////////////////////////////////////////////////////////////////////////// -// -// The struct 'self_nested_refactoring' is used to indicate, that the -// refactoring algorithm should be 'self-nested'. -// -// The struct 'non_nested_refactoring' is used to indicate, that no nesting -// of refactoring algorithms is reqired. -// -/////////////////////////////////////////////////////////////////////////////// - -struct non_nested_refactoring { typedef non_nested_refactoring embed_t; }; -struct self_nested_refactoring { typedef self_nested_refactoring embed_t; }; - -/////////////////////////////////////////////////////////////////////////////// -namespace impl { - -/////////////////////////////////////////////////////////////////////////////// -// -// Helper templates for refactoring parsers -// -/////////////////////////////////////////////////////////////////////////////// - - /////////////////////////////////////////////////////////////////////////// - // - // refactor the left unary operand of a binary parser - // - // The refactoring should be done only if the left operand is an - // unary_parser_category parser. - // - /////////////////////////////////////////////////////////////////////////// - - /////////////////////////////////////////////////////////////////////////// - template - struct refactor_unary_nested { - - template < - typename ParserT, typename NestedT, - typename ScannerT, typename BinaryT - > - static typename parser_result::type - parse(ParserT const &, ScannerT const& scan, BinaryT const& binary, - NestedT const& /*nested_d*/) - { - return binary.parse(scan); - } - }; - - template <> - struct refactor_unary_nested { - - template < - typename ParserT, typename ScannerT, typename BinaryT, - typename NestedT - > - static typename parser_result::type - parse(ParserT const &, ScannerT const& scan, BinaryT const& binary, - NestedT const& nested_d) - { - typedef typename BinaryT::parser_generator_t op_t; - typedef - typename BinaryT::left_t::parser_generator_t - unary_t; - - return - unary_t::generate( - nested_d[ - op_t::generate(binary.left().subject(), binary.right()) - ] - ).parse(scan); - } - }; - - /////////////////////////////////////////////////////////////////////////// - template - struct refactor_unary_non_nested { - - template - static typename parser_result::type - parse(ParserT const &, ScannerT const& scan, BinaryT const& binary) - { - return binary.parse(scan); - } - }; - - template <> - struct refactor_unary_non_nested { - - template - static typename parser_result::type - parse(ParserT const &, ScannerT const& scan, BinaryT const& binary) - { - typedef typename BinaryT::parser_generator_t op_t; - typedef - typename BinaryT::left_t::parser_generator_t - unary_t; - - return unary_t::generate( - op_t::generate(binary.left().subject(), binary.right()) - ).parse(scan); - } - }; - - /////////////////////////////////////////////////////////////////////////// - template - struct refactor_unary_type { - - template - static typename parser_result::type - parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary, - NestedT const& nested_d) - { - typedef - typename BinaryT::left_t::parser_category_t - parser_category_t; - - return refactor_unary_nested:: - parse(p, scan, binary, nested_d); - } - }; - - template <> - struct refactor_unary_type { - - template - static typename parser_result::type - parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary, - non_nested_refactoring const&) - { - typedef - typename BinaryT::left_t::parser_category_t - parser_category_t; - - return refactor_unary_non_nested:: - parse(p, scan, binary); - } - - }; - - template <> - struct refactor_unary_type { - - template - static typename parser_result::type - parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary, - self_nested_refactoring const &nested_tag) - { - typedef - typename BinaryT::left_t::parser_category_t - parser_category_t; - typedef typename ParserT::parser_generator_t parser_generator_t; - - parser_generator_t nested_d(nested_tag); - return refactor_unary_nested:: - parse(p, scan, binary, nested_d); - } - - }; - - /////////////////////////////////////////////////////////////////////////// - // - // refactor the action on the left operand of a binary parser - // - // The refactoring should be done only if the left operand is an - // action_parser_category parser. - // - /////////////////////////////////////////////////////////////////////////// - - /////////////////////////////////////////////////////////////////////////// - template - struct refactor_action_nested { - - template < - typename ParserT, typename ScannerT, typename BinaryT, - typename NestedT - > - static typename parser_result::type - parse(ParserT const &, ScannerT const& scan, BinaryT const& binary, - NestedT const& nested_d) - { - return nested_d[binary].parse(scan); - } - }; - - template <> - struct refactor_action_nested { - - template < - typename ParserT, typename ScannerT, typename BinaryT, - typename NestedT - > - static typename parser_result::type - parse(ParserT const &, ScannerT const& scan, BinaryT const& binary, - NestedT const& nested_d) - { - typedef typename BinaryT::parser_generator_t binary_gen_t; - - return ( - nested_d[ - binary_gen_t::generate( - binary.left().subject(), - binary.right() - ) - ][binary.left().predicate()] - ).parse(scan); - } - }; - - /////////////////////////////////////////////////////////////////////////// - template - struct refactor_action_non_nested { - - template - static typename parser_result::type - parse(ParserT const &, ScannerT const& scan, BinaryT const& binary) - { - return binary.parse(scan); - } - }; - - template <> - struct refactor_action_non_nested { - - template - static typename parser_result::type - parse(ParserT const &, ScannerT const& scan, BinaryT const& binary) - { - typedef typename BinaryT::parser_generator_t binary_gen_t; - - return ( - binary_gen_t::generate( - binary.left().subject(), - binary.right() - )[binary.left().predicate()] - ).parse(scan); - } - }; - - /////////////////////////////////////////////////////////////////////////// - template - struct refactor_action_type { - - template - static typename parser_result::type - parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary, - NestedT const& nested_d) - { - typedef - typename BinaryT::left_t::parser_category_t - parser_category_t; - - return refactor_action_nested:: - parse(p, scan, binary, nested_d); - } - }; - - template <> - struct refactor_action_type { - - template - static typename parser_result::type - parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary, - non_nested_refactoring const&) - { - typedef - typename BinaryT::left_t::parser_category_t - parser_category_t; - - return refactor_action_non_nested:: - parse(p, scan, binary); - } - }; - - template <> - struct refactor_action_type { - - template - static typename parser_result::type - parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary, - self_nested_refactoring const &nested_tag) - { - typedef typename ParserT::parser_generator_t parser_generator_t; - typedef - typename BinaryT::left_t::parser_category_t - parser_category_t; - - parser_generator_t nested_d(nested_tag); - return refactor_action_nested:: - parse(p, scan, binary, nested_d); - } - }; - - /////////////////////////////////////////////////////////////////////////// - // - // refactor the action attached to a binary parser - // - // The refactoring should be done only if the given parser is an - // binary_parser_category parser. - // - /////////////////////////////////////////////////////////////////////////// - - /////////////////////////////////////////////////////////////////////////// - template - struct attach_action_nested { - - template < - typename ParserT, typename ScannerT, typename ActionT, - typename NestedT - > - static typename parser_result::type - parse(ParserT const &, ScannerT const& scan, ActionT const &action, - NestedT const& nested_d) - { - return action.parse(scan); - } - }; - - template <> - struct attach_action_nested { - - template < - typename ParserT, typename ScannerT, typename ActionT, - typename NestedT - > - static typename parser_result::type - parse(ParserT const &, ScannerT const& scan, ActionT const &action, - NestedT const& nested_d) - { - typedef - typename ActionT::subject_t::parser_generator_t - binary_gen_t; - - return ( - binary_gen_t::generate( - nested_d[action.subject().left()[action.predicate()]], - nested_d[action.subject().right()[action.predicate()]] - ) - ).parse(scan); - } - }; - - /////////////////////////////////////////////////////////////////////////// - template - struct attach_action_non_nested { - - template - static typename parser_result::type - parse(ParserT const &, ScannerT const& scan, ActionT const &action) - { - return action.parse(scan); - } - }; - - template <> - struct attach_action_non_nested { - - template - static typename parser_result::type - parse(ParserT const &, ScannerT const& scan, ActionT const &action) - { - typedef - typename ActionT::subject_t::parser_generator_t - binary_gen_t; - - return ( - binary_gen_t::generate( - action.subject().left()[action.predicate()], - action.subject().right()[action.predicate()] - ) - ).parse(scan); - } - }; - - /////////////////////////////////////////////////////////////////////////// - template - struct attach_action_type { - - template - static typename parser_result::type - parse(ParserT const &p, ScannerT const& scan, ActionT const& action, - NestedT const& nested_d) - { - typedef - typename ActionT::subject_t::parser_category_t - parser_category_t; - - return attach_action_nested:: - parse(p, scan, action, nested_d); - } - }; - - template <> - struct attach_action_type { - - template - static typename parser_result::type - parse(ParserT const &p, ScannerT const& scan, ActionT const &action, - non_nested_refactoring const&) - { - typedef - typename ActionT::subject_t::parser_category_t - parser_category_t; - - return attach_action_non_nested:: - parse(p, scan, action); - } - }; - - template <> - struct attach_action_type { - - template - static typename parser_result::type - parse(ParserT const &p, ScannerT const& scan, ActionT const &action, - self_nested_refactoring const& nested_tag) - { - typedef typename ParserT::parser_generator_t parser_generator_t; - typedef - typename ActionT::subject_t::parser_category_t - parser_category_t; - - parser_generator_t nested_d(nested_tag); - return attach_action_nested:: - parse(p, scan, action, nested_d); - } - }; - -} // namespace impl - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#endif - diff --git a/boost/boost/spirit/meta/impl/traverse.ipp b/boost/boost/spirit/meta/impl/traverse.ipp deleted file mode 100644 index 71c9a9fa80..0000000000 --- a/boost/boost/spirit/meta/impl/traverse.ipp +++ /dev/null @@ -1,389 +0,0 @@ -/*============================================================================= - Copyright (c) 2002-2003 Joel de Guzman - Copyright (c) 2002-2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_TRAVERSE_IPP) -#define BOOST_SPIRIT_TRAVERSE_IPP - -/////////////////////////////////////////////////////////////////////////////// -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -/////////////////////////////////////////////////////////////////////////////// -namespace impl -{ - - template - struct traverse_post_order_return_category; - -} // namespace impl - -/////////////////////////////////////////////////////////////////////////////// -// -// Environment class for post_order_traversal -// -/////////////////////////////////////////////////////////////////////////////// - -template -struct traverse_post_order_env { - - BOOST_STATIC_CONSTANT(int, level = Level); - BOOST_STATIC_CONSTANT(int, node = Node); - BOOST_STATIC_CONSTANT(int, index = Index); - BOOST_STATIC_CONSTANT(int, lastleft = LastLeft); -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// traverse_post_order_return template -// -// This template is a helper for dispatching the calculation of a parser -// type result for a traversal level to the corresponding parser_category -// based specialization. -// -/////////////////////////////////////////////////////////////////////////////// - -template -struct traverse_post_order_return { - - typedef typename ParserT::parser_category_t parser_category_t; - typedef typename impl::traverse_post_order_return_category - ::template result::type type; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// parser_traversal_..._result templates -// -// These are metafunctions, which calculate the resulting parser type -// for all subparsers and feed these types to the user supplied -// metafunctions to get back the resulting parser type of this traversal -// level. -// -/////////////////////////////////////////////////////////////////////////////// - -template -struct parser_traversal_plain_result { - - typedef typename MetaT::template plain_result::type type; -}; - -/////////////////////////////////////////////////////////////////////////////// -template -struct parser_traversal_unary_result { - - typedef typename MetaT - ::template unary_result::type type; -}; - -/////////////////////////////////////////////////////////////////////////////// -template -struct parser_traversal_action_result { - - typedef typename MetaT - ::template action_result::type type; -}; - -/////////////////////////////////////////////////////////////////////////////// -template < - typename MetaT, typename BinaryT, typename LeftT, - typename RightT, typename EnvT -> -struct parser_traversal_binary_result { - - BOOST_STATIC_CONSTANT(int, - thisnum = (node_count::value + EnvT::lastleft-1)); - BOOST_STATIC_CONSTANT(int, - leftnum = (node_count::value + EnvT::lastleft-1)); - BOOST_STATIC_CONSTANT(int, - leafnum = (leaf_count::value + EnvT::index)); - - typedef parser_traversal_binary_result self_t; - - // left traversal environment and resulting parser type - typedef traverse_post_order_env< - (EnvT::level+1), (self_t::leftnum), (EnvT::index), (EnvT::lastleft) - > left_sub_env_t; - typedef typename traverse_post_order_return< - MetaT, LeftT, left_sub_env_t - >::type - left_t; - - // right traversal environment and resulting parser type - typedef traverse_post_order_env< - (EnvT::level+1), (self_t::thisnum-1), (self_t::leafnum), (self_t::leftnum+1) - > right_sub_env_t; - typedef typename traverse_post_order_return< - MetaT, RightT, right_sub_env_t - >::type - right_t; - - typedef typename MetaT::template binary_result< - BinaryT, left_t, right_t, EnvT - >::type - type; -}; - -/////////////////////////////////////////////////////////////////////////////// -namespace impl -{ - /////////////////////////////////////////////////////////////////////////// - // - // Meta functions, which dispatch the calculation of the return type of - // of the post_order traverse function to the result template of the - // corresponding parser_category based metafunction template. - // - /////////////////////////////////////////////////////////////////////////// - - template - struct traverse_post_order_return_category; - - template <> - struct traverse_post_order_return_category { - - template - struct result { - - typedef typename parser_traversal_plain_result< - MetaT, ParserT, EnvT - >::type - type; - }; - }; - - template <> - struct traverse_post_order_return_category { - - template - struct result { - - typedef typename parser_traversal_unary_result< - MetaT, ParserT, typename ParserT::subject_t, EnvT - >::type - type; - }; - }; - - template <> - struct traverse_post_order_return_category { - - template - struct result { - - typedef typename parser_traversal_action_result< - MetaT, ParserT, typename ParserT::subject_t, EnvT - >::type - type; - }; - }; - - template <> - struct traverse_post_order_return_category { - - template - struct result { - - typedef typename parser_traversal_binary_result< - MetaT, ParserT, typename ParserT::left_t, - typename ParserT::right_t, EnvT - >::type - type; - }; - }; - - /////////////////////////////////////////////////////////////////////////// - // - // Post-order parser traversal - // - // The following templates contain the parser_category based code for - // - // - calculating the type of the resulting parser, which is to be - // returned from a level of traversal - // - traversing down the composite parser structure, this traversal - // returnes a new parser object - // - // Both tasks are delegated to the MetaT metafunction supplied by the - // user. - // - /////////////////////////////////////////////////////////////////////////// - - template - struct traverse_post_order; - - template <> - struct traverse_post_order { - - template - struct result { - - typedef - typename parser_traversal_plain_result::type - type; - }; - - template - static - typename parser_traversal_plain_result::type - generate(MetaT const &meta_, ParserT const &parser_, EnvT const &env) - { - return meta_.generate_plain(parser_, env); - } - }; - - template <> - struct traverse_post_order { - - template < - typename MetaT, typename ParserT, typename SubjectT, typename EnvT - > - struct result { - - typedef typename parser_traversal_unary_result< - MetaT, ParserT, SubjectT, EnvT - >::type - type; - }; - - template - static - typename parser_traversal_unary_result< - MetaT, ParserT, - typename traverse_post_order_return< - MetaT, typename ParserT::subject_t, EnvT - >::type, - EnvT - >::type - generate(MetaT const &meta_, ParserT const &unary_, EnvT const &env) - { - typedef typename ParserT::subject_t subject_t; - typedef typename subject_t::parser_category_t subject_category_t; - - return meta_.generate_unary( - unary_, - traverse_post_order::generate(meta_, - unary_.subject(), - traverse_post_order_env< - EnvT::level+1, EnvT::node-1, EnvT::index, EnvT::lastleft - >() - ), - env - ); - } - }; - - template <> - struct traverse_post_order { - - template < - typename MetaT, typename ParserT, typename SubjectT, typename EnvT - > - struct result { - - typedef typename parser_traversal_action_result< - MetaT, ParserT, SubjectT, EnvT - >::type - type; - }; - - template - static - typename parser_traversal_action_result< - MetaT, ParserT, - typename traverse_post_order_return< - MetaT, typename ParserT::subject_t, EnvT - >::type, - EnvT - >::type - generate(MetaT const &meta_, ParserT const &action_, EnvT const &env) - { - typedef typename ParserT::subject_t subject_t; - typedef typename subject_t::parser_category_t subject_category_t; - - return meta_.generate_action( - action_, - traverse_post_order::generate(meta_, - action_.subject(), - traverse_post_order_env< - EnvT::level+1, EnvT::node-1, EnvT::index, EnvT::lastleft - >() - ), - env - ); - } - }; - - template <> - struct traverse_post_order { - - template < - typename MetaT, typename ParserT, typename LeftT, - typename RightT, typename EnvT - > - struct result { - - typedef typename parser_traversal_binary_result< - MetaT, ParserT, LeftT, RightT, EnvT - >::type - type; - }; - - template - static - typename parser_traversal_binary_result< - MetaT, ParserT, - typename traverse_post_order_return< - MetaT, typename ParserT::left_t, EnvT - >::type, - typename traverse_post_order_return< - MetaT, typename ParserT::right_t, EnvT - >::type, - EnvT - >::type - generate(MetaT const &meta_, ParserT const &binary_, EnvT const& /*env*/) - { - typedef typename ParserT::left_t left_t; - typedef typename ParserT::right_t right_t; - typedef typename left_t::parser_category_t left_category_t; - typedef typename right_t::parser_category_t right_category_t; - - enum { - leftnum = (node_count::value + EnvT::lastleft-1), - thisnum = (node_count::value + EnvT::lastleft-1), - rightnum = (thisnum-1), - leafnum = (leaf_count::value + EnvT::index) - }; - - return meta_.generate_binary( - binary_, - traverse_post_order::generate( - meta_, binary_.left(), - traverse_post_order_env< - EnvT::level+1, leftnum, EnvT::index, EnvT::lastleft - >() - ), - traverse_post_order::generate( - meta_, binary_.right(), - traverse_post_order_env< - EnvT::level+1, rightnum, leafnum, leftnum+1 - >() - ), - traverse_post_order_env< - EnvT::level, thisnum, EnvT::index, EnvT::lastleft - >() - ); - } - }; - -} // namespace impl - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#endif // !defined(BOOST_SPIRIT_TRAVERSE_IPP) diff --git a/boost/boost/spirit/meta/parser_traits.hpp b/boost/boost/spirit/meta/parser_traits.hpp deleted file mode 100644 index 3a967415e9..0000000000 --- a/boost/boost/spirit/meta/parser_traits.hpp +++ /dev/null @@ -1,316 +0,0 @@ -/*============================================================================= - Copyright (c) 2002-2003 Joel de Guzman - Copyright (c) 2002-2003 Hartmut Kaiser - Copyright (c) 2003 Martin Wille - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_PARSER_TRAITS_HPP) -#define BOOST_SPIRIT_PARSER_TRAITS_HPP - -#include -#include - -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -/////////////////////////////////////////////////////////////////////////////// -// -// Parser traits templates -// -// Used to determine the type and several other characteristics of a given -// parser type. -// -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// -// The is_parser traits template can be used to tell wether a given -// class is a parser. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct is_parser -{ - BOOST_STATIC_CONSTANT(bool, value = - (::boost::is_base_and_derived, T>::value)); - -// [JDG 2/3/03] simplified implementation by -// using boost::is_base_and_derived -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// The is_unary_composite traits template can be used to tell if a given -// parser is a unary parser as for instance kleene_star or optional. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct is_unary_composite { - - BOOST_STATIC_CONSTANT(bool, value = (::boost::is_convertible< - typename UnaryT::parser_category_t, unary_parser_category>::value)); -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// The is_acction_parser traits template can be used to tell if a given -// parser is a action parser, i.e. it is a composite consisting of a -// auxilliary parser and an attached semantic action. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct is_action_parser { - - BOOST_STATIC_CONSTANT(bool, value = (::boost::is_convertible< - typename ActionT::parser_category_t, action_parser_category>::value)); -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// The is_binary_composite traits template can be used to tell if a given -// parser is a binary parser as for instance sequence or difference. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct is_binary_composite { - - BOOST_STATIC_CONSTANT(bool, value = (::boost::is_convertible< - typename BinaryT::parser_category_t, binary_parser_category>::value)); -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// The is_composite_parser traits template can be used to tell if a given -// parser is a unary or a binary parser composite type. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct is_composite_parser { - - BOOST_STATIC_CONSTANT(bool, value = ( - ::boost::spirit::is_unary_composite::value || - ::boost::spirit::is_binary_composite::value)); -}; - -/////////////////////////////////////////////////////////////////////////////// -template -struct is_alternative { - - BOOST_STATIC_CONSTANT(bool, value = ( - ::boost::spirit::impl::parser_type_traits::is_alternative)); -}; - -template -struct is_sequence { - - BOOST_STATIC_CONSTANT(bool, value = ( - ::boost::spirit::impl::parser_type_traits::is_sequence)); -}; - -template -struct is_sequential_or { - - BOOST_STATIC_CONSTANT(bool, value = ( - ::boost::spirit::impl::parser_type_traits::is_sequential_or)); -}; - -template -struct is_intersection { - - BOOST_STATIC_CONSTANT(bool, value = ( - ::boost::spirit::impl::parser_type_traits::is_intersection)); -}; - -template -struct is_difference { - - BOOST_STATIC_CONSTANT(bool, value = ( - ::boost::spirit::impl::parser_type_traits::is_difference)); -}; - -template -struct is_exclusive_or { - - BOOST_STATIC_CONSTANT(bool, value = ( - ::boost::spirit::impl::parser_type_traits::is_exclusive_or)); -}; - -template -struct is_optional { - - BOOST_STATIC_CONSTANT(bool, value = ( - ::boost::spirit::impl::parser_type_traits::is_optional)); -}; - -template -struct is_kleene_star { - - BOOST_STATIC_CONSTANT(bool, value = ( - ::boost::spirit::impl::parser_type_traits::is_kleene_star)); -}; - -template -struct is_positive { - - BOOST_STATIC_CONSTANT(bool, value = ( - ::boost::spirit::impl::parser_type_traits::is_positive)); -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// Parser extraction templates -// -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// -// The unary_subject template can be used to return the type of the -// parser used as the subject of an unary parser. -// If the parser under inspection is not an unary type parser the compilation -// will fail. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct unary_subject { - - BOOST_STATIC_ASSERT(::boost::spirit::is_unary_composite::value); - typedef typename UnaryT::subject_t type; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// The get_unary_subject template function returns the parser object, which -// is used as the subject of an unary parser. -// If the parser under inspection is not an unary type parser the compilation -// will fail. -// -/////////////////////////////////////////////////////////////////////////////// -template -inline typename unary_subject::type const & -get_unary_subject(UnaryT const &unary_) -{ - BOOST_STATIC_ASSERT(::boost::spirit::is_unary_composite::value); - return unary_.subject(); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// The binary_left_subject and binary_right_subject templates can be used to -// return the types of the parsers used as the left and right subject of an -// binary parser. -// If the parser under inspection is not a binary type parser the compilation -// will fail. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct binary_left_subject { - - BOOST_STATIC_ASSERT(::boost::spirit::is_binary_composite::value); - typedef typename BinaryT::left_t type; -}; - -template -struct binary_right_subject { - - BOOST_STATIC_ASSERT(::boost::spirit::is_binary_composite::value); - typedef typename BinaryT::right_t type; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// The get_binary_left_subject and get_binary_right_subject template functions -// return the parser object, which is used as the left or right subject of a -// binary parser. -// If the parser under inspection is not a binary type parser the compilation -// will fail. -// -/////////////////////////////////////////////////////////////////////////////// -template -inline typename binary_left_subject::type const & -get_binary_left_subject(BinaryT const &binary_) -{ - BOOST_STATIC_ASSERT(::boost::spirit::is_binary_composite::value); - return binary_.left(); -} - -template -inline typename binary_right_subject::type const & -get_binary_right_subject(BinaryT const &binary_) -{ - BOOST_STATIC_ASSERT(::boost::spirit::is_binary_composite::value); - return binary_.right(); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// The action_subject template can be used to return the type of the -// parser used as the subject of an action parser. -// If the parser under inspection is not an action type parser the compilation -// will fail. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct action_subject { - - BOOST_STATIC_ASSERT(::boost::spirit::is_action_parser::value); - typedef typename ActionT::subject_t type; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// The get_action_subject template function returns the parser object, which -// is used as the subject of an action parser. -// If the parser under inspection is not an action type parser the compilation -// will fail. -// -/////////////////////////////////////////////////////////////////////////////// -template -inline typename action_subject::type const & -get_action_subject(ActionT const &action_) -{ - BOOST_STATIC_ASSERT(::boost::spirit::is_action_parser::value); - return action_.subject(); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// The semantic_action template can be used to return the type of the -// attached semantic action of an action parser. -// If the parser under inspection is not an action type parser the compilation -// will fail. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct semantic_action { - - BOOST_STATIC_ASSERT(::boost::spirit::is_action_parser::value); - typedef typename ActionT::predicate_t type; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// The get_semantic_action template function returns the attached semantic -// action of an action parser. -// If the parser under inspection is not an action type parser the compilation -// will fail. -// -/////////////////////////////////////////////////////////////////////////////// -template -inline typename semantic_action::type const & -get_semantic_action(ActionT const &action_) -{ - BOOST_STATIC_ASSERT(::boost::spirit::is_action_parser::value); - return action_.predicate(); -} - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#endif // !defined(BOOST_SPIRIT_PARSER_TRAITS_HPP) diff --git a/boost/boost/spirit/meta/refactoring.hpp b/boost/boost/spirit/meta/refactoring.hpp deleted file mode 100644 index 6e92683b70..0000000000 --- a/boost/boost/spirit/meta/refactoring.hpp +++ /dev/null @@ -1,274 +0,0 @@ -/*============================================================================= - Copyright (c) 2002-2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_REFACTORING_HPP -#define BOOST_SPIRIT_REFACTORING_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include -#include -#include -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -/////////////////////////////////////////////////////////////////////////////// -// -// refactor_unary_parser class -// -// This helper template allows to attach an unary operation to a newly -// constructed parser, which combines the subject of the left operand of -// the original given parser (BinaryT) with the right operand of the -// original binary parser through the original binary operation and -// rewraps the resulting parser with the original unary operator. -// -// For instance given the parser: -// *some_parser - another_parser -// -// will be refactored to: -// *(some_parser - another_parser) -// -// If the parser to refactor is not a unary parser, no refactoring is done -// at all. -// -// The original parser should be a binary_parser_category parser, -// else the compilation will fail -// -/////////////////////////////////////////////////////////////////////////////// - -template -class refactor_unary_gen; - -template -class refactor_unary_parser : - public parser > { - -public: - // the parser to refactor has to be at least a binary_parser_category - // parser - BOOST_STATIC_ASSERT(( - boost::is_convertible::value - )); - - refactor_unary_parser(BinaryT const& binary_, NestedT const& nested_) - : binary(binary_), nested(nested_) {} - - typedef refactor_unary_parser self_t; - typedef refactor_unary_gen parser_generator_t; - typedef typename BinaryT::left_t::parser_category_t parser_category_t; - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - return impl::refactor_unary_type:: - parse(*this, scan, binary, nested); - } - -private: - typename as_parser::type::embed_t binary; - typename NestedT::embed_t nested; -}; - -////////////////////////////////// -template -class refactor_unary_gen { - -public: - typedef refactor_unary_gen embed_t; - - refactor_unary_gen(NestedT const& nested_ = non_nested_refactoring()) - : nested(nested_) {} - - template - refactor_unary_parser - operator[](parser const& subject) const - { - return refactor_unary_parser - (subject.derived(), nested); - } - -private: - typename NestedT::embed_t nested; -}; - -const refactor_unary_gen<> refactor_unary_d = refactor_unary_gen<>(); - -/////////////////////////////////////////////////////////////////////////////// -// -// refactor_action_parser class -// -// This helper template allows to attach an action taken from the left -// operand of the given binary parser to a newly constructed parser, -// which combines the subject of the left operand of the original binary -// parser with the right operand of the original binary parser by means of -// the original binary operator parser. -// -// For instance the parser: -// some_parser[some_attached_functor] - another_parser -// -// will be refactored to: -// (some_parser - another_parser)[some_attached_functor] -// -// If the left operand to refactor is not an action parser, no refactoring -// is done at all. -// -// The original parser should be a binary_parser_category parser, -// else the compilation will fail -// -/////////////////////////////////////////////////////////////////////////////// - -template -class refactor_action_gen; - -template -class refactor_action_parser : - public parser > { - -public: - // the parser to refactor has to be at least a binary_parser_category - // parser - BOOST_STATIC_ASSERT(( - boost::is_convertible::value - )); - - refactor_action_parser(BinaryT const& binary_, NestedT const& nested_) - : binary(binary_), nested(nested_) {} - - typedef refactor_action_parser self_t; - typedef refactor_action_gen parser_generator_t; - typedef typename BinaryT::left_t::parser_category_t parser_category_t; - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - return impl::refactor_action_type:: - parse(*this, scan, binary, nested); - } - -private: - typename as_parser::type::embed_t binary; - typename NestedT::embed_t nested; -}; - -////////////////////////////////// -template -class refactor_action_gen { - -public: - typedef refactor_action_gen embed_t; - - refactor_action_gen(NestedT const& nested_ = non_nested_refactoring()) - : nested(nested_) {} - - template - refactor_action_parser - operator[](parser const& subject) const - { - return refactor_action_parser - (subject.derived(), nested); - } - -private: - typename NestedT::embed_t nested; -}; - -const refactor_action_gen<> refactor_action_d = refactor_action_gen<>(); - -/////////////////////////////////////////////////////////////////////////////// -// -// attach_action_parser class -// -// This helper template allows to attach an action given separately -// to to all parsers, out of which the given parser is constructed and -// reconstructs a new parser having the same structure. -// -// For instance the parser: -// (some_parser >> another_parser)[some_attached_functor] -// -// will be refactored to: -// some_parser[some_attached_functor] -// >> another_parser[some_attached_functor] -// -// The original parser should be a action_parser_category parser, -// else the compilation will fail -// -// If the parser, to which the action is attached is not an binary parser, -// no refactoring is done at all. -// -/////////////////////////////////////////////////////////////////////////////// - -template -class attach_action_gen; - -template -class attach_action_parser : - public parser > { - -public: - // the parser to refactor has to be at least a action_parser_category - // parser - BOOST_STATIC_ASSERT(( - boost::is_convertible::value - )); - - attach_action_parser(ActionT const& actor_, NestedT const& nested_) - : actor(actor_), nested(nested_) {} - - typedef attach_action_parser self_t; - typedef attach_action_gen parser_generator_t; - typedef typename ActionT::parser_category_t parser_category_t; - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - return impl::attach_action_type:: - parse(*this, scan, actor, nested); - } - -private: - typename as_parser::type::embed_t actor; - typename NestedT::embed_t nested; -}; - -////////////////////////////////// -template -class attach_action_gen { - -public: - typedef attach_action_gen embed_t; - - attach_action_gen(NestedT const& nested_ = non_nested_refactoring()) - : nested(nested_) {} - - template - attach_action_parser, NestedT> - operator[](action const& actor) const - { - return attach_action_parser, NestedT> - (actor, nested); - } - -private: - typename NestedT::embed_t nested; -}; - -const attach_action_gen<> attach_action_d = attach_action_gen<>(); - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#endif // BOOST_SPIRIT_REFACTORING_HPP - diff --git a/boost/boost/spirit/meta/traverse.hpp b/boost/boost/spirit/meta/traverse.hpp deleted file mode 100644 index 0151412c1c..0000000000 --- a/boost/boost/spirit/meta/traverse.hpp +++ /dev/null @@ -1,218 +0,0 @@ -/*============================================================================= - Copyright (c) 2002-2003 Joel de Guzman - Copyright (c) 2002-2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_TRAVERSE_HPP) -#define BOOST_SPIRIT_TRAVERSE_HPP - -#include - -namespace boost { namespace spirit -{ - /////////////////////////////////////////////////////////////////////////// - // - // Post-order traversal of auxilliary parsers. - // - /////////////////////////////////////////////////////////////////////////// - struct post_order - { - // Return the parser type, which is generated as the result of the - // traverse function below. - - template - struct result - { - typedef typename - traverse_post_order_return< - MetaT - , ParserT - , traverse_post_order_env<0, 0, 0, 0> - >::type - type; - }; - - // Traverse a given parser and refactor it with the help of the given - // MetaT metafunction template. - - template - static typename result::type - traverse(MetaT const &meta_, ParserT const &parser_) - { - typedef typename ParserT::parser_category_t parser_category_t; - return impl::traverse_post_order::generate( - meta_, parser_, traverse_post_order_env<0, 0, 0, 0>()); - } - }; - - /////////////////////////////////////////////////////////////////////////// - // - // Transform policies - // - // The following policy classes could be used to assemble some new - // transformation metafunction which uses identity transformations - // for some parser_category type parsers. - // - /////////////////////////////////////////////////////////////////////////// - - /////////////////////////////////////////////////////////////////////////// - // transform plain parsers - template - struct plain_identity_policy - { - template - struct plain_result - { - // plain parsers should be embedded and returned correctly - typedef typename ParserT::embed_t type; - }; - - template - typename parser_traversal_plain_result::type - generate_plain(ParserT const &parser_, EnvT const& /*env*/) const - { - return parser_; - } - }; - - ////////////////////////////////// - // transform unary parsers - template - struct unary_identity_policy_return - { - typedef typename UnaryT::parser_generator_t parser_generator_t; - typedef typename parser_generator_t - ::template result::type type; - }; - - template - struct unary_identity_policy - { - template - struct unary_result - { - typedef - typename unary_identity_policy_return::type - type; - }; - - template - typename parser_traversal_unary_result< - TransformT, UnaryT, SubjectT, EnvT>::type - generate_unary( - UnaryT const &, SubjectT const &subject_, EnvT const& /*env*/) const - { - typedef typename UnaryT::parser_generator_t parser_generator_t; - return parser_generator_t::template generate(subject_); - } - }; - - ////////////////////////////////// - // transform action parsers - template - struct action_identity_policy - { - template - struct action_result - { - typedef action type; - }; - - template - typename parser_traversal_action_result< - TransformT, ActionT, SubjectT, EnvT - >::type - generate_action(ActionT const &action_, SubjectT const &subject_, - EnvT const& /*env*/) const - { - return subject_[action_.predicate()]; - } - }; - - ////////////////////////////////// - // transform binary parsers - template - struct binary_identity_policy_return - { - typedef typename BinaryT::parser_generator_t parser_generator_t; - typedef typename parser_generator_t - ::template result::type type; - }; - - template - struct binary_identity_policy - { - template - struct binary_result { - - typedef typename - binary_identity_policy_return::type - type; - }; - - template - typename parser_traversal_binary_result< - TransformT, BinaryT, LeftT, RightT, EnvT - >::type - generate_binary( - BinaryT const &, LeftT const& left_ - , RightT const& right_, EnvT const& /*env*/) const - { - typedef typename BinaryT::parser_generator_t parser_generator_t; - return parser_generator_t:: - template generate(left_, right_); - } - }; - - /////////////////////////////////////////////////////////////////////////// - // - // transform_policies template - // - // The transform_policies template metafunction could serve as a - // base class for new metafunctions to be passed to the traverse meta - // template (see above), where only minimal parts have to be - // overwritten. - // - /////////////////////////////////////////////////////////////////////////// - - template < - typename TransformT, - typename PlainPolicyT = plain_identity_policy, - typename UnaryPolicyT = unary_identity_policy, - typename ActionPolicyT = action_identity_policy, - typename BinaryPolicyT = binary_identity_policy - > - struct transform_policies : - public PlainPolicyT, - public UnaryPolicyT, - public ActionPolicyT, - public BinaryPolicyT - { - }; - - /////////////////////////////////////////////////////////////////////////// - // - // Identity transformation - // - // The identity_transform metafunction supplied to the traverse - // template will generate a new parser, which will be exactly - // identical to the parser given as the parameter to the traverse - // metafunction. I.e. the following conceptual 'equation' will be - // always true: - // - // some_parser == - // post_order::traverse(identity_transform(), some_parser) - // - /////////////////////////////////////////////////////////////////////////// - - struct identity_transform : transform_policies {}; - -}} // namespace boost::spirit - -#endif // !defined(BOOST_SPIRIT_TRAVERSE_HPP) diff --git a/boost/boost/spirit/phoenix.hpp b/boost/boost/spirit/phoenix.hpp deleted file mode 100644 index f3655b2cb9..0000000000 --- a/boost/boost/spirit/phoenix.hpp +++ /dev/null @@ -1,26 +0,0 @@ -/*============================================================================= - Phoenix V1.2.1 - Copyright (c) 2001-2002 Joel de Guzman - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -==============================================================================*/ -#if !defined(BOOST_SPIRIT_PHOENIX_HPP) -#define BOOST_SPIRIT_PHOENIX_HPP - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#endif // !defined(BOOST_SPIRIT_PHOENIX_HPP) diff --git a/boost/boost/spirit/phoenix/actor.hpp b/boost/boost/spirit/phoenix/actor.hpp deleted file mode 100644 index 9398bc1a66..0000000000 --- a/boost/boost/spirit/phoenix/actor.hpp +++ /dev/null @@ -1,596 +0,0 @@ -/*============================================================================= - Phoenix v1.2 - Copyright (c) 2001-2002 Joel de Guzman - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -==============================================================================*/ -#ifndef PHOENIX_ACTOR_HPP -#define PHOENIX_ACTOR_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace phoenix { - -// These are forward declared here because we cannot include impl.hpp -// or operators.hpp yet but the actor's assignment operator and index -// operator are required to be members. - -////////////////////////////////// -struct assign_op; -struct index_op; - -////////////////////////////////// -namespace impl { - - template - struct make_binary1; -} - -/////////////////////////////////////////////////////////////////////////////// -// -// unpack_tuple class -// -// This class is used to unpack a supplied tuple such, that the members of -// this tuple will be handled as if they would be supplied separately. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct unpack_tuple : public TupleT { - - typedef TupleT tuple_t; - - unpack_tuple() {} - unpack_tuple(tuple_t const &tuple_) : TupleT(tuple_) {} -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// actor class -// -// This class is a protocol class for all actors. This class is -// essentially an interface contract. The actor class does not -// really know how how to act on anything but instead relies on the -// template parameter BaseT (from which the actor will derive from) -// to do the actual action. -// -// An actor is a functor that is capable of accepting arguments up -// to a predefined maximum. It is up to the base class to do the -// actual processing or possibly to limit the arity (no. of -// arguments) passed in. Upon invocation of the functor through a -// supplied operator(), the actor funnels the arguments passed in -// by the client into a tuple and calls the base eval member -// function. -// -// Schematically: -// -// arg0 ---------| -// arg1 ---------| -// arg2 ---------|---> tupled_args ---> base.eval -// ... | -// argN ---------| -// -// actor::operator()(arg0, arg1... argN) -// ---> BaseT::eval(tupled_args); -// -// Actor base classes from which this class inherits from are -// expected to have a corresponding member function eval compatible -// with the conceptual Interface: -// -// template -// actor_return_type -// eval(TupleT const& args) const; -// -// where args are the actual arguments passed in by the client -// funneled into a tuple (see tuple.hpp for details). -// -// The actor_return_type can be anything. Base classes are free to -// return any type, even argument dependent types (types that are -// deduced from the types of the arguments). After evaluating the -// parameters and doing some computations or actions, the eval -// member function concludes by returning something back to the -// client. To do this, the forwarding function (the actor's -// operator()) needs to know the return type of the eval member -// function that it is calling. For this purpose, actor base -// classes are required to provide a nested template class: -// -// template -// struct result; -// -// This auxiliary class provides the result type information -// returned by the eval member function of a base actor class. The -// nested template class result should have a typedef 'type' that -// reflects the return type of its member function eval. It is -// basically a type computer that answers the question "given -// arguments packed into a TupleT type, what will be the result -// type of the eval member function of ActorT?". The template class -// actor_result queries this to extract the return type of an -// actor. Example: -// -// typedef typename actor_result::type -// actor_return_type; -// -// where actor_return_type is the actual type returned by ActorT's -// eval member function given some arguments in a TupleT. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct actor_result { - - typedef typename ActorT::template result::type type; - typedef typename remove_reference::type plain_type; -}; - -////////////////////////////////// -template -struct actor : public BaseT { - - actor(); - actor(BaseT const& base); - - typename actor_result >::type - operator()() const; - - template - typename actor_result >::type - operator()(A& a) const; - - template - typename actor_result >::type - operator()(A& a, B& b) const; - - template - typename actor_result >::type - operator()(A& a, B& b, C& c) const; - -#if PHOENIX_LIMIT > 3 - template - typename actor_result >::type - operator()(A& a, B& b, C& c, D& d) const; - - template - typename actor_result >::type - operator()(A& a, B& b, C& c, D& d, E& e) const; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F> - typename actor_result >::type - operator()(A& a, B& b, C& c, D& d, E& e, F& f) const; - -#if PHOENIX_LIMIT > 6 - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G> - typename actor_result >::type - operator()(A& a, B& b, C& c, D& d, E& e, F& f, G& g) const; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H> - typename actor_result - >::type - operator()(A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h) const; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I> - typename actor_result - >::type - operator()(A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i) const; - -#if PHOENIX_LIMIT > 9 - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J> - typename actor_result - >::type - operator()( - A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j) const; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K> - typename actor_result - >::type - operator()( - A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j, - K& k) const; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L> - typename actor_result - >::type - operator()( - A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j, - K& k, L& l) const; - -#if PHOENIX_LIMIT > 12 - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M> - typename actor_result - >::type - operator()( - A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j, - K& k, L& l, M& m) const; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M, typename N> - typename actor_result - >::type - operator()( - A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j, - K& k, L& l, M& m, N& n) const; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M, typename N, typename O> - typename actor_result - >::type - operator()( - A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j, - K& k, L& l, M& m, N& n, O& o) const; - -#endif -#endif -#endif -#endif - - template - typename actor_result >::type - operator()(unpack_tuple const &t) const; - - template - typename impl::make_binary1::type - operator=(B const& b) const; - - template - typename impl::make_binary1::type - operator[](B const& b) const; -}; - -/////////////////////////////////////////////////////////////////////////// -// -// as_actor -// -// as_actor is a meta-program that converts an arbitrary type into -// an actor. All participants in the framework must be first-class -// actors. This meta-program is used all throughout the framework -// whenever an unknown type needs to be converted to an actor. -// as_actor specializations are expected to have a typedef 'type'. -// This is the destination actor type. A static member function -// 'convert' converts an object to this target type. -// -// The meta-program does no conversion if the object to be -// converted is already an actor. -// -/////////////////////////////////////////////////////////////////////////// -template -struct as_actor; - -////////////////////////////////// -template -struct as_actor > { - - typedef actor type; - static type convert(actor const& x) { return x; } -}; - -////////////////////////////////// -template <> -struct as_actor { - - typedef nil_t type; - static nil_t convert(nil_t /*x*/) - { return nil_t(); } -}; - -////////////////////////////////// -template <> -struct as_actor { - - typedef void type; - // ERROR!!! -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// actor class implementation -// -/////////////////////////////////////////////////////////////////////////////// -template -actor::actor() -: BaseT() {} - -////////////////////////////////// -template -actor::actor(BaseT const& base) -: BaseT(base) {} - -////////////////////////////////// -template -inline typename actor_result >::type -actor::operator()() const -{ - return BaseT::eval(tuple<>()); -} - -////////////////////////////////// -template -template -inline typename actor_result >::type -actor::operator()(A& a) const -{ - return BaseT::eval(tuple(a)); -} - -////////////////////////////////// -template -template -inline typename actor_result >::type -actor::operator()(A& a, B& b) const -{ - return BaseT::eval(tuple(a, b)); -} - -////////////////////////////////// -template -template -inline typename actor_result >::type -actor::operator()(A& a, B& b, C& c) const -{ - return BaseT::eval(tuple(a, b, c)); -} - -#if PHOENIX_LIMIT > 3 -////////////////////////////////// -template -template -inline typename actor_result >::type -actor::operator()(A& a, B& b, C& c, D& d) const -{ - return BaseT::eval(tuple(a, b, c, d)); -} - -////////////////////////////////// -template -template -inline typename actor_result >::type -actor::operator()(A& a, B& b, C& c, D& d, E& e) const -{ - return BaseT::eval(tuple(a, b, c, d, e)); -} - -////////////////////////////////// -template -template < - typename A, typename B, typename C, typename D, typename E, - typename F> -inline typename actor_result ->::type -actor::operator()( - A& a, B& b, C& c, D& d, E& e, F& f -) const -{ - return BaseT::eval( - tuple - (a, b, c, d, e, f) - ); -} - -#if PHOENIX_LIMIT > 6 -////////////////////////////////// -template -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G> -inline typename actor_result ->::type -actor::operator()( - A& a, B& b, C& c, D& d, E& e, F& f, G& g -) const -{ - return BaseT::eval( - tuple - (a, b, c, d, e, f, g) - ); -} - -////////////////////////////////// -template -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H> -inline typename actor_result ->::type -actor::operator()( - A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h -) const -{ - return BaseT::eval( - tuple - (a, b, c, d, e, f, g, h) - ); -} - -////////////////////////////////// -template -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I> -inline typename actor_result ->::type -actor::operator()( - A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i -) const -{ - return BaseT::eval( - tuple - (a, b, c, d, e, f, g, h, i) - ); -} - -#if PHOENIX_LIMIT > 9 -////////////////////////////////// -template -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J> -inline typename actor_result ->::type -actor::operator()( - A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j -) const -{ - return BaseT::eval( - tuple - (a, b, c, d, e, f, g, h, i, j) - ); -} - -////////////////////////////////// -template -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K> -inline typename actor_result ->::type -actor::operator()( - A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j, - K& k -) const -{ - return BaseT::eval( - tuple - (a, b, c, d, e, f, g, h, i, j, k) - ); -} - -////////////////////////////////// -template -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L> -inline typename actor_result ->::type -actor::operator()( - A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j, - K& k, L& l -) const -{ - return BaseT::eval( - tuple - (a, b, c, d, e, f, g, h, i, j, k, l) - ); -} - -#if PHOENIX_LIMIT > 12 -////////////////////////////////// -template -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M> -inline typename actor_result ->::type -actor::operator()( - A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j, - K& k, L& l, M& m -) const -{ - return BaseT::eval( - tuple - (a, b, c, d, e, f, g, h, i, j, k, l, m) - ); -} - -////////////////////////////////// -template -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M, typename N> -inline typename actor_result ->::type -actor::operator()( - A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j, - K& k, L& l, M& m, N& n -) const -{ - return BaseT::eval( - tuple - (a, b, c, d, e, f, g, h, i, j, k, l, m, n) - ); -} - -////////////////////////////////// -template -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M, typename N, typename O> -inline typename actor_result ->::type -actor::operator()( - A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j, - K& k, L& l, M& m, N& n, O& o -) const -{ - return BaseT::eval( - tuple - (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) - ); -} - -#endif -#endif -#endif -#endif - -////////////////////////////////// -template -template -typename actor_result >::type -actor::operator()(unpack_tuple const &t) const -{ - return BaseT::eval(t); -} - -/////////////////////////////////////////////////////////////////////////////// -} // namespace phoenix - -#endif diff --git a/boost/boost/spirit/phoenix/binders.hpp b/boost/boost/spirit/phoenix/binders.hpp deleted file mode 100644 index 4b2ca57e8f..0000000000 --- a/boost/boost/spirit/phoenix/binders.hpp +++ /dev/null @@ -1,4067 +0,0 @@ -/*============================================================================= - Phoenix v1.2 - Copyright (c) 2001-2002 Joel de Guzman - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -==============================================================================*/ -#ifndef PHOENIX_BINDERS_HPP -#define PHOENIX_BINDERS_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace phoenix { - -/////////////////////////////////////////////////////////////////////////////// -// -// Binders -// -// There are times when it is desireable to bind a simple functor, -// function, member function or member variable for deferred -// evaluation. This can be done through the binding facilities -// provided below. There are template classes: -// -// 1) function_ptr ( function pointer binder ) -// 2) functor ( functor pointer binder ) -// 3) member_function_ptr ( member function pointer binder ) -// 4) member_var_ptr ( member variable pointer binder ) -// -// These template classes are specialized lazy function classes for -// functors, function pointers, member function pointers and member -// variable pointers, respectively. These are subclasses of the -// lazy-function class (see functions.hpp). Each of these has a -// corresponding overloaded bind(x) function. Each bind(x) function -// generates a suitable binder object. -// -// Example, given a function foo: -// -// void foo_(int n) { std::cout << n << std::endl; } -// -// Here's how the function foo is bound: -// -// bind(&foo_) -// -// This bind expression results to a lazy-function (see -// functions.hpp) that is lazily evaluated. This bind expression is -// also equivalent to: -// -// function_ptr foo = &foo_; -// -// The template parameter of the function_ptr is the return and -// argument types of actual signature of the function to be bound -// read from left to right: -// -// void foo_(int); ---> function_ptr -// -// Either bind(&foo_) and its equivalent foo can now be used in the -// same way a lazy function (see functions.hpp) is used: -// -// bind(&foo_)(arg1) -// -// or -// -// foo(arg1) -// -// The latter, of course, being much easier to understand. This is -// now a full-fledged lazy function that can finally be evaluated -// by another function call invocation. A second function call will -// invoke the actual foo function: -// -// int i = 4; -// foo(arg1)(i); -// -// will print out "4". -// -// Binding functors and member functions can be done similarly. -// Here's how to bind a functor (e.g. std::plus): -// -// bind(std::plus()) -// -// or -// -// functor > plus; -// -// Again, these are full-fledged lazy functions. In this case, -// unlike the first example, expect 2 arguments (std::plus -// needs two arguments lhs and rhs). Either or both of which can be -// lazily bound: -// -// plus(arg1, arg2) // arg1 + arg2 -// plus(100, arg1) // 100 + arg1 -// plus(100, 200) // 300 -// -// A bound member function takes in a pointer or reference to an -// object as the first argument. For instance, given: -// -// struct xyz { void foo(int) const; }; -// -// xyz's foo member function can be bound as: -// -// bind(&xyz::foo) -// -// or -// -// member_function_ptr xyz_foo = &xyz::foo; -// -// The template parameter of the member_function_ptr is the return, -// class and argument types of actual signature of the function to -// be bound read from left to right: -// -// void xyz::foo_(int); ---> member_function_ptr -// -// Take note that a member_function_ptr lazy-function expects the -// first argument to be a pointer or reference to an object. Both -// the object (reference or pointer) and the arguments can be -// lazily bound. Examples: -// -// xyz obj; -// xyz_foo(arg1, arg2) // arg1.foo(arg2) -// xyz_foo(obj, arg1) // obj.foo(arg1) -// xyz_foo(obj, 100) // obj.foo(100) -// -// Be reminded that var(obj) must be used to call non-const member -// functions. For example, if xyz was declared as: -// -// struct xyz { void foo(int); }; -// -// the pointer or reference to the object must also be non-const. -// Lazily bound arguments are stored as const value by default (see -// variable class in primitives.hpp). -// -// xyz_foo(var(obj), 100) // obj.foo(100) -// -// Finally, member variables can be bound much like member -// functions. For instance, given: -// -// struct xyz { int v; }; -// -// xyz::v can be bound as: -// -// bind(&xyz::v) -// or -// -// member_var_ptr xyz_v = &xyz::v; -// -// The template parameter of the member_var_ptr is the type of the -// variable followed by the class: -// -// int xyz::v; ---> member_var_ptr -// -// Just like the member_function_ptr, member_var_ptr also expects -// the first argument to be a pointer or reference to an object. -// Both the object (reference or pointer) and the arguments can be -// lazily bound. Examples: -// -// xyz obj; -// xyz_v(arg1) // arg1.v -// xyz_v(obj) // obj.v -// -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// -// Functor binder -// -/////////////////////////////////////////////////////////////////////////////// -template -struct functor_action : public FuncT { - -#if !defined(__BORLANDC__) && (!defined(__MWERKS__) || (__MWERKS__ > 0x3002)) - - template < - typename A = nil_t - , typename B = nil_t - , typename C = nil_t - -#if PHOENIX_LIMIT > 3 - , typename D = nil_t - , typename E = nil_t - , typename F = nil_t - -#if PHOENIX_LIMIT > 6 - , typename G = nil_t - , typename H = nil_t - , typename I = nil_t - -#if PHOENIX_LIMIT > 9 - , typename J = nil_t - , typename K = nil_t - , typename L = nil_t - -#if PHOENIX_LIMIT > 12 - , typename M = nil_t - , typename N = nil_t - , typename O = nil_t - -#endif -#endif -#endif -#endif - > - struct result { typedef typename FuncT::result_type type; }; -#endif - - functor_action(FuncT fptr_ = FuncT()) - : FuncT(fptr_) {} -}; - -#if defined(__BORLANDC__) || (defined(__MWERKS__) && (__MWERKS__ <= 0x3002)) - -/////////////////////////////////////////////////////////////////////////////// -// -// The following specializations are needed because Borland and CodeWarrior -// does not accept default template arguments in nested template classes in -// classes (i.e functor_action::result) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct composite0_result, TupleT> { - - typedef typename FuncT::result_type type; -}; - -////////////////////////////////// -template -struct composite1_result, TupleT, A> { - - typedef typename FuncT::result_type type; -}; - -////////////////////////////////// -template -struct composite2_result, TupleT, A, B> { - - typedef typename FuncT::result_type type; -}; - -////////////////////////////////// -template -struct composite3_result, TupleT, A, B, C> { - - typedef typename FuncT::result_type type; -}; - -#if PHOENIX_LIMIT > 3 -////////////////////////////////// -template -struct composite4_result, TupleT, - A, B, C, D> { - - typedef typename FuncT::result_type type; -}; - -////////////////////////////////// -template -struct composite5_result, TupleT, - A, B, C, D, E> { - - typedef typename FuncT::result_type type; -}; - -////////////////////////////////// -template -struct composite6_result, TupleT, - A, B, C, D, E, F> { - - typedef typename FuncT::result_type type; -}; - -#if PHOENIX_LIMIT > 6 -////////////////////////////////// -template -struct composite7_result, TupleT, - A, B, C, D, E, F, G> { - - typedef typename FuncT::result_type type; -}; - -////////////////////////////////// -template -struct composite8_result, TupleT, - A, B, C, D, E, F, G, H> { - - typedef typename FuncT::result_type type; -}; - -////////////////////////////////// -template -struct composite9_result, TupleT, - A, B, C, D, E, F, G, H, I> { - - typedef typename FuncT::result_type type; -}; - -#if PHOENIX_LIMIT > 9 -////////////////////////////////// -template -struct composite10_result, TupleT, - A, B, C, D, E, F, G, H, I, J> { - - typedef typename FuncT::result_type type; -}; - -////////////////////////////////// -template -struct composite11_result, TupleT, - A, B, C, D, E, F, G, H, I, J, K> { - - typedef typename FuncT::result_type type; -}; - -////////////////////////////////// -template -struct composite12_result, TupleT, - A, B, C, D, E, F, G, H, I, J, K, L> { - - typedef typename FuncT::result_type type; -}; - -#if PHOENIX_LIMIT > 12 -////////////////////////////////// -template -struct composite13_result, TupleT, - A, B, C, D, E, F, G, H, I, J, K, L, M> { - - typedef typename FuncT::result_type type; -}; - -////////////////////////////////// -template -struct composite14_result, TupleT, - A, B, C, D, E, F, G, H, I, J, K, L, M, N> { - - typedef typename FuncT::result_type type; -}; - -////////////////////////////////// -template -struct composite15_result, TupleT, - A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> { - - typedef typename FuncT::result_type type; -}; - -#endif -#endif -#endif -#endif -#endif - -////////////////////////////////// -template -struct functor : public function > { - - functor(FuncT func) - : function >(functor_action(func)) {}; -}; - -////////////////////////////////// -template -inline functor -bind(FuncT func) -{ - return functor(func); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Member variable pointer binder -// -/////////////////////////////////////////////////////////////////////////////// -namespace impl { - - ////////////////////////////////// - template - struct as_ptr { - - typedef T* pointer_type; - - static T* get(T& ref) - { return &ref; } - }; - - ////////////////////////////////// - template - struct as_ptr { - - typedef T* pointer_type; - - static T* get(T* ptr) - { return ptr; } - }; -} - -////////////////////////////////// -template -struct member_var_ptr_action_result { - - typedef typename ActionT::template result::type type; -}; - -////////////////////////////////// -template -struct member_var_ptr_action { - - typedef member_var_ptr_action self_t; - - template - struct result { - typedef typename boost::mpl::if_, T const&, T& - >::type type; - }; - - typedef T ClassT::*mem_var_ptr_t; - - member_var_ptr_action(mem_var_ptr_t ptr_) - : ptr(ptr_) {} - - template - typename member_var_ptr_action_result::type - operator()(CT& obj) const - { return impl::as_ptr::get(obj)->*ptr; } - - mem_var_ptr_t ptr; -}; - -////////////////////////////////// -template -struct member_var_ptr -: public function > { - - member_var_ptr(T ClassT::*mp) - : function > - (member_var_ptr_action(mp)) {} -}; - -////////////////////////////////// -template -inline member_var_ptr -bind(T ClassT::*mp) -{ - return member_var_ptr(mp); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Function pointer binder (main class) -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename RT - , typename A = nil_t - , typename B = nil_t - , typename C = nil_t - -#if PHOENIX_LIMIT > 3 - , typename D = nil_t - , typename E = nil_t - , typename F = nil_t - -#if PHOENIX_LIMIT > 6 - , typename G = nil_t - , typename H = nil_t - , typename I = nil_t - -#if PHOENIX_LIMIT > 9 - , typename J = nil_t - , typename K = nil_t - , typename L = nil_t - -#if PHOENIX_LIMIT > 12 - , typename M = nil_t - , typename N = nil_t - , typename O = nil_t - -#endif -#endif -#endif -#endif - - , typename NU = nil_t // Not used -> -struct function_ptr_action; - -////////////////////////////////// -template < - typename RT - , typename A = nil_t - , typename B = nil_t - , typename C = nil_t - -#if PHOENIX_LIMIT > 3 - , typename D = nil_t - , typename E = nil_t - , typename F = nil_t - -#if PHOENIX_LIMIT > 6 - , typename G = nil_t - , typename H = nil_t - , typename I = nil_t - -#if PHOENIX_LIMIT > 9 - , typename J = nil_t - , typename K = nil_t - , typename L = nil_t - -#if PHOENIX_LIMIT > 12 - , typename M = nil_t - , typename N = nil_t - , typename O = nil_t - -#endif -#endif -#endif -#endif -> -struct function_ptr -: public function 3 - , D, E, F -#if PHOENIX_LIMIT > 6 - , G, H, I -#if PHOENIX_LIMIT > 9 - , J, K, L -#if PHOENIX_LIMIT > 12 - , M, N, O -#endif -#endif -#endif -#endif - > > { - - typedef function_ptr_action 3 - , D, E, F -#if PHOENIX_LIMIT > 6 - , G, H, I -#if PHOENIX_LIMIT > 9 - , J, K, L -#if PHOENIX_LIMIT > 12 - , M, N, O -#endif -#endif -#endif -#endif - > action_t; - - template - function_ptr(FPT fp) - : function(action_t(fp)) {} -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// Function pointer binder (specialization for 0 arg) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct function_ptr_action 3 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(*func_ptr_t)(); - - function_ptr_action(func_ptr_t fptr_) - : fptr(fptr_) {} - - result_type operator()() const - { return fptr(); } - - func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline function_ptr -bind(RT(*fptr)()) -{ - return function_ptr(fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Function pointer binder (specialization for 1 arg) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct function_ptr_action 3 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(*func_ptr_t)(A); - - template - struct result { typedef result_type type; }; - - function_ptr_action(func_ptr_t fptr_) - : fptr(fptr_) {} - - result_type operator()(A a) const - { return fptr(a); } - - func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline function_ptr -bind(RT(*fptr)(A)) -{ - return function_ptr(fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Function pointer binder (specialization for 2 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct function_ptr_action 3 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(*func_ptr_t)(A, B); - - template - struct result { typedef result_type type; }; - - function_ptr_action(func_ptr_t fptr_) - : fptr(fptr_) {} - - result_type operator()(A a, B b) const - { return fptr(a, b); } - - func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline function_ptr -bind(RT(*fptr)(A, B)) -{ - return function_ptr(fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Function pointer binder (specialization for 3 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct function_ptr_action 3 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(*func_ptr_t)(A, B, C); - - template - struct result { typedef result_type type; }; - - function_ptr_action(func_ptr_t fptr_) - : fptr(fptr_) {} - - result_type operator()(A a, B b, C c) const - { return fptr(a, b, c); } - - func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline function_ptr -bind(RT(*fptr)(A, B, C)) -{ - return function_ptr(fptr); -} - -#if PHOENIX_LIMIT > 3 -/////////////////////////////////////////////////////////////////////////////// -// -// Function pointer binder (specialization for 4 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct function_ptr_action 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(*func_ptr_t)(A, B, C, D); - - template - struct result { typedef result_type type; }; - - function_ptr_action(func_ptr_t fptr_) - : fptr(fptr_) {} - - result_type operator()(A a, B b, C c, D d) const - { return fptr(a, b, c, d); } - - func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline function_ptr -bind(RT(*fptr)(A, B, C, D)) -{ - return function_ptr(fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Function pointer binder (specialization for 5 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct function_ptr_action 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(*func_ptr_t)(A, B, C, D, E); - - template < - typename A_, typename B_, typename C_, typename D_, typename E_ - > - struct result { typedef result_type type; }; - - function_ptr_action(func_ptr_t fptr_) - : fptr(fptr_) {} - - result_type operator()( - A a, B b, C c, D d, E e - ) const - { return fptr(a, b, c, d, e); } - - func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline function_ptr -bind(RT(*fptr)(A, B, C, D, E)) -{ - return function_ptr(fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Function pointer binder (specialization for 6 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct function_ptr_action 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(*func_ptr_t)(A, B, C, D, E, F); - - template < - typename A_, typename B_, typename C_, typename D_, typename E_, - typename F_ - > - struct result { typedef result_type type; }; - - function_ptr_action(func_ptr_t fptr_) - : fptr(fptr_) {} - - result_type operator()( - A a, B b, C c, D d, E e, - F f - ) const - { return fptr(a, b, c, d, e, f); } - - func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline function_ptr -bind(RT(*fptr)(A, B, C, D, E, F)) -{ - return function_ptr(fptr); -} - -#if PHOENIX_LIMIT > 6 -/////////////////////////////////////////////////////////////////////////////// -// -// Function pointer binder (specialization for 7 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct function_ptr_action 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(*func_ptr_t)(A, B, C, D, E, F, G); - - template < - typename A_, typename B_, typename C_, typename D_, typename E_, - typename F_, typename G_ - > - struct result { typedef result_type type; }; - - function_ptr_action(func_ptr_t fptr_) - : fptr(fptr_) {} - - result_type operator()( - A a, B b, C c, D d, E e, - F f, G g - ) const - { return fptr(a, b, c, d, e, f, g); } - - func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline function_ptr -bind(RT(*fptr)(A, B, C, D, E, F, G)) -{ - return function_ptr(fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Function pointer binder (specialization for 8 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct function_ptr_action 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(*func_ptr_t)(A, B, C, D, E, F, G, H); - - template < - typename A_, typename B_, typename C_, typename D_, typename E_, - typename F_, typename G_, typename H_ - > - struct result { typedef result_type type; }; - - function_ptr_action(func_ptr_t fptr_) - : fptr(fptr_) {} - - result_type operator()( - A a, B b, C c, D d, E e, - F f, G g, H h - ) const - { return fptr(a, b, c, d, e, f, g, h); } - - func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline function_ptr -bind(RT(*fptr)(A, B, C, D, E, F, G, H)) -{ - return function_ptr(fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Function pointer binder (specialization for 9 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct function_ptr_action 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(*func_ptr_t)(A, B, C, D, E, F, G, H, I); - - template < - typename A_, typename B_, typename C_, typename D_, typename E_, - typename F_, typename G_, typename H_, typename I_ - > - struct result { typedef result_type type; }; - - function_ptr_action(func_ptr_t fptr_) - : fptr(fptr_) {} - - result_type operator()( - A a, B b, C c, D d, E e, - F f, G g, H h, I i - ) const - { return fptr(a, b, c, d, e, f, g, h, i); } - - func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline function_ptr -bind(RT(*fptr)(A, B, C, D, E, F, G, H, I)) -{ - return function_ptr(fptr); -} - -#if PHOENIX_LIMIT > 9 -/////////////////////////////////////////////////////////////////////////////// -// -// Function pointer binder (specialization for 10 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct function_ptr_action 12 - nil_t, nil_t, nil_t, -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(*func_ptr_t)(A, B, C, D, E, F, G, H, I, J); - - template < - typename A_, typename B_, typename C_, typename D_, typename E_, - typename F_, typename G_, typename H_, typename I_, typename J_ - > - struct result { typedef result_type type; }; - - function_ptr_action(func_ptr_t fptr_) - : fptr(fptr_) {} - - result_type operator()( - A a, B b, C c, D d, E e, - F f, G g, H h, I i, J j - ) const - { return fptr(a, b, c, d, e, f, g, h, i, j); } - - func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline function_ptr -bind(RT(*fptr)(A, B, C, D, E, F, G, H, I, J)) -{ - return function_ptr(fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Function pointer binder (specialization for 11 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct function_ptr_action 12 - nil_t, nil_t, nil_t, -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(*func_ptr_t)(A, B, C, D, E, F, G, H, I, J, K); - - template < - typename A_, typename B_, typename C_, typename D_, typename E_, - typename F_, typename G_, typename H_, typename I_, typename J_, - typename K_ - > - struct result { typedef result_type type; }; - - function_ptr_action(func_ptr_t fptr_) - : fptr(fptr_) {} - - result_type operator()( - A a, B b, C c, D d, E e, - F f, G g, H h, I i, J j, - K k - ) const - { return fptr(a, b, c, d, e, f, g, h, i, j, k); } - - func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline function_ptr -bind(RT(*fptr)(A, B, C, D, E, F, G, H, I, J, K)) -{ - return function_ptr(fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Function pointer binder (specialization for 12 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct function_ptr_action 12 - nil_t, nil_t, nil_t, -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(*func_ptr_t)(A, B, C, D, E, F, G, H, I, J, K, L); - - template < - typename A_, typename B_, typename C_, typename D_, typename E_, - typename F_, typename G_, typename H_, typename I_, typename J_, - typename K_, typename L_ - > - struct result { typedef result_type type; }; - - function_ptr_action(func_ptr_t fptr_) - : fptr(fptr_) {} - - result_type operator()( - A a, B b, C c, D d, E e, - F f, G g, H h, I i, J j, - K k, L l - ) const - { return fptr(a, b, c, d, e, f, g, h, i, j, k, l); } - - func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline function_ptr -bind(RT(*fptr)(A, B, C, D, E, F, G, H, I, J, K, L)) -{ - return function_ptr(fptr); -} - -#if PHOENIX_LIMIT > 12 -/////////////////////////////////////////////////////////////////////////////// -// -// Function pointer binder (specialization for 13 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct function_ptr_action { - - typedef RT result_type; - typedef RT(*func_ptr_t)(A, B, C, D, E, F, G, H, I, J, K, L, M); - - template < - typename A_, typename B_, typename C_, typename D_, typename E_, - typename F_, typename G_, typename H_, typename I_, typename J_, - typename K_, typename L_, typename M_ - > - struct result { typedef result_type type; }; - - function_ptr_action(func_ptr_t fptr_) - : fptr(fptr_) {} - - result_type operator()( - A a, B b, C c, D d, E e, - F f, G g, H h, I i, J j, - K k, L l, M m - ) const - { return fptr(a, b, c, d, e, f, g, h, i, j, k, l, m); } - - func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline function_ptr -bind(RT(*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M)) -{ - return function_ptr(fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Function pointer binder (specialization for 14 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct function_ptr_action { - - typedef RT result_type; - typedef RT(*func_ptr_t)(A, B, C, D, E, F, G, H, I, J, K, L, M, N); - - template < - typename A_, typename B_, typename C_, typename D_, typename E_, - typename F_, typename G_, typename H_, typename I_, typename J_, - typename K_, typename L_, typename M_, typename N_ - > - struct result { typedef result_type type; }; - - function_ptr_action(func_ptr_t fptr_) - : fptr(fptr_) {} - - result_type operator()( - A a, B b, C c, D d, E e, - F f, G g, H h, I i, J j, - K k, L l, M m, N n - ) const - { return fptr(a, b, c, d, e, f, g, h, i, j, k, l, m, n); } - - func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline function_ptr -bind(RT(*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N)) -{ - return function_ptr(fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Function pointer binder (specialization for 15 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct function_ptr_action { - - typedef RT result_type; - typedef RT(*func_ptr_t)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O); - - template < - typename A_, typename B_, typename C_, typename D_, typename E_, - typename F_, typename G_, typename H_, typename I_, typename J_, - typename K_, typename L_, typename M_, typename N_, typename O_ - > - struct result { typedef result_type type; }; - - function_ptr_action(func_ptr_t fptr_) - : fptr(fptr_) {} - - result_type operator()( - A a, B b, C c, D d, E e, - F f, G g, H h, I i, J j, - K k, L l, M m, N n, O o - ) const - { return fptr(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o); } - - func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline function_ptr -bind(RT(*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) -{ - return function_ptr(fptr); -} - -#endif -#endif -#endif -#endif -/////////////////////////////////////////////////////////////////////////////// -// -// Member function pointer binder (main class) -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename RT, - typename ClassT - , typename A = nil_t - , typename B = nil_t - , typename C = nil_t - -#if PHOENIX_LIMIT > 3 - , typename D = nil_t - , typename E = nil_t - , typename F = nil_t - -#if PHOENIX_LIMIT > 6 - , typename G = nil_t - , typename H = nil_t - , typename I = nil_t - -#if PHOENIX_LIMIT > 9 - , typename J = nil_t - , typename K = nil_t - , typename L = nil_t - -#if PHOENIX_LIMIT > 12 - , typename M = nil_t - , typename N = nil_t - , typename O = nil_t - -#endif -#endif -#endif -#endif - - , typename NU = nil_t // Not used -> -struct member_function_ptr_action; - -////////////////////////////////// -template < - typename RT, - typename ClassT - , typename A = nil_t - , typename B = nil_t - , typename C = nil_t - -#if PHOENIX_LIMIT > 3 - , typename D = nil_t - , typename E = nil_t - , typename F = nil_t - -#if PHOENIX_LIMIT > 6 - , typename G = nil_t - , typename H = nil_t - , typename I = nil_t - -#if PHOENIX_LIMIT > 9 - , typename J = nil_t - , typename K = nil_t - , typename L = nil_t - -#if PHOENIX_LIMIT > 12 - , typename M = nil_t - , typename N = nil_t - , typename O = nil_t - -#endif -#endif -#endif -#endif -> -struct member_function_ptr -: public function 3 - , D, E, F -#if PHOENIX_LIMIT > 6 - , G, H, I -#if PHOENIX_LIMIT > 9 - , J, K, L -#if PHOENIX_LIMIT > 12 - , M, N, O -#endif -#endif -#endif -#endif - > > { - - typedef member_function_ptr_action 3 - , D, E, F -#if PHOENIX_LIMIT > 6 - , G, H, I -#if PHOENIX_LIMIT > 9 - , J, K, L -#if PHOENIX_LIMIT > 12 - , M, N, O -#endif -#endif -#endif -#endif - > action_t; - - template - member_function_ptr(FPT fp) - : function(action_t(fp)) {} -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// Member function pointer binder (specialization for 0 arg) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct member_function_ptr_action 3 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(ClassT::*mf)(); - typedef RT(ClassT::*cmf)() const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template - struct result { typedef result_type type; }; - - member_function_ptr_action(mem_func_ptr_t fptr_) - : fptr(fptr_) {} - - template - result_type operator()(CT& obj) const - { return (impl::as_ptr::get(obj)->*fptr)(); } - - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)()) -{ - return member_function_ptr(fptr); -} - -template -inline member_function_ptr -bind(RT(ClassT::*fptr)() const) -{ - return member_function_ptr(fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Member function pointer binder (specialization for 1 arg) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct member_function_ptr_action 3 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A); - typedef RT(ClassT::*cmf)(A) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template - struct result { typedef result_type type; }; - - member_function_ptr_action(mem_func_ptr_t fptr_) - : fptr(fptr_) {} - - template - result_type operator()(CT& obj, A a) const - { return (impl::as_ptr::get(obj)->*fptr)(a); } - - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A)) -{ - return member_function_ptr(fptr); -} - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A) const) -{ - return member_function_ptr(fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Member function pointer binder (specialization for 2 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct member_function_ptr_action 3 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B); - typedef RT(ClassT::*cmf)(A, B) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template - struct result { typedef result_type type; }; - - member_function_ptr_action(mem_func_ptr_t fptr_) - : fptr(fptr_) {} - - template - result_type operator()(CT& obj, A a, B b) const - { return (impl::as_ptr::get(obj)->*fptr)(a, b); } - - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B)) -{ - return member_function_ptr(fptr); -} - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B) const) -{ - return member_function_ptr(fptr); -} - -#if PHOENIX_LIMIT > 3 -/////////////////////////////////////////////////////////////////////////////// -// -// Member function pointer binder (specialization for 3 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct member_function_ptr_action 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C); - typedef RT(ClassT::*cmf)(A, B, C) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template - struct result { typedef result_type type; }; - - member_function_ptr_action(mem_func_ptr_t fptr_) - : fptr(fptr_) {} - - template - result_type operator()(CT& obj, A a, B b, C c) const - { return (impl::as_ptr::get(obj)->*fptr)(a, b, c); } - - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C)) -{ - return member_function_ptr(fptr); -} - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C) const) -{ - return member_function_ptr(fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Member function pointer binder (specialization for 4 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct member_function_ptr_action 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C, D); - typedef RT(ClassT::*cmf)(A, B, C, D) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template - struct result { typedef result_type type; }; - - member_function_ptr_action(mem_func_ptr_t fptr_) - : fptr(fptr_) {} - - template - result_type operator()(CT& obj, - A a, B b, C c, D d - ) const - { return (impl::as_ptr::get(obj)->*fptr)(a, b, c, d); } - - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C, D)) -{ - return member_function_ptr< - RT, ClassT, A, B, C, D>(fptr); -} - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C, D) const) -{ - return member_function_ptr< - RT, ClassT const, A, B, C, D>(fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Member function pointer binder (specialization for 5 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct member_function_ptr_action 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C, D, E); - typedef RT(ClassT::*cmf)(A, B, C, D, E) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template - struct result { typedef result_type type; }; - - member_function_ptr_action(mem_func_ptr_t fptr_) - : fptr(fptr_) {} - - template - result_type operator()(CT& obj, - A a, B b, C c, D d, E e - ) const - { return (impl::as_ptr::get(obj)->*fptr)(a, b, c, d, e); } - - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C, D, E)) -{ - return member_function_ptr< - RT, ClassT, A, B, C, D, E>(fptr); -} - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C, D, E) const) -{ - return member_function_ptr< - RT, ClassT const, A, B, C, D, E>(fptr); -} - -#if PHOENIX_LIMIT > 6 -/////////////////////////////////////////////////////////////////////////////// -// -// Member function pointer binder (specialization for 6 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct member_function_ptr_action 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C, D, E, F); - typedef RT(ClassT::*cmf)(A, B, C, D, E, F) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template - struct result { typedef result_type type; }; - - member_function_ptr_action(mem_func_ptr_t fptr_) - : fptr(fptr_) {} - - template - result_type operator()(CT& obj, - A a, B b, C c, D d, E e, F f - ) const - { return (impl::as_ptr::get(obj)->*fptr)(a, b, c, d, e, f); } - - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C, D, E, F)) -{ - return member_function_ptr< - RT, ClassT, A, B, C, D, E, F>(fptr); -} - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C, D, E, F) const) -{ - return member_function_ptr< - RT, ClassT const, A, B, C, D, E, F>(fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Member function pointer binder (specialization for 7 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct member_function_ptr_action 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C, D, E, F, G); - typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template - struct result { typedef result_type type; }; - - member_function_ptr_action(mem_func_ptr_t fptr_) - : fptr(fptr_) {} - - template - result_type operator()(CT& obj, - A a, B b, C c, D d, E e, F f, G g - ) const - { return (impl::as_ptr::get(obj)->*fptr)(a, b, c, d, e, f, g); } - - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G)) -{ - return member_function_ptr< - RT, ClassT, A, B, C, D, E, F, G>(fptr); -} - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G) const) -{ - return member_function_ptr< - RT, ClassT const, A, B, C, D, E, F, G>(fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Member function pointer binder (specialization for 8 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct member_function_ptr_action 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H); - typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template - struct result { typedef result_type type; }; - - member_function_ptr_action(mem_func_ptr_t fptr_) - : fptr(fptr_) {} - - template - result_type operator()(CT& obj, - A a, B b, C c, D d, E e, F f, G g, H h - ) const - { return (impl::as_ptr::get(obj)->*fptr)(a, b, c, d, e, f, g, h); } - - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H)) -{ - return member_function_ptr< - RT, ClassT, A, B, C, D, E, F, G, H>(fptr); -} - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H) const) -{ - return member_function_ptr< - RT, ClassT const, A, B, C, D, E, F, G, H>(fptr); -} - -#if PHOENIX_LIMIT > 9 -/////////////////////////////////////////////////////////////////////////////// -// -// Member function pointer binder (specialization for 9 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct member_function_ptr_action 12 - nil_t, nil_t, nil_t, -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I); - typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template - struct result { typedef result_type type; }; - - member_function_ptr_action(mem_func_ptr_t fptr_) - : fptr(fptr_) {} - - template - result_type operator()(CT& obj, - A a, B b, C c, D d, E e, F f, G g, H h, I i - ) const - { return (impl::as_ptr::get(obj)->*fptr)(a, b, c, d, e, f, g, h, i); } - - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I)) -{ - return member_function_ptr< - RT, ClassT, A, B, C, D, E, F, G, H, I>(fptr); -} - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I) const) -{ - return member_function_ptr< - RT, ClassT const, A, B, C, D, E, F, G, H, I>(fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Member function pointer binder (specialization for 10 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct member_function_ptr_action 12 - nil_t, nil_t, nil_t, -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J); - typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template - struct result { typedef result_type type; }; - - member_function_ptr_action(mem_func_ptr_t fptr_) - : fptr(fptr_) {} - - template - result_type operator()(CT& obj, - A a, B b, C c, D d, E e, F f, G g, H h, I i, J j - ) const - { - return (impl::as_ptr::get(obj)->*fptr) - (a, b, c, d, e, f, g, h, i, j); - } - - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J)) -{ - return member_function_ptr< - RT, ClassT, A, B, C, D, E, F, G, H, I, J>(fptr); -} - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J) const) -{ - return member_function_ptr< - RT, ClassT const, A, B, C, D, E, F, G, H, I, J>(fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Member function pointer binder (specialization for 11 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct member_function_ptr_action 12 - nil_t, nil_t, nil_t, -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K); - typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template - struct result { typedef result_type type; }; - - member_function_ptr_action(mem_func_ptr_t fptr_) - : fptr(fptr_) {} - - template - result_type operator()(CT& obj, - A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k - ) const - { - return (impl::as_ptr::get(obj)->*fptr) - (a, b, c, d, e, f, g, h, i, j, k); - } - - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K)) -{ - return member_function_ptr< - RT, ClassT, A, B, C, D, E, F, G, H, I, J, K>(fptr); -} - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K) const) -{ - return member_function_ptr< - RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K>(fptr); -} - -#if PHOENIX_LIMIT > 12 -/////////////////////////////////////////////////////////////////////////////// -// -// Member function pointer binder (specialization for 12 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct member_function_ptr_action { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K, L); - typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K, L) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template - struct result { typedef result_type type; }; - - member_function_ptr_action(mem_func_ptr_t fptr_) - : fptr(fptr_) {} - - template - result_type operator()(CT& obj, - A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l - ) const - { - return (impl::as_ptr::get(obj)->*fptr) - (a, b, c, d, e, f, g, h, i, j, k, l); - } - - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L)) -{ - return member_function_ptr< - RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L>(fptr); -} - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L) const) -{ - return member_function_ptr< - RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L>(fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Member function pointer binder (specialization for 13 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct member_function_ptr_action { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K, L, M); - typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K, L, M) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template - struct result { typedef result_type type; }; - - member_function_ptr_action(mem_func_ptr_t fptr_) - : fptr(fptr_) {} - - template - result_type operator()(CT& obj, - A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m - ) const - { - return (impl::as_ptr::get(obj)->*fptr) - (a, b, c, d, e, f, g, h, i, j, k, l, m); - } - - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M)) -{ - return member_function_ptr< - RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M>(fptr); -} - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M) const) -{ - return member_function_ptr< - RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M>(fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Member function pointer binder (specialization for 14 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct member_function_ptr_action { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K, L, M, N); - typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K, L, M, N) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template - struct result { typedef result_type type; }; - - member_function_ptr_action(mem_func_ptr_t fptr_) - : fptr(fptr_) {} - - template - result_type operator()(CT& obj, - A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n - ) const - { - return (impl::as_ptr::get(obj)->*fptr) - (a, b, c, d, e, f, g, h, i, j, k, l, m, n); - } - - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N)) -{ - return member_function_ptr< - RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N>(fptr); -} - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N) const) -{ - return member_function_ptr< - RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N>(fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Member function pointer binder (specialization for 15 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct member_function_ptr_action { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O); - typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template - struct result { typedef result_type type; }; - - member_function_ptr_action(mem_func_ptr_t fptr_) - : fptr(fptr_) {} - - template - result_type operator()(CT& obj, - A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o - ) const - { - return (impl::as_ptr::get(obj)->*fptr) - (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o); - } - - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) -{ - return member_function_ptr< - RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(fptr); -} - -////////////////////////////////// -template -inline member_function_ptr -bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) const) -{ - return member_function_ptr< - RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(fptr); -} - -#endif -#endif -#endif -#endif - -/////////////////////////////////////////////////////////////////////////////// -// -// Bound member function binder (main class) -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename RT, - typename ClassT - , typename A = nil_t - , typename B = nil_t - , typename C = nil_t - -#if PHOENIX_LIMIT > 3 - , typename D = nil_t - , typename E = nil_t - , typename F = nil_t - -#if PHOENIX_LIMIT > 6 - , typename G = nil_t - , typename H = nil_t - , typename I = nil_t - -#if PHOENIX_LIMIT > 9 - , typename J = nil_t - , typename K = nil_t - , typename L = nil_t - -#if PHOENIX_LIMIT > 12 - , typename M = nil_t - , typename N = nil_t - , typename O = nil_t - -#endif -#endif -#endif -#endif - - , typename NU = nil_t // Not used -> -struct bound_member_action; - -////////////////////////////////// -template < - typename RT, - typename ClassT - , typename A = nil_t - , typename B = nil_t - , typename C = nil_t - -#if PHOENIX_LIMIT > 3 - , typename D = nil_t - , typename E = nil_t - , typename F = nil_t - -#if PHOENIX_LIMIT > 6 - , typename G = nil_t - , typename H = nil_t - , typename I = nil_t - -#if PHOENIX_LIMIT > 9 - , typename J = nil_t - , typename K = nil_t - , typename L = nil_t - -#if PHOENIX_LIMIT > 12 - , typename M = nil_t - , typename N = nil_t - , typename O = nil_t - -#endif -#endif -#endif -#endif -> -struct bound_member -: public function 3 - , D, E, F -#if PHOENIX_LIMIT > 6 - , G, H, I -#if PHOENIX_LIMIT > 9 - , J, K, L -#if PHOENIX_LIMIT > 12 - , M, N, O -#endif -#endif -#endif -#endif - > > { - - typedef bound_member_action 3 - , D, E, F -#if PHOENIX_LIMIT > 6 - , G, H, I -#if PHOENIX_LIMIT > 9 - , J, K, L -#if PHOENIX_LIMIT > 12 - , M, N, O -#endif -#endif -#endif -#endif - > action_t; - - template - bound_member(CT & c, FPT fp) - : function(action_t(c,fp)) {} - -#if !defined(__BORLANDC__) - template - bound_member(CT * c, FPT fp) - : function(action_t(c,fp)) {} -#endif -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// Bound member function binder (specialization for 0 arg) -// -/////////////////////////////////////////////////////////////////////////////// - -template -struct bound_member_action 3 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(ClassT::*mf)(); - typedef RT(ClassT::*cmf)() const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template - struct result { typedef result_type type; }; - - template - bound_member_action(CT & obj_, mem_func_ptr_t fptr_) - : obj(impl::as_ptr::get(obj_)), fptr(fptr_) {} - - result_type operator()() const - { return (obj->*fptr)(); } - - typename impl::as_ptr::pointer_type obj; - mem_func_ptr_t fptr; -}; - -////////////////////////////////// - -template -inline bound_member -bind(ClassT & obj, RT(ClassT::*fptr)()) -{ - return bound_member(obj, fptr); -} - -template -inline bound_member -bind(ClassT * obj, RT(ClassT::*fptr)()) -{ -#if defined(__MWERKS__) && (__MWERKS__ < 0x3003) - return bound_member(*obj, fptr); -#else - return bound_member(obj, fptr); -#endif -} - -template -inline bound_member -bind(ClassT const& obj, RT(ClassT::*fptr)()) -{ - return bound_member(obj, fptr); -} - -template -inline bound_member -bind(ClassT const* obj, RT(ClassT::*fptr)() const) -{ -#if defined(__MWERKS__) && (__MWERKS__ < 0x3003) - return bound_member(*obj, fptr); -#else - return bound_member(obj, fptr); -#endif -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Bound member function binder (specialization for 1 arg) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct bound_member_action 3 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A); - typedef RT(ClassT::*cmf)(A) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template - struct result { typedef result_type type; }; - - template - bound_member_action(CT & obj_, mem_func_ptr_t fptr_) - : obj(impl::as_ptr::get(obj_)), fptr(fptr_) {} - - result_type operator()(A a) const - { return (obj->*fptr)(a); } - - typename impl::as_ptr::pointer_type obj; - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline bound_member -bind(ClassT & obj, RT(ClassT::*fptr)(A)) -{ - return bound_member(obj,fptr); -} - -template -inline bound_member -bind(ClassT * obj, RT(ClassT::*fptr)(A)) -{ - return bound_member(obj,fptr); -} - -////////////////////////////////// -template -inline bound_member -bind(ClassT const& obj, RT(ClassT::*fptr)(A) const) -{ - return bound_member(obj,fptr); -} - -template -inline bound_member -bind(ClassT const* obj, RT(ClassT::*fptr)(A) const) -{ - return bound_member(obj,fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Bound member function binder (specialization for 2 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct bound_member_action 3 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B); - typedef RT(ClassT::*cmf)(A, B) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template - struct result { typedef result_type type; }; - - template - bound_member_action(CT & obj_, mem_func_ptr_t fptr_) - : obj(impl::as_ptr::get(obj_)), fptr(fptr_) {} - - result_type operator()(A a, B b) const - { return (obj->*fptr)(a, b); } - - typename impl::as_ptr::pointer_type obj; - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline bound_member -bind(ClassT & obj,RT(ClassT::*fptr)(A, B)) -{ - return bound_member(obj,fptr); -} - -template -inline bound_member -bind(ClassT * obj,RT(ClassT::*fptr)(A, B)) -{ - return bound_member(obj,fptr); -} - -template -inline bound_member -bind(ClassT const& obj,RT(ClassT::*fptr)(A, B) const) -{ - return bound_member(obj,fptr); -} - -template -inline bound_member -bind(ClassT const* obj,RT(ClassT::*fptr)(A, B) const) -{ - return bound_member(obj,fptr); -} - -#if PHOENIX_LIMIT > 3 -/////////////////////////////////////////////////////////////////////////////// -// -// Bound member function binder (specialization for 3 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct bound_member_action 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C); - typedef RT(ClassT::*cmf)(A, B, C) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template - struct result { typedef result_type type; }; - - template - bound_member_action(CT & obj_, mem_func_ptr_t fptr_) - : obj(impl::as_ptr::get(obj_)), fptr(fptr_) {} - - result_type operator()(A a, B b, C c) const - { return (obj->*fptr)(a, b, c); } - - typename impl::as_ptr::pointer_type obj; - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline bound_member -bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C)) -{ - return bound_member(obj,fptr); -} - -template -inline bound_member -bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C)) -{ - return bound_member(obj,fptr); -} - -template -inline bound_member -bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C) const) -{ - return bound_member(obj,fptr); -} - -template -inline bound_member -bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C) const) -{ - return bound_member(obj,fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Bound member function binder (specialization for 4 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct bound_member_action 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C, D); - typedef RT(ClassT::*cmf)(A, B, C, D) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template - struct result { typedef result_type type; }; - - template - bound_member_action(CT & obj_, mem_func_ptr_t fptr_) - : obj(impl::as_ptr::get(obj_)), fptr(fptr_) {} - - result_type operator()(A a, B b, C c, D d) const - { return (obj->*fptr)(a, b, c, d); } - - typename impl::as_ptr::pointer_type obj; - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline bound_member -bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D)) -{ - return bound_member< - RT, ClassT, A, B, C, D>(obj,fptr); -} - -template -inline bound_member -bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D)) -{ - return bound_member< - RT, ClassT, A, B, C, D>(obj,fptr); -} - -template -inline bound_member -bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D) const) -{ - return bound_member< - RT, ClassT const, A, B, C, D>(obj,fptr); -} - -template -inline bound_member -bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D) const) -{ - return bound_member< - RT, ClassT const, A, B, C, D>(obj,fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Bound member function binder (specialization for 5 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct bound_member_action 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C, D, E); - typedef RT(ClassT::*cmf)(A, B, C, D, E) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template - struct result { typedef result_type type; }; - - template - bound_member_action(CT & obj_, mem_func_ptr_t fptr_) - : obj(impl::as_ptr::get(obj_)), fptr(fptr_) {} - - result_type operator()( - A a, B b, C c, D d, E e - ) const - { return (obj->*fptr)(a, b, c, d, e); } - - typename impl::as_ptr::pointer_type obj; - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline bound_member -bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E)) -{ - return bound_member< - RT, ClassT, A, B, C, D, E>(obj,fptr); -} - -template -inline bound_member -bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E)) -{ - return bound_member< - RT, ClassT, A, B, C, D, E>(obj,fptr); -} - -template -inline bound_member -bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E) const) -{ - return bound_member< - RT, ClassT const, A, B, C, D, E>(obj,fptr); -} - -template -inline bound_member -bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E) const) -{ - return bound_member< - RT, ClassT const, A, B, C, D, E>(obj,fptr); -} - -#if PHOENIX_LIMIT > 6 -/////////////////////////////////////////////////////////////////////////////// -// -// Bound member function binder (specialization for 6 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct bound_member_action 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C, D, E, F); - typedef RT(ClassT::*cmf)(A, B, C, D, E, F) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template < - typename A_, typename B_, typename C_, typename D_, - typename E_, typename F_ - > - struct result { typedef result_type type; }; - - template - bound_member_action(CT & obj_, mem_func_ptr_t fptr_) - : obj(impl::as_ptr::get(obj_)), fptr(fptr_) {} - - result_type operator()( - A a, B b, C c, D d, E e, F f - ) const - { return (obj->*fptr)(a, b, c, d, e, f); } - - typename impl::as_ptr::pointer_type obj; - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline bound_member -bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F)) -{ - return bound_member< - RT, ClassT, A, B, C, D, E, F>(obj,fptr); -} - -template -inline bound_member -bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F)) -{ - return bound_member< - RT, ClassT, A, B, C, D, E, F>(obj,fptr); -} - -template -inline bound_member -bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F) const) -{ - return bound_member< - RT, ClassT const, A, B, C, D, E, F>(obj,fptr); -} - -template -inline bound_member -bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F) const) -{ - return bound_member< - RT, ClassT const, A, B, C, D, E, F>(obj,fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Bound member function binder (specialization for 7 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct bound_member_action 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C, D, E, F, G); - typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template < - typename A_, typename B_, typename C_, typename D_, - typename E_, typename F_, typename G_ - > - struct result { typedef result_type type; }; - - template - bound_member_action(CT & obj_, mem_func_ptr_t fptr_) - : obj(impl::as_ptr::get(obj_)), fptr(fptr_) {} - - result_type operator()( - A a, B b, C c, D d, E e, F f, G g - ) const - { return (obj->*fptr)(a, b, c, d, e, f, g); } - - typename impl::as_ptr::pointer_type obj; - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline bound_member -bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G)) -{ - return bound_member< - RT, ClassT, A, B, C, D, E, F, G>(obj,fptr); -} - -template -inline bound_member -bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G)) -{ - return bound_member< - RT, ClassT, A, B, C, D, E, F, G>(obj,fptr); -} - -template -inline bound_member -bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G) const) -{ - return bound_member< - RT, ClassT const, A, B, C, D, E, F, G>(obj,fptr); -} - -template -inline bound_member -bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G) const) -{ - return bound_member< - RT, ClassT const, A, B, C, D, E, F, G>(obj,fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Bound member function binder (specialization for 8 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct bound_member_action 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H); - typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template < - typename A_, typename B_, typename C_, typename D_, - typename E_, typename F_, typename G_, typename H_ - > - struct result { typedef result_type type; }; - - template - bound_member_action(CT & obj_, mem_func_ptr_t fptr_) - : obj(impl::as_ptr::get(obj_)), fptr(fptr_) {} - - result_type operator()( - A a, B b, C c, D d, E e, F f, G g, H h - ) const - { return (obj->*fptr)(a, b, c, d, e, f, g, h); } - - typename impl::as_ptr::pointer_type obj; - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline bound_member -bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H)) -{ - return bound_member< - RT, ClassT, A, B, C, D, E, F, G, H>(obj,fptr); -} - -template -inline bound_member -bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H)) -{ - return bound_member< - RT, ClassT, A, B, C, D, E, F, G, H>(obj,fptr); -} - -template -inline bound_member -bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H) const) -{ - return bound_member< - RT, ClassT const, A, B, C, D, E, F, G, H>(obj,fptr); -} - -template -inline bound_member -bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H) const) -{ - return bound_member< - RT, ClassT const, A, B, C, D, E, F, G, H>(obj,fptr); -} - -#if PHOENIX_LIMIT > 9 -/////////////////////////////////////////////////////////////////////////////// -// -// Bound member function binder (specialization for 9 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct bound_member_action 12 - nil_t, nil_t, nil_t, -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I); - typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template < - typename A_, typename B_, typename C_, typename D_, - typename E_, typename F_, typename G_, typename H_, typename I_ - > - struct result { typedef result_type type; }; - - template - bound_member_action(CT & obj_, mem_func_ptr_t fptr_) - : obj(impl::as_ptr::get(obj_)), fptr(fptr_) {} - - result_type operator()( - A a, B b, C c, D d, E e, F f, G g, H h, I i - ) const - { return (obj->*fptr)(a, b, c, d, e, f, g, h, i); } - - typename impl::as_ptr::pointer_type obj; - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline bound_member -bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I)) -{ - return bound_member< - RT, ClassT, A, B, C, D, E, F, G, H, I>(obj,fptr); -} - -template -inline bound_member -bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I)) -{ - return bound_member< - RT, ClassT, A, B, C, D, E, F, G, H, I>(obj,fptr); -} - -template -inline bound_member -bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I) const) -{ - return bound_member< - RT, ClassT const, A, B, C, D, E, F, G, H, I>(obj,fptr); -} - -template -inline bound_member -bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I) const) -{ - return bound_member< - RT, ClassT const, A, B, C, D, E, F, G, H, I>(obj,fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Bound member function binder (specialization for 10 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct bound_member_action 12 - nil_t, nil_t, nil_t, -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J); - typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template < - typename A_, typename B_, typename C_, typename D_, - typename E_, typename F_, typename G_, typename H_, typename I_, - typename J_ - > - struct result { typedef result_type type; }; - - template - bound_member_action(CT & obj_, mem_func_ptr_t fptr_) - : obj(impl::as_ptr::get(obj_)), fptr(fptr_) {} - - result_type operator()( - A a, B b, C c, D d, E e, F f, G g, H h, I i, J j - ) const - { - return (obj->*fptr)(a, b, c, d, e, f, g, h, i, j); - } - - typename impl::as_ptr::pointer_type obj; - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline bound_member -bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J)) -{ - return bound_member< - RT, ClassT, A, B, C, D, E, F, G, H, I, J>(obj,fptr); -} - -template -inline bound_member -bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J)) -{ - return bound_member< - RT, ClassT, A, B, C, D, E, F, G, H, I, J>(obj,fptr); -} - -template -inline bound_member -bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J) const) -{ - return bound_member< - RT, ClassT const, A, B, C, D, E, F, G, H, I, J>(obj,fptr); -} - -template -inline bound_member -bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J) const) -{ - return bound_member< - RT, ClassT const, A, B, C, D, E, F, G, H, I, J>(obj,fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Bound member function binder (specialization for 11 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct bound_member_action 12 - nil_t, nil_t, nil_t, -#endif - nil_t // Unused -> { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K); - typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template < - typename A_, typename B_, typename C_, typename D_, - typename E_, typename F_, typename G_, typename H_, typename I_, - typename J_, typename K_ - > - struct result { typedef result_type type; }; - - template - bound_member_action(CT & obj_, mem_func_ptr_t fptr_) - : obj(impl::as_ptr::get(obj_)), fptr(fptr_) {} - - result_type operator()( - A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k - ) const - { - return (obj->*fptr)(a, b, c, d, e, f, g, h, i, j, k); - } - - typename impl::as_ptr::pointer_type obj; - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline bound_member -bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K)) -{ - return bound_member< - RT, ClassT, A, B, C, D, E, F, G, H, I, J, K>(obj,fptr); -} - -template -inline bound_member -bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K)) -{ - return bound_member< - RT, ClassT, A, B, C, D, E, F, G, H, I, J, K>(obj,fptr); -} - -template -inline bound_member -bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K) const) -{ - return bound_member< - RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K>(obj,fptr); -} - -template -inline bound_member -bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K) const) -{ - return bound_member< - RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K>(obj,fptr); -} - -#if PHOENIX_LIMIT > 12 -/////////////////////////////////////////////////////////////////////////////// -// -// Bound member function binder (specialization for 12 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct bound_member_action { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K, L); - typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K, L) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template < - typename A_, typename B_, typename C_, typename D_, - typename E_, typename F_, typename G_, typename H_, typename I_, - typename J_, typename K_, typename L_ - > - struct result { typedef result_type type; }; - - template - bound_member_action(CT & obj_, mem_func_ptr_t fptr_) - : obj(impl::as_ptr::get(obj_)), fptr(fptr_) {} - - result_type operator()( - A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l - ) const - { - return (obj->*fptr)(a, b, c, d, e, f, g, h, i, j, k, l); - } - - typename impl::as_ptr::pointer_type obj; - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline bound_member -bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L)) -{ - return bound_member< - RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L>(obj,fptr); -} - -template -inline bound_member -bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L)) -{ - return bound_member< - RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L>(obj,fptr); -} - -template -inline bound_member -bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L) const) -{ - return bound_member< - RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L>(obj,fptr); -} - -template -inline bound_member -bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L) const) -{ - return bound_member< - RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L>(obj,fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Bound member function binder (specialization for 13 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct bound_member_action { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K, L, M); - typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K, L, M) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template < - typename A_, typename B_, typename C_, typename D_, - typename E_, typename F_, typename G_, typename H_, typename I_, - typename J_, typename K_, typename L_, typename M_ - > - struct result { typedef result_type type; }; - - template - bound_member_action(CT & obj_, mem_func_ptr_t fptr_) - : obj(impl::as_ptr::get(obj_)), fptr(fptr_) {} - - result_type operator()( - A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m - ) const - { - return (obj->*fptr)(a, b, c, d, e, f, g, h, i, j, k, l, m); - } - - typename impl::as_ptr::pointer_type obj; - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline bound_member -bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M)) -{ - return bound_member< - RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M>(obj,fptr); -} - -template -inline bound_member -bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M)) -{ - return bound_member< - RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M>(obj,fptr); -} - -template -inline bound_member -bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M) const) -{ - return bound_member< - RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M>(obj,fptr); -} - -template -inline bound_member -bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M) const) -{ - return bound_member< - RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M>(obj,fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Bound member function binder (specialization for 14 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct bound_member_action { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K, L, M, N); - typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K, L, M, N) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template < - typename A_, typename B_, typename C_, typename D_, - typename E_, typename F_, typename G_, typename H_, typename I_, - typename J_, typename K_, typename L_, typename M_, typename N_ - > - struct result { typedef result_type type; }; - - template - bound_member_action(CT & obj_, mem_func_ptr_t fptr_) - : obj(impl::as_ptr::get(obj_)), fptr(fptr_) {} - - result_type operator()( - A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n - ) const - { - return (obj->*fptr)(a, b, c, d, e, f, g, h, i, j, k, l, m, n); - } - - typename impl::as_ptr::pointer_type obj; - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline bound_member -bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N)) -{ - return bound_member< - RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N>(obj,fptr); -} - -template -inline bound_member -bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N)) -{ - return bound_member< - RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N>(obj,fptr); -} - -template -inline bound_member -bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N) const) -{ - return bound_member< - RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N>(obj,fptr); -} - -template -inline bound_member -bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N) const) -{ - return bound_member< - RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N>(obj,fptr); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Bound member function binder (specialization for 15 args) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct bound_member_action { - - typedef RT result_type; - typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O); - typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) const; - typedef typename boost::mpl::if_, cmf, mf>::type - mem_func_ptr_t; - - template < - typename A_, typename B_, typename C_, typename D_, - typename E_, typename F_, typename G_, typename H_, typename I_, - typename J_, typename K_, typename L_, typename M_, typename N_, - typename O_ - > - struct result { typedef result_type type; }; - - template - bound_member_action(CT & obj_, mem_func_ptr_t fptr_) - : obj(impl::as_ptr::get(obj_)), fptr(fptr_) {} - - result_type operator()( - A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o - ) const - { - return (obj->*fptr)(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o); - } - - typename impl::as_ptr::pointer_type obj; - mem_func_ptr_t fptr; -}; - -////////////////////////////////// -template -inline bound_member -bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) -{ - return bound_member< - RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(obj,fptr); -} - -template -inline bound_member -bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) -{ - return bound_member< - RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(obj,fptr); -} - -template -inline bound_member -bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) const) -{ - return bound_member< - RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(obj,fptr); -} - -template -inline bound_member -bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) const) -{ - return bound_member< - RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(obj,fptr); -} - -#endif -#endif -#endif -#endif - -} // namespace phoenix - -#endif diff --git a/boost/boost/spirit/phoenix/casts.hpp b/boost/boost/spirit/phoenix/casts.hpp deleted file mode 100644 index 3782e9f8b4..0000000000 --- a/boost/boost/spirit/phoenix/casts.hpp +++ /dev/null @@ -1,1471 +0,0 @@ -/*============================================================================= - Phoenix V1.2.1 - Copyright (c) 2001-2003 Joel de Guzman - Copyright (c) 2001-2003 Hartmut Kaiser - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -==============================================================================*/ - -#ifndef PHOENIX_CASTS_HPP -#define PHOENIX_CASTS_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace phoenix { - -/////////////////////////////////////////////////////////////////////////////// -// -// Phoenix predefined maximum construct_ limit. This limit defines the maximum -// number of parameters supported for calles to the set of construct_ template -// functions (lazy object construction, see below). This number defaults to 3. -// The actual maximum is rounded up in multiples of 3. Thus, if this value -// is 4, the actual limit is 6. The ultimate maximum limit in this -// implementation is 15. -// PHOENIX_CONSTRUCT_LIMIT should NOT be greater than PHOENIX_LIMIT! - -#if !defined(PHOENIX_CONSTRUCT_LIMIT) -#define PHOENIX_CONSTRUCT_LIMIT PHOENIX_LIMIT -#endif - -// ensure PHOENIX_CONSTRUCT_LIMIT <= PHOENIX_LIMIT -BOOST_STATIC_ASSERT(PHOENIX_CONSTRUCT_LIMIT <= PHOENIX_LIMIT); - -// ensure PHOENIX_CONSTRUCT_LIMIT <= 15 -BOOST_STATIC_ASSERT(PHOENIX_CONSTRUCT_LIMIT <= 15); - -/////////////////////////////////////////////////////////////////////////////// -// -// Lazy C++ casts -// -// The set of lazy C++ cast template classes and functions provide a way -// of lazily casting certain type to another during parsing. -// The lazy C++ templates are (syntactically) used very much like -// the well known C++ casts: -// -// A *a = static_cast_(...actor returning a convertible type...); -// -// where the given parameter should be an actor, which eval() function -// returns a convertible type. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct static_cast_l { - - template - struct result { typedef T type; }; - - static_cast_l(A const& a_) - : a(a_) {} - - template - T - eval(TupleT const& args) const - { - return static_cast(a.eval(args)); - } - - A a; -}; - -////////////////////////////////// -template -inline actor > -static_cast_(actor const& a) -{ - typedef static_cast_l cast_t; - return actor(cast_t(a)); -} - -////////////////////////////////// -template -struct dynamic_cast_l { - - template - struct result { typedef T type; }; - - dynamic_cast_l(A const& a_) - : a(a_) {} - - template - T - eval(TupleT const& args) const - { - return dynamic_cast(a.eval(args)); - } - - A a; -}; - -////////////////////////////////// -template -inline actor > -dynamic_cast_(actor const& a) -{ - typedef dynamic_cast_l cast_t; - return actor(cast_t(a)); -} - -////////////////////////////////// -template -struct reinterpret_cast_l { - - template - struct result { typedef T type; }; - - reinterpret_cast_l(A const& a_) - : a(a_) {} - - template - T - eval(TupleT const& args) const - { - return reinterpret_cast(a.eval(args)); - } - - A a; -}; - -////////////////////////////////// -template -inline actor > -reinterpret_cast_(actor const& a) -{ - typedef reinterpret_cast_l cast_t; - return actor(cast_t(a)); -} - -////////////////////////////////// -template -struct const_cast_l { - - template - struct result { typedef T type; }; - - const_cast_l(A const& a_) - : a(a_) {} - - template - T - eval(TupleT const& args) const - { - return const_cast(a.eval(args)); - } - - A a; -}; - -////////////////////////////////// -template -inline actor > -const_cast_(actor const& a) -{ - typedef const_cast_l cast_t; - return actor(cast_t(a)); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// construct_ -// -// Lazy object construction -// -// The set of construct_<> template classes and functions provide a way -// of lazily constructing certain object from a arbitrary set of -// actors during parsing. -// The construct_ templates are (syntactically) used very much like -// the well known C++ casts: -// -// A a = construct_(...arbitrary list of actors...); -// -// where the given parameters are submitted as parameters to the -// contructor of the object of type A. (This certainly implies, that -// type A has a constructor with a fitting set of parameter types -// defined.) -// -// The maximum number of needed parameters is controlled through the -// preprocessor constant PHOENIX_CONSTRUCT_LIMIT. Note though, that this -// limit should not be greater than PHOENIX_LIMIT. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct construct_l_0 { - typedef T result_type; - - T operator()() const { - return T(); - } -}; - - -template -struct construct_l { - - template < - typename A - , typename B - , typename C - -#if PHOENIX_CONSTRUCT_LIMIT > 3 - , typename D - , typename E - , typename F - -#if PHOENIX_CONSTRUCT_LIMIT > 6 - , typename G - , typename H - , typename I - -#if PHOENIX_CONSTRUCT_LIMIT > 9 - , typename J - , typename K - , typename L - -#if PHOENIX_CONSTRUCT_LIMIT > 12 - , typename M - , typename N - , typename O -#endif -#endif -#endif -#endif - > - struct result { typedef T type; }; - - T operator()() const - { - return T(); - } - - template - T operator()(A const& a) const - { - T t(a); - return t; - } - - template - T operator()(A const& a, B const& b) const - { - T t(a, b); - return t; - } - - template - T operator()(A const& a, B const& b, C const& c) const - { - T t(a, b, c); - return t; - } - -#if PHOENIX_CONSTRUCT_LIMIT > 3 - template < - typename A, typename B, typename C, typename D - > - T operator()( - A const& a, B const& b, C const& c, D const& d) const - { - T t(a, b, c, d); - return t; - } - - template < - typename A, typename B, typename C, typename D, typename E - > - T operator()( - A const& a, B const& b, C const& c, D const& d, E const& e) const - { - T t(a, b, c, d, e); - return t; - } - - template < - typename A, typename B, typename C, typename D, typename E, - typename F - > - T operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f) const - { - T t(a, b, c, d, e, f); - return t; - } - -#if PHOENIX_CONSTRUCT_LIMIT > 6 - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G - > - T operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g) const - { - T t(a, b, c, d, e, f, g); - return t; - } - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H - > - T operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h) const - { - T t(a, b, c, d, e, f, g, h); - return t; - } - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I - > - T operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i) const - { - T t(a, b, c, d, e, f, g, h, i); - return t; - } - -#if PHOENIX_CONSTRUCT_LIMIT > 9 - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J - > - T operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j) const - { - T t(a, b, c, d, e, f, g, h, i, j); - return t; - } - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K - > - T operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k) const - { - T t(a, b, c, d, e, f, g, h, i, j, k); - return t; - } - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L - > - T operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l) const - { - T t(a, b, c, d, e, f, g, h, i, j, k, l); - return t; - } - -#if PHOENIX_CONSTRUCT_LIMIT > 12 - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M - > - T operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l, M const& m) const - { - T t(a, b, c, d, e, f, g, h, i, j, k, l, m); - return t; - } - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M, typename N - > - T operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l, M const& m, N const& n) const - { - T t(a, b, c, d, e, f, g, h, i, j, k, l, m, n); - return t; - } - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M, typename N, typename O - > - T operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l, M const& m, N const& n, O const& o) const - { - T t(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o); - return t; - } - -#endif -#endif -#endif -#endif -}; - - -template -struct construct_1 { - - template < - typename A - > - struct result { typedef T type; }; - - template - T operator()(A const& a) const - { - T t(a); - return t; - } - -}; - -template -struct construct_2 { - - template < - typename A - , typename B - > - struct result { typedef T type; }; - - template - T operator()(A const& a, B const& b) const - { - T t(a, b); - return t; - } - -}; - -template -struct construct_3 { - - template < - typename A - , typename B - , typename C - > - struct result { typedef T type; }; - - template - T operator()(A const& a, B const& b, C const& c) const - { - T t(a, b, c); - return t; - } -}; - -#if PHOENIX_CONSTRUCT_LIMIT > 3 -template -struct construct_4 { - - template < - typename A - , typename B - , typename C - , typename D - > - struct result { typedef T type; }; - - template < - typename A, typename B, typename C, typename D - > - T operator()( - A const& a, B const& b, C const& c, D const& d) const - { - T t(a, b, c, d); - return t; - } -}; - - -template -struct construct_5 { - - template < - typename A - , typename B - , typename C - , typename D - , typename E - > - struct result { typedef T type; }; - - template < - typename A, typename B, typename C, typename D, typename E - > - T operator()( - A const& a, B const& b, C const& c, D const& d, E const& e) const - { - T t(a, b, c, d, e); - return t; - } -}; - - -template -struct construct_6 { - - template < - typename A - , typename B - , typename C - , typename D - , typename E - , typename F - > - struct result { typedef T type; }; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F - > - T operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f) const - { - T t(a, b, c, d, e, f); - return t; - } -}; -#endif - - -#if PHOENIX_CONSTRUCT_LIMIT > 6 -template -struct construct_7 { - - template < - typename A - , typename B - , typename C - , typename D - , typename E - , typename F - , typename G - > - struct result { typedef T type; }; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G - > - T operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g) const - { - T t(a, b, c, d, e, f, g); - return t; - } -}; - -template -struct construct_8 { - - template < - typename A - , typename B - , typename C - , typename D - , typename E - , typename F - , typename G - , typename H - > - struct result { typedef T type; }; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H - > - T operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h) const - { - T t(a, b, c, d, e, f, g, h); - return t; - } -}; - -template -struct construct_9 { - - template < - typename A - , typename B - , typename C - , typename D - , typename E - , typename F - , typename G - , typename H - , typename I - > - struct result { typedef T type; }; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I - > - T operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i) const - { - T t(a, b, c, d, e, f, g, h, i); - return t; - } -}; -#endif - - -#if PHOENIX_CONSTRUCT_LIMIT > 9 -template -struct construct_10 { - - template < - typename A - , typename B - , typename C - , typename D - , typename E - , typename F - , typename G - , typename H - , typename I - , typename J - > - struct result { typedef T type; }; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J - > - T operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j) const - { - T t(a, b, c, d, e, f, g, h, i, j); - return t; - } -}; - -template -struct construct_11 { - - template < - typename A - , typename B - , typename C - , typename D - , typename E - , typename F - , typename G - , typename H - , typename I - , typename J - , typename K - > - struct result { typedef T type; }; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K - > - T operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k) const - { - T t(a, b, c, d, e, f, g, h, i, j, k); - return t; - } -}; - -template -struct construct_12 { - - template < - typename A - , typename B - , typename C - , typename D - , typename E - , typename F - , typename G - , typename H - , typename I - , typename J - , typename K - , typename L - > - struct result { typedef T type; }; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L - > - T operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l) const - { - T t(a, b, c, d, f, e, g, h, i, j, k, l); - return t; - } -}; -#endif - -#if PHOENIX_CONSTRUCT_LIMIT > 12 -template -struct construct_13 { - - template < - typename A - , typename B - , typename C - , typename D - , typename E - , typename F - , typename G - , typename H - , typename I - , typename J - , typename K - , typename L - , typename M - > - struct result { typedef T type; }; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M - > - T operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l, M const& m) const - { - T t(a, b, c, d, e, f, g, h, i, j, k, l, m); - return t; - } -}; - -template -struct construct_14 { - - template < - typename A - , typename B - , typename C - , typename D - , typename E - , typename F - , typename G - , typename H - , typename I - , typename J - , typename K - , typename L - , typename M - , typename N - > - struct result { typedef T type; }; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M, typename N - > - T operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l, M const& m, N const& n) const - { - T t(a, b, c, d, e, f, g, h, i, j, k, l, m, n); - return t; - } -}; - -template -struct construct_15 { - - template < - typename A - , typename B - , typename C - , typename D - , typename E - , typename F - , typename G - , typename H - , typename I - , typename J - , typename K - , typename L - , typename M - , typename N - , typename O - > - struct result { typedef T type; }; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M, typename N, typename O - > - T operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l, M const& m, N const& n, O const& o) const - { - T t(a, b, c, d, f, e, g, h, i, j, k, l, m, n, o); - return t; - } -}; -#endif - - -#if defined(__BORLANDC__) || (defined(__MWERKS__) && (__MWERKS__ <= 0x3002)) - -/////////////////////////////////////////////////////////////////////////////// -// -// The following specializations are needed because Borland and CodeWarrior -// does not accept default template arguments in nested template classes in -// classes (i.e construct_l::result) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct composite0_result, TupleT> { - - typedef T type; -}; - -////////////////////////////////// -template -struct composite1_result, TupleT, A> { - - typedef T type; -}; - -////////////////////////////////// -template -struct composite2_result, TupleT, A, B> { - - typedef T type; -}; - -////////////////////////////////// -template -struct composite3_result, TupleT, A, B, C> { - - typedef T type; -}; - -#if PHOENIX_LIMIT > 3 -////////////////////////////////// -template -struct composite4_result, TupleT, - A, B, C, D> { - - typedef T type; -}; - -////////////////////////////////// -template -struct composite5_result, TupleT, - A, B, C, D, E> { - - typedef T type; -}; - -////////////////////////////////// -template -struct composite6_result, TupleT, - A, B, C, D, E, F> { - - typedef T type; -}; - -#if PHOENIX_LIMIT > 6 -////////////////////////////////// -template -struct composite7_result, TupleT, - A, B, C, D, E, F, G> { - - typedef T type; -}; - -////////////////////////////////// -template -struct composite8_result, TupleT, - A, B, C, D, E, F, G, H> { - - typedef T type; -}; - -////////////////////////////////// -template -struct composite9_result, TupleT, - A, B, C, D, E, F, G, H, I> { - - typedef T type; -}; - -#if PHOENIX_LIMIT > 9 -////////////////////////////////// -template -struct composite10_result, TupleT, - A, B, C, D, E, F, G, H, I, J> { - - typedef T type; -}; - -////////////////////////////////// -template -struct composite11_result, TupleT, - A, B, C, D, E, F, G, H, I, J, K> { - - typedef T type; -}; - -////////////////////////////////// -template -struct composite12_result, TupleT, - A, B, C, D, E, F, G, H, I, J, K, L> { - - typedef T type; -}; - -#if PHOENIX_LIMIT > 12 -////////////////////////////////// -template -struct composite13_result, TupleT, - A, B, C, D, E, F, G, H, I, J, K, L, M> { - - typedef T type; -}; - -////////////////////////////////// -template -struct composite14_result, TupleT, - A, B, C, D, E, F, G, H, I, J, K, L, M, N> { - - typedef T type; -}; - -////////////////////////////////// -template -struct composite15_result, TupleT, - A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> { - - typedef T type; -}; - -#endif -#endif -#endif -#endif -#endif - -////////////////////////////////// -template -inline typename impl::make_composite >::type -construct_() -{ - typedef impl::make_composite > make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(construct_l_0())); -} - -////////////////////////////////// -template -inline typename impl::make_composite, A>::type -construct_(A const& a) -{ - typedef impl::make_composite, A> make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(construct_1(), - as_actor::convert(a) - )); -} - -////////////////////////////////// -template -inline typename impl::make_composite, A, B>::type -construct_(A const& a, B const& b) -{ - typedef impl::make_composite, A, B> make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(construct_2(), - as_actor::convert(a), - as_actor::convert(b) - )); -} - -////////////////////////////////// -template -inline typename impl::make_composite, A, B, C>::type -construct_(A const& a, B const& b, C const& c) -{ - typedef impl::make_composite, A, B, C> make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(construct_3(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c) - )); -} - -#if PHOENIX_CONSTRUCT_LIMIT > 3 -////////////////////////////////// -template < - typename T, typename A, typename B, typename C, typename D -> -inline typename impl::make_composite, A, B, C, D>::type -construct_( - A const& a, B const& b, C const& c, D const& d) -{ - typedef - impl::make_composite, A, B, C, D> - make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(construct_4(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d) - )); -} - -////////////////////////////////// -template < - typename T, typename A, typename B, typename C, typename D, typename E -> -inline typename impl::make_composite, A, B, C, D, E>::type -construct_( - A const& a, B const& b, C const& c, D const& d, E const& e) -{ - typedef - impl::make_composite, A, B, C, D, E> - make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(construct_5(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e) - )); -} - -////////////////////////////////// -template < - typename T, typename A, typename B, typename C, typename D, typename E, - typename F -> -inline typename impl::make_composite, A, B, C, D, E, F>::type -construct_( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f) -{ - typedef - impl::make_composite, A, B, C, D, E, F> - make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(construct_6(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f) - )); -} - -#if PHOENIX_CONSTRUCT_LIMIT > 6 -////////////////////////////////// -template < - typename T, typename A, typename B, typename C, typename D, typename E, - typename F, typename G -> -inline typename impl::make_composite, A, B, C, D, E, F, G>::type -construct_( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g) -{ - typedef - impl::make_composite, A, B, C, D, E, F, G> - make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(construct_7(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g) - )); -} - -////////////////////////////////// -template < - typename T, typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H -> -inline typename impl::make_composite, A, B, C, D, E, F, G, H>::type -construct_( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h) -{ - typedef - impl::make_composite, A, B, C, D, E, F, G, H> - make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(construct_8(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g), - as_actor::convert(h) - )); -} - -////////////////////////////////// -template < - typename T, typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I -> -inline typename impl::make_composite, A, B, C, D, E, F, G, H, I>::type -construct_( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i) -{ - typedef - impl::make_composite, A, B, C, D, E, F, G, H, I> - make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(construct_9(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g), - as_actor::convert(h), - as_actor::convert(i) - )); -} - -#if PHOENIX_CONSTRUCT_LIMIT > 9 -////////////////////////////////// -template < - typename T, typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J -> -inline typename impl::make_composite< - construct_10, A, B, C, D, E, F, G, H, I, J>::type -construct_( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j) -{ - typedef - impl::make_composite< - construct_10, A, B, C, D, E, F, G, H, I, J - > - make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(construct_10(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g), - as_actor::convert(h), - as_actor::convert(i), - as_actor::convert(j) - )); -} - -////////////////////////////////// -template < - typename T, typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, typename K -> -inline typename impl::make_composite< - construct_11, A, B, C, D, E, F, G, H, I, J, K>::type -construct_( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k) -{ - typedef - impl::make_composite< - construct_11, A, B, C, D, E, F, G, H, I, J, K - > - make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(construct_11(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g), - as_actor::convert(h), - as_actor::convert(i), - as_actor::convert(j), - as_actor::convert(k) - )); -} - -////////////////////////////////// -template < - typename T, typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, typename K, - typename L -> -inline typename impl::make_composite< - construct_12, A, B, C, D, E, F, G, H, I, J, K, L>::type -construct_( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l) -{ - typedef - impl::make_composite< - construct_12, A, B, C, D, E, F, G, H, I, J, K, L - > - make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(construct_12(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g), - as_actor::convert(h), - as_actor::convert(i), - as_actor::convert(j), - as_actor::convert(k), - as_actor::convert(l) - )); -} - -#if PHOENIX_CONSTRUCT_LIMIT > 12 -////////////////////////////////// -template < - typename T, typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, typename K, - typename L, typename M -> -inline typename impl::make_composite< - construct_13, A, B, C, D, E, F, G, H, I, J, K, L, M>::type -construct_( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l, M const& m) -{ - typedef - impl::make_composite< - construct_13, A, B, C, D, E, F, G, H, I, J, K, L, M - > - make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(construct_13(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g), - as_actor::convert(h), - as_actor::convert(i), - as_actor::convert(j), - as_actor::convert(k), - as_actor::convert(l), - as_actor::convert(m) - )); -} - -////////////////////////////////// -template < - typename T, typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, typename K, - typename L, typename M, typename N -> -inline typename impl::make_composite< - construct_14, A, B, C, D, E, F, G, H, I, J, K, L, M>::type -construct_( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l, M const& m, N const& n) -{ - typedef - impl::make_composite< - construct_14, A, B, C, D, E, F, G, H, I, J, K, L, M, N - > - make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(construct_14(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g), - as_actor::convert(h), - as_actor::convert(i), - as_actor::convert(j), - as_actor::convert(k), - as_actor::convert(l), - as_actor::convert(m), - as_actor::convert(n) - )); -} - -////////////////////////////////// -template < - typename T, typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, typename K, - typename L, typename M, typename N, typename O -> -inline typename impl::make_composite< - construct_15, A, B, C, D, E, F, G, H, I, J, K, L, M, O>::type -construct_( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l, M const& m, N const& n, O const& o) -{ - typedef - impl::make_composite< - construct_15, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O - > - make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(construct_15(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g), - as_actor::convert(h), - as_actor::convert(i), - as_actor::convert(j), - as_actor::convert(k), - as_actor::convert(l), - as_actor::convert(m), - as_actor::convert(n), - as_actor::convert(o) - )); -} - -#endif -#endif -#endif -#endif - -/////////////////////////////////////////////////////////////////////////////// -} // namespace phoenix - -#endif // PHOENIX_CASTS_HPP diff --git a/boost/boost/spirit/phoenix/closures.hpp b/boost/boost/spirit/phoenix/closures.hpp deleted file mode 100644 index fb707ba469..0000000000 --- a/boost/boost/spirit/phoenix/closures.hpp +++ /dev/null @@ -1,440 +0,0 @@ -/*============================================================================= - Phoenix V1.2.1 - Copyright (c) 2001-2002 Joel de Guzman - MT code Copyright (c) 2002-2003 Martin Wille - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -==============================================================================*/ -#ifndef PHOENIX_CLOSURES_HPP -#define PHOENIX_CLOSURES_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include -#include - -#ifdef PHOENIX_THREADSAFE -#include -#include -#endif - -/////////////////////////////////////////////////////////////////////////////// -namespace phoenix { - -/////////////////////////////////////////////////////////////////////////////// -// -// Adaptable closures -// -// The framework will not be complete without some form of closures -// support. Closures encapsulate a stack frame where local -// variables are created upon entering a function and destructed -// upon exiting. Closures provide an environment for local -// variables to reside. Closures can hold heterogeneous types. -// -// Phoenix closures are true hardware stack based closures. At the -// very least, closures enable true reentrancy in lambda functions. -// A closure provides access to a function stack frame where local -// variables reside. Modeled after Pascal nested stack frames, -// closures can be nested just like nested functions where code in -// inner closures may access local variables from in-scope outer -// closures (accessing inner scopes from outer scopes is an error -// and will cause a run-time assertion failure). -// -// There are three (3) interacting classes: -// -// 1) closure: -// -// At the point of declaration, a closure does not yet create a -// stack frame nor instantiate any variables. A closure declaration -// declares the types and names[note] of the local variables. The -// closure class is meant to be subclassed. It is the -// responsibility of a closure subclass to supply the names for -// each of the local variable in the closure. Example: -// -// struct my_closure : closure { -// -// member1 num; // names the 1st (int) local variable -// member2 message; // names the 2nd (string) local variable -// member3 real; // names the 3rd (double) local variable -// }; -// -// my_closure clos; -// -// Now that we have a closure 'clos', its local variables can be -// accessed lazily using the dot notation. Each qualified local -// variable can be used just like any primitive actor (see -// primitives.hpp). Examples: -// -// clos.num = 30 -// clos.message = arg1 -// clos.real = clos.num * 1e6 -// -// The examples above are lazily evaluated. As usual, these -// expressions return composite actors that will be evaluated -// through a second function call invocation (see operators.hpp). -// Each of the members (clos.xxx) is an actor. As such, applying -// the operator() will reveal its identity: -// -// clos.num() // will return the current value of clos.num -// -// *** [note] Acknowledgement: Juan Carlos Arevalo-Baeza (JCAB) -// introduced and initilally implemented the closure member names -// that uses the dot notation. -// -// 2) closure_member -// -// The named local variables of closure 'clos' above are actually -// closure members. The closure_member class is an actor and -// conforms to its conceptual interface. member1..memberN are -// predefined typedefs that correspond to each of the listed types -// in the closure template parameters. -// -// 3) closure_frame -// -// When a closure member is finally evaluated, it should refer to -// an actual instance of the variable in the hardware stack. -// Without doing so, the process is not complete and the evaluated -// member will result to an assertion failure. Remember that the -// closure is just a declaration. The local variables that a -// closure refers to must still be instantiated. -// -// The closure_frame class does the actual instantiation of the -// local variables and links these variables with the closure and -// all its members. There can be multiple instances of -// closure_frames typically situated in the stack inside a -// function. Each closure_frame instance initiates a stack frame -// with a new set of closure local variables. Example: -// -// void foo() -// { -// closure_frame frame(clos); -// /* do something */ -// } -// -// where 'clos' is an instance of our closure 'my_closure' above. -// Take note that the usage above precludes locally declared -// classes. If my_closure is a locally declared type, we can still -// use its self_type as a paramater to closure_frame: -// -// closure_frame frame(clos); -// -// Upon instantiation, the closure_frame links the local variables -// to the closure. The previous link to another closure_frame -// instance created before is saved. Upon destruction, the -// closure_frame unlinks itself from the closure and relinks the -// preceding closure_frame prior to this instance. -// -// The local variables in the closure 'clos' above is default -// constructed in the stack inside function 'foo'. Once 'foo' is -// exited, all of these local variables are destructed. In some -// cases, default construction is not desirable and we need to -// initialize the local closure variables with some values. This -// can be done by passing in the initializers in a compatible -// tuple. A compatible tuple is one with the same number of -// elements as the destination and where each element from the -// destination can be constructed from each corresponding element -// in the source. Example: -// -// tuple init(123, "Hello", 1000); -// closure_frame frame(clos, init); -// -// Here now, our closure_frame's variables are initialized with -// int: 123, char const*: "Hello" and int: 1000. -// -/////////////////////////////////////////////////////////////////////////////// - -namespace impl -{ - /////////////////////////////////////////////////////////////////////// - // closure_frame_holder is a simple class that encapsulates the - // storage for a frame pointer. It uses thread specific data in - // case when multithreading is enabled, an ordinary pointer otherwise - // - // it has get() and set() member functions. set() has to be used - // _after_ get(). get() contains intialisation code in the multi - // threading case - // - // closure_frame_holder is used by the closure<> class to store - // the pointer to the current frame. - // -#ifndef PHOENIX_THREADSAFE - template - struct closure_frame_holder - { - typedef FrameT frame_t; - typedef frame_t *frame_ptr; - - closure_frame_holder() : frame(0) {} - - frame_ptr &get() { return frame; } - void set(frame_t *f) { frame = f; } - - private: - frame_ptr frame; - - // no copies, no assignments - closure_frame_holder(closure_frame_holder const &); - closure_frame_holder &operator=(closure_frame_holder const &); - }; -#else - template - struct closure_frame_holder - { - typedef FrameT frame_t; - typedef frame_t *frame_ptr; - - closure_frame_holder() : tsp_frame() {} - - frame_ptr &get() - { - if (!tsp_frame.get()) - tsp_frame.reset(new frame_ptr(0)); - return *tsp_frame; - } - void set(frame_ptr f) - { - *tsp_frame = f; - } - - private: - boost::thread_specific_ptr tsp_frame; - - // no copies, no assignments - closure_frame_holder(closure_frame_holder const &); - closure_frame_holder &operator=(closure_frame_holder const &); - }; -#endif -} // namespace phoenix::impl - -/////////////////////////////////////////////////////////////////////////////// -// -// closure_frame class -// -/////////////////////////////////////////////////////////////////////////////// -template -class closure_frame : public ClosureT::tuple_t { - -public: - - closure_frame(ClosureT const& clos) - : ClosureT::tuple_t(), save(clos.frame.get()), frame(clos.frame) - { clos.frame.set(this); } - - template - closure_frame(ClosureT const& clos, TupleT const& init) - : ClosureT::tuple_t(init), save(clos.frame.get()), frame(clos.frame) - { clos.frame.set(this); } - - ~closure_frame() - { frame.set(save); } - -private: - - closure_frame(closure_frame const&); // no copy - closure_frame& operator=(closure_frame const&); // no assign - - closure_frame* save; - impl::closure_frame_holder& frame; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// closure_member class -// -/////////////////////////////////////////////////////////////////////////////// -template -class closure_member { - -public: - - typedef typename ClosureT::tuple_t tuple_t; - - closure_member() - : frame(ClosureT::closure_frame_holder_ref()) {} - - template - struct result { - - typedef typename tuple_element< - N, typename ClosureT::tuple_t - >::rtype type; - }; - - template - typename tuple_element::rtype - eval(TupleT const& /*args*/) const - { - using namespace std; - assert(frame.get() != 0); - return (*frame.get())[tuple_index()]; - } - -private: - impl::closure_frame_holder &frame; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// closure class -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename T0 = nil_t - , typename T1 = nil_t - , typename T2 = nil_t - -#if PHOENIX_LIMIT > 3 - , typename T3 = nil_t - , typename T4 = nil_t - , typename T5 = nil_t - -#if PHOENIX_LIMIT > 6 - , typename T6 = nil_t - , typename T7 = nil_t - , typename T8 = nil_t - -#if PHOENIX_LIMIT > 9 - , typename T9 = nil_t - , typename T10 = nil_t - , typename T11 = nil_t - -#if PHOENIX_LIMIT > 12 - , typename T12 = nil_t - , typename T13 = nil_t - , typename T14 = nil_t - -#endif -#endif -#endif -#endif -> -class closure { - -public: - - typedef tuple< - T0, T1, T2 -#if PHOENIX_LIMIT > 3 - , T3, T4, T5 -#if PHOENIX_LIMIT > 6 - , T6, T7, T8 -#if PHOENIX_LIMIT > 9 - , T9, T10, T11 -#if PHOENIX_LIMIT > 12 - , T12, T13, T14 -#endif -#endif -#endif -#endif - > tuple_t; - - typedef closure< - T0, T1, T2 -#if PHOENIX_LIMIT > 3 - , T3, T4, T5 -#if PHOENIX_LIMIT > 6 - , T6, T7, T8 -#if PHOENIX_LIMIT > 9 - , T9, T10, T11 -#if PHOENIX_LIMIT > 12 - , T12, T13, T14 -#endif -#endif -#endif -#endif - > self_t; - - typedef closure_frame closure_frame_t; - - closure() - : frame() { closure_frame_holder_ref(&frame); } - closure_frame_t& context() { assert(frame!=0); return frame.get(); } - closure_frame_t const& context() const { assert(frame!=0); return frame.get(); } - - typedef actor > member1; - typedef actor > member2; - typedef actor > member3; - -#if PHOENIX_LIMIT > 3 - typedef actor > member4; - typedef actor > member5; - typedef actor > member6; - -#if PHOENIX_LIMIT > 6 - typedef actor > member7; - typedef actor > member8; - typedef actor > member9; - -#if PHOENIX_LIMIT > 9 - typedef actor > member10; - typedef actor > member11; - typedef actor > member12; - -#if PHOENIX_LIMIT > 12 - typedef actor > member13; - typedef actor > member14; - typedef actor > member15; - -#endif -#endif -#endif -#endif - -#if !defined(__MWERKS__) || (__MWERKS__ > 0x3002) -private: -#endif - - closure(closure const&); // no copy - closure& operator=(closure const&); // no assign - -#if !defined(__MWERKS__) || (__MWERKS__ > 0x3002) - template - friend class closure_member; - - template - friend class closure_frame; -#endif - - typedef impl::closure_frame_holder holder_t; - -#ifdef PHOENIX_THREADSAFE - static boost::thread_specific_ptr & - tsp_frame_instance() - { - static boost::thread_specific_ptr the_instance; - return the_instance; - } - - static void - tsp_frame_instance_init() - { - tsp_frame_instance(); - } -#endif - - static holder_t & - closure_frame_holder_ref(holder_t* holder_ = 0) - { -#ifdef PHOENIX_THREADSAFE - static boost::once_flag been_here = BOOST_ONCE_INIT; - boost::call_once(tsp_frame_instance_init, been_here); - boost::thread_specific_ptr &tsp_frame = tsp_frame_instance(); - if (!tsp_frame.get()) - tsp_frame.reset(new holder_t *(0)); - holder_t *& holder = *tsp_frame; -#else - static holder_t* holder = 0; -#endif - if (holder_ != 0) - holder = holder_; - return *holder; - } - - mutable holder_t frame; -}; - -} - // namespace phoenix - -#endif diff --git a/boost/boost/spirit/phoenix/composite.hpp b/boost/boost/spirit/phoenix/composite.hpp deleted file mode 100644 index 903d31935e..0000000000 --- a/boost/boost/spirit/phoenix/composite.hpp +++ /dev/null @@ -1,1423 +0,0 @@ -/*============================================================================= - Phoenix V1.2.1 - Copyright (c) 2001-2002 Joel de Guzman - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -==============================================================================*/ -#ifndef PHOENIX_COMPOSITE_HPP -#define PHOENIX_COMPOSITE_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace phoenix { - -/////////////////////////////////////////////////////////////////////////////// -// -// composite class -// -// A composite is an actor base class composed of zero or more -// actors (see actor.hpp) and an operation. A composite is itself -// an actor superclass and conforms to its conceptual interface. -// Its eval member function un-funnels the tupled actual arguments -// from the tuple by invoking each of the actors' eval member -// function. The results of each are then passed on as arguments to -// the operation. Specializations are provided to handle different -// numbers of actors. -// -// Schematically: -// -// actor0.eval(tupled_args) --> arg0 --> | -// actor1.eval(tupled_args) --> arg1 --> | -// actor2.eval(tupled_args) --> arg3 --> | --> operation(arg0...argN) -// ... | -// actorN.eval(tupled_args) --> argN --> | -// -// The operation can be any suitable functor that can accept the -// arguments passed in by the composite. The operation is expected -// to have a member operator() that carries out the actual -// operation. There should be a one to one correspondence between -// actors of the composite and the arguments of the operation's -// member operator(). -// -// The operation is also expected to have a nested template class -// result. The nested template class result should have a -// typedef 'type' that reflects the return type of its member -// operator(). This is essentially a type computer that answers the -// metaprogramming question "Given arguments of type T0...TN, what -// will be its operator()'s return type?". -// -// There is a special case for operations that accept no arguments. -// Such nullary operations are only required to define a typedef -// result_type that reflects the return type of its operator(). -// -// Here's an example of a simple operation that squares a number: -// -// struct square { -// -// template -// struct result { typedef ArgT type; }; -// -// template -// ArgT operator()(ArgT n) const { return n * n; } -// }; -// -// As can be seen, operations can be polymorphic. Its arguments and -// return type are not fixed to a particular type. The example -// above for example, can handle any ArgT type as long as it has a -// multiplication operator. -// -// Composites are not created directly. Instead, there are meta- -// programs provided that indirectly create composites. See -// operators.hpp, binders.hpp and functions.hpp for examples. -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename OperationT - , typename A = nil_t - , typename B = nil_t - , typename C = nil_t - -#if PHOENIX_LIMIT > 3 - , typename D = nil_t - , typename E = nil_t - , typename F = nil_t - -#if PHOENIX_LIMIT > 6 - , typename G = nil_t - , typename H = nil_t - , typename I = nil_t - -#if PHOENIX_LIMIT > 9 - , typename J = nil_t - , typename K = nil_t - , typename L = nil_t - -#if PHOENIX_LIMIT > 12 - , typename M = nil_t - , typename N = nil_t - , typename O = nil_t - -#endif -#endif -#endif -#endif - - , typename NU = nil_t // Not used -> -struct composite; - -/////////////////////////////////////////////////////////////////////////////// -// -// composite <0 actor> class -// -/////////////////////////////////////////////////////////////////////////////// -template -struct composite0_result { - - typedef typename OperationT::result_type type; -}; - -////////////////////////////////// -template -struct composite 3 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif -#endif - nil_t // Unused -> { - - typedef composite self_t; - - template - struct result { - - typedef typename composite0_result< - OperationT, TupleT - >::type type; - }; - - composite(OperationT const& op_) - : op(op_) {} - - template - typename OperationT::result_type - eval(TupleT const& /*args*/) const - { - return op(); - } - - mutable OperationT op; // operation -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// composite <1 actor> class -// -/////////////////////////////////////////////////////////////////////////////// -template -struct composite1_result { - - typedef typename OperationT::template result< - typename actor_result::plain_type - >::type type; -}; - -////////////////////////////////// -template -struct composite 3 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif -#endif - nil_t // Unused -> { - - typedef composite self_t; - - template - struct result { - - typedef typename composite1_result< - OperationT, TupleT, A - >::type type; - }; - - composite(OperationT const& op_, - A const& a_) - : op(op_), a(a_) {} - - template - typename actor_result::type - eval(TupleT const& args) const - { - typename actor_result::type ra = a.eval(args); - return op(ra); - } - - mutable OperationT op; // operation - A a; // actors -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// composite <2 actors> class -// -/////////////////////////////////////////////////////////////////////////////// -template -struct composite2_result { - - typedef typename OperationT::template result< - typename actor_result::plain_type, - typename actor_result::plain_type - >::type type; -}; - -////////////////////////////////// -template -struct composite 3 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif -#endif - nil_t // Unused -> { - - typedef composite self_t; - - template - struct result { - - typedef typename composite2_result< - OperationT, TupleT, A, B - >::type type; - }; - - composite(OperationT const& op_, - A const& a_, B const& b_) - : op(op_), a(a_), b(b_) {} - - template - typename actor_result::type - eval(TupleT const& args) const - { - typename actor_result::type ra = a.eval(args); - typename actor_result::type rb = b.eval(args); - return op(ra, rb); - } - - mutable OperationT op; // operation - A a; B b; // actors -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// composite <3 actors> class -// -/////////////////////////////////////////////////////////////////////////////// -template -struct composite3_result { - - typedef typename OperationT::template result< - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type - >::type type; -}; - -////////////////////////////////// -template -struct composite 3 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif -#endif - nil_t // Unused -> { - - typedef composite self_t; - - template - struct result { - - typedef typename composite3_result< - OperationT, TupleT, A, B, C - >::type type; - }; - - composite(OperationT const& op_, - A const& a_, B const& b_, C const& c_) - : op(op_), a(a_), b(b_), c(c_) {} - - template - typename actor_result::type - eval(TupleT const& args) const - { - typename actor_result::type ra = a.eval(args); - typename actor_result::type rb = b.eval(args); - typename actor_result::type rc = c.eval(args); - return op(ra, rb, rc); - } - - mutable OperationT op; // operation - A a; B b; C c; // actors -}; - -#if PHOENIX_LIMIT > 3 -/////////////////////////////////////////////////////////////////////////////// -// -// composite <4 actors> class -// -/////////////////////////////////////////////////////////////////////////////// -template -struct composite4_result { - - typedef typename OperationT::template result< - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type - >::type type; -}; - -////////////////////////////////// -template -struct composite 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif - nil_t // Unused -> { - - typedef composite self_t; - - template - struct result { - - typedef typename composite4_result< - OperationT, TupleT, A, B, C, D - >::type type; - }; - - composite(OperationT const& op_, - A const& a_, B const& b_, C const& c_, D const& d_) - : op(op_), a(a_), b(b_), c(c_), d(d_) {} - - template - typename actor_result::type - eval(TupleT const& args) const - { - typename actor_result::type ra = a.eval(args); - typename actor_result::type rb = b.eval(args); - typename actor_result::type rc = c.eval(args); - typename actor_result::type rd = d.eval(args); - return op(ra, rb, rc, rd); - } - - mutable OperationT op; // operation - A a; B b; C c; D d; // actors -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// composite <5 actors> class -// -/////////////////////////////////////////////////////////////////////////////// -template -struct composite5_result { - - typedef typename OperationT::template result< - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type - >::type type; -}; - -////////////////////////////////// -template -struct composite 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif - nil_t // Unused -> { - - typedef composite self_t; - - template - struct result { - - typedef typename composite5_result< - OperationT, TupleT, A, B, C, D, E - >::type type; - }; - - composite(OperationT const& op_, - A const& a_, B const& b_, C const& c_, D const& d_, E const& e_) - : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_) {} - - template - typename actor_result::type - eval(TupleT const& args) const - { - typename actor_result::type ra = a.eval(args); - typename actor_result::type rb = b.eval(args); - typename actor_result::type rc = c.eval(args); - typename actor_result::type rd = d.eval(args); - typename actor_result::type re = e.eval(args); - return op(ra, rb, rc, rd, re); - } - - mutable OperationT op; // operation - A a; B b; C c; D d; E e; // actors -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// composite <6 actors> class -// -/////////////////////////////////////////////////////////////////////////////// -template -struct composite6_result { - - typedef typename OperationT::template result< - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type - >::type type; -}; - -////////////////////////////////// -template -struct composite 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif - nil_t // Unused -> { - - typedef composite self_t; - - template - struct result { - - typedef typename composite6_result< - OperationT, TupleT, A, B, C, D, E, F - >::type type; - }; - - composite(OperationT const& op_, - A const& a_, B const& b_, C const& c_, D const& d_, E const& e_, - F const& f_) - : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_), - f(f_) {} - - template - typename actor_result::type - eval(TupleT const& args) const - { - typename actor_result::type ra = a.eval(args); - typename actor_result::type rb = b.eval(args); - typename actor_result::type rc = c.eval(args); - typename actor_result::type rd = d.eval(args); - typename actor_result::type re = e.eval(args); - typename actor_result::type rf = f.eval(args); - return op(ra, rb, rc, rd, re, rf); - } - - mutable OperationT op; // operation - A a; B b; C c; D d; E e; F f; // actors -}; - -#if PHOENIX_LIMIT > 6 -/////////////////////////////////////////////////////////////////////////////// -// -// composite <7 actors> class -// -/////////////////////////////////////////////////////////////////////////////// -template -struct composite7_result { - - typedef typename OperationT::template result< - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type - >::type type; -}; - -////////////////////////////////// -template -struct composite 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif - nil_t // Unused -> { - - typedef composite self_t; - - template - struct result { - - typedef typename composite7_result< - OperationT, TupleT, A, B, C, D, E, F, G - >::type type; - }; - - composite(OperationT const& op_, - A const& a_, B const& b_, C const& c_, D const& d_, E const& e_, - F const& f_, G const& g_) - : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_), - f(f_), g(g_) {} - - template - typename actor_result::type - eval(TupleT const& args) const - { - typename actor_result::type ra = a.eval(args); - typename actor_result::type rb = b.eval(args); - typename actor_result::type rc = c.eval(args); - typename actor_result::type rd = d.eval(args); - typename actor_result::type re = e.eval(args); - typename actor_result::type rf = f.eval(args); - typename actor_result::type rg = g.eval(args); - return op(ra, rb, rc, rd, re, rf, rg); - } - - mutable OperationT op; // operation - A a; B b; C c; D d; E e; F f; G g; // actors -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// composite <8 actors> class -// -/////////////////////////////////////////////////////////////////////////////// -template -struct composite8_result { - - typedef typename OperationT::template result< - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type - >::type type; -}; - -////////////////////////////////// -template -struct composite 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif - nil_t // Unused -> { - - typedef composite self_t; - - template - struct result { - - typedef typename composite8_result< - OperationT, TupleT, A, B, C, D, E, F, G, H - >::type type; - }; - - composite(OperationT const& op_, - A const& a_, B const& b_, C const& c_, D const& d_, E const& e_, - F const& f_, G const& g_, H const& h_) - : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_), - f(f_), g(g_), h(h_) {} - - template - typename actor_result::type - eval(TupleT const& args) const - { - typename actor_result::type ra = a.eval(args); - typename actor_result::type rb = b.eval(args); - typename actor_result::type rc = c.eval(args); - typename actor_result::type rd = d.eval(args); - typename actor_result::type re = e.eval(args); - typename actor_result::type rf = f.eval(args); - typename actor_result::type rg = g.eval(args); - typename actor_result::type rh = h.eval(args); - return op(ra, rb, rc, rd, re, rf, rg, rh); - } - - mutable OperationT op; // operation - A a; B b; C c; D d; E e; F f; G g; H h; // actors -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// composite <9 actors> class -// -/////////////////////////////////////////////////////////////////////////////// -template -struct composite9_result { - - typedef typename OperationT::template result< - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type - >::type type; -}; - -////////////////////////////////// -template -struct composite 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif - nil_t // Unused -> { - - typedef composite self_t; - - template - struct result { - - typedef typename composite9_result< - OperationT, TupleT, A, B, C, D, E, F, G, H, I - >::type type; - }; - - composite(OperationT const& op_, - A const& a_, B const& b_, C const& c_, D const& d_, E const& e_, - F const& f_, G const& g_, H const& h_, I const& i_) - : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_), - f(f_), g(g_), h(h_), i(i_) {} - - template - typename actor_result::type - eval(TupleT const& args) const - { - typename actor_result::type ra = a.eval(args); - typename actor_result::type rb = b.eval(args); - typename actor_result::type rc = c.eval(args); - typename actor_result::type rd = d.eval(args); - typename actor_result::type re = e.eval(args); - typename actor_result::type rf = f.eval(args); - typename actor_result::type rg = g.eval(args); - typename actor_result::type rh = h.eval(args); - typename actor_result::type ri = i.eval(args); - return op(ra, rb, rc, rd, re, rf, rg, rh, ri); - } - - mutable OperationT op; // operation - A a; B b; C c; D d; E e; F f; G g; H h; I i; // actors -}; - -#if PHOENIX_LIMIT > 9 -/////////////////////////////////////////////////////////////////////////////// -// -// composite <10 actors> class -// -/////////////////////////////////////////////////////////////////////////////// -template -struct composite10_result { - - typedef typename OperationT::template result< - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type - >::type type; -}; - -////////////////////////////////// -template -struct composite 12 - nil_t, nil_t, nil_t, -#endif - nil_t // Unused -> { - - typedef composite self_t; - - template - struct result { - - typedef typename composite10_result< - OperationT, TupleT, A, B, C, D, E, F, G, H, I, J - >::type type; - }; - - composite(OperationT const& op_, - A const& a_, B const& b_, C const& c_, D const& d_, E const& e_, - F const& f_, G const& g_, H const& h_, I const& i_, J const& j_) - : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_), - f(f_), g(g_), h(h_), i(i_), j(j_) {} - - template - typename actor_result::type - eval(TupleT const& args) const - { - typename actor_result::type ra = a.eval(args); - typename actor_result::type rb = b.eval(args); - typename actor_result::type rc = c.eval(args); - typename actor_result::type rd = d.eval(args); - typename actor_result::type re = e.eval(args); - typename actor_result::type rf = f.eval(args); - typename actor_result::type rg = g.eval(args); - typename actor_result::type rh = h.eval(args); - typename actor_result::type ri = i.eval(args); - typename actor_result::type rj = j.eval(args); - return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj); - } - - mutable OperationT op; // operation - A a; B b; C c; D d; E e; F f; G g; H h; I i; J j; // actors -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// composite <11 actors> class -// -/////////////////////////////////////////////////////////////////////////////// -template -struct composite11_result { - - typedef typename OperationT::template result< - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type - >::type type; -}; - -////////////////////////////////// -template -struct composite 12 - nil_t, nil_t, nil_t, -#endif - nil_t // Unused -> { - - typedef composite self_t; - - template - struct result { - - typedef typename composite11_result< - OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K - >::type type; - }; - - composite(OperationT const& op_, - A const& a_, B const& b_, C const& c_, D const& d_, E const& e_, - F const& f_, G const& g_, H const& h_, I const& i_, J const& j_, - K const& k_) - : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_), - f(f_), g(g_), h(h_), i(i_), j(j_), - k(k_) {} - - template - typename actor_result::type - eval(TupleT const& args) const - { - typename actor_result::type ra = a.eval(args); - typename actor_result::type rb = b.eval(args); - typename actor_result::type rc = c.eval(args); - typename actor_result::type rd = d.eval(args); - typename actor_result::type re = e.eval(args); - typename actor_result::type rf = f.eval(args); - typename actor_result::type rg = g.eval(args); - typename actor_result::type rh = h.eval(args); - typename actor_result::type ri = i.eval(args); - typename actor_result::type rj = j.eval(args); - typename actor_result::type rk = k.eval(args); - return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk); - } - - mutable OperationT op; // operation - A a; B b; C c; D d; E e; F f; G g; H h; I i; J j; - K k;// actors -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// composite <12 actors> class -// -/////////////////////////////////////////////////////////////////////////////// -template -struct composite12_result { - - typedef typename OperationT::template result< - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type - >::type type; -}; - -////////////////////////////////// -template -struct composite 12 - nil_t, nil_t, nil_t, -#endif - nil_t // Unused -> { - - typedef composite self_t; - - template - struct result { - - typedef typename composite12_result< - OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K, L - >::type type; - }; - - composite(OperationT const& op_, - A const& a_, B const& b_, C const& c_, D const& d_, E const& e_, - F const& f_, G const& g_, H const& h_, I const& i_, J const& j_, - K const& k_, L const& l_) - : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_), - f(f_), g(g_), h(h_), i(i_), j(j_), - k(k_), l(l_) {} - - template - typename actor_result::type - eval(TupleT const& args) const - { - typename actor_result::type ra = a.eval(args); - typename actor_result::type rb = b.eval(args); - typename actor_result::type rc = c.eval(args); - typename actor_result::type rd = d.eval(args); - typename actor_result::type re = e.eval(args); - typename actor_result::type rf = f.eval(args); - typename actor_result::type rg = g.eval(args); - typename actor_result::type rh = h.eval(args); - typename actor_result::type ri = i.eval(args); - typename actor_result::type rj = j.eval(args); - typename actor_result::type rk = k.eval(args); - typename actor_result::type rl = l.eval(args); - return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl); - } - - mutable OperationT op; // operation - A a; B b; C c; D d; E e; F f; G g; H h; I i; J j; - K k; L l;// actors -}; - -#if PHOENIX_LIMIT > 12 -/////////////////////////////////////////////////////////////////////////////// -// -// composite <13 actors> class -// -/////////////////////////////////////////////////////////////////////////////// -template -struct composite13_result { - - typedef typename OperationT::template result< - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type - >::type type; -}; - -////////////////////////////////// -template -struct composite { - - typedef composite self_t; - - template - struct result { - - typedef typename composite13_result< - OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K, L, M - >::type type; - }; - - composite(OperationT const& op_, - A const& a_, B const& b_, C const& c_, D const& d_, E const& e_, - F const& f_, G const& g_, H const& h_, I const& i_, J const& j_, - K const& k_, L const& l_, M const& m_) - : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_), - f(f_), g(g_), h(h_), i(i_), j(j_), - k(k_), l(l_), m(m_) {} - - template - typename actor_result::type - eval(TupleT const& args) const - { - typename actor_result::type ra = a.eval(args); - typename actor_result::type rb = b.eval(args); - typename actor_result::type rc = c.eval(args); - typename actor_result::type rd = d.eval(args); - typename actor_result::type re = e.eval(args); - typename actor_result::type rf = f.eval(args); - typename actor_result::type rg = g.eval(args); - typename actor_result::type rh = h.eval(args); - typename actor_result::type ri = i.eval(args); - typename actor_result::type rj = j.eval(args); - typename actor_result::type rk = k.eval(args); - typename actor_result::type rl = l.eval(args); - typename actor_result::type rm = m.eval(args); - return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl, rm); - } - - mutable OperationT op; // operation - A a; B b; C c; D d; E e; F f; G g; H h; I i; J j; - K k; L l; M m; // actors -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// composite <14 actors> class -// -/////////////////////////////////////////////////////////////////////////////// -template -struct composite14_result { - - typedef typename OperationT::template result< - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type - >::type type; -}; - -////////////////////////////////// -template -struct composite { - - typedef composite self_t; - - template - struct result { - - typedef typename composite14_result< - OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K, L, M, N - >::type type; - }; - - composite(OperationT const& op_, - A const& a_, B const& b_, C const& c_, D const& d_, E const& e_, - F const& f_, G const& g_, H const& h_, I const& i_, J const& j_, - K const& k_, L const& l_, M const& m_, N const& n_) - : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_), - f(f_), g(g_), h(h_), i(i_), j(j_), - k(k_), l(l_), m(m_), n(n_) {} - - template - typename actor_result::type - eval(TupleT const& args) const - { - typename actor_result::type ra = a.eval(args); - typename actor_result::type rb = b.eval(args); - typename actor_result::type rc = c.eval(args); - typename actor_result::type rd = d.eval(args); - typename actor_result::type re = e.eval(args); - typename actor_result::type rf = f.eval(args); - typename actor_result::type rg = g.eval(args); - typename actor_result::type rh = h.eval(args); - typename actor_result::type ri = i.eval(args); - typename actor_result::type rj = j.eval(args); - typename actor_result::type rk = k.eval(args); - typename actor_result::type rl = l.eval(args); - typename actor_result::type rm = m.eval(args); - typename actor_result::type rn = n.eval(args); - return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl, rm, rn); - } - - mutable OperationT op; // operation - A a; B b; C c; D d; E e; F f; G g; H h; I i; J j; - K k; L l; M m; N n; // actors -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// composite <15 actors> class -// -/////////////////////////////////////////////////////////////////////////////// -template -struct composite15_result { - - typedef typename OperationT::template result< - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type, - typename actor_result::plain_type - >::type type; -}; - -////////////////////////////////// -template -struct composite { - - typedef composite self_t; - - template - struct result { - - typedef typename composite15_result< - OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O - >::type type; - }; - - composite(OperationT const& op_, - A const& a_, B const& b_, C const& c_, D const& d_, E const& e_, - F const& f_, G const& g_, H const& h_, I const& i_, J const& j_, - K const& k_, L const& l_, M const& m_, N const& n_, O const& o_) - : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_), - f(f_), g(g_), h(h_), i(i_), j(j_), - k(k_), l(l_), m(m_), n(n_), o(o_) {} - - template - typename actor_result::type - eval(TupleT const& args) const - { - typename actor_result::type ra = a.eval(args); - typename actor_result::type rb = b.eval(args); - typename actor_result::type rc = c.eval(args); - typename actor_result::type rd = d.eval(args); - typename actor_result::type re = e.eval(args); - typename actor_result::type rf = f.eval(args); - typename actor_result::type rg = g.eval(args); - typename actor_result::type rh = h.eval(args); - typename actor_result::type ri = i.eval(args); - typename actor_result::type rj = j.eval(args); - typename actor_result::type rk = k.eval(args); - typename actor_result::type rl = l.eval(args); - typename actor_result::type rm = m.eval(args); - typename actor_result::type rn = n.eval(args); - typename actor_result::type ro = o.eval(args); - return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl, rm, rn, ro); - } - - mutable OperationT op; // operation - A a; B b; C c; D d; E e; F f; G g; H h; I i; J j; - K k; L l; M m; N n; O o; // actors -}; - -#endif -#endif -#endif -#endif - -namespace impl { - - /////////////////////////////////////////////////////////////////////////// - // - // make_composite is basically a type computer that answers the - // question "Given types T0..TN, what composite type should I - // create and if I were to generate an actual - // composite, what type should I return?" - // - /////////////////////////////////////////////////////////////////////////// - template < - typename OperationT - , typename A = nil_t - , typename B = nil_t - , typename C = nil_t - -#if PHOENIX_LIMIT > 3 - , typename D = nil_t - , typename E = nil_t - , typename F = nil_t - -#if PHOENIX_LIMIT > 6 - , typename G = nil_t - , typename H = nil_t - , typename I = nil_t - -#if PHOENIX_LIMIT > 9 - , typename J = nil_t - , typename K = nil_t - , typename L = nil_t - -#if PHOENIX_LIMIT > 12 - , typename M = nil_t - , typename N = nil_t - , typename O = nil_t - -#endif -#endif -#endif -#endif - > - struct make_composite { - - typedef composite::type - , typename as_actor::type - , typename as_actor::type - -#if PHOENIX_LIMIT > 3 - , typename as_actor::type - , typename as_actor::type - , typename as_actor::type - -#if PHOENIX_LIMIT > 6 - , typename as_actor::type - , typename as_actor::type - , typename as_actor::type - -#if PHOENIX_LIMIT > 9 - , typename as_actor::type - , typename as_actor::type - , typename as_actor::type - -#if PHOENIX_LIMIT > 12 - , typename as_actor::type - , typename as_actor::type - , typename as_actor::type - -#endif -#endif -#endif -#endif - > composite_type; - - typedef actor type; - }; - - /////////////////////////////////////////////////////////////////////////// - // - // make_unary, make_binary, make_binary1, make_binary2 and - // make_binary3 utilities are provided here for easy creation of - // unary and binary composites. - // - /////////////////////////////////////////////////////////////////////////// - - ////////////////////////////////// input is an actor - template - struct make_unary { - - typedef typename make_composite - >::type type; - - static type - construct(actor const& _0) - { - typedef typename make_composite - >::composite_type - ret_t; - - return ret_t(OperationT(), _0); - } - }; - - ////////////////////////////////// LHS is an actor, RHS is unknown - template - struct make_binary1 { - - typedef typename make_composite - , B>::type type; - - static type - construct(actor const& _0, B const& _1) - { - typedef typename make_composite - , B>::composite_type - ret_t; - - return ret_t(OperationT(), _0, as_actor::convert(_1)); - } - }; - - ////////////////////////////////// LHS is unknown, RHS is an actor - template - struct make_binary2 { - - typedef typename make_composite - >::type type; - - static type - construct(A const& _0, actor const& _1) - { - typedef typename make_composite - >::composite_type - ret_t; - - return ret_t(OperationT(), as_actor::convert(_0), _1); - } - }; - - ////////////////////////////////// Both LHS and RHS are actors - template - struct make_binary3 { - - typedef typename make_composite - , actor >::type type; - - static type - construct(actor const& _0, actor const& _1) - { - typedef typename make_composite - , actor >::composite_type - ret_t; - - return ret_t(OperationT(), _0, _1); - } - }; - -} // namespace impl - -} // namespace phoenix - -#endif diff --git a/boost/boost/spirit/phoenix/functions.hpp b/boost/boost/spirit/phoenix/functions.hpp deleted file mode 100644 index dc13485857..0000000000 --- a/boost/boost/spirit/phoenix/functions.hpp +++ /dev/null @@ -1,761 +0,0 @@ -/*============================================================================= - Phoenix V1.2.1 - Copyright (c) 2001-2002 Joel de Guzman - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -==============================================================================*/ -#ifndef PHOENIX_FUNCTIONS_HPP -#define PHOENIX_FUNCTIONS_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace phoenix { - -/////////////////////////////////////////////////////////////////////////////// -// -// function class -// -// Lazy functions -// -// This class provides a mechanism for lazily evaluating functions. -// Syntactically, a lazy function looks like an ordinary C/C++ -// function. The function call looks the same. However, unlike -// ordinary functions, the actual function execution is deferred. -// (see actor.hpp, primitives.hpp and composite.hpp for an -// overview). For example here are sample factorial function calls: -// -// factorial(4) -// factorial(arg1) -// factorial(arg1 * 6) -// -// These functions are automatically lazily bound unlike ordinary -// function pointers or functor objects that need to be explicitly -// bound through the bind function (see binders.hpp). -// -// A lazy function works in conjunction with a user defined functor -// (as usual with a member operator()). Only special forms of -// functor objects are allowed. This is required to enable true -// polymorphism (STL style monomorphic functors and function -// pointers can still be used through the bind facility in -// binders.hpp). -// -// This special functor is expected to have a nested template class -// result (where N is the number of arguments of its -// member operator()). The nested template class result should have -// a typedef 'type' that reflects the return type of its member -// operator(). This is essentially a type computer that answers the -// metaprogramming question "Given arguments of type A...TN, what -// will be the operator()'s return type?". -// -// There is a special case for functors that accept no arguments. -// Such nullary functors are only required to define a typedef -// result_type that reflects the return type of its operator(). -// -// Here's an example of a simple functor that computes the -// factorial of a number: -// -// struct factorial_impl { -// -// template -// struct result { typedef Arg type; }; -// -// template -// Arg operator()(Arg n) const -// { return (n <= 0) ? 1 : n * this->operator()(n-1); } -// }; -// -// As can be seen, the functor can be polymorphic. Its arguments -// and return type are not fixed to a particular type. The example -// above for example, can handle any type as long as it can carry -// out the required operations (i.e. <=, * and -). -// -// We can now declare and instantiate a lazy 'factorial' function: -// -// function factorial; -// -// Invoking a lazy function 'factorial' does not immediately -// execute the functor factorial_impl. Instead, a composite (see -// composite.hpp) object is created and returned to the caller. -// Example: -// -// factorial(arg1) -// -// does nothing more than return a composite. A second function -// call will invoke the actual factorial function. Example: -// -// int i = 4; -// cout << factorial(arg1)(i); -// -// will print out "24". -// -// Take note that in certain cases (e.g. for functors with state), -// an instance may be passed on to the constructor. Example: -// -// function factorial(ftor); -// -// where ftor is an instance of factorial_impl (this is not -// necessary in this case since factorial is a simple stateless -// functor). Take care though when using functors with state -// because the functors are taken in by value. It is best to keep -// the data manipulated by a functor outside the functor itself and -// keep a reference to this data inside the functor. Also, it is -// best to keep functors as small as possible. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct function { - - function() : op() {} - function(OperationT const& op_) : op(op_) {} - - actor > - operator()() const; - - template - typename impl::make_composite::type - operator()(A const& a) const; - - template - typename impl::make_composite::type - operator()(A const& a, B const& b) const; - - template - typename impl::make_composite::type - operator()(A const& a, B const& b, C const& c) const; - -#if PHOENIX_LIMIT > 3 - - template - typename impl::make_composite::type - operator()(A const& a, B const& b, C const& c, D const& d) const; - - template - typename impl::make_composite< - OperationT, A, B, C, D, E - >::type - operator()( - A const& a, B const& b, C const& c, D const& d, E const& e - ) const; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F - > - typename impl::make_composite< - OperationT, A, B, C, D, E, F - >::type - operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f - ) const; - -#if PHOENIX_LIMIT > 6 - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G - > - typename impl::make_composite< - OperationT, A, B, C, D, E, F, G - >::type - operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g - ) const; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H - > - typename impl::make_composite< - OperationT, A, B, C, D, E, F, G, H - >::type - operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h - ) const; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I - > - typename impl::make_composite< - OperationT, A, B, C, D, E, F, G, H, I - >::type - operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i - ) const; - -#if PHOENIX_LIMIT > 9 - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J - > - typename impl::make_composite< - OperationT, A, B, C, D, E, F, G, H, I, J - >::type - operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j - ) const; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K - > - typename impl::make_composite< - OperationT, A, B, C, D, E, F, G, H, I, J, K - >::type - operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k - ) const; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L - > - typename impl::make_composite< - OperationT, A, B, C, D, E, F, G, H, I, J, K, L - >::type - operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l - ) const; - -#if PHOENIX_LIMIT > 12 - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M - > - typename impl::make_composite< - OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M - >::type - operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l, M const& m - ) const; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M, typename N - > - typename impl::make_composite< - OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N - >::type - operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l, M const& m, N const& n - ) const; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M, typename N, typename O - > - typename impl::make_composite< - OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O - >::type - operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l, M const& m, N const& n, O const& o - ) const; - -#endif -#endif -#endif -#endif - - OperationT op; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// function class implementation -// -/////////////////////////////////////////////////////////////////////////////// -template -inline actor > -function::operator()() const -{ - return actor >(op); -} - -////////////////////////////////// -template -template -inline typename impl::make_composite::type -function::operator()(A const& a) const -{ - typedef typename impl::make_composite::composite_type ret_t; - return ret_t - ( - op, - as_actor::convert(a) - ); -} - -////////////////////////////////// -template -template -inline typename impl::make_composite::type -function::operator()(A const& a, B const& b) const -{ - typedef - typename impl::make_composite::composite_type - ret_t; - - return ret_t( - op, - as_actor::convert(a), - as_actor::convert(b) - ); -} - -////////////////////////////////// -template -template -inline typename impl::make_composite::type -function::operator()(A const& a, B const& b, C const& c) const -{ - typedef - typename impl::make_composite::composite_type - ret_t; - - return ret_t( - op, - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c) - ); -} - -#if PHOENIX_LIMIT > 3 -////////////////////////////////// -template -template < - typename A, typename B, typename C, typename D -> -inline typename impl::make_composite< - OperationT, A, B, C, D ->::type -function::operator()( - A const& a, B const& b, C const& c, D const& d -) const -{ - typedef typename impl::make_composite< - OperationT, A, B, C, D - >::composite_type ret_t; - - return ret_t( - op, - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d) - ); -} - -////////////////////////////////// -template -template < - typename A, typename B, typename C, typename D, typename E -> -inline typename impl::make_composite< - OperationT, A, B, C, D, E ->::type -function::operator()( - A const& a, B const& b, C const& c, D const& d, E const& e -) const -{ - typedef typename impl::make_composite< - OperationT, A, B, C, D, E - >::composite_type ret_t; - - return ret_t( - op, - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e) - ); -} - -////////////////////////////////// -template -template < - typename A, typename B, typename C, typename D, typename E, - typename F -> -inline typename impl::make_composite< - OperationT, A, B, C, D, E, F ->::type -function::operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f -) const -{ - typedef typename impl::make_composite< - OperationT, A, B, C, D, E, F - >::composite_type ret_t; - - return ret_t( - op, - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f) - ); -} - -#if PHOENIX_LIMIT > 6 - -////////////////////////////////// -template -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G -> -inline typename impl::make_composite< - OperationT, A, B, C, D, E, F, G ->::type -function::operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g -) const -{ - typedef typename impl::make_composite< - OperationT, A, B, C, D, E, F, G - >::composite_type ret_t; - - return ret_t( - op, - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g) - ); -} - -////////////////////////////////// -template -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H -> -inline typename impl::make_composite< - OperationT, A, B, C, D, E, F, G, H ->::type -function::operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h -) const -{ - typedef typename impl::make_composite< - OperationT, A, B, C, D, E, F, G, H - >::composite_type ret_t; - - return ret_t( - op, - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g), - as_actor::convert(h) - ); -} - -////////////////////////////////// -template -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I -> -inline typename impl::make_composite< - OperationT, A, B, C, D, E, F, G, H, I ->::type -function::operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i -) const -{ - typedef typename impl::make_composite< - OperationT, A, B, C, D, E, F, G, H, I - >::composite_type ret_t; - - return ret_t( - op, - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g), - as_actor::convert(h), - as_actor::convert(i) - ); -} - -#if PHOENIX_LIMIT > 9 - -////////////////////////////////// -template -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J -> -inline typename impl::make_composite< - OperationT, A, B, C, D, E, F, G, H, I, J ->::type -function::operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j -) const -{ - typedef typename impl::make_composite< - OperationT, A, B, C, D, E, F, G, H, I, J - >::composite_type ret_t; - - return ret_t( - op, - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g), - as_actor::convert(h), - as_actor::convert(i), - as_actor::convert(j) - ); -} - -////////////////////////////////// -template -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K -> -inline typename impl::make_composite< - OperationT, A, B, C, D, E, F, G, H, I, J, K ->::type -function::operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k -) const -{ - typedef typename impl::make_composite< - OperationT, A, B, C, D, E, F, G, H, I, J, K - >::composite_type ret_t; - - return ret_t( - op, - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g), - as_actor::convert(h), - as_actor::convert(i), - as_actor::convert(j), - as_actor::convert(k) - ); -} - -////////////////////////////////// -template -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L -> -inline typename impl::make_composite< - OperationT, A, B, C, D, E, F, G, H, I, J, K, L ->::type -function::operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l -) const -{ - typedef typename impl::make_composite< - OperationT, A, B, C, D, E, F, G, H, I, J, K, L - >::composite_type ret_t; - - return ret_t( - op, - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g), - as_actor::convert(h), - as_actor::convert(i), - as_actor::convert(j), - as_actor::convert(k), - as_actor::convert(l) - ); -} - -#if PHOENIX_LIMIT > 12 - -////////////////////////////////// -template -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M -> -inline typename impl::make_composite< - OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M ->::type -function::operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l, M const& m -) const -{ - typedef typename impl::make_composite< - OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M - >::composite_type ret_t; - - return ret_t( - op, - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g), - as_actor::convert(h), - as_actor::convert(i), - as_actor::convert(j), - as_actor::convert(k), - as_actor::convert(l), - as_actor::convert(m) - ); -} - -////////////////////////////////// -template -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M, typename N -> -inline typename impl::make_composite< - OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N ->::type -function::operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l, M const& m, N const& n -) const -{ - typedef typename impl::make_composite< - OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N - >::composite_type ret_t; - - return ret_t( - op, - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g), - as_actor::convert(h), - as_actor::convert(i), - as_actor::convert(j), - as_actor::convert(k), - as_actor::convert(l), - as_actor::convert(m), - as_actor::convert(n) - ); -} - -////////////////////////////////// -template -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M, typename N, typename O -> -inline typename impl::make_composite< - OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O ->::type -function::operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l, M const& m, N const& n, O const& o -) const -{ - typedef typename impl::make_composite< - OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O - >::composite_type ret_t; - - return ret_t( - op, - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g), - as_actor::convert(h), - as_actor::convert(i), - as_actor::convert(j), - as_actor::convert(k), - as_actor::convert(l), - as_actor::convert(m), - as_actor::convert(n), - as_actor::convert(o) - ); -} - -#endif -#endif -#endif -#endif - -/////////////////////////////////////////////////////////////////////////////// -} // namespace phoenix - -#endif diff --git a/boost/boost/spirit/phoenix/new.hpp b/boost/boost/spirit/phoenix/new.hpp deleted file mode 100644 index acd3255c94..0000000000 --- a/boost/boost/spirit/phoenix/new.hpp +++ /dev/null @@ -1,1316 +0,0 @@ -/*============================================================================= - Phoenix V1.2.1 - Copyright (c) 2001-2003 Joel de Guzman - Copyright (c) 2001-2003 Hartmut Kaiser - Copyright (c) 2003 Vaclav Vesely - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -==============================================================================*/ - -#ifndef PHOENIX_NEW_HPP -#define PHOENIX_NEW_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace phoenix { - -/////////////////////////////////////////////////////////////////////////////// -// -// Phoenix predefined maximum new_ limit. This limit defines the maximum -// number of parameters supported for calles to the set of new_ template -// functions (lazy object construction, see below). This number defaults to 3. -// The actual maximum is rounded up in multiples of 3. Thus, if this value -// is 4, the actual limit is 6. The ultimate maximum limit in this -// implementation is 15. -// PHOENIX_CONSTRUCT_LIMIT should NOT be greater than PHOENIX_LIMIT! - -#if !defined(PHOENIX_CONSTRUCT_LIMIT) -#define PHOENIX_CONSTRUCT_LIMIT PHOENIX_LIMIT -#endif - -// ensure PHOENIX_CONSTRUCT_LIMIT <= PHOENIX_LIMIT -BOOST_STATIC_ASSERT(PHOENIX_CONSTRUCT_LIMIT <= PHOENIX_LIMIT); - -// ensure PHOENIX_CONSTRUCT_LIMIT <= 15 -BOOST_STATIC_ASSERT(PHOENIX_CONSTRUCT_LIMIT <= 15); - -/////////////////////////////////////////////////////////////////////////////// -// -// new_ -// -// Lazy object construction -// -// The set of new_<> template classes and functions provide a way -// of lazily constructing certain object from a arbitrary set of -// actors during parsing. -// The new_ templates are (syntactically) used very much like -// the well known C++ casts: -// -// A *a = new_(...arbitrary list of actors...); -// -// where the given parameters are submitted as parameters to the -// contructor of the object of type A. (This certainly implies, that -// type A has a constructor with a fitting set of parameter types -// defined.) -// -// The maximum number of needed parameters is controlled through the -// preprocessor constant PHOENIX_CONSTRUCT_LIMIT. Note though, that this -// limit should not be greater than PHOENIX_LIMIT. -// -/////////////////////////////////////////////////////////////////////////////// - -template -struct new_l_0 -{ - typedef T* result_type; - - T* operator()() const - { - return new T(); - } -}; - -template -struct new_l { - - template < - typename A - , typename B - , typename C - -#if PHOENIX_CONSTRUCT_LIMIT > 3 - , typename D - , typename E - , typename F - -#if PHOENIX_CONSTRUCT_LIMIT > 6 - , typename G - , typename H - , typename I - -#if PHOENIX_CONSTRUCT_LIMIT > 9 - , typename J - , typename K - , typename L - -#if PHOENIX_CONSTRUCT_LIMIT > 12 - , typename M - , typename N - , typename O -#endif -#endif -#endif -#endif - > - struct result { typedef T* type; }; - - T* operator()() const { - return new T(); - } - - template - T* operator()(A const& a) const { - return new T(a); - } - - template - T* operator()(A const& a, B const& b) const { - return new T(a, b); - } - - template - T* operator()(A const& a, B const& b, C const& c) const { - return new T(a, b, c); - } - -#if PHOENIX_CONSTRUCT_LIMIT > 3 - template < - typename A, typename B, typename C, typename D - > - T* operator()( - A const& a, B const& b, C const& c, D const& d) const - { - return new T(a, b, c, d); - } - - template < - typename A, typename B, typename C, typename D, typename E - > - T* operator()( - A const& a, B const& b, C const& c, D const& d, E const& e) const - { - return new T(a, b, c, d, e); - } - - template < - typename A, typename B, typename C, typename D, typename E, - typename F - > - T* operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f) const - { - return new T(a, b, c, d, e, f); - } - -#if PHOENIX_CONSTRUCT_LIMIT > 6 - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G - > - T* operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g) const - { - return new T(a, b, c, d, e, f, g); - } - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H - > - T* operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h) const - { - return new T(a, b, c, d, e, f, g, h); - } - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I - > - T* operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i) const - { - return new T(a, b, c, d, e, f, g, h, i); - } - -#if PHOENIX_CONSTRUCT_LIMIT > 9 - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J - > - T* operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j) const - { - return new T(a, b, c, d, e, f, g, h, i, j); - } - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K - > - T* operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k) const - { - return new T(a, b, c, d, e, f, g, h, i, j, k); - } - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L - > - T* operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l) const - { - return new T(a, b, c, d, e, f, g, h, i, j, k, l); - } - -#if PHOENIX_CONSTRUCT_LIMIT > 12 - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M - > - T* operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l, M const& m) const - { - return new T(a, b, c, d, e, f, g, h, i, j, k, l, m); - } - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M, typename N - > - T* operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l, M const& m, N const& n) const - { - return new T(a, b, c, d, e, f, g, h, i, j, k, l, m, n); - } - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M, typename N, typename O - > - T* operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l, M const& m, N const& n, O const& o) const - { - return new T(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o); - } - -#endif -#endif -#endif -#endif -}; - -template -struct new_1 { - - template < - typename A - > - struct result { typedef T* type; }; - - template - T* operator()(A const& a) const { - return new T(a); - } - -}; - -template -struct new_2 { - - template < - typename A - , typename B - > - struct result { typedef T* type; }; - - template - T* operator()(A const& a, B const& b) const { - return new T(a, b); - } - -}; - -template -struct new_3 { - - template < - typename A - , typename B - , typename C - > - struct result { typedef T* type; }; - - template - T* operator()(A const& a, B const& b, C const& c) const { - return new T(a, b, c); - } -}; - -#if PHOENIX_CONSTRUCT_LIMIT > 3 -template -struct new_4 { - - template < - typename A - , typename B - , typename C - , typename D - > - struct result { typedef T* type; }; - - - template < - typename A, typename B, typename C, typename D - > - T* operator()( - A const& a, B const& b, C const& c, D const& d) const - { - return new T(a, b, c, d); - } -}; - - -template -struct new_5 { - - template < - typename A - , typename B - , typename C - , typename D - , typename E - > - struct result { typedef T* type; }; - - template < - typename A, typename B, typename C, typename D, typename E - > - T* operator()( - A const& a, B const& b, C const& c, D const& d, E const& e) const - { - return new T(a, b, c, d, e); - } -}; - - -template -struct new_6 { - - template < - typename A - , typename B - , typename C - , typename D - , typename E - , typename F - > - struct result { typedef T* type; }; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F - > - T* operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f) const - { - return new T(a, b, c, d, e, f); - } -}; -#endif - - -#if PHOENIX_CONSTRUCT_LIMIT > 6 -template -struct new_7 { - - template < - typename A - , typename B - , typename C - , typename D - , typename E - , typename F - , typename G - > - struct result { typedef T* type; }; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G - > - T* operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g) const - { - return new T(a, b, c, d, e, f, g); - } -}; - -template -struct new_8 { - - template < - typename A - , typename B - , typename C - , typename D - , typename E - , typename F - , typename G - , typename H - > - struct result { typedef T* type; }; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H - > - T* operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h) const - { - return new T(a, b, c, d, e, f, g, h); - } -}; - -template -struct new_9 { - - template < - typename A - , typename B - , typename C - , typename D - , typename E - , typename F - , typename G - , typename H - , typename I - > - struct result { typedef T* type; }; - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I - > - T* operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i) const - { - return new T(a, b, c, d, e, f, g, h, i); - } -}; -#endif - - -#if PHOENIX_CONSTRUCT_LIMIT > 9 -template -struct new_10 { - - template < - typename A - , typename B - , typename C - , typename D - , typename E - , typename F - , typename G - , typename H - , typename I - , typename J - > - struct result { typedef T* type; }; - - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J - > - T* operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j) const - { - return new T(a, b, c, d, e, f, g, h, i, j); - } -}; - -template -struct new_11 { - - template < - typename A - , typename B - , typename C - , typename D - , typename E - , typename F - , typename G - , typename H - , typename I - , typename J - , typename K - > - struct result { typedef T* type; }; - - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K - > - T* operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k) const - { - return new T(a, b, c, d, e, f, g, h, i, j, k); - } - -}; - -template -struct new_12 { - - template < - typename A - , typename B - , typename C - , typename D - , typename E - , typename F - , typename G - , typename H - , typename I - , typename J - , typename K - , typename L - > - struct result { typedef T* type; }; - - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L - > - T* operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l) const - { - return new T(a, b, c, d, f, e, g, h, i, j, k, l); - } -}; -#endif - -#if PHOENIX_CONSTRUCT_LIMIT > 12 -template -struct new_13 { - - template < - typename A - , typename B - , typename C - , typename D - , typename E - , typename F - , typename G - , typename H - , typename I - , typename J - , typename K - , typename L - , typename M - > - struct result { typedef T* type; }; - - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M - > - T* operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l, M const& m) const - { - return new T(a, b, c, d, e, f, g, h, i, j, k, l, m); - } -}; - -template -struct new_14 { - - template < - typename A - , typename B - , typename C - , typename D - , typename E - , typename F - , typename G - , typename H - , typename I - , typename J - , typename K - , typename L - , typename M - , typename N - > - struct result { typedef T* type; }; - - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M, typename N - > - T* operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l, M const& m, N const& n) const - { - return new T(a, b, c, d, e, f, g, h, i, j, k, l, m, n); - } - -}; - -template -struct new_15 { - - template < - typename A - , typename B - , typename C - , typename D - , typename E - , typename F - , typename G - , typename H - , typename I - , typename J - , typename K - , typename L - , typename M - , typename N - , typename O - > - struct result { typedef T* type; }; - - - template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M, typename N, typename O - > - T* operator()( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l, M const& m, N const& n, O const& o) const - { - return new T(a, b, c, d, f, e, g, h, i, j, k, l, m, n, o); - } - -}; -#endif - - -#if defined(__BORLANDC__) || (defined(__MWERKS__) && (__MWERKS__ <= 0x3002)) - -/////////////////////////////////////////////////////////////////////////////// -// -// The following specializations are needed because Borland and CodeWarrior -// does not accept default template arguments in nested template classes in -// classes (i.e new_l::result) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct composite0_result, TupleT> { - - typedef T* type; -}; - -////////////////////////////////// -template -struct composite1_result, TupleT, A> { - - typedef T* type; -}; - -////////////////////////////////// -template -struct composite2_result, TupleT, A, B> { - - typedef T* type; -}; - -////////////////////////////////// -template -struct composite3_result, TupleT, A, B, C> { - - typedef T* type; -}; - -#if PHOENIX_LIMIT > 3 -////////////////////////////////// -template -struct composite4_result, TupleT, - A, B, C, D> { - - typedef T* type; -}; - -////////////////////////////////// -template -struct composite5_result, TupleT, - A, B, C, D, E> { - - typedef T* type; -}; - -////////////////////////////////// -template -struct composite6_result, TupleT, - A, B, C, D, E, F> { - - typedef T* type; -}; - -#if PHOENIX_LIMIT > 6 -////////////////////////////////// -template -struct composite7_result, TupleT, - A, B, C, D, E, F, G> { - - typedef T* type; -}; - -////////////////////////////////// -template -struct composite8_result, TupleT, - A, B, C, D, E, F, G, H> { - - typedef T* type; -}; - -////////////////////////////////// -template -struct composite9_result, TupleT, - A, B, C, D, E, F, G, H, I> { - - typedef T* type; -}; - -#if PHOENIX_LIMIT > 9 -////////////////////////////////// -template -struct composite10_result, TupleT, - A, B, C, D, E, F, G, H, I, J> { - - typedef T* type; -}; - -////////////////////////////////// -template -struct composite11_result, TupleT, - A, B, C, D, E, F, G, H, I, J, K> { - - typedef T* type; -}; - -////////////////////////////////// -template -struct composite12_result, TupleT, - A, B, C, D, E, F, G, H, I, J, K, L> { - - typedef T* type; -}; - -#if PHOENIX_LIMIT > 12 -////////////////////////////////// -template -struct composite13_result, TupleT, - A, B, C, D, E, F, G, H, I, J, K, L, M> { - - typedef T* type; -}; - -////////////////////////////////// -template -struct composite14_result, TupleT, - A, B, C, D, E, F, G, H, I, J, K, L, M, N> { - - typedef T* type; -}; - -////////////////////////////////// -template -struct composite15_result, TupleT, - A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> { - - typedef T* type; -}; - -#endif -#endif -#endif -#endif -#endif - -////////////////////////////////// -template -inline typename impl::make_composite >::type -new_() -{ - typedef impl::make_composite > make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(new_l_0())); -} - -////////////////////////////////// -template -inline typename impl::make_composite, A>::type -new_(A const& a) -{ - typedef impl::make_composite, A> make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(new_1(), - as_actor::convert(a) - )); -} - -////////////////////////////////// -template -inline typename impl::make_composite, A, B>::type -new_(A const& a, B const& b) -{ - typedef impl::make_composite, A, B> make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(new_2(), - as_actor::convert(a), - as_actor::convert(b) - )); -} - -////////////////////////////////// -template -inline typename impl::make_composite, A, B, C>::type -new_(A const& a, B const& b, C const& c) -{ - typedef impl::make_composite, A, B, C> make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(new_3(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c) - )); -} - -#if PHOENIX_CONSTRUCT_LIMIT > 3 -////////////////////////////////// -template < - typename T, typename A, typename B, typename C, typename D -> -inline typename impl::make_composite, A, B, C, D>::type -new_( - A const& a, B const& b, C const& c, D const& d) -{ - typedef - impl::make_composite, A, B, C, D> - make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(new_4(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d) - )); -} - -////////////////////////////////// -template < - typename T, typename A, typename B, typename C, typename D, typename E -> -inline typename impl::make_composite, A, B, C, D, E>::type -new_( - A const& a, B const& b, C const& c, D const& d, E const& e) -{ - typedef - impl::make_composite, A, B, C, D, E> - make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(new_5(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e) - )); -} - -////////////////////////////////// -template < - typename T, typename A, typename B, typename C, typename D, typename E, - typename F -> -inline typename impl::make_composite, A, B, C, D, E, F>::type -new_( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f) -{ - typedef - impl::make_composite, A, B, C, D, E, F> - make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(new_6(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f) - )); -} - -#if PHOENIX_CONSTRUCT_LIMIT > 6 -////////////////////////////////// -template < - typename T, typename A, typename B, typename C, typename D, typename E, - typename F, typename G -> -inline typename impl::make_composite, A, B, C, D, E, F, G>::type -new_( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g) -{ - typedef - impl::make_composite, A, B, C, D, E, F, G> - make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(new_7(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g) - )); -} - -////////////////////////////////// -template < - typename T, typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H -> -inline typename impl::make_composite, A, B, C, D, E, F, G, H>::type -new_( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h) -{ - typedef - impl::make_composite, A, B, C, D, E, F, G, H> - make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(new_8(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g), - as_actor::convert(h) - )); -} - -////////////////////////////////// -template < - typename T, typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I -> -inline typename impl::make_composite, A, B, C, D, E, F, G, H, I>::type -new_( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i) -{ - typedef - impl::make_composite, A, B, C, D, E, F, G, H, I> - make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(new_9(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g), - as_actor::convert(h), - as_actor::convert(i) - )); -} - -#if PHOENIX_CONSTRUCT_LIMIT > 9 -////////////////////////////////// -template < - typename T, typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J -> -inline typename impl::make_composite< - new_10, A, B, C, D, E, F, G, H, I, J>::type -new_( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j) -{ - typedef - impl::make_composite< - new_10, A, B, C, D, E, F, G, H, I, J - > - make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(new_10(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g), - as_actor::convert(h), - as_actor::convert(i), - as_actor::convert(j) - )); -} - -////////////////////////////////// -template < - typename T, typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, typename K -> -inline typename impl::make_composite< - new_11, A, B, C, D, E, F, G, H, I, J, K>::type -new_( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k) -{ - typedef - impl::make_composite< - new_11, A, B, C, D, E, F, G, H, I, J, K - > - make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(new_11(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g), - as_actor::convert(h), - as_actor::convert(i), - as_actor::convert(j), - as_actor::convert(k) - )); -} - -////////////////////////////////// -template < - typename T, typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, typename K, - typename L -> -inline typename impl::make_composite< - new_12, A, B, C, D, E, F, G, H, I, J, K, L>::type -new_( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l) -{ - typedef - impl::make_composite< - new_12, A, B, C, D, E, F, G, H, I, J, K, L - > - make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(new_12(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g), - as_actor::convert(h), - as_actor::convert(i), - as_actor::convert(j), - as_actor::convert(k), - as_actor::convert(l) - )); -} - -#if PHOENIX_CONSTRUCT_LIMIT > 12 -////////////////////////////////// -template < - typename T, typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, typename K, - typename L, typename M -> -inline typename impl::make_composite< - new_13, A, B, C, D, E, F, G, H, I, J, K, L, M>::type -new_( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l, M const& m) -{ - typedef - impl::make_composite< - new_13, A, B, C, D, E, F, G, H, I, J, K, L, M - > - make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(new_13(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g), - as_actor::convert(h), - as_actor::convert(i), - as_actor::convert(j), - as_actor::convert(k), - as_actor::convert(l), - as_actor::convert(m) - )); -} - -////////////////////////////////// -template < - typename T, typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, typename K, - typename L, typename M, typename N -> -inline typename impl::make_composite< - new_14, A, B, C, D, E, F, G, H, I, J, K, L, M>::type -new_( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l, M const& m, N const& n) -{ - typedef - impl::make_composite< - new_14, A, B, C, D, E, F, G, H, I, J, K, L, M, N - > - make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(new_14(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g), - as_actor::convert(h), - as_actor::convert(i), - as_actor::convert(j), - as_actor::convert(k), - as_actor::convert(l), - as_actor::convert(m), - as_actor::convert(n) - )); -} - -////////////////////////////////// -template < - typename T, typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, typename K, - typename L, typename M, typename N, typename O -> -inline typename impl::make_composite< - new_15, A, B, C, D, E, F, G, H, I, J, K, L, M, O>::type -new_( - A const& a, B const& b, C const& c, D const& d, E const& e, - F const& f, G const& g, H const& h, I const& i, J const& j, - K const& k, L const& l, M const& m, N const& n, O const& o) -{ - typedef - impl::make_composite< - new_15, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O - > - make_composite_t; - typedef typename make_composite_t::type type_t; - typedef typename make_composite_t::composite_type composite_type_t; - - return type_t(composite_type_t(new_15(), - as_actor::convert(a), - as_actor::convert(b), - as_actor::convert(c), - as_actor::convert(d), - as_actor::convert(e), - as_actor::convert(f), - as_actor::convert(g), - as_actor::convert(h), - as_actor::convert(i), - as_actor::convert(j), - as_actor::convert(k), - as_actor::convert(l), - as_actor::convert(m), - as_actor::convert(n), - as_actor::convert(o) - )); -} - -#endif -#endif -#endif -#endif - -/////////////////////////////////////////////////////////////////////////////// -} // namespace phoenix - -#endif // PHOENIX_NEW_HPP diff --git a/boost/boost/spirit/phoenix/operators.hpp b/boost/boost/spirit/phoenix/operators.hpp deleted file mode 100644 index 95f70a9b30..0000000000 --- a/boost/boost/spirit/phoenix/operators.hpp +++ /dev/null @@ -1,2203 +0,0 @@ -/*============================================================================= - Phoenix V1.2.1 - Copyright (c) 2001-2002 Joel de Guzman - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -==============================================================================*/ -#ifndef PHOENIX_OPERATORS_HPP -#define PHOENIX_OPERATORS_HPP - -/////////////////////////////////////////////////////////////////////////////// -#if !defined(BOOST_NO_CWCTYPE) - #include -#endif - -#if defined(__BORLANDC__) || (defined(__ICL) && __ICL >= 700) -#define CREF const& -#else -#define CREF -#endif - -#include -#include -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace phoenix { - -/////////////////////////////////////////////////////////////////////////////// -// -// Operators -// -// Lazy operators -// -// This class provides a mechanism for lazily evaluating operators. -// Syntactically, a lazy operator looks like an ordinary C/C++ -// infix, prefix or postfix operator. The operator application -// looks the same. However, unlike ordinary operators, the actual -// operator execution is deferred. (see actor.hpp, primitives.hpp -// and composite.hpp for an overview). Samples: -// -// arg1 + arg2 -// 1 + arg1 * arg2 -// 1 / -arg1 -// arg1 < 150 -// -// T1 set of classes implement all the C++ free operators. Like -// lazy functions (see functions.hpp), lazy operators are not -// immediately executed when invoked. Instead, a composite (see -// composite.hpp) object is created and returned to the caller. -// Example: -// -// (arg1 + arg2) * arg3 -// -// does nothing more than return a composite. T1 second function -// call will evaluate the actual operators. Example: -// -// int i = 4, j = 5, k = 6; -// cout << ((arg1 + arg2) * arg3)(i, j, k); -// -// will print out "54". -// -// Arbitrarily complex expressions can be lazily evaluated -// following three simple rules: -// -// 1) Lazy evaluated binary operators apply when at least one -// of the operands is an actor object (see actor.hpp and -// primitives.hpp). Consequently, if an operand is not an actor -// object, it is implicitly converted to an object of type -// actor > (where T is the original type of the -// operand). -// -// 2) Lazy evaluated unary operators apply only to operands -// which are actor objects. -// -// 3) The result of a lazy operator is a composite actor object -// that can in turn apply to rule 1. -// -// Example: -// -// arg1 + 3 -// -// is a lazy expression involving the operator+. Following rule 1, -// lazy evaluation is triggered since arg1 is an instance of an -// actor > class (see primitives.hpp). The right -// operand <3> is implicitly converted to an actor >. -// The result of this binary + expression is a composite object, -// following rule 3. -// -// Take note that although at least one of the operands must be a -// valid actor class in order for lazy evaluation to take effect, -// if this is not the case and we still want to lazily evaluate an -// expression, we can use var(x), val(x) or cref(x) to transform -// the operand into a valid action object (see primitives.hpp). -// Example: -// -// val(1) << 3; -// -// Supported operators: -// -// Unary operators: -// -// prefix: ~, !, -, +, ++, --, & (reference), * (dereference) -// postfix: ++, -- -// -// Binary operators: -// -// =, [], +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>= -// +, -, *, /, %, &, |, ^, <<, >> -// ==, !=, <, >, <=, >= -// &&, || -// -// Each operator has a special tag type associated with it. For -// example the binary + operator has a plus_op tag type associated -// with it. This is used to specialize either the unary_operator or -// binary_operator template classes (see unary_operator and -// binary_operator below). Specializations of these unary_operator -// and binary_operator are the actual workhorses that implement the -// operations. The behavior of each lazy operator depends on these -// unary_operator and binary_operator specializations. 'preset' -// specializations conform to the canonical operator rules modeled -// by the behavior of integers and pointers: -// -// Prefix -, + and ~ accept constant arguments and return an -// object by value. -// -// The ! accept constant arguments and returns a boolean -// result. -// -// The & (address-of), * (dereference) both return a reference -// to an object. -// -// Prefix ++ returns a reference to its mutable argument after -// it is incremented. -// -// Postfix ++ returns the mutable argument by value before it -// is incremented. -// -// The += and its family accept mutable right hand side (rhs) -// operand and return a reference to the rhs operand. -// -// Infix + and its family accept constant arguments and return -// an object by value. -// -// The == and its family accept constant arguments and return a -// boolean result. -// -// Operators && and || accept constant arguments and return a -// boolean result and are short circuit evaluated as expected. -// -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// -// Operator tags -// -// Each C++ operator has a corresponding tag type. This is -// used as a means for specializing the unary_operator and -// binary_operator (see below). The tag also serves as the -// lazy operator type compatible as a composite operation -// see (composite.hpp). -// -/////////////////////////////////////////////////////////////////////////////// - -// Unary operator tags - -struct negative_op; struct positive_op; -struct logical_not_op; struct invert_op; -struct reference_op; struct dereference_op; -struct pre_incr_op; struct pre_decr_op; -struct post_incr_op; struct post_decr_op; - -// Binary operator tags - -struct assign_op; struct index_op; -struct plus_assign_op; struct minus_assign_op; -struct times_assign_op; struct divide_assign_op; struct mod_assign_op; -struct and_assign_op; struct or_assign_op; struct xor_assign_op; -struct shift_l_assign_op; struct shift_r_assign_op; - -struct plus_op; struct minus_op; -struct times_op; struct divide_op; struct mod_op; -struct and_op; struct or_op; struct xor_op; -struct shift_l_op; struct shift_r_op; - -struct eq_op; struct not_eq_op; -struct lt_op; struct lt_eq_op; -struct gt_op; struct gt_eq_op; -struct logical_and_op; struct logical_or_op; - -/////////////////////////////////////////////////////////////////////////////// -// -// unary_operator -// -// The unary_operator class implements most of the C++ unary -// operators. Each specialization is basically a simple static eval -// function plus a result_type typedef that determines the return -// type of the eval function. -// -// TagT is one of the unary operator tags above and T is the data -// type (argument) involved in the operation. -// -// Only the behavior of C/C++ built-in types are taken into account -// in the specializations provided below. For user-defined types, -// these specializations may still be used provided that the -// operator overloads of such types adhere to the standard behavior -// of built-in types. -// -// T1 separate special_ops.hpp file implements more stl savvy -// specializations. Other more specialized unary_operator -// implementations may be defined by the client for specific -// unary operator tags/data types. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct unary_operator; - -////////////////////////////////// -template -struct unary_operator { - - typedef T const result_type; - static result_type eval(T const& v) - { return -v; } -}; - -////////////////////////////////// -template -struct unary_operator { - - typedef T const result_type; - static result_type eval(T const& v) - { return +v; } -}; - -////////////////////////////////// -template -struct unary_operator { - - typedef T const result_type; - static result_type eval(T const& v) - { return !v; } -}; - -////////////////////////////////// -template -struct unary_operator { - - typedef T const result_type; - static result_type eval(T const& v) - { return ~v; } -}; - -////////////////////////////////// -template -struct unary_operator { - - typedef T* result_type; - static result_type eval(T& v) - { return &v; } -}; - -////////////////////////////////// -template -struct unary_operator { - - typedef T& result_type; - static result_type eval(T* v) - { return *v; } -}; - -////////////////////////////////// -template -struct unary_operator { - - typedef T& result_type; - static result_type eval(T* const v) - { return *v; } -}; - -////////////////////////////////// -template <> -struct unary_operator { - - // G++ eager template instantiation - // somehow requires this. - typedef nil_t result_type; -}; - -////////////////////////////////// -#ifndef __BORLANDC__ -template <> -struct unary_operator { - - // G++ eager template instantiation - // somehow requires this. - typedef nil_t result_type; -}; -#endif - -////////////////////////////////// -template -struct unary_operator { - - typedef T& result_type; - static result_type eval(T& v) - { return ++v; } -}; - -////////////////////////////////// -template -struct unary_operator { - - typedef T& result_type; - static result_type eval(T& v) - { return --v; } -}; - -////////////////////////////////// -template -struct unary_operator { - - typedef T const result_type; - static result_type eval(T& v) - { T t(v); ++v; return t; } -}; - -////////////////////////////////// -template -struct unary_operator { - - typedef T const result_type; - static result_type eval(T& v) - { T t(v); --v; return t; } -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// rank -// -// rank class has a static int constant 'value' that defines the -// absolute rank of a type. rank is used to choose the result -// type of binary operators such as +. The type with the higher -// rank wins and is used as the operator's return type. T1 generic -// user defined type has a very high rank and always wins when -// compared against a user defined type. If this is not desireable, -// one can write a rank specialization for the type. -// -// Take note that ranks 0..9999 are reserved for the framework. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct rank { static int const value = INT_MAX; }; - -template <> struct rank { static int const value = 0; }; -template <> struct rank { static int const value = 10; }; - -template <> struct rank { static int const value = 20; }; -template <> struct rank { static int const value = 20; }; -template <> struct rank { static int const value = 30; }; -#if !defined(BOOST_NO_INTRINSIC_WCHAR_T) -template <> struct rank { static int const value = 40; }; -#endif // !defined(BOOST_NO_INTRINSIC_WCHAR_T) - -template <> struct rank { static int const value = 50; }; -template <> struct rank { static int const value = 60; }; - -template <> struct rank { static int const value = 70; }; -template <> struct rank { static int const value = 80; }; - -template <> struct rank { static int const value = 90; }; -template <> struct rank { static int const value = 100; }; - -#ifdef BOOST_HAS_LONG_LONG -template <> struct rank< ::boost::long_long_type> { static int const value = 110; }; -template <> struct rank< ::boost::ulong_long_type> { static int const value = 120; }; -#endif - -template <> struct rank { static int const value = 130; }; -template <> struct rank { static int const value = 140; }; -template <> struct rank { static int const value = 150; }; - -template struct rank -{ static int const value = 160; }; - -template struct rank -{ static int const value = 160; }; - -template struct rank -{ static int const value = 160; }; - -/////////////////////////////////////////////////////////////////////////////// -// -// higher_rank -// -// Chooses the type (T0 or T1) with the higher rank. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct higher_rank { - typedef typename boost::mpl::if_c< - rank::value < rank::value, - T1, T0>::type type; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// binary_operator -// -// The binary_operator class implements most of the C++ binary -// operators. Each specialization is basically a simple static eval -// function plus a result_type typedef that determines the return -// type of the eval function. -// -// TagT is one of the binary operator tags above T0 and T1 are the -// (arguments') data types involved in the operation. -// -// Only the behavior of C/C++ built-in types are taken into account -// in the specializations provided below. For user-defined types, -// these specializations may still be used provided that the -// operator overloads of such types adhere to the standard behavior -// of built-in types. -// -// T1 separate special_ops.hpp file implements more stl savvy -// specializations. Other more specialized unary_operator -// implementations may be defined by the client for specific -// unary operator tags/data types. -// -// All binary_operator except the logical_and_op and logical_or_op -// have an eval static function that carries out the actual operation. -// The logical_and_op and logical_or_op d are special because these -// two operators are short-circuit evaluated. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct binary_operator; - -////////////////////////////////// -template -struct binary_operator { - - typedef T0& result_type; - static result_type eval(T0& lhs, T1 const& rhs) - { return lhs = rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - // G++ eager template instantiation - // somehow requires this. - typedef nil_t result_type; -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef T0& result_type; - static result_type eval(T0* ptr, T1 const& index) - { return ptr[index]; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef T0& result_type; - static result_type eval(T0* const ptr, T1 const& index) - { return ptr[index]; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef T0& result_type; - static result_type eval(T0* ptr, T1 const& index) - { return ptr[index]; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef T0& result_type; - static result_type eval(T0& lhs, T1 const& rhs) - { return lhs += rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef T0& result_type; - static result_type eval(T0& lhs, T1 const& rhs) - { return lhs -= rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef T0& result_type; - static result_type eval(T0& lhs, T1 const& rhs) - { return lhs *= rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef T0& result_type; - static result_type eval(T0& lhs, T1 const& rhs) - { return lhs /= rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef T0& result_type; - static result_type eval(T0& lhs, T1 const& rhs) - { return lhs %= rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef T0& result_type; - static result_type eval(T0& lhs, T1 const& rhs) - { return lhs &= rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef T0& result_type; - static result_type eval(T0& lhs, T1 const& rhs) - { return lhs |= rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef T0& result_type; - static result_type eval(T0& lhs, T1 const& rhs) - { return lhs ^= rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef T0& result_type; - static result_type eval(T0& lhs, T1 const& rhs) - { return lhs <<= rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef T0& result_type; - static result_type eval(T0& lhs, T1 const& rhs) - { return lhs >>= rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef typename higher_rank::type const result_type; - static result_type eval(T0 const& lhs, T1 const& rhs) - { return lhs + rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef typename higher_rank::type const result_type; - static result_type eval(T0 const& lhs, T1 const& rhs) - { return lhs - rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef typename higher_rank::type const result_type; - static result_type eval(T0 const& lhs, T1 const& rhs) - { return lhs * rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef typename higher_rank::type const result_type; - static result_type eval(T0 const& lhs, T1 const& rhs) - { return lhs / rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef typename higher_rank::type const result_type; - static result_type eval(T0 const& lhs, T1 const& rhs) - { return lhs % rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef typename higher_rank::type const result_type; - static result_type eval(T0 const& lhs, T1 const& rhs) - { return lhs & rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef typename higher_rank::type const result_type; - static result_type eval(T0 const& lhs, T1 const& rhs) - { return lhs | rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef typename higher_rank::type const result_type; - static result_type eval(T0 const& lhs, T1 const& rhs) - { return lhs ^ rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef T0 const result_type; - static result_type eval(T0 const& lhs, T1 const& rhs) - { return lhs << rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef T0 const result_type; - static result_type eval(T0 const& lhs, T1 const& rhs) - { return lhs >> rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef bool result_type; - static result_type eval(T0 const& lhs, T1 const& rhs) - { return lhs == rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef bool result_type; - static result_type eval(T0 const& lhs, T1 const& rhs) - { return lhs != rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef bool result_type; - static result_type eval(T0 const& lhs, T1 const& rhs) - { return lhs < rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef bool result_type; - static result_type eval(T0 const& lhs, T1 const& rhs) - { return lhs <= rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef bool result_type; - static result_type eval(T0 const& lhs, T1 const& rhs) - { return lhs > rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef bool result_type; - static result_type eval(T0 const& lhs, T1 const& rhs) - { return lhs >= rhs; } -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef bool result_type; - // no eval function, see comment above. -}; - -////////////////////////////////// -template -struct binary_operator { - - typedef bool result_type; - // no eval function, see comment above. -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// negative lazy operator (prefix -) -// -/////////////////////////////////////////////////////////////////////////////// -struct negative_op { - - template - struct result { - - typedef typename unary_operator::result_type type; - }; - - template - typename unary_operator::result_type - operator()(T0& _0) const - { return unary_operator::eval(_0); } -}; - -////////////////////////////////// -template -inline typename impl::make_unary::type -operator-(actor const& _0) -{ - return impl::make_unary::construct(_0); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// positive lazy operator (prefix +) -// -/////////////////////////////////////////////////////////////////////////////// -struct positive_op { - - template - struct result { - - typedef typename unary_operator::result_type type; - }; - - template - typename unary_operator::result_type - operator()(T0& _0) const - { return unary_operator::eval(_0); } -}; - -////////////////////////////////// -template -inline typename impl::make_unary::type -operator+(actor const& _0) -{ - return impl::make_unary::construct(_0); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// logical not lazy operator (prefix !) -// -/////////////////////////////////////////////////////////////////////////////// -struct logical_not_op { - - template - struct result { - - typedef typename unary_operator::result_type type; - }; - - template - typename unary_operator::result_type - operator()(T0& _0) const - { return unary_operator::eval(_0); } -}; - -////////////////////////////////// -template -inline typename impl::make_unary::type -operator!(actor const& _0) -{ - return impl::make_unary::construct(_0); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// invert lazy operator (prefix ~) -// -/////////////////////////////////////////////////////////////////////////////// -struct invert_op { - - template - struct result { - - typedef typename unary_operator::result_type type; - }; - - template - typename unary_operator::result_type - operator()(T0& _0) const - { return unary_operator::eval(_0); } -}; - -////////////////////////////////// -template -inline typename impl::make_unary::type -operator~(actor const& _0) -{ - return impl::make_unary::construct(_0); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// reference lazy operator (prefix &) -// -/////////////////////////////////////////////////////////////////////////////// -struct reference_op { - - template - struct result { - - typedef typename unary_operator::result_type type; - }; - - template - typename unary_operator::result_type - operator()(T0& _0) const - { return unary_operator::eval(_0); } -}; - -////////////////////////////////// -template -inline typename impl::make_unary::type -operator&(actor const& _0) -{ - return impl::make_unary::construct(_0); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// dereference lazy operator (prefix *) -// -/////////////////////////////////////////////////////////////////////////////// -struct dereference_op { - - template - struct result { - - typedef typename unary_operator::result_type type; - }; - - template - typename unary_operator::result_type - operator()(T0& _0) const - { return unary_operator::eval(_0); } -}; - -////////////////////////////////// -template -inline typename impl::make_unary::type -operator*(actor const& _0) -{ - return impl::make_unary::construct(_0); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// pre increment lazy operator (prefix ++) -// -/////////////////////////////////////////////////////////////////////////////// -struct pre_incr_op { - - template - struct result { - - typedef typename unary_operator::result_type type; - }; - - template - typename unary_operator::result_type - operator()(T0& _0) const - { return unary_operator::eval(_0); } -}; - -////////////////////////////////// -template -inline typename impl::make_unary::type -operator++(actor const& _0) -{ - return impl::make_unary::construct(_0); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// pre decrement lazy operator (prefix --) -// -/////////////////////////////////////////////////////////////////////////////// -struct pre_decr_op { - - template - struct result { - - typedef typename unary_operator::result_type type; - }; - - template - typename unary_operator::result_type - operator()(T0& _0) const - { return unary_operator::eval(_0); } -}; - -////////////////////////////////// -template -inline typename impl::make_unary::type -operator--(actor const& _0) -{ - return impl::make_unary::construct(_0); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// post increment lazy operator (postfix ++) -// -/////////////////////////////////////////////////////////////////////////////// -struct post_incr_op { - - template - struct result { - - typedef typename unary_operator::result_type type; - }; - - template - typename unary_operator::result_type - operator()(T0& _0) const - { return unary_operator::eval(_0); } -}; - -////////////////////////////////// -template -inline typename impl::make_unary::type -operator++(actor const& _0, int) -{ - return impl::make_unary::construct(_0); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// post decrement lazy operator (postfix --) -// -/////////////////////////////////////////////////////////////////////////////// -struct post_decr_op { - - template - struct result { - - typedef typename unary_operator::result_type type; - }; - - template - typename unary_operator::result_type - operator()(T0& _0) const - { return unary_operator::eval(_0); } -}; - -////////////////////////////////// -template -inline typename impl::make_unary::type -operator--(actor const& _0, int) -{ - return impl::make_unary::construct(_0); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// assignment lazy operator (infix =) -// The acual lazy operator is a member of the actor class. -// -/////////////////////////////////////////////////////////////////////////////// -struct assign_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -template -inline typename impl::make_binary1::type -actor::operator=(B const& _1) const -{ - return impl::make_binary1::construct(*this, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// index lazy operator (array index []) -// The acual lazy operator is a member of the actor class. -// -/////////////////////////////////////////////////////////////////////////////// -struct index_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -template -inline typename impl::make_binary1::type -actor::operator[](B const& _1) const -{ - return impl::make_binary1::construct(*this, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// plus assign lazy operator (infix +=) -// -/////////////////////////////////////////////////////////////////////////////// -struct plus_assign_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator+=(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// minus assign lazy operator (infix -=) -// -/////////////////////////////////////////////////////////////////////////////// -struct minus_assign_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator-=(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// times assign lazy operator (infix *=) -// -/////////////////////////////////////////////////////////////////////////////// -struct times_assign_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator*=(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// divide assign lazy operator (infix /=) -// -/////////////////////////////////////////////////////////////////////////////// -struct divide_assign_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator/=(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// mod assign lazy operator (infix %=) -// -/////////////////////////////////////////////////////////////////////////////// -struct mod_assign_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator%=(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// and assign lazy operator (infix &=) -// -/////////////////////////////////////////////////////////////////////////////// -struct and_assign_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator&=(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// or assign lazy operator (infix |=) -// -/////////////////////////////////////////////////////////////////////////////// -struct or_assign_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator|=(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// xor assign lazy operator (infix ^=) -// -/////////////////////////////////////////////////////////////////////////////// -struct xor_assign_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator^=(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// shift left assign lazy operator (infix <<=) -// -/////////////////////////////////////////////////////////////////////////////// -struct shift_l_assign_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator<<=(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// shift right assign lazy operator (infix >>=) -// -/////////////////////////////////////////////////////////////////////////////// -struct shift_r_assign_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator>>=(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// plus lazy operator (infix +) -// -/////////////////////////////////////////////////////////////////////////////// -struct plus_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator+(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary2::type -operator+(T0 CREF _0, actor const& _1) -{ - return impl::make_binary2::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary3::type -operator+(actor const& _0, actor const& _1) -{ - return impl::make_binary3::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// minus lazy operator (infix -) -// -/////////////////////////////////////////////////////////////////////////////// -struct minus_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator-(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary2::type -operator-(T0 CREF _0, actor const& _1) -{ - return impl::make_binary2::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary3::type -operator-(actor const& _0, actor const& _1) -{ - return impl::make_binary3::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// times lazy operator (infix *) -// -/////////////////////////////////////////////////////////////////////////////// -struct times_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator*(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary2::type -operator*(T0 CREF _0, actor const& _1) -{ - return impl::make_binary2::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary3::type -operator*(actor const& _0, actor const& _1) -{ - return impl::make_binary3::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// divide lazy operator (infix /) -// -/////////////////////////////////////////////////////////////////////////////// -struct divide_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator/(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary2::type -operator/(T0 CREF _0, actor const& _1) -{ - return impl::make_binary2::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary3::type -operator/(actor const& _0, actor const& _1) -{ - return impl::make_binary3::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// mod lazy operator (infix %) -// -/////////////////////////////////////////////////////////////////////////////// -struct mod_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator%(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary2::type -operator%(T0 CREF _0, actor const& _1) -{ - return impl::make_binary2::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary3::type -operator%(actor const& _0, actor const& _1) -{ - return impl::make_binary3::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// and lazy operator (infix &) -// -/////////////////////////////////////////////////////////////////////////////// -struct and_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator&(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary2::type -operator&(T0 CREF _0, actor const& _1) -{ - return impl::make_binary2::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary3::type -operator&(actor const& _0, actor const& _1) -{ - return impl::make_binary3::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// or lazy operator (infix |) -// -/////////////////////////////////////////////////////////////////////////////// -struct or_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator|(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary2::type -operator|(T0 CREF _0, actor const& _1) -{ - return impl::make_binary2::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary3::type -operator|(actor const& _0, actor const& _1) -{ - return impl::make_binary3::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// xor lazy operator (infix ^) -// -/////////////////////////////////////////////////////////////////////////////// -struct xor_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator^(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary2::type -operator^(T0 CREF _0, actor const& _1) -{ - return impl::make_binary2::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary3::type -operator^(actor const& _0, actor const& _1) -{ - return impl::make_binary3::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// shift left lazy operator (infix <<) -// -/////////////////////////////////////////////////////////////////////////////// -struct shift_l_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator<<(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary2::type -operator<<(T0 CREF _0, actor const& _1) -{ - return impl::make_binary2::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary3::type -operator<<(actor const& _0, actor const& _1) -{ - return impl::make_binary3::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// shift right lazy operator (infix >>) -// -/////////////////////////////////////////////////////////////////////////////// -struct shift_r_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator>>(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary2::type -operator>>(T0 CREF _0, actor const& _1) -{ - return impl::make_binary2::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary3::type -operator>>(actor const& _0, actor const& _1) -{ - return impl::make_binary3::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// equal lazy operator (infix ==) -// -/////////////////////////////////////////////////////////////////////////////// -struct eq_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator==(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary2::type -operator==(T0 CREF _0, actor const& _1) -{ - return impl::make_binary2::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary3::type -operator==(actor const& _0, actor const& _1) -{ - return impl::make_binary3::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// not equal lazy operator (infix !=) -// -/////////////////////////////////////////////////////////////////////////////// -struct not_eq_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator!=(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary2::type -operator!=(T0 CREF _0, actor const& _1) -{ - return impl::make_binary2::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary3::type -operator!=(actor const& _0, actor const& _1) -{ - return impl::make_binary3::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// less than lazy operator (infix <) -// -/////////////////////////////////////////////////////////////////////////////// -struct lt_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator<(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary2::type -operator<(T0 CREF _0, actor const& _1) -{ - return impl::make_binary2::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary3::type -operator<(actor const& _0, actor const& _1) -{ - return impl::make_binary3::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// less than equal lazy operator (infix <=) -// -/////////////////////////////////////////////////////////////////////////////// -struct lt_eq_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator<=(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary2::type -operator<=(T0 CREF _0, actor const& _1) -{ - return impl::make_binary2::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary3::type -operator<=(actor const& _0, actor const& _1) -{ - return impl::make_binary3::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// greater than lazy operator (infix >) -// -/////////////////////////////////////////////////////////////////////////////// -struct gt_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator>(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary2::type -operator>(T0 CREF _0, actor const& _1) -{ - return impl::make_binary2::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary3::type -operator>(actor const& _0, actor const& _1) -{ - return impl::make_binary3::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// greater than equal lazy operator (infix >=) -// -/////////////////////////////////////////////////////////////////////////////// -struct gt_eq_op { - - template - struct result { - - typedef typename binary_operator - ::result_type type; - }; - - template - typename binary_operator::result_type - operator()(T0& _0, T1& _1) const - { return binary_operator::eval(_0, _1); } -}; - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator>=(actor const& _0, T1 CREF _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary2::type -operator>=(T0 CREF _0, actor const& _1) -{ - return impl::make_binary2::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary3::type -operator>=(actor const& _0, actor const& _1) -{ - return impl::make_binary3::construct(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// logical and lazy operator (infix &&) -// -// The logical_and_composite class and its corresponding generators are -// provided to allow short-circuit evaluation of the operator's -// operands. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct logical_and_composite { - - typedef logical_and_composite self_t; - - template - struct result { - - typedef typename binary_operator::plain_type, - typename actor_result::plain_type - >::result_type type; - }; - - logical_and_composite(A0 const& _0, A1 const& _1) - : a0(_0), a1(_1) {} - - template - typename actor_result::type - eval(TupleT const& args) const - { - return a0.eval(args) && a1.eval(args); - } - - A0 a0; A1 a1; // actors -}; - -#if !(defined(__ICL) && __ICL <= 500) -////////////////////////////////// -template -inline actor, typename as_actor::type> > -operator&&(actor const& _0, T1 CREF _1) -{ - return logical_and_composite - , typename as_actor::type> - (_0, as_actor::convert(_1)); -} - -////////////////////////////////// -template -inline actor::type, actor > > -operator&&(T0 CREF _0, actor const& _1) -{ - return logical_and_composite - ::type, actor > - (as_actor::convert(_0), _1); -} - -////////////////////////////////// -template -inline actor, actor > > -operator&&(actor const& _0, actor const& _1) -{ - return logical_and_composite - , actor > - (_0, _1); -} -#else -////////////////////////////////// -template -inline actor::type, typename as_actor::type> > -operator&&(T0 CREF _0, T1 CREF _1) -{ - return logical_and_composite - ::type, typename as_actor::type> - (as_actor::convert(_0), as_actor::convert(_1)); -} -#endif // !(__ICL && __ICL <= 500) - -/////////////////////////////////////////////////////////////////////////////// -// -// logical or lazy operator (infix ||) -// -// The logical_or_composite class and its corresponding generators are -// provided to allow short-circuit evaluation of the operator's -// operands. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct logical_or_composite { - - typedef logical_or_composite self_t; - - template - struct result { - - typedef typename binary_operator::plain_type, - typename actor_result::plain_type - >::result_type type; - }; - - logical_or_composite(A0 const& _0, A1 const& _1) - : a0(_0), a1(_1) {} - - template - typename actor_result::type - eval(TupleT const& args) const - { - return a0.eval(args) || a1.eval(args); - } - - A0 a0; A1 a1; // actors -}; - -////////////////////////////////// -template -inline actor, typename as_actor::type> > -operator||(actor const& _0, T1 CREF _1) -{ - return logical_or_composite - , typename as_actor::type> - (_0, as_actor::convert(_1)); -} - -////////////////////////////////// -template -inline actor::type, actor > > -operator||(T0 CREF _0, actor const& _1) -{ - return logical_or_composite - ::type, actor > - (as_actor::convert(_0), _1); -} - -////////////////////////////////// -template -inline actor, actor > > -operator||(actor const& _0, actor const& _1) -{ - return logical_or_composite - , actor > - (_0, _1); -} - -} // namespace phoenix - -#undef CREF -#endif diff --git a/boost/boost/spirit/phoenix/primitives.hpp b/boost/boost/spirit/phoenix/primitives.hpp deleted file mode 100644 index 16d5925ea7..0000000000 --- a/boost/boost/spirit/phoenix/primitives.hpp +++ /dev/null @@ -1,248 +0,0 @@ -/*============================================================================= - Phoenix V1.2.1 - Copyright (c) 2001-2002 Joel de Guzman - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -==============================================================================*/ -#ifndef PHOENIX_PRIMITIVES_HPP -#define PHOENIX_PRIMITIVES_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace phoenix { - -/////////////////////////////////////////////////////////////////////////////// -// -// argument class -// -// Lazy arguments -// -// An actor base class that extracts and returns the Nth argument -// from the argument list passed in the 'args' tuple in the eval -// member function (see actor.hpp). There are some predefined -// argument constants that can be used as actors (arg1..argN). -// -// The argument actor is a place-holder for the actual arguments -// passed by the client. For example, wherever arg1 is seen placed -// in a lazy function (see functions.hpp) or lazy operator (see -// operators.hpp), this will be replaced by the actual first -// argument in the actual function evaluation. Argument actors are -// essentially lazy arguments. A lazy argument is a full actor in -// its own right and can be evaluated through the actor's operator(). -// -// Example: -// -// char c = 'A'; -// int i = 123; -// const char* s = "Hello World"; -// -// cout << arg1(c) << ' '; -// cout << arg1(i, s) << ' '; -// cout << arg2(i, s) << ' '; -// -// will print out "A 123 Hello World" -// -/////////////////////////////////////////////////////////////////////////////// -template -struct argument { - - template - struct result { typedef typename tuple_element::type type; }; - - template - typename tuple_element::type - eval(TupleT const& args) const - { - return args[tuple_index()]; - } -}; - -////////////////////////////////// -actor > const arg1 = argument<0>(); -actor > const arg2 = argument<1>(); -actor > const arg3 = argument<2>(); - -#if PHOENIX_LIMIT > 3 -actor > const arg4 = argument<3>(); -actor > const arg5 = argument<4>(); -actor > const arg6 = argument<5>(); - -#if PHOENIX_LIMIT > 6 -actor > const arg7 = argument<6>(); -actor > const arg8 = argument<7>(); -actor > const arg9 = argument<8>(); - -#if PHOENIX_LIMIT > 9 -actor > const arg10 = argument<9>(); -actor > const arg11 = argument<10>(); -actor > const arg12 = argument<11>(); - -#if PHOENIX_LIMIT > 12 -actor > const arg13 = argument<12>(); -actor > const arg14 = argument<13>(); -actor > const arg15 = argument<14>(); - -#endif -#endif -#endif -#endif -/////////////////////////////////////////////////////////////////////////////// -// -// value class -// -// Lazy values -// -// A bound actual parameter is kept in a value class for deferred -// access later when needed. A value object is immutable. Value -// objects are typically created through the val(x) free function -// which returns a value with T deduced from the type of x. x is -// held in the value object by value. -// -// Lazy values are actors. As such, lazy values can be evaluated -// through the actor's operator(). Such invocation gives the value's -// identity. Example: -// -// cout << val(3)() << val("Hello World")(); -// -// prints out "3 Hello World" -// -/////////////////////////////////////////////////////////////////////////////// -template -struct value { - - typedef typename boost::remove_reference::type plain_t; - - template - struct result { typedef plain_t const type; }; - - value(plain_t val_) - : val(val_) {} - - template - plain_t const - eval(TupleT const& /*args*/) const - { - return val; - } - - plain_t val; -}; - -////////////////////////////////// -template -inline actor > const -val(T v) -{ - return value(v); -} - -////////////////////////////////// -template -void -val(actor const& v); // This is undefined and not allowed. - -/////////////////////////////////////////////////////////////////////////// -// -// Arbitrary types T are typically converted to a actor > -// (see as_actor in actor.hpp). A specialization is also provided -// for arrays. T[N] arrays are converted to actor >. -// -/////////////////////////////////////////////////////////////////////////// -template -struct as_actor { - - typedef actor > type; - static type convert(T const& x) - { return value(x); } -}; - -////////////////////////////////// -template -struct as_actor { - - typedef actor > type; - static type convert(T const x[N]) - { return value(x); } -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// variable class -// -// Lazy variables -// -// A bound actual parameter may also be held by non-const reference -// in a variable class for deferred access later when needed. A -// variable object is mutable, i.e. its referenced variable can be -// modified. Variable objects are typically created through the -// var(x) free function which returns a variable with T deduced -// from the type of x. x is held in the value object by -// reference. -// -// Lazy variables are actors. As such, lazy variables can be -// evaluated through the actor's operator(). Such invocation gives -// the variables's identity. Example: -// -// int i = 3; -// char const* s = "Hello World"; -// cout << var(i)() << var(s)(); -// -// prints out "3 Hello World" -// -// Another free function const_(x) may also be used. const_(x) creates -// a variable object using a constant reference. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct variable { - - template - struct result { typedef T& type; }; - - variable(T& var_) - : var(var_) {} - - template - T& - eval(TupleT const& /*args*/) const - { - return var; - } - - T& var; -}; - -////////////////////////////////// -template -inline actor > const -var(T& v) -{ - return variable(v); -} - -////////////////////////////////// -template -inline actor > const -const_(T const& v) -{ - return variable(v); -} - -////////////////////////////////// -template -void -var(actor const& v); // This is undefined and not allowed. - -////////////////////////////////// -template -void -const_(actor const& v); // This is undefined and not allowed. - -/////////////////////////////////////////////////////////////////////////////// -} // namespace phoenix - -#endif diff --git a/boost/boost/spirit/phoenix/special_ops.hpp b/boost/boost/spirit/phoenix/special_ops.hpp deleted file mode 100644 index 47cd9470b7..0000000000 --- a/boost/boost/spirit/phoenix/special_ops.hpp +++ /dev/null @@ -1,342 +0,0 @@ -/*============================================================================= - Phoenix V1.2.1 - Copyright (c) 2001-2002 Joel de Guzman - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -==============================================================================*/ -#ifndef PHOENIX_SPECIAL_OPS_HPP -#define PHOENIX_SPECIAL_OPS_HPP - -#include -#ifdef BOOST_NO_STRINGSTREAM -#include -#define PHOENIX_SSTREAM strstream -#else -#include -#define PHOENIX_SSTREAM stringstream -#endif - -/////////////////////////////////////////////////////////////////////////////// -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -#if defined(_STLPORT_VERSION) && defined(__STL_USE_OWN_NAMESPACE) -#define PHOENIX_STD _STLP_STD -#define PHOENIX_NO_STD_NAMESPACE -#else -#define PHOENIX_STD std -#endif - -/////////////////////////////////////////////////////////////////////////////// -//#if !defined(PHOENIX_NO_STD_NAMESPACE) -namespace PHOENIX_STD -{ -//#endif - - template class complex; - -//#if !defined(PHOENIX_NO_STD_NAMESPACE) -} -//#endif - -/////////////////////////////////////////////////////////////////////////////// -namespace phoenix -{ - -/////////////////////////////////////////////////////////////////////////////// -// -// The following specializations take into account the C++ standard -// library components. There are a couple of issues that have to be -// dealt with to enable lazy operator overloads for the standard -// library classes. -// -// *iostream (e.g. cout, cin, strstream/ stringstream) uses non- -// canonical shift operator overloads where the lhs is taken in -// by reference. -// -// *I/O manipulators overloads for the RHS of the << and >> -// operators. -// -// *STL iterators can be objects that conform to pointer semantics. -// Some operators need to be specialized for these. -// -// *std::complex is given a rank (see rank class in operators.hpp) -// -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// -// specialization for rank -// -/////////////////////////////////////////////////////////////////////////////// -template struct rank > -{ static int const value = 170 + rank::value; }; - -/////////////////////////////////////////////////////////////////////////////// -// -// specializations for std::istream -// -/////////////////////////////////////////////////////////////////////////////// -#if defined(__GNUC__) && (__GNUC__ < 3) - #if defined(_STLPORT_VERSION) - #define PHOENIX_ISTREAM _IO_istream_withassign - #else - #define PHOENIX_ISTREAM PHOENIX_STD::_IO_istream_withassign - #endif -#else -// #if (defined(__ICL) && defined(_STLPORT_VERSION)) -// #define PHOENIX_ISTREAM istream_withassign -// #else - #define PHOENIX_ISTREAM PHOENIX_STD::istream -// #endif -#endif - -////////////////////////////////// -#if defined(__GNUC__) && (__GNUC__ < 3) -// || (defined(__ICL) && defined(_STLPORT_VERSION)) -template -struct binary_operator -{ - typedef PHOENIX_STD::istream& result_type; - static result_type eval(PHOENIX_STD::istream& out, T1& rhs) - { return out >> rhs; } -}; -#endif - -////////////////////////////////// -template -struct binary_operator -{ - typedef PHOENIX_STD::istream& result_type; - static result_type eval(PHOENIX_STD::istream& out, T1& rhs) - { return out >> rhs; } -}; - -////////////////////////////////// -template -inline typename impl::make_binary3 - , BaseT>::type -operator>>(PHOENIX_ISTREAM& _0, actor const& _1) -{ - return impl::make_binary3 - , BaseT> - ::construct(var(_0), _1); -} - -#undef PHOENIX_ISTREAM -/////////////////////////////////////////////////////////////////////////////// -// -// specializations for std::ostream -// -/////////////////////////////////////////////////////////////////////////////// -#if defined(__GNUC__) && (__GNUC__ < 3) - #if defined(_STLPORT_VERSION) - #define PHOENIX_OSTREAM _IO_ostream_withassign - #else - #define PHOENIX_OSTREAM PHOENIX_STD::_IO_ostream_withassign - #endif -#else -// #if (defined(__ICL) && defined(_STLPORT_VERSION)) -// #define PHOENIX_OSTREAM ostream_withassign -// #else - #define PHOENIX_OSTREAM PHOENIX_STD::ostream -// #endif -#endif - -////////////////////////////////// -#if defined(__GNUC__) && (__GNUC__ < 3) -// || (defined(__ICL) && defined(_STLPORT_VERSION)) -template -struct binary_operator -{ - typedef PHOENIX_STD::ostream& result_type; - static result_type eval(PHOENIX_STD::ostream& out, T1 const& rhs) - { return out << rhs; } -}; -#endif - -////////////////////////////////// -template -struct binary_operator -{ - typedef PHOENIX_STD::ostream& result_type; - static result_type eval(PHOENIX_STD::ostream& out, T1 const& rhs) - { return out << rhs; } -}; - -////////////////////////////////// -template -inline typename impl::make_binary3 - , BaseT>::type -operator<<(PHOENIX_OSTREAM& _0, actor const& _1) -{ - return impl::make_binary3 - , BaseT> - ::construct(var(_0), _1); -} - -#undef PHOENIX_OSTREAM - -/////////////////////////////////////////////////////////////////////////////// -// -// specializations for std::strstream / stringstream -// -/////////////////////////////////////////////////////////////////////////////// -template -struct binary_operator -{ - typedef PHOENIX_STD::istream& result_type; - static result_type eval(PHOENIX_STD::istream& out, T1& rhs) - { return out >> rhs; } -}; - -////////////////////////////////// -template -inline typename impl::make_binary3 - , BaseT>::type -operator>>(PHOENIX_STD::PHOENIX_SSTREAM& _0, actor const& _1) -{ - return impl::make_binary3 - , BaseT> - ::construct(var(_0), _1); -} - -////////////////////////////////// -template -struct binary_operator -{ - typedef PHOENIX_STD::ostream& result_type; - static result_type eval(PHOENIX_STD::ostream& out, T1 const& rhs) - { return out << rhs; } -}; - -////////////////////////////////// -template -inline typename impl::make_binary3 - , BaseT>::type -operator<<(PHOENIX_STD::PHOENIX_SSTREAM& _0, actor const& _1) -{ - return impl::make_binary3 - , BaseT> - ::construct(var(_0), _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// I/O manipulator specializations -// -/////////////////////////////////////////////////////////////////////////////// -#if (!defined(__GNUC__) || (__GNUC__ > 2)) -// && !(defined(__ICL) && defined(_STLPORT_VERSION)) - -typedef PHOENIX_STD::ios_base& (*iomanip_t)(PHOENIX_STD::ios_base&); -typedef PHOENIX_STD::istream& (*imanip_t)(PHOENIX_STD::istream&); -typedef PHOENIX_STD::ostream& (*omanip_t)(PHOENIX_STD::ostream&); - -#if defined(__BORLANDC__) - -/////////////////////////////////////////////////////////////////////////////// -// -// Borland does not like i/o manipulators functions such as endl to -// be the rhs of a lazy << operator (Borland incorrectly reports -// ambiguity). To get around the problem, we provide function -// pointer versions of the same name with a single trailing -// underscore. -// -// You can use the same trick for other i/o manipulators. -// Alternatively, you can prefix the manipulator with a '&' -// operator. Example: -// -// cout << arg1 << &endl -// -/////////////////////////////////////////////////////////////////////////////// - -imanip_t ws_ = &PHOENIX_STD::ws; -iomanip_t dec_ = &PHOENIX_STD::dec; -iomanip_t hex_ = &PHOENIX_STD::hex; -iomanip_t oct_ = &PHOENIX_STD::oct; -omanip_t endl_ = &PHOENIX_STD::endl; -omanip_t ends_ = &PHOENIX_STD::ends; -omanip_t flush_ = &PHOENIX_STD::flush; - -#else // __BORLANDC__ - -/////////////////////////////////////////////////////////////////////////////// -// -// The following are overloads for I/O manipulators. -// -/////////////////////////////////////////////////////////////////////////////// -template -inline typename impl::make_binary1::type -operator>>(actor const& _0, imanip_t _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator>>(actor const& _0, iomanip_t _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator<<(actor const& _0, omanip_t _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -////////////////////////////////// -template -inline typename impl::make_binary1::type -operator<<(actor const& _0, iomanip_t _1) -{ - return impl::make_binary1::construct(_0, _1); -} - -#endif // __BORLANDC__ -#endif // !defined(__GNUC__) || (__GNUC__ > 2) - -/////////////////////////////////////////////////////////////////////////////// -// -// specializations for stl iterators and containers -// -/////////////////////////////////////////////////////////////////////////////// -template -struct unary_operator -{ - typedef typename T::reference result_type; - static result_type eval(T const& iter) - { return *iter; } -}; - -////////////////////////////////// -template -struct binary_operator -{ - typedef typename T0::reference result_type; - static result_type eval(T0& container, T1 const& index) - { return container[index]; } -}; - -////////////////////////////////// -template -struct binary_operator -{ - typedef typename T0::const_reference result_type; - static result_type eval(T0 const& container, T1 const& index) - { return container[index]; } -}; - -/////////////////////////////////////////////////////////////////////////////// -} // namespace phoenix - -#undef PHOENIX_SSTREAM -#undef PHOENIX_STD -#endif diff --git a/boost/boost/spirit/phoenix/statements.hpp b/boost/boost/spirit/phoenix/statements.hpp deleted file mode 100644 index d20d199818..0000000000 --- a/boost/boost/spirit/phoenix/statements.hpp +++ /dev/null @@ -1,444 +0,0 @@ -/*============================================================================= - Phoenix V1.2.1 - Copyright (c) 2001-2002 Joel de Guzman - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -==============================================================================*/ -#ifndef PHOENIX_STATEMENTS_HPP -#define PHOENIX_STATEMENTS_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace phoenix { - -/////////////////////////////////////////////////////////////////////////////// -// -// sequential_composite -// -// Two or more actors separated by the comma generates a -// sequential_composite which is a composite actor. Example: -// -// actor, -// actor, -// actor -// -// The actors are evaluated sequentially. The result type of this -// is void. Note that the last actor should not have a trailing -// comma. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct sequential_composite { - - typedef sequential_composite self_t; - - template - struct result { typedef void type; }; - - sequential_composite(A0 const& _0, A1 const& _1) - : a0(_0), a1(_1) {} - - template - void - eval(TupleT const& args) const - { - a0.eval(args); - a1.eval(args); - } - - A0 a0; A1 a1; // actors -}; - -////////////////////////////////// -template -inline actor, actor > > -operator,(actor const& _0, actor const& _1) -{ - return sequential_composite, actor >(_0, _1); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// if_then_else_composite -// -// This composite has two (2) forms: -// -// if_(condition) -// [ -// statement -// ] -// -// and -// -// if_(condition) -// [ -// true_statement -// ] -// .else_ -// [ -// false_statement -// ] -// -// where condition is an actor that evaluates to bool. If condition -// is true, the true_statement (again an actor) is executed -// otherwise, the false_statement (another actor) is executed. The -// result type of this is void. Note the trailing underscore after -// if_ and the the leading dot and the trailing underscore before -// and after .else_. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct if_then_else_composite { - - typedef if_then_else_composite self_t; - - template - struct result { - - typedef void type; - }; - - if_then_else_composite( - CondT const& cond_, - ThenT const& then_, - ElseT const& else__) - : cond(cond_), then(then_), else_(else__) {} - - template - void eval(TupleT const& args) const - { - if (cond.eval(args)) - then.eval(args); - else - else_.eval(args); - } - - CondT cond; ThenT then; ElseT else_; // actors -}; - -////////////////////////////////// -template -struct else_gen { - - else_gen(CondT const& cond_, ThenT const& then_) - : cond(cond_), then(then_) {} - - template - actor::type> > - operator[](ElseT const& else_) - { - typedef if_then_else_composite::type> - result; - - return result(cond, then, as_actor::convert(else_)); - } - - CondT cond; ThenT then; -}; - -////////////////////////////////// -template -struct if_then_composite { - - typedef if_then_composite self_t; - - template - struct result { typedef void type; }; - - if_then_composite(CondT const& cond_, ThenT const& then_) - : cond(cond_), then(then_), else_(cond, then) {} - - template - void eval(TupleT const& args) const - { - if (cond.eval(args)) - then.eval(args); - } - - CondT cond; ThenT then; // actors - else_gen else_; -}; - -////////////////////////////////// -template -struct if_gen { - - if_gen(CondT const& cond_) - : cond(cond_) {} - - template - actor::type, - typename as_actor::type> > - operator[](ThenT const& then) const - { - typedef if_then_composite< - typename as_actor::type, - typename as_actor::type> - result; - - return result( - as_actor::convert(cond), - as_actor::convert(then)); - } - - CondT cond; -}; - -////////////////////////////////// -template -inline if_gen -if_(CondT const& cond) -{ - return if_gen(cond); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// while_composite -// -// This composite has the form: -// -// while_(condition) -// [ -// statement -// ] -// -// While the condition (an actor) evaluates to true, statement -// (another actor) is executed. The result type of this is void. -// Note the trailing underscore after while_. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct while_composite { - - typedef while_composite self_t; - - template - struct result { typedef void type; }; - - while_composite(CondT const& cond_, DoT const& do__) - : cond(cond_), do_(do__) {} - - template - void eval(TupleT const& args) const - { - while (cond.eval(args)) - do_.eval(args); - } - - CondT cond; - DoT do_; -}; - -////////////////////////////////// -template -struct while_gen { - - while_gen(CondT const& cond_) - : cond(cond_) {} - - template - actor::type, - typename as_actor::type> > - operator[](DoT const& do_) const - { - typedef while_composite< - typename as_actor::type, - typename as_actor::type> - result; - - return result( - as_actor::convert(cond), - as_actor::convert(do_)); - } - - CondT cond; -}; - -////////////////////////////////// -template -inline while_gen -while_(CondT const& cond) -{ - return while_gen(cond); -} - -/////////////////////////////////////////////////////////////////////////////// -// -// do_composite -// -// This composite has the form: -// -// do_ -// [ -// statement -// ] -// .while_(condition) -// -// While the condition (an actor) evaluates to true, statement -// (another actor) is executed. The statement is executed at least -// once. The result type of this is void. Note the trailing -// underscore after do_ and the the leading dot and the trailing -// underscore before and after .while_. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct do_composite { - - typedef do_composite self_t; - - template - struct result { typedef void type; }; - - do_composite(DoT const& do__, CondT const& cond_) - : do_(do__), cond(cond_) {} - - template - void eval(TupleT const& args) const - { - do - do_.eval(args); - while (cond.eval(args)); - } - - DoT do_; - CondT cond; -}; - -//////////////////////////////////// -template -struct do_gen2 { - - do_gen2(DoT const& do__) - : do_(do__) {} - - template - actor::type, - typename as_actor::type> > - while_(CondT const& cond) const - { - typedef do_composite< - typename as_actor::type, - typename as_actor::type> - result; - - return result( - as_actor::convert(do_), - as_actor::convert(cond)); - } - - DoT do_; -}; - -//////////////////////////////////// -struct do_gen { - - template - do_gen2 - operator[](DoT const& do_) const - { - return do_gen2(do_); - } -}; - -do_gen const do_ = do_gen(); - -/////////////////////////////////////////////////////////////////////////////// -// -// for_composite -// -// This statement has the form: -// -// for_(init, condition, step) -// [ -// statement -// ] -// -// Where init, condition, step and statement are all actors. init -// is executed once before entering the for-loop. The for-loop -// exits once condition evaluates to false. At each loop iteration, -// step and statement is called. The result of this statement is -// void. Note the trailing underscore after for_. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct for_composite { - - typedef composite self_t; - - template - struct result { typedef void type; }; - - for_composite( - InitT const& init_, - CondT const& cond_, - StepT const& step_, - DoT const& do__) - : init(init_), cond(cond_), step(step_), do_(do__) {} - - template - void - eval(TupleT const& args) const - { - for (init.eval(args); cond.eval(args); step.eval(args)) - do_.eval(args); - } - - InitT init; CondT cond; StepT step; DoT do_; // actors -}; - -////////////////////////////////// -template -struct for_gen { - - for_gen( - InitT const& init_, - CondT const& cond_, - StepT const& step_) - : init(init_), cond(cond_), step(step_) {} - - template - actor::type, - typename as_actor::type, - typename as_actor::type, - typename as_actor::type> > - operator[](DoT const& do_) const - { - typedef for_composite< - typename as_actor::type, - typename as_actor::type, - typename as_actor::type, - typename as_actor::type> - result; - - return result( - as_actor::convert(init), - as_actor::convert(cond), - as_actor::convert(step), - as_actor::convert(do_)); - } - - InitT init; CondT cond; StepT step; -}; - -////////////////////////////////// -template -inline for_gen -for_(InitT const& init, CondT const& cond, StepT const& step) -{ - return for_gen(init, cond, step); -} - -} // namespace phoenix - -#endif diff --git a/boost/boost/spirit/phoenix/tuple_helpers.hpp b/boost/boost/spirit/phoenix/tuple_helpers.hpp deleted file mode 100644 index f8875e0c79..0000000000 --- a/boost/boost/spirit/phoenix/tuple_helpers.hpp +++ /dev/null @@ -1,1076 +0,0 @@ -/*============================================================================= - Phoenix V1.2.1 - Copyright (c) 2002 Joel de Guzman - Copyright (c) 2002-2003 Hartmut Kaiser - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -==============================================================================*/ -#ifndef PHOENIX_TUPLEHELPERS_HPP -#define PHOENIX_TUPLEHELPERS_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace phoenix -{ - -/////////////////////////////////////////////////////////////////////////////// -// -// make_tuple template class -// -// This template class is used to calculate a tuple type required to hold -// the given template parameter type -// -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// normal (non-tuple types are wrapped into a tuple) -template -struct make_tuple { - - typedef tuple type; -}; - -/////////////////////////////////////////////////////////////////////////////// -// nil_t is converted to an empty tuple type -template <> -struct make_tuple { - - typedef tuple<> type; -}; - -/////////////////////////////////////////////////////////////////////////////// -// tuple types are left alone without any refactoring -template < - typename A, typename B, typename C -#if PHOENIX_LIMIT > 3 - , typename D, typename E, typename F -#if PHOENIX_LIMIT > 6 - , typename G, typename H, typename I -#if PHOENIX_LIMIT > 9 - , typename J, typename K, typename L -#if PHOENIX_LIMIT > 12 - , typename M, typename N, typename O -#endif -#endif -#endif -#endif -> -struct make_tuple 3 - , D, E, F -#if PHOENIX_LIMIT > 6 - , G, H, I -#if PHOENIX_LIMIT > 9 - , J, K, L -#if PHOENIX_LIMIT > 12 - , M, N, O -#endif -#endif -#endif -#endif - > > { - -// the tuple parameter itself is the required tuple type - typedef tuple 3 - , D, E, F -#if PHOENIX_LIMIT > 6 - , G, H, I -#if PHOENIX_LIMIT > 9 - , J, K, L -#if PHOENIX_LIMIT > 12 - , M, N, O -#endif -#endif -#endif -#endif - > type; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// concat_tuple type computer -// -// This class returns the type of a tuple, which is constructed by -// concatenating a tuple with a given type -// -/////////////////////////////////////////////////////////////////////////////// -template -struct concat_tuple; - -/////////////////////////////////////////////////////////////////////////////// -// -// concat tuple <0 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template -struct concat_tuple, AppendT> { - - typedef tuple type; -}; - -template <> -struct concat_tuple, nil_t> { - - typedef tuple<> type; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// concat tuple <1 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template -struct concat_tuple, AppendT> { - - typedef tuple type; -}; - -template -struct concat_tuple, nil_t> { - - typedef tuple type; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// concat tuple <2 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template -struct concat_tuple, AppendT> { - - typedef tuple type; -}; - -template -struct concat_tuple, nil_t> { - - typedef tuple type; -}; - -#if PHOENIX_LIMIT > 3 -/////////////////////////////////////////////////////////////////////////////// -// -// concat tuple <3 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename A, typename B, typename C, - typename AppendT -> -struct concat_tuple, AppendT> { - - typedef tuple type; -}; - -template < - typename A, typename B, typename C -> -struct concat_tuple, nil_t> { - - typedef tuple type; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// concat tuple <4 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename A, typename B, typename C, typename D, - typename AppendT -> -struct concat_tuple, AppendT> { - - typedef tuple type; -}; - -template < - typename A, typename B, typename C, typename D -> -struct concat_tuple, nil_t> { - - typedef tuple type; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// concat tuple <5 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename A, typename B, typename C, typename D, typename E, - typename AppendT -> -struct concat_tuple, AppendT> { - - typedef tuple type; -}; - -template < - typename A, typename B, typename C, typename D, typename E -> -struct concat_tuple, nil_t> { - - typedef tuple type; -}; - -#if PHOENIX_LIMIT > 6 -/////////////////////////////////////////////////////////////////////////////// -// -// concat tuple <6 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename A, typename B, typename C, typename D, typename E, typename F, - typename AppendT -> -struct concat_tuple, AppendT> { - - typedef tuple type; -}; - -template < - typename A, typename B, typename C, typename D, typename E, typename F -> -struct concat_tuple, nil_t> { - - typedef tuple type; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// concat tuple <7 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename A, typename B, typename C, typename D, typename E, typename F, - typename G, - typename AppendT -> -struct concat_tuple, AppendT> { - - typedef tuple type; -}; - -template < - typename A, typename B, typename C, typename D, typename E, typename F, - typename G -> -struct concat_tuple, nil_t> { - - typedef tuple type; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// concat tuple <8 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename A, typename B, typename C, typename D, typename E, typename F, - typename G, typename H, - typename AppendT -> -struct concat_tuple, AppendT> { - - typedef tuple type; -}; - -template < - typename A, typename B, typename C, typename D, typename E, typename F, - typename G, typename H -> -struct concat_tuple, nil_t> { - - typedef tuple type; -}; - -#if PHOENIX_LIMIT > 9 -/////////////////////////////////////////////////////////////////////////////// -// -// concat tuple <9 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename A, typename B, typename C, typename D, typename E, typename F, - typename G, typename H, typename I, - typename AppendT -> -struct concat_tuple, AppendT> { - - typedef tuple type; -}; - -template < - typename A, typename B, typename C, typename D, typename E, typename F, - typename G, typename H, typename I -> -struct concat_tuple, nil_t> { - - typedef tuple type; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// concat tuple <10 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename A, typename B, typename C, typename D, typename E, typename F, - typename G, typename H, typename I, typename J, - typename AppendT -> -struct concat_tuple, AppendT> { - - typedef tuple type; -}; - -template < - typename A, typename B, typename C, typename D, typename E, typename F, - typename G, typename H, typename I, typename J -> -struct concat_tuple, nil_t> { - - typedef tuple type; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// concat tuple <11 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename A, typename B, typename C, typename D, typename E, typename F, - typename G, typename H, typename I, typename J, typename K, - typename AppendT -> -struct concat_tuple, AppendT> { - - typedef tuple type; -}; - -template < - typename A, typename B, typename C, typename D, typename E, typename F, - typename G, typename H, typename I, typename J, typename K -> -struct concat_tuple, nil_t> { - - typedef tuple type; -}; - -#if PHOENIX_LIMIT > 12 -/////////////////////////////////////////////////////////////////////////////// -// -// concat tuple <12 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename A, typename B, typename C, typename D, typename E, typename F, - typename G, typename H, typename I, typename J, typename K, typename L, - typename AppendT -> -struct concat_tuple, AppendT> { - - typedef tuple type; -}; - -template < - typename A, typename B, typename C, typename D, typename E, typename F, - typename G, typename H, typename I, typename J, typename K, typename L -> -struct concat_tuple, nil_t> { - - typedef tuple type; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// concat tuple <13 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename A, typename B, typename C, typename D, typename E, typename F, - typename G, typename H, typename I, typename J, typename K, typename L, - typename M, - typename AppendT -> -struct concat_tuple, AppendT> { - - typedef tuple type; -}; - -template < - typename A, typename B, typename C, typename D, typename E, typename F, - typename G, typename H, typename I, typename J, typename K, typename L, - typename M -> -struct concat_tuple, nil_t> { - - typedef tuple type; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// concat tuple <14 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename A, typename B, typename C, typename D, typename E, typename F, - typename G, typename H, typename I, typename J, typename K, typename L, - typename M, typename N, - typename AppendT -> -struct concat_tuple, AppendT> { - - typedef tuple type; -}; - -template < - typename A, typename B, typename C, typename D, typename E, typename F, - typename G, typename H, typename I, typename J, typename K, typename L, - typename M, typename N -> -struct concat_tuple, nil_t> { - - typedef tuple type; -}; - -#endif -#endif -#endif -#endif - -/////////////////////////////////////////////////////////////////////////////// -// -// concat_tuples type computer -// -// This template class returns the type of a tuple built from the -// concatenation of two given tuples. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct concat_tuple_element { - - typedef - typename concat_tuple_element< - typename concat_tuple::type, TupleT2, N+1, - typename tuple_element::type - >::type - type; -}; - -template -struct concat_tuple_element { - - typedef TupleT1 type; -}; - -template -struct concat_tuples { - - typedef - typename concat_tuple_element< - TupleT1, TupleT2, 0, - typename tuple_element<0, TupleT2>::type - >::type - type; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// convert_actors template function -// -// The convert_actors template functions constructs a new tuple object -// composed of the elements returned by the actors contained in the -// input tuple. (i.e. the given tuple type 'actor_tuple' contains a set -// of actors to evaluate and the resulting tuple contains the results of -// evaluating the actors.) -// -/////////////////////////////////////////////////////////////////////////////// -template -struct actor_result; // forward declaration - -namespace impl -{ - template - struct convert_actors_ {}; -} - -template -TupleResultT -convert_actors(ActorTupleT const& actor_tuple) -{ - BOOST_STATIC_ASSERT(ActorTupleT::length <= TupleResultT::length); - BOOST_STATIC_CONSTANT(int, length = TupleResultT::length); - return impl::convert_actors_ - ::template apply::do_(actor_tuple); -} - -namespace impl -{ - template - struct convert_actor - { - typedef typename tuple_element::type type; - - template - struct is_default_t {}; - typedef is_default_t is_default; - typedef is_default_t is_not_default; - - static type - actor_element(ActorTupleT const& /*actor_tuple*/, is_default) - { - return type(); // default construct - } - - static type - actor_element(ActorTupleT const& actor_tuple, is_not_default) - { - BOOST_STATIC_ASSERT(ActorTupleT::length <= TupleResultT::length); - return actor_tuple[tuple_index()](); // apply the actor - } - - static type - do_(ActorTupleT const& actor_tuple) - { - return actor_element( - actor_tuple, is_default_t<(N >= ActorTupleT::length)>()); - } - }; - - /////////////////////////////////////// - template <> - struct convert_actors_<1> - { - template - struct apply - { - static TupleResultT - do_(ActorTupleT const& actor_tuple) - { - typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; - - return TupleResultT( - converter0::do_(actor_tuple) - ); - } - }; - }; - - /////////////////////////////////////// - template <> - struct convert_actors_<2> - { - template - struct apply - { - static TupleResultT - do_(ActorTupleT const& actor_tuple) - { - typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; - typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; - - using namespace tuple_index_names; - return TupleResultT( - converter0::do_(actor_tuple) - , converter1::do_(actor_tuple) - ); - } - }; - }; - - /////////////////////////////////////// - template <> - struct convert_actors_<3> - { - template - struct apply - { - static TupleResultT - do_(ActorTupleT const& actor_tuple) - { - typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; - typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; - typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; - - using namespace tuple_index_names; - return TupleResultT( - converter0::do_(actor_tuple) - , converter1::do_(actor_tuple) - , converter2::do_(actor_tuple) - ); - } - }; - }; - - #if PHOENIX_LIMIT > 3 - - ///////////////////////////////////// - template <> - struct convert_actors_<4> - { - template - struct apply - { - static TupleResultT - do_(ActorTupleT const& actor_tuple) - { - typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; - typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; - typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; - typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; - - using namespace tuple_index_names; - return TupleResultT( - converter0::do_(actor_tuple) - , converter1::do_(actor_tuple) - , converter2::do_(actor_tuple) - , converter3::do_(actor_tuple) - ); - } - }; - }; - - ///////////////////////////////////// - template <> - struct convert_actors_<5> - { - template - struct apply - { - static TupleResultT - do_(ActorTupleT const& actor_tuple) - { - typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; - typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; - typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; - typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; - typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; - - using namespace tuple_index_names; - return TupleResultT( - converter0::do_(actor_tuple) - , converter1::do_(actor_tuple) - , converter2::do_(actor_tuple) - , converter3::do_(actor_tuple) - , converter4::do_(actor_tuple) - ); - } - }; - }; - - ///////////////////////////////////// - template <> - struct convert_actors_<6> - { - template - struct apply - { - static TupleResultT - do_(ActorTupleT const& actor_tuple) - { - typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; - typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; - typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; - typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; - typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; - typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; - - using namespace tuple_index_names; - return TupleResultT( - converter0::do_(actor_tuple) - , converter1::do_(actor_tuple) - , converter2::do_(actor_tuple) - , converter3::do_(actor_tuple) - , converter4::do_(actor_tuple) - , converter5::do_(actor_tuple) - ); - } - }; - }; - - #if PHOENIX_LIMIT > 6 - - ///////////////////////////////////// - template <> - struct convert_actors_<7> - { - template - struct apply - { - static TupleResultT - do_(ActorTupleT const& actor_tuple) - { - typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; - typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; - typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; - typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; - typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; - typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; - typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; - - using namespace tuple_index_names; - return TupleResultT( - converter0::do_(actor_tuple) - , converter1::do_(actor_tuple) - , converter2::do_(actor_tuple) - , converter3::do_(actor_tuple) - , converter4::do_(actor_tuple) - , converter5::do_(actor_tuple) - , converter6::do_(actor_tuple) - ); - } - }; - }; - - ///////////////////////////////////// - template <> - struct convert_actors_<8> - { - template - struct apply - { - static TupleResultT - do_(ActorTupleT const& actor_tuple) - { - typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; - typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; - typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; - typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; - typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; - typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; - typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; - typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; - - using namespace tuple_index_names; - return TupleResultT( - converter0::do_(actor_tuple) - , converter1::do_(actor_tuple) - , converter2::do_(actor_tuple) - , converter3::do_(actor_tuple) - , converter4::do_(actor_tuple) - , converter5::do_(actor_tuple) - , converter6::do_(actor_tuple) - , converter7::do_(actor_tuple) - ); - } - }; - }; - - ///////////////////////////////////// - template <> - struct convert_actors_<9> - { - template - struct apply - { - static TupleResultT - do_(ActorTupleT const& actor_tuple) - { - typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; - typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; - typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; - typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; - typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; - typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; - typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; - typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; - typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; - - using namespace tuple_index_names; - return TupleResultT( - converter0::do_(actor_tuple) - , converter1::do_(actor_tuple) - , converter2::do_(actor_tuple) - , converter3::do_(actor_tuple) - , converter4::do_(actor_tuple) - , converter5::do_(actor_tuple) - , converter6::do_(actor_tuple) - , converter7::do_(actor_tuple) - , converter8::do_(actor_tuple) - ); - } - }; - }; - - #if PHOENIX_LIMIT > 9 - - ///////////////////////////////////// - template <> - struct convert_actors_<10> - { - template - struct apply - { - static TupleResultT - do_(ActorTupleT const& actor_tuple) - { - typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; - typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; - typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; - typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; - typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; - typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; - typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; - typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; - typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; - typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; - - using namespace tuple_index_names; - return TupleResultT( - converter0::do_(actor_tuple) - , converter1::do_(actor_tuple) - , converter2::do_(actor_tuple) - , converter3::do_(actor_tuple) - , converter4::do_(actor_tuple) - , converter5::do_(actor_tuple) - , converter6::do_(actor_tuple) - , converter7::do_(actor_tuple) - , converter8::do_(actor_tuple) - , converter9::do_(actor_tuple) - ); - } - }; - }; - - ///////////////////////////////////// - template <> - struct convert_actors_<11> - { - template - struct apply - { - static TupleResultT - do_(ActorTupleT const& actor_tuple) - { - typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; - typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; - typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; - typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; - typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; - typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; - typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; - typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; - typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; - typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; - typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10; - - using namespace tuple_index_names; - return TupleResultT( - converter0::do_(actor_tuple) - , converter1::do_(actor_tuple) - , converter2::do_(actor_tuple) - , converter3::do_(actor_tuple) - , converter4::do_(actor_tuple) - , converter5::do_(actor_tuple) - , converter6::do_(actor_tuple) - , converter7::do_(actor_tuple) - , converter8::do_(actor_tuple) - , converter9::do_(actor_tuple) - , converter10::do_(actor_tuple) - ); - } - }; - }; - - ///////////////////////////////////// - template <> - struct convert_actors_<12> - { - template - struct apply - { - static TupleResultT - do_(ActorTupleT const& actor_tuple) - { - typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; - typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; - typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; - typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; - typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; - typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; - typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; - typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; - typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; - typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; - typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10; - typedef impl::convert_actor<11, TupleResultT, ActorTupleT> converter11; - - using namespace tuple_index_names; - return TupleResultT( - converter0::do_(actor_tuple) - , converter1::do_(actor_tuple) - , converter2::do_(actor_tuple) - , converter3::do_(actor_tuple) - , converter4::do_(actor_tuple) - , converter5::do_(actor_tuple) - , converter6::do_(actor_tuple) - , converter7::do_(actor_tuple) - , converter8::do_(actor_tuple) - , converter9::do_(actor_tuple) - , converter10::do_(actor_tuple) - , converter11::do_(actor_tuple) - ); - } - }; - }; - - #if PHOENIX_LIMIT > 12 - - ///////////////////////////////////// - template <> - struct convert_actors_<13> - { - template - struct apply - { - static TupleResultT - do_(ActorTupleT const& actor_tuple) - { - typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; - typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; - typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; - typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; - typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; - typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; - typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; - typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; - typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; - typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; - typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10; - typedef impl::convert_actor<11, TupleResultT, ActorTupleT> converter11; - typedef impl::convert_actor<12, TupleResultT, ActorTupleT> converter12; - - using namespace tuple_index_names; - return TupleResultT( - converter0::do_(actor_tuple) - , converter1::do_(actor_tuple) - , converter2::do_(actor_tuple) - , converter3::do_(actor_tuple) - , converter4::do_(actor_tuple) - , converter5::do_(actor_tuple) - , converter6::do_(actor_tuple) - , converter7::do_(actor_tuple) - , converter8::do_(actor_tuple) - , converter9::do_(actor_tuple) - , converter10::do_(actor_tuple) - , converter11::do_(actor_tuple) - , converter12::do_(actor_tuple) - ); - } - }; - }; - - /////////////////////////////////////// - template <> - struct convert_actors_<14> - { - template - struct apply - { - static TupleResultT - do_(ActorTupleT const& actor_tuple) - { - typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; - typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; - typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; - typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; - typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; - typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; - typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; - typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; - typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; - typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; - typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10; - typedef impl::convert_actor<11, TupleResultT, ActorTupleT> converter11; - typedef impl::convert_actor<12, TupleResultT, ActorTupleT> converter12; - typedef impl::convert_actor<13, TupleResultT, ActorTupleT> converter13; - - using namespace tuple_index_names; - return TupleResultT( - converter0::do_(actor_tuple) - , converter1::do_(actor_tuple) - , converter2::do_(actor_tuple) - , converter3::do_(actor_tuple) - , converter4::do_(actor_tuple) - , converter5::do_(actor_tuple) - , converter6::do_(actor_tuple) - , converter7::do_(actor_tuple) - , converter8::do_(actor_tuple) - , converter9::do_(actor_tuple) - , converter10::do_(actor_tuple) - , converter11::do_(actor_tuple) - , converter12::do_(actor_tuple) - , converter13::do_(actor_tuple) - ); - } - }; - }; - - /////////////////////////////////////// - template <> - struct convert_actors_<15> - { - template - struct apply - { - static TupleResultT - do_(ActorTupleT const& actor_tuple) - { - typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; - typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; - typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; - typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; - typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; - typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; - typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; - typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; - typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; - typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; - typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10; - typedef impl::convert_actor<11, TupleResultT, ActorTupleT> converter11; - typedef impl::convert_actor<12, TupleResultT, ActorTupleT> converter12; - typedef impl::convert_actor<13, TupleResultT, ActorTupleT> converter13; - typedef impl::convert_actor<14, TupleResultT, ActorTupleT> converter14; - - using namespace tuple_index_names; - return TupleResultT( - converter0::do_(actor_tuple) - , converter1::do_(actor_tuple) - , converter2::do_(actor_tuple) - , converter3::do_(actor_tuple) - , converter4::do_(actor_tuple) - , converter5::do_(actor_tuple) - , converter6::do_(actor_tuple) - , converter7::do_(actor_tuple) - , converter8::do_(actor_tuple) - , converter9::do_(actor_tuple) - , converter10::do_(actor_tuple) - , converter11::do_(actor_tuple) - , converter12::do_(actor_tuple) - , converter13::do_(actor_tuple) - , converter14::do_(actor_tuple) - ); - } - }; - }; - - #endif - #endif - #endif - #endif -} // namespace impl - - -/////////////////////////////////////////////////////////////////////////////// -} // namespace phoenix - -#endif // PHOENIX_TUPLEHELPERS_HPP diff --git a/boost/boost/spirit/phoenix/tuples.hpp b/boost/boost/spirit/phoenix/tuples.hpp deleted file mode 100644 index 0cde04127f..0000000000 --- a/boost/boost/spirit/phoenix/tuples.hpp +++ /dev/null @@ -1,1330 +0,0 @@ -/*============================================================================= - Phoenix V1.2.1 - Copyright (c) 2001-2002 Joel de Guzman - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -==============================================================================*/ -#ifndef PHOENIX_TUPLES_HPP -#define PHOENIX_TUPLES_HPP - -#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300) -#error "Sorry, Phoenix does not support VC6 and VC7. Please upgrade to at least VC7.1" -#endif - -/////////////////////////////////////////////////////////////////////////////// -// -// Phoenix predefined maximum limit. This limit defines the maximum -// number of elements a tuple can hold. This number defaults to 3. The -// actual maximum is rounded up in multiples of 3. Thus, if this value -// is 4, the actual limit is 6. The ultimate maximum limit in this -// implementation is 15. -// -/////////////////////////////////////////////////////////////////////////////// -#ifndef PHOENIX_LIMIT -#define PHOENIX_LIMIT 3 -#endif - -#if defined(__BORLANDC__) && (__BORLANDC__ <= 0x561) -namespace phoenix { namespace borland_only -{ - namespace ftors - { - // We define these dummy template functions. Borland complains when - // a template class has the same name as a template function, - // regardless if they are in different namespaces. - - template void if_(T) {} - template void for_(T) {} - template void while_(T) {} - template void do_(T) {} - } - - namespace tmpls - { - // We define these dummy template functions. Borland complains when - // a template class has the same name as a template function, - // regardless if they are in different namespaces. - - template struct if_ {}; - template struct for_ {}; - template struct while_ {}; - template struct do_ {}; - } - -}} // namespace phoenix::borland_only -#endif - -/////////////////////////////////////////////////////////////////////////////// -#include -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace phoenix { - -/////////////////////////////////////////////////////////////////////////////// -// -// tuple -// -// Tuples hold heterogeneous types up to a predefined maximum. Only -// the most basic functionality needed is provided. Unlike other -// recursive list-like tuple implementations, this tuple -// implementation uses simple structs similar to std::pair with -// specialization for 0 to N tuple elements. -// -// 1) Construction -// Here are examples on how to construct tuples: -// -// typedef tuple t1_t; -// typedef tuple t2_t; -// -// // this tuple has an int and char members -// t1_t t1(3, 'c'); -// -// // this tuple has an int, std::string and double members -// t2_t t2(3, "hello", 3.14); -// -// Tuples can also be constructed from other tuples. The -// source and destination tuples need not have exactly the -// same element types. The only requirement is that the -// source tuple have the same number of elements as the -// destination and that each element slot in the -// destination can be copy constructed from the source -// element. For example: -// -// tuple t3(t1); // OK. Compatible tuples -// tuple t4(t2); // Error! Incompatible tuples -// -// 2) Member access -// A member in a tuple can be accessed using the -// tuple's [] operator by specifying the Nth -// tuple_index. Here are some examples: -// -// tuple_index<0> ix0; // 0th index == 1st item -// tuple_index<1> ix1; // 1st index == 2nd item -// tuple_index<2> ix2; // 2nd index == 3rd item -// -// t1[ix0] = 33; // sets the int member of the tuple t1 -// t2[ix2] = 6e6; // sets the double member of the tuple t2 -// t1[ix1] = 'a'; // sets the char member of the tuple t1 -// -// There are some predefined names are provided in sub- -// namespace tuple_index_names: -// -// tuple_index<0> _1; -// tuple_index<1> _2; -// ... -// tuple_index _N; -// -// These indexes may be used by 'using' namespace -// phoenix::tuple_index_names. -// -// Access to out of bound indexes returns a nil_t value. -// -// 3) Member type inquiry -// The type of an individual member can be queried. -// Example: -// -// tuple_element<1, t2_t>::type -// -// Refers to the type of the second member (note zero based, -// thus 0 = 1st item, 1 = 2nd item) of the tuple. -// -// Aside from tuple_element::type, there are two -// more types that tuple_element provides: rtype and -// crtype. While 'type' is the plain underlying type, -// 'rtype' is the reference type, or type& and 'crtype' -// is the constant reference type or type const&. The -// latter two are provided to make it easy for the -// client in dealing with the possibility of reference -// to reference when type is already a reference, which -// is illegal in C++. -// -// Access to out of bound indexes returns a nil_t type. -// -// 4) Tuple length -// The number of elements in a tuple can be queried. -// Example: -// -// int n = t1.length; -// -// gets the number of elements in tuple t1. -// -// length is a static constant. Thus, TupleT::length -// also works. Example: -// -// int n = t1_t::length; -// -/////////////////////////////////////////////////////////////////////////////// -struct nil_t {}; -using boost::remove_reference; -using boost::call_traits; - -////////////////////////////////// -namespace impl { - - template - struct access { - - typedef const T& ctype; - typedef T& type; - }; - - template - struct access { - - typedef T& ctype; - typedef T& type; - }; -} - -/////////////////////////////////////////////////////////////////////////////// -// -// tuple_element -// -// A query class that gets the Nth element inside a tuple. -// Examples: -// -// tuple_element<1, tuple >::type // plain -// tuple_element<1, tuple >::rtype // ref -// tuple_element<1, tuple >::crtype // const ref -// -// Has type char which is the 2nd type in the tuple -// (note zero based, thus 0 = 1st item, 1 = 2nd item). -// -// Given a tuple object, the static function tuple_element::get(tuple) gets the Nth element in the tuple. The -// tuple class' tuple::operator[] uses this to get its Nth -// element. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct tuple_element -{ - typedef nil_t type; - typedef nil_t& rtype; - typedef nil_t const& crtype; - - static nil_t get(TupleT const& t) { return nil_t(); } -}; - -////////////////////////////////// -template -struct tuple_element<0, TupleT> -{ - typedef typename TupleT::a_type type; - typedef typename impl::access::type rtype; - typedef typename impl::access::ctype crtype; - - static rtype get(TupleT& t) { return t.a; } - static crtype get(TupleT const& t) { return t.a; } -}; - -////////////////////////////////// -template -struct tuple_element<1, TupleT> -{ - typedef typename TupleT::b_type type; - typedef typename impl::access::type rtype; - typedef typename impl::access::ctype crtype; - - static rtype get(TupleT& t) { return t.b; } - static crtype get(TupleT const& t) { return t.b; } -}; - -////////////////////////////////// -template -struct tuple_element<2, TupleT> -{ - typedef typename TupleT::c_type type; - typedef typename impl::access::type rtype; - typedef typename impl::access::ctype crtype; - - static rtype get(TupleT& t) { return t.c; } - static crtype get(TupleT const& t) { return t.c; } -}; - -#if PHOENIX_LIMIT > 3 -////////////////////////////////// -template -struct tuple_element<3, TupleT> -{ - typedef typename TupleT::d_type type; - typedef typename impl::access::type rtype; - typedef typename impl::access::ctype crtype; - - static rtype get(TupleT& t) { return t.d; } - static crtype get(TupleT const& t) { return t.d; } -}; - -////////////////////////////////// -template -struct tuple_element<4, TupleT> -{ - typedef typename TupleT::e_type type; - typedef typename impl::access::type rtype; - typedef typename impl::access::ctype crtype; - - static rtype get(TupleT& t) { return t.e; } - static crtype get(TupleT const& t) { return t.e; } -}; - -////////////////////////////////// -template -struct tuple_element<5, TupleT> -{ - typedef typename TupleT::f_type type; - typedef typename impl::access::type rtype; - typedef typename impl::access::ctype crtype; - - static rtype get(TupleT& t) { return t.f; } - static crtype get(TupleT const& t) { return t.f; } -}; - -#if PHOENIX_LIMIT > 6 -////////////////////////////////// -template -struct tuple_element<6, TupleT> -{ - typedef typename TupleT::g_type type; - typedef typename impl::access::type rtype; - typedef typename impl::access::ctype crtype; - - static rtype get(TupleT& t) { return t.g; } - static crtype get(TupleT const& t) { return t.g; } -}; - -////////////////////////////////// -template -struct tuple_element<7, TupleT> -{ - typedef typename TupleT::h_type type; - typedef typename impl::access::type rtype; - typedef typename impl::access::ctype crtype; - - static rtype get(TupleT& t) { return t.h; } - static crtype get(TupleT const& t) { return t.h; } -}; - -////////////////////////////////// -template -struct tuple_element<8, TupleT> -{ - typedef typename TupleT::i_type type; - typedef typename impl::access::type rtype; - typedef typename impl::access::ctype crtype; - - static rtype get(TupleT& t) { return t.i; } - static crtype get(TupleT const& t) { return t.i; } -}; - -#if PHOENIX_LIMIT > 9 -////////////////////////////////// -template -struct tuple_element<9, TupleT> -{ - typedef typename TupleT::j_type type; - typedef typename impl::access::type rtype; - typedef typename impl::access::ctype crtype; - - static rtype get(TupleT& t) { return t.j; } - static crtype get(TupleT const& t) { return t.j; } -}; - -////////////////////////////////// -template -struct tuple_element<10, TupleT> -{ - typedef typename TupleT::k_type type; - typedef typename impl::access::type rtype; - typedef typename impl::access::ctype crtype; - - static rtype get(TupleT& t) { return t.k; } - static crtype get(TupleT const& t) { return t.k; } -}; - -////////////////////////////////// -template -struct tuple_element<11, TupleT> -{ - typedef typename TupleT::l_type type; - typedef typename impl::access::type rtype; - typedef typename impl::access::ctype crtype; - - static rtype get(TupleT& t) { return t.l; } - static crtype get(TupleT const& t) { return t.l; } -}; - -#if PHOENIX_LIMIT > 12 -////////////////////////////////// -template -struct tuple_element<12, TupleT> -{ - typedef typename TupleT::m_type type; - typedef typename impl::access::type rtype; - typedef typename impl::access::ctype crtype; - - static rtype get(TupleT& t) { return t.m; } - static crtype get(TupleT const& t) { return t.m; } -}; - -////////////////////////////////// -template -struct tuple_element<13, TupleT> -{ - typedef typename TupleT::n_type type; - typedef typename impl::access::type rtype; - typedef typename impl::access::ctype crtype; - - static rtype get(TupleT& t) { return t.n; } - static crtype get(TupleT const& t) { return t.n; } -}; - -////////////////////////////////// -template -struct tuple_element<14, TupleT> -{ - typedef typename TupleT::o_type type; - typedef typename impl::access::type rtype; - typedef typename impl::access::ctype crtype; - - static rtype get(TupleT& t) { return t.o; } - static crtype get(TupleT const& t) { return t.o; } -}; - -#endif -#endif -#endif -#endif - -/////////////////////////////////////////////////////////////////////////////// -// -// tuple forward declaration. -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename A = nil_t - , typename B = nil_t - , typename C = nil_t - -#if PHOENIX_LIMIT > 3 - , typename D = nil_t - , typename E = nil_t - , typename F = nil_t - -#if PHOENIX_LIMIT > 6 - , typename G = nil_t - , typename H = nil_t - , typename I = nil_t - -#if PHOENIX_LIMIT > 9 - , typename J = nil_t - , typename K = nil_t - , typename L = nil_t - -#if PHOENIX_LIMIT > 12 - , typename M = nil_t - , typename N = nil_t - , typename O = nil_t - -#endif -#endif -#endif -#endif - - , typename NU = nil_t // Not used -> -struct tuple; - -/////////////////////////////////////////////////////////////////////////////// -// -// tuple_index -// -// This class wraps an integer in a type to be used for indexing -// the Nth element in a tuple. See tuple operator[]. Some -// predefined names are provided in sub-namespace -// tuple_index_names. -// -/////////////////////////////////////////////////////////////////////////////// -template -struct tuple_index {}; - -////////////////////////////////// -namespace tuple_index_names { - - tuple_index<0> const _1 = tuple_index<0>(); - tuple_index<1> const _2 = tuple_index<1>(); - tuple_index<2> const _3 = tuple_index<2>(); - -#if PHOENIX_LIMIT > 3 - tuple_index<3> const _4 = tuple_index<3>(); - tuple_index<4> const _5 = tuple_index<4>(); - tuple_index<5> const _6 = tuple_index<5>(); - -#if PHOENIX_LIMIT > 6 - tuple_index<6> const _7 = tuple_index<6>(); - tuple_index<7> const _8 = tuple_index<7>(); - tuple_index<8> const _9 = tuple_index<8>(); - -#if PHOENIX_LIMIT > 9 - tuple_index<9> const _10 = tuple_index<9>(); - tuple_index<10> const _11 = tuple_index<10>(); - tuple_index<11> const _12 = tuple_index<11>(); - -#if PHOENIX_LIMIT > 12 - tuple_index<12> const _13 = tuple_index<12>(); - tuple_index<13> const _14 = tuple_index<13>(); - tuple_index<14> const _15 = tuple_index<14>(); - -#endif -#endif -#endif -#endif -} - -/////////////////////////////////////////////////////////////////////////////// -// -// tuple_common class -// -/////////////////////////////////////////////////////////////////////////////// -template -struct tuple_base { - - typedef nil_t a_type; - typedef nil_t b_type; - typedef nil_t c_type; - -#if PHOENIX_LIMIT > 3 - typedef nil_t d_type; - typedef nil_t e_type; - typedef nil_t f_type; - -#if PHOENIX_LIMIT > 6 - typedef nil_t g_type; - typedef nil_t h_type; - typedef nil_t i_type; - -#if PHOENIX_LIMIT > 9 - typedef nil_t j_type; - typedef nil_t k_type; - typedef nil_t l_type; - -#if PHOENIX_LIMIT > 12 - typedef nil_t m_type; - typedef nil_t n_type; - typedef nil_t o_type; - -#endif -#endif -#endif -#endif - - template - typename tuple_element::crtype - operator[](tuple_index) const - { - return tuple_element - ::get(*static_cast(this)); - } - - template - typename tuple_element::rtype - operator[](tuple_index) - { - return tuple_element - ::get(*static_cast(this)); - } -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// tuple <0 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template <> -struct tuple<> -: public tuple_base > { - - BOOST_STATIC_CONSTANT(int, length = 0); -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// tuple <1 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template -struct tuple 3 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif -#endif - nil_t // Unused -> -: public tuple_base > { - - BOOST_STATIC_CONSTANT(int, length = 1); - typedef A a_type; - - tuple() {} - - tuple( - typename call_traits::param_type a_ - ): a(a_) {} - - template - tuple(TupleT const& init) - : a(init[tuple_index<0>()]) - { BOOST_STATIC_ASSERT(TupleT::length == length); } - - A a; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// tuple <2 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template -struct tuple 3 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif -#endif - nil_t // Unused -> -: public tuple_base > { - - BOOST_STATIC_CONSTANT(int, length = 2); - typedef A a_type; typedef B b_type; - - tuple() {} - - tuple( - typename call_traits::param_type a_, - typename call_traits::param_type b_ - ): a(a_), b(b_) {} - - template - tuple(TupleT const& init) - : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]) - { BOOST_STATIC_ASSERT(TupleT::length == length); } - - A a; B b; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// tuple <3 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template -struct tuple 3 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif -#endif - nil_t // Unused -> -: public tuple_base > { - - BOOST_STATIC_CONSTANT(int, length = 3); - typedef A a_type; typedef B b_type; - typedef C c_type; - - tuple() {} - - tuple( - typename call_traits::param_type a_, - typename call_traits::param_type b_, - typename call_traits::param_type c_ - ): a(a_), b(b_), c(c_) {} - - template - tuple(TupleT const& init) - : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), - c(init[tuple_index<2>()]) - { BOOST_STATIC_ASSERT(TupleT::length == length); } - - A a; B b; C c; -}; - -#if PHOENIX_LIMIT > 3 -/////////////////////////////////////////////////////////////////////////////// -// -// tuple <4 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template -struct tuple 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif - nil_t // Unused -> -: public tuple_base > { - - BOOST_STATIC_CONSTANT(int, length = 4); - typedef A a_type; typedef B b_type; - typedef C c_type; typedef D d_type; - - tuple() {} - - tuple( - typename call_traits::param_type a_, - typename call_traits::param_type b_, - typename call_traits::param_type c_, - typename call_traits::param_type d_ - ): a(a_), b(b_), c(c_), d(d_) {} - - template - tuple(TupleT const& init) - : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), - c(init[tuple_index<2>()]), d(init[tuple_index<3>()]) - { BOOST_STATIC_ASSERT(TupleT::length == length); } - - A a; B b; C c; D d; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// tuple <5 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template -struct tuple 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif - nil_t // Unused -> -: public tuple_base > { - - BOOST_STATIC_CONSTANT(int, length = 5); - typedef A a_type; typedef B b_type; - typedef C c_type; typedef D d_type; - typedef E e_type; - - tuple() {} - - tuple( - typename call_traits::param_type a_, - typename call_traits::param_type b_, - typename call_traits::param_type c_, - typename call_traits::param_type d_, - typename call_traits::param_type e_ - ): a(a_), b(b_), c(c_), d(d_), e(e_) {} - - template - tuple(TupleT const& init) - : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), - c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), - e(init[tuple_index<4>()]) - { BOOST_STATIC_ASSERT(TupleT::length == length); } - - A a; B b; C c; D d; E e; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// tuple <6 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename A, typename B, typename C, typename D, typename E, - typename F> -struct tuple 6 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif -#endif - nil_t // Unused -> -: public tuple_base > { - - BOOST_STATIC_CONSTANT(int, length = 6); - typedef A a_type; typedef B b_type; - typedef C c_type; typedef D d_type; - typedef E e_type; typedef F f_type; - - tuple() {} - - tuple( - typename call_traits::param_type a_, - typename call_traits::param_type b_, - typename call_traits::param_type c_, - typename call_traits::param_type d_, - typename call_traits::param_type e_, - typename call_traits::param_type f_ - ): a(a_), b(b_), c(c_), d(d_), e(e_), - f(f_) {} - - template - tuple(TupleT const& init) - : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), - c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), - e(init[tuple_index<4>()]), f(init[tuple_index<5>()]) - { BOOST_STATIC_ASSERT(TupleT::length == length); } - - A a; B b; C c; D d; E e; - F f; -}; - -#if PHOENIX_LIMIT > 6 -/////////////////////////////////////////////////////////////////////////////// -// -// tuple <7 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G> -struct tuple 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif - nil_t // Unused -> -: public tuple_base > { - - BOOST_STATIC_CONSTANT(int, length = 7); - typedef A a_type; typedef B b_type; - typedef C c_type; typedef D d_type; - typedef E e_type; typedef F f_type; - typedef G g_type; - - tuple() {} - - tuple( - typename call_traits::param_type a_, - typename call_traits::param_type b_, - typename call_traits::param_type c_, - typename call_traits::param_type d_, - typename call_traits::param_type e_, - typename call_traits::param_type f_, - typename call_traits::param_type g_ - ): a(a_), b(b_), c(c_), d(d_), e(e_), - f(f_), g(g_) {} - - template - tuple(TupleT const& init) - : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), - c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), - e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), - g(init[tuple_index<6>()]) - { BOOST_STATIC_ASSERT(TupleT::length == length); } - - A a; B b; C c; D d; E e; - F f; G g; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// tuple <8 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H> -struct tuple 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif - nil_t // Unused -> -: public tuple_base > { - - BOOST_STATIC_CONSTANT(int, length = 8); - typedef A a_type; typedef B b_type; - typedef C c_type; typedef D d_type; - typedef E e_type; typedef F f_type; - typedef G g_type; typedef H h_type; - - tuple() {} - - tuple( - typename call_traits::param_type a_, - typename call_traits::param_type b_, - typename call_traits::param_type c_, - typename call_traits::param_type d_, - typename call_traits::param_type e_, - typename call_traits::param_type f_, - typename call_traits::param_type g_, - typename call_traits::param_type h_ - ): a(a_), b(b_), c(c_), d(d_), e(e_), - f(f_), g(g_), h(h_) {} - - template - tuple(TupleT const& init) - : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), - c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), - e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), - g(init[tuple_index<6>()]), h(init[tuple_index<7>()]) - { BOOST_STATIC_ASSERT(TupleT::length == length); } - - A a; B b; C c; D d; E e; - F f; G g; H h; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// tuple <9 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I> -struct tuple 9 - nil_t, nil_t, nil_t, -#if PHOENIX_LIMIT > 12 - nil_t, nil_t, nil_t, -#endif -#endif - nil_t // Unused -> -: public tuple_base > { - - BOOST_STATIC_CONSTANT(int, length = 9); - typedef A a_type; typedef B b_type; - typedef C c_type; typedef D d_type; - typedef E e_type; typedef F f_type; - typedef G g_type; typedef H h_type; - typedef I i_type; - - tuple() {} - - tuple( - typename call_traits::param_type a_, - typename call_traits::param_type b_, - typename call_traits::param_type c_, - typename call_traits::param_type d_, - typename call_traits::param_type e_, - typename call_traits::param_type f_, - typename call_traits::param_type g_, - typename call_traits::param_type h_, - typename call_traits::param_type i_ - ): a(a_), b(b_), c(c_), d(d_), e(e_), - f(f_), g(g_), h(h_), i(i_) {} - - template - tuple(TupleT const& init) - : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), - c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), - e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), - g(init[tuple_index<6>()]), h(init[tuple_index<7>()]), - i(init[tuple_index<8>()]) - { BOOST_STATIC_ASSERT(TupleT::length == length); } - - A a; B b; C c; D d; E e; - F f; G g; H h; I i; -}; - -#if PHOENIX_LIMIT > 9 -/////////////////////////////////////////////////////////////////////////////// -// -// tuple <10 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J> -struct tuple 12 - nil_t, nil_t, nil_t, -#endif - nil_t // Unused -> -: public tuple_base > { - - BOOST_STATIC_CONSTANT(int, length = 10); - typedef A a_type; typedef B b_type; - typedef C c_type; typedef D d_type; - typedef E e_type; typedef F f_type; - typedef G g_type; typedef H h_type; - typedef I i_type; typedef J j_type; - - tuple() {} - - tuple( - typename call_traits::param_type a_, - typename call_traits::param_type b_, - typename call_traits::param_type c_, - typename call_traits::param_type d_, - typename call_traits::param_type e_, - typename call_traits::param_type f_, - typename call_traits::param_type g_, - typename call_traits::param_type h_, - typename call_traits::param_type i_, - typename call_traits::param_type j_ - ): a(a_), b(b_), c(c_), d(d_), e(e_), - f(f_), g(g_), h(h_), i(i_), j(j_) {} - - template - tuple(TupleT const& init) - : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), - c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), - e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), - g(init[tuple_index<6>()]), h(init[tuple_index<7>()]), - i(init[tuple_index<8>()]), j(init[tuple_index<9>()]) - { BOOST_STATIC_ASSERT(TupleT::length == length); } - - A a; B b; C c; D d; E e; - F f; G g; H h; I i; J j; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// tuple <11 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K> -struct tuple 12 - nil_t, nil_t, nil_t, -#endif - nil_t // Unused -> -: public tuple_base > { - - BOOST_STATIC_CONSTANT(int, length = 11); - typedef A a_type; typedef B b_type; - typedef C c_type; typedef D d_type; - typedef E e_type; typedef F f_type; - typedef G g_type; typedef H h_type; - typedef I i_type; typedef J j_type; - typedef K k_type; - - tuple() {} - - tuple( - typename call_traits::param_type a_, - typename call_traits::param_type b_, - typename call_traits::param_type c_, - typename call_traits::param_type d_, - typename call_traits::param_type e_, - typename call_traits::param_type f_, - typename call_traits::param_type g_, - typename call_traits::param_type h_, - typename call_traits::param_type i_, - typename call_traits::param_type j_, - typename call_traits::param_type k_ - ): a(a_), b(b_), c(c_), d(d_), e(e_), - f(f_), g(g_), h(h_), i(i_), j(j_), - k(k_) {} - - template - tuple(TupleT const& init) - : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), - c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), - e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), - g(init[tuple_index<6>()]), h(init[tuple_index<7>()]), - i(init[tuple_index<8>()]), j(init[tuple_index<9>()]), - k(init[tuple_index<10>()]) - { BOOST_STATIC_ASSERT(TupleT::length == length); } - - A a; B b; C c; D d; E e; - F f; G g; H h; I i; J j; - K k; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// tuple <12 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L> -struct tuple 12 - nil_t, nil_t, nil_t, -#endif - nil_t // Unused -> -: public tuple_base > { - - BOOST_STATIC_CONSTANT(int, length = 12); - typedef A a_type; typedef B b_type; - typedef C c_type; typedef D d_type; - typedef E e_type; typedef F f_type; - typedef G g_type; typedef H h_type; - typedef I i_type; typedef J j_type; - typedef K k_type; typedef L l_type; - - tuple() {} - - tuple( - typename call_traits::param_type a_, - typename call_traits::param_type b_, - typename call_traits::param_type c_, - typename call_traits::param_type d_, - typename call_traits::param_type e_, - typename call_traits::param_type f_, - typename call_traits::param_type g_, - typename call_traits::param_type h_, - typename call_traits::param_type i_, - typename call_traits::param_type j_, - typename call_traits::param_type k_, - typename call_traits::param_type l_ - ): a(a_), b(b_), c(c_), d(d_), e(e_), - f(f_), g(g_), h(h_), i(i_), j(j_), - k(k_), l(l_) {} - - template - tuple(TupleT const& init) - : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), - c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), - e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), - g(init[tuple_index<6>()]), h(init[tuple_index<7>()]), - i(init[tuple_index<8>()]), j(init[tuple_index<9>()]), - k(init[tuple_index<10>()]), l(init[tuple_index<11>()]) - { BOOST_STATIC_ASSERT(TupleT::length == length); } - - A a; B b; C c; D d; E e; - F f; G g; H h; I i; J j; - K k; L l; -}; - -#if PHOENIX_LIMIT > 12 -/////////////////////////////////////////////////////////////////////////////// -// -// tuple <13 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M> -struct tuple -: public tuple_base< - tuple > { - - BOOST_STATIC_CONSTANT(int, length = 13); - typedef A a_type; typedef B b_type; - typedef C c_type; typedef D d_type; - typedef E e_type; typedef F f_type; - typedef G g_type; typedef H h_type; - typedef I i_type; typedef J j_type; - typedef K k_type; typedef L l_type; - typedef M m_type; - - tuple() {} - - tuple( - typename call_traits::param_type a_, - typename call_traits::param_type b_, - typename call_traits::param_type c_, - typename call_traits::param_type d_, - typename call_traits::param_type e_, - typename call_traits::param_type f_, - typename call_traits::param_type g_, - typename call_traits::param_type h_, - typename call_traits::param_type i_, - typename call_traits::param_type j_, - typename call_traits::param_type k_, - typename call_traits::param_type l_, - typename call_traits::param_type m_ - ): a(a_), b(b_), c(c_), d(d_), e(e_), - f(f_), g(g_), h(h_), i(i_), j(j_), - k(k_), l(l_), m(m_) {} - - template - tuple(TupleT const& init) - : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), - c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), - e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), - g(init[tuple_index<6>()]), h(init[tuple_index<7>()]), - i(init[tuple_index<8>()]), j(init[tuple_index<9>()]), - k(init[tuple_index<10>()]), l(init[tuple_index<11>()]), - m(init[tuple_index<12>()]) - { BOOST_STATIC_ASSERT(TupleT::length == length); } - - A a; B b; C c; D d; E e; - F f; G g; H h; I i; J j; - K k; L l; M m; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// tuple <14 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M, typename N> -struct tuple -: public tuple_base< - tuple > { - - BOOST_STATIC_CONSTANT(int, length = 14); - typedef A a_type; typedef B b_type; - typedef C c_type; typedef D d_type; - typedef E e_type; typedef F f_type; - typedef G g_type; typedef H h_type; - typedef I i_type; typedef J j_type; - typedef K k_type; typedef L l_type; - typedef M m_type; typedef N n_type; - - tuple() {} - - tuple( - typename call_traits::param_type a_, - typename call_traits::param_type b_, - typename call_traits::param_type c_, - typename call_traits::param_type d_, - typename call_traits::param_type e_, - typename call_traits::param_type f_, - typename call_traits::param_type g_, - typename call_traits::param_type h_, - typename call_traits::param_type i_, - typename call_traits::param_type j_, - typename call_traits::param_type k_, - typename call_traits::param_type l_, - typename call_traits::param_type m_, - typename call_traits::param_type n_ - ): a(a_), b(b_), c(c_), d(d_), e(e_), - f(f_), g(g_), h(h_), i(i_), j(j_), - k(k_), l(l_), m(m_), n(n_) {} - - template - tuple(TupleT const& init) - : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), - c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), - e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), - g(init[tuple_index<6>()]), h(init[tuple_index<7>()]), - i(init[tuple_index<8>()]), j(init[tuple_index<9>()]), - k(init[tuple_index<10>()]), l(init[tuple_index<11>()]), - m(init[tuple_index<12>()]), n(init[tuple_index<13>()]) - { BOOST_STATIC_ASSERT(TupleT::length == length); } - - A a; B b; C c; D d; E e; - F f; G g; H h; I i; J j; - K k; L l; M m; N n; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// tuple <15 member> class -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename A, typename B, typename C, typename D, typename E, - typename F, typename G, typename H, typename I, typename J, - typename K, typename L, typename M, typename N, typename O> -struct tuple -: public tuple_base< - tuple > { - - BOOST_STATIC_CONSTANT(int, length = 15); - typedef A a_type; typedef B b_type; - typedef C c_type; typedef D d_type; - typedef E e_type; typedef F f_type; - typedef G g_type; typedef H h_type; - typedef I i_type; typedef J j_type; - typedef K k_type; typedef L l_type; - typedef M m_type; typedef N n_type; - typedef O o_type; - - tuple() {} - - tuple( - typename call_traits::param_type a_, - typename call_traits::param_type b_, - typename call_traits::param_type c_, - typename call_traits::param_type d_, - typename call_traits::param_type e_, - typename call_traits::param_type f_, - typename call_traits::param_type g_, - typename call_traits::param_type h_, - typename call_traits::param_type i_, - typename call_traits::param_type j_, - typename call_traits::param_type k_, - typename call_traits::param_type l_, - typename call_traits::param_type m_, - typename call_traits::param_type n_, - typename call_traits::param_type o_ - ): a(a_), b(b_), c(c_), d(d_), e(e_), - f(f_), g(g_), h(h_), i(i_), j(j_), - k(k_), l(l_), m(m_), n(n_), o(o_) {} - - template - tuple(TupleT const& init) - : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), - c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), - e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), - g(init[tuple_index<6>()]), h(init[tuple_index<7>()]), - i(init[tuple_index<8>()]), j(init[tuple_index<9>()]), - k(init[tuple_index<10>()]), l(init[tuple_index<11>()]), - m(init[tuple_index<12>()]), n(init[tuple_index<13>()]), - o(init[tuple_index<14>()]) - { BOOST_STATIC_ASSERT(TupleT::length == length); } - - A a; B b; C c; D d; E e; - F f; G g; H h; I i; J j; - K k; L l; M m; N n; O o; -}; - -#endif -#endif -#endif -#endif - -/////////////////////////////////////////////////////////////////////////////// -} // namespace phoenix - -#endif diff --git a/boost/boost/spirit/symbols.hpp b/boost/boost/spirit/symbols.hpp deleted file mode 100644 index 24d913acff..0000000000 --- a/boost/boost/spirit/symbols.hpp +++ /dev/null @@ -1,22 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_SYMBOLS_MAIN_HPP) -#define BOOST_SPIRIT_SYMBOLS_MAIN_HPP - -#include - -/////////////////////////////////////////////////////////////////////////////// -// -// Master header for Spirit.Symbols -// -/////////////////////////////////////////////////////////////////////////////// - -#include - -#endif // !defined(BOOST_SPIRIT_SYMBOLS_MAIN_HPP) diff --git a/boost/boost/spirit/symbols/impl/symbols.ipp b/boost/boost/spirit/symbols/impl/symbols.ipp deleted file mode 100644 index bc8c0e74cd..0000000000 --- a/boost/boost/spirit/symbols/impl/symbols.ipp +++ /dev/null @@ -1,114 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_SYMBOLS_IPP -#define BOOST_SPIRIT_SYMBOLS_IPP - -/////////////////////////////////////////////////////////////////////////////// -#include -#include - -// MSVC: void warning about the use of 'this' pointer in constructors -#if defined(BOOST_MSVC) -#pragma warning(push) -#pragma warning(disable : 4355) -#endif - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -/////////////////////////////////////////////////////////////////////////////// -// -// symbols class implementation -// -/////////////////////////////////////////////////////////////////////////////// -template -inline symbols::symbols() -: SetT() -, add(*this) -{ -} - -////////////////////////////////// -template -symbols::symbols(symbols const& other) -: SetT(other) -// Tru64 CXX seems to be confused by the explicit call of the default -// constructor and generates wrong code which invalidates the just contructed -// first base class in the line above. -#if !BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590041)) -, parser >() -#endif -, add(*this) -{ -} - -////////////////////////////////// -template -inline symbols::~symbols() -{} - -////////////////////////////////// -template -inline symbols& -symbols::operator=(symbols const& other) -{ - SetT::operator=(other); - return *this; -} - -////////////////////////////////// -template -inline symbol_inserter const& -symbols::operator=(CharT const* str) -{ - return add, str; -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Symbol table utilities -// -/////////////////////////////////////////////////////////////////////////////// -template -inline T* -find(symbols const& table, CharT const* sym) -{ - CharT const* last = sym; - while (*last) - last++; - scanner scan(sym, last); - T* result = table.find(scan); - return scan.at_end()? result: 0; -} - -////////////////////////////////// -template -inline T* -add(symbols& table, CharT const* sym, T const& data) -{ - CharT const* first = sym; - CharT const* last = sym; - while (*last) - last++; - scanner scan(first, last); - if (table.find(scan) && scan.at_end()) - return 0; // symbol already contained in symbol table - table.add(sym, last, data); - first = sym; - return table.find(scan); // refind the inserted symbol -} - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#if defined(BOOST_MSVC) -#pragma warning(pop) -#endif - -#endif diff --git a/boost/boost/spirit/symbols/impl/tst.ipp b/boost/boost/spirit/symbols/impl/tst.ipp deleted file mode 100644 index 47169cf877..0000000000 --- a/boost/boost/spirit/symbols/impl/tst.ipp +++ /dev/null @@ -1,277 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_TST_IPP -#define BOOST_SPIRIT_TST_IPP - -/////////////////////////////////////////////////////////////////////////////// -#include // for std::auto_ptr -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - - namespace impl - { - -/////////////////////////////////////////////////////////////////////////////// -// -// tst class -// -// Ternary Search Tree implementation. The data structure is faster than -// hashing for many typical search problems especially when the search -// interface is iterator based. Searching for a string of length k in a -// ternary search tree with n strings will require at most O(log n+k) -// character comparisons. TSTs are many times faster than hash tables -// for unsuccessful searches since mismatches are discovered earlier -// after examining only a few characters. Hash tables always examine an -// entire key when searching. -// -// For details see http://www.cs.princeton.edu/~rs/strings/. -// -// *** This is a low level class and is -// not meant for public consumption *** -// -/////////////////////////////////////////////////////////////////////////////// - template - struct tst_node - { - tst_node(CharT value_) - : value(value_) - , left(0) - , right(0) - { middle.link = 0; } - - ~tst_node() - { - delete left; - delete right; - if (value) - delete middle.link; - else - delete middle.data; - } - - tst_node* - clone() const - { - std::auto_ptr copy(new tst_node(value)); - - if (left) - copy->left = left->clone(); - if (right) - copy->right = right->clone(); - - if (value && middle.link) - { - copy->middle.link = middle.link->clone(); - } - else - { - std::auto_ptr mid_data(new T(*middle.data)); - copy->middle.data = mid_data.release(); - } - - return copy.release(); - } - - union center { - - tst_node* link; - T* data; - }; - - CharT value; - tst_node* left; - center middle; - tst_node* right; - }; - - /////////////////////////////////////////////////////////////////////////// - template - class tst - { - public: - - struct search_info - { - T* data; - std::size_t length; - }; - - tst() - : root(0) {} - - tst(tst const& other) - : root(other.root ? other.root->clone() : 0) {} - - ~tst() - { delete root; } - - tst& - operator=(tst const& other) - { - if (this != &other) - { - node_t* new_root = other.root ? other.root->clone() : 0; - delete root; - root = new_root; - } - return *this; - } - - template - T* add(IteratorT first, IteratorT const& last, T const& data) - { - if (first == last) - return 0; - - node_t** np = &root; - CharT ch = *first; - - BOOST_SPIRIT_ASSERT(first == last || ch != 0 - && "Won't add string containing null character"); - - for (;;) - { - if (*np == 0 || ch == 0) - { - node_t* right = 0; - if (np != 0) - right = *np; - *np = new node_t(ch); - if (right) - (**np).right = right; - } - - if (ch < (**np).value) - { - np = &(**np).left; - } - else - { - if (ch == (**np).value) - { - if (ch == 0) - { - if ((**np).middle.data == 0) - { - (**np).middle.data = new T(data); - return (**np).middle.data; - } - else - { - // re-addition is disallowed - return 0; - } - } - ++first; - ch = (first == last) ? CharT(0) : *first; - BOOST_SPIRIT_ASSERT(first == last || ch != 0 - && "Won't add string containing null character"); - np = &(**np).middle.link; - } - else - { - np = &(**np).right; - } - } - } - } - - template - search_info find(ScannerT const& scan) const - { - search_info result = { 0, 0 }; - if (scan.at_end()) { - return result; - } - - typedef typename ScannerT::iterator_t iterator_t; - node_t* np = root; - CharT ch = *scan; - iterator_t save = scan.first; - iterator_t latest = scan.first; - std::size_t latest_len = 0; - - while (np) - { - - if (ch < np->value) // => go left! - { - if (np->value == 0) - { - result.data = np->middle.data; - if (result.data) - { - latest = scan.first; - latest_len = result.length; - } - } - - np = np->left; - } - else if (ch == np->value) // => go middle! - { - // Matching the null character is not allowed. - if (np->value == 0) - { - result.data = np->middle.data; - if (result.data) - { - latest = scan.first; - latest_len = result.length; - } - break; - } - - ++scan; - ch = scan.at_end() ? CharT(0) : *scan; - np = np->middle.link; - ++result.length; - } - else // (ch > np->value) => go right! - { - if (np->value == 0) - { - result.data = np->middle.data; - if (result.data) - { - latest = scan.first; - latest_len = result.length; - } - } - - np = np->right; - } - } - - if (result.data == 0) - { - scan.first = save; - } - else - { - scan.first = latest; - result.length = latest_len; - } - return result; - } - - private: - - typedef tst_node node_t; - node_t* root; - }; - -/////////////////////////////////////////////////////////////////////////////// - } // namespace impl - -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/symbols/symbols.hpp b/boost/boost/spirit/symbols/symbols.hpp deleted file mode 100644 index 4f6d2ab1a8..0000000000 --- a/boost/boost/spirit/symbols/symbols.hpp +++ /dev/null @@ -1,225 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_SYMBOLS_HPP -#define BOOST_SPIRIT_SYMBOLS_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include - -#include - -#include -#include - -#include - - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -/////////////////////////////////////////////////////////////////////////////// -// -// symbols class -// -// This class implements a symbol table. The symbol table holds a -// dictionary of symbols where each symbol is a sequence of CharTs. -// The template class can work efficiently with 8, 16 and 32 bit -// characters. Mutable data of type T is associated with each -// symbol. -// -// The class is a parser. The parse member function returns -// additional information in the symbol_match class (see below). -// The additional data is a pointer to some data associated with -// the matching symbol. -// -// The actual set implementation is supplied by the SetT template -// parameter. By default, this uses the tst class (see tst.ipp). -// -// Symbols are added into the symbol table statically using the -// construct: -// -// sym = a, b, c, d ...; -// -// where sym is a symbol table and a..d are strings. Example: -// -// sym = "pineapple", "orange", "banana", "apple"; -// -// Alternatively, symbols may be added dynamically through the -// member functor 'add' (see symbol_inserter below). The member -// functor 'add' may be attached to a parser as a semantic action -// taking in a begin/end pair: -// -// p[sym.add] -// -// where p is a parser (and sym is a symbol table). On success, -// the matching portion of the input is added to the symbol table. -// -// 'add' may also be used to directly initialize data. Examples: -// -// sym.add("hello", 1)("crazy", 2)("world", 3); -// -/////////////////////////////////////////////////////////////////////////////// -template -class symbols -: private SetT -, public parser > -{ -public: - - typedef parser > parser_base_t; - typedef symbols self_t; - typedef self_t const& embed_t; - typedef T symbol_data_t; - typedef boost::reference_wrapper symbol_ref_t; - - symbols(); - symbols(symbols const& other); - ~symbols(); - - symbols& - operator=(symbols const& other); - - symbol_inserter const& - operator=(CharT const* str); - - template - struct result - { - typedef typename match_result::type type; - }; - - template - typename parser_result::type - parse_main(ScannerT const& scan) const - { - typedef typename ScannerT::iterator_t iterator_t; - iterator_t first = scan.first; - typename SetT::search_info result = SetT::find(scan); - - if (result.data) - return scan. - create_match( - result.length, - symbol_ref_t(*result.data), - first, - scan.first); - else - return scan.no_match(); - } - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - return impl::implicit_lexeme_parse - (*this, scan, scan); - } - - template < typename ScannerT > - T* find(ScannerT const& scan) const - { return SetT::find(scan).data; } - - symbol_inserter const add; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// Symbol table utilities -// -// add -// -// adds a symbol 'sym' (string) to a symbol table 'table' plus an -// optional data 'data' associated with the symbol. Returns a pointer to -// the data associated with the symbol or NULL if add failed (e.g. when -// the symbol is already added before). -// -// find -// -// finds a symbol 'sym' (string) from a symbol table 'table'. Returns a -// pointer to the data associated with the symbol or NULL if not found -// -/////////////////////////////////////////////////////////////////////////////// -template -T* add(symbols& table, CharT const* sym, T const& data = T()); - -template -T* find(symbols const& table, CharT const* sym); - -/////////////////////////////////////////////////////////////////////////////// -// -// symbol_inserter class -// -// The symbols class holds an instance of this class named 'add'. -// This can be called directly just like a member function, -// passing in a first/last iterator and optional data: -// -// sym.add(first, last, data); -// -// Or, passing in a C string and optional data: -// -// sym.add(c_string, data); -// -// where sym is a symbol table. The 'data' argument is optional. -// This may also be used as a semantic action since it conforms -// to the action interface (see action.hpp): -// -// p[sym.add] -// -/////////////////////////////////////////////////////////////////////////////// -template -class symbol_inserter -{ -public: - - symbol_inserter(SetT& set_) - : set(set_) {} - - typedef symbol_inserter const & result_type; - - template - symbol_inserter const& - operator()(IteratorT first, IteratorT const& last, T const& data = T()) const - { - set.add(first, last, data); - return *this; - } - - template - symbol_inserter const& - operator()(CharT const* str, T const& data = T()) const - { - CharT const* last = str; - while (*last) - last++; - set.add(str, last, data); - return *this; - } - - template - symbol_inserter const& - operator,(CharT const* str) const - { - CharT const* last = str; - while (*last) - last++; - set.add(str, last, T()); - return *this; - } - -private: - - SetT& set; -}; - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#include -#endif diff --git a/boost/boost/spirit/utility.hpp b/boost/boost/spirit/utility.hpp deleted file mode 100644 index 6fdf7ba835..0000000000 --- a/boost/boost/spirit/utility.hpp +++ /dev/null @@ -1,41 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2001-2003 Daniel Nuffer - Copyright (c) 2001-2003 Hartmut Kaiser - Copyright (c) 2002-2003 Martin Wille - Copyright (c) 2002 Juan Carlos Arevalo-Baeza - Copyright (c) 2002 Raghavendra Satish - Copyright (c) 2002 Jeff Westfahl - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_UTILITY_MAIN_HPP) -#define BOOST_SPIRIT_UTILITY_MAIN_HPP - -#include - -/////////////////////////////////////////////////////////////////////////////// -// -// Master header for Spirit.Utilities -// -/////////////////////////////////////////////////////////////////////////////// - -// Utility.Parsers -#include -#include -#include -#include -#include -#include -#include -#include - -// Utility.Support -#include -#include - - -#endif // !defined(BOOST_SPIRIT_UTILITY_MAIN_HPP) diff --git a/boost/boost/spirit/utility/chset.hpp b/boost/boost/spirit/utility/chset.hpp deleted file mode 100644 index 4273d1ce24..0000000000 --- a/boost/boost/spirit/utility/chset.hpp +++ /dev/null @@ -1,183 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - Copyright (c) 2001-2003 Daniel Nuffer - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_CHSET_HPP -#define BOOST_SPIRIT_CHSET_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -namespace utility { namespace impl { - - // This is here because some compilers choke on out-of-line member - // template functions. And we don't want to put the whole algorithm - // in the chset constructor in the class definition. - template - void construct_chset(boost::shared_ptr >& ptr, - CharT2 const* definition); - -}} // namespace utility::impl - -/////////////////////////////////////////////////////////////////////////////// -// -// chset class -// -/////////////////////////////////////////////////////////////////////////////// -template -class chset: public char_parser > { - -public: - chset(); - chset(chset const& arg_); - explicit chset(CharT arg_); - explicit chset(anychar_parser arg_); - explicit chset(nothing_parser arg_); - explicit chset(chlit const& arg_); - explicit chset(range const& arg_); - explicit chset(negated_char_parser > const& arg_); - explicit chset(negated_char_parser > const& arg_); - - template - explicit chset(CharT2 const* definition) - : ptr(new basic_chset()) - { - utility::impl::construct_chset(ptr, definition); - } - ~chset(); - - chset& operator=(chset const& rhs); - chset& operator=(CharT rhs); - chset& operator=(anychar_parser rhs); - chset& operator=(nothing_parser rhs); - chset& operator=(chlit const& rhs); - chset& operator=(range const& rhs); - chset& operator=(negated_char_parser > const& rhs); - chset& operator=(negated_char_parser > const& rhs); - - void set(range const& arg_); - void set(negated_char_parser > const& arg_); - void set(negated_char_parser > const& arg_); - - void clear(range const& arg_); - void clear(negated_char_parser > const& arg_); - bool test(CharT ch) const; - chset& inverse(); - void swap(chset& x); - - chset& operator|=(chset const& x); - chset& operator&=(chset const& x); - chset& operator-=(chset const& x); - chset& operator^=(chset const& x); - -private: - - boost::shared_ptr > ptr; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// Generator functions -// -/////////////////////////////////////////////////////////////////////////////// -template -inline chset -chset_p(chlit const& arg_) -{ return chset(arg_); } - -////////////////////////////////// -template -inline chset -chset_p(range const& arg_) -{ return chset(arg_); } - -template -inline chset -chset_p(negated_char_parser > const& arg_) -{ return chset(arg_); } - -template -inline chset -chset_p(negated_char_parser > const& arg_) -{ return chset(arg_); } - -////////////////////////////////// -inline chset -chset_p(char const* init) -{ return chset(init); } - -////////////////////////////////// -inline chset -chset_p(wchar_t const* init) -{ return chset(init); } - -////////////////////////////////// -inline chset -chset_p(char ch) -{ return chset(ch); } - -////////////////////////////////// -inline chset -chset_p(wchar_t ch) -{ return chset(ch); } - -////////////////////////////////// -inline chset -chset_p(int ch) -{ return chset(ch); } - -////////////////////////////////// -inline chset -chset_p(unsigned int ch) -{ return chset(ch); } - -////////////////////////////////// -inline chset -chset_p(short ch) -{ return chset(ch); } - -#if !defined(BOOST_NO_INTRINSIC_WCHAR_T) -////////////////////////////////// -inline chset -chset_p(unsigned short ch) -{ return chset(ch); } -#endif -////////////////////////////////// -inline chset -chset_p(long ch) -{ return chset(ch); } - -////////////////////////////////// -inline chset -chset_p(unsigned long ch) -{ return chset(ch); } - -#ifdef BOOST_HAS_LONG_LONG -////////////////////////////////// -inline chset< ::boost::long_long_type> -chset_p( ::boost::long_long_type ch) -{ return chset< ::boost::long_long_type>(ch); } - -////////////////////////////////// -inline chset< ::boost::ulong_long_type> -chset_p( ::boost::ulong_long_type ch) -{ return chset< ::boost::ulong_long_type>(ch); } -#endif - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#endif - -#include -#include diff --git a/boost/boost/spirit/utility/chset_operators.hpp b/boost/boost/spirit/utility/chset_operators.hpp deleted file mode 100644 index e1446ff5f7..0000000000 --- a/boost/boost/spirit/utility/chset_operators.hpp +++ /dev/null @@ -1,398 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - Copyright (c) 2001-2003 Daniel Nuffer - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_CHSET_OPERATORS_HPP -#define BOOST_SPIRIT_CHSET_OPERATORS_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -/////////////////////////////////////////////////////////////////////////////// -// -// chset free operators -// -// Where a and b are both chsets, implements: -// -// a | b, a & b, a - b, a ^ b -// -// Where a is a chset, implements: -// -// ~a -// -/////////////////////////////////////////////////////////////////////////////// -template -chset -operator~(chset const& a); - -////////////////////////////////// -template -chset -operator|(chset const& a, chset const& b); - -////////////////////////////////// -template -chset -operator&(chset const& a, chset const& b); - -////////////////////////////////// -template -chset -operator-(chset const& a, chset const& b); - -////////////////////////////////// -template -chset -operator^(chset const& a, chset const& b); - -/////////////////////////////////////////////////////////////////////////////// -// -// range <--> chset free operators -// -// Where a is a chset and b is a range, and vice-versa, implements: -// -// a | b, a & b, a - b, a ^ b -// -/////////////////////////////////////////////////////////////////////////////// -template -chset -operator|(chset const& a, range const& b); - -////////////////////////////////// -template -chset -operator&(chset const& a, range const& b); - -////////////////////////////////// -template -chset -operator-(chset const& a, range const& b); - -////////////////////////////////// -template -chset -operator^(chset const& a, range const& b); - -////////////////////////////////// -template -chset -operator|(range const& a, chset const& b); - -////////////////////////////////// -template -chset -operator&(range const& a, chset const& b); - -////////////////////////////////// -template -chset -operator-(range const& a, chset const& b); - -////////////////////////////////// -template -chset -operator^(range const& a, chset const& b); - -/////////////////////////////////////////////////////////////////////////////// -// -// chlit <--> chset free operators -// -// Where a is a chset and b is a chlit, and vice-versa, implements: -// -// a | b, a & b, a - b, a ^ b -// -/////////////////////////////////////////////////////////////////////////////// -template -chset -operator|(chset const& a, chlit const& b); - -////////////////////////////////// -template -chset -operator&(chset const& a, chlit const& b); - -////////////////////////////////// -template -chset -operator-(chset const& a, chlit const& b); - -////////////////////////////////// -template -chset -operator^(chset const& a, chlit const& b); - -////////////////////////////////// -template -chset -operator|(chlit const& a, chset const& b); - -////////////////////////////////// -template -chset -operator&(chlit const& a, chset const& b); - -////////////////////////////////// -template -chset -operator-(chlit const& a, chset const& b); - -////////////////////////////////// -template -chset -operator^(chlit const& a, chset const& b); - -/////////////////////////////////////////////////////////////////////////////// -// -// negated_char_parser <--> chset free operators -// -// Where a is a chset and b is a range, and vice-versa, implements: -// -// a | b, a & b, a - b, a ^ b -// -/////////////////////////////////////////////////////////////////////////////// -template -chset -operator|(chset const& a, negated_char_parser > const& b); - -////////////////////////////////// -template -chset -operator&(chset const& a, negated_char_parser > const& b); - -////////////////////////////////// -template -chset -operator-(chset const& a, negated_char_parser > const& b); - -////////////////////////////////// -template -chset -operator^(chset const& a, negated_char_parser > const& b); - -////////////////////////////////// -template -chset -operator|(negated_char_parser > const& a, chset const& b); - -////////////////////////////////// -template -chset -operator&(negated_char_parser > const& a, chset const& b); - -////////////////////////////////// -template -chset -operator-(negated_char_parser > const& a, chset const& b); - -////////////////////////////////// -template -chset -operator^(negated_char_parser > const& a, chset const& b); - -/////////////////////////////////////////////////////////////////////////////// -// -// negated_char_parser <--> chset free operators -// -// Where a is a chset and b is a chlit, and vice-versa, implements: -// -// a | b, a & b, a - b, a ^ b -// -/////////////////////////////////////////////////////////////////////////////// -template -chset -operator|(chset const& a, negated_char_parser > const& b); - -////////////////////////////////// -template -chset -operator&(chset const& a, negated_char_parser > const& b); - -////////////////////////////////// -template -chset -operator-(chset const& a, negated_char_parser > const& b); - -////////////////////////////////// -template -chset -operator^(chset const& a, negated_char_parser > const& b); - -////////////////////////////////// -template -chset -operator|(negated_char_parser > const& a, chset const& b); - -////////////////////////////////// -template -chset -operator&(negated_char_parser > const& a, chset const& b); - -////////////////////////////////// -template -chset -operator-(negated_char_parser > const& a, chset const& b); - -////////////////////////////////// -template -chset -operator^(negated_char_parser > const& a, chset const& b); - -/////////////////////////////////////////////////////////////////////////////// -// -// literal primitives <--> chset free operators -// -// Where a is a chset and b is a literal primitive, -// and vice-versa, implements: -// -// a | b, a & b, a - b, a ^ b -// -/////////////////////////////////////////////////////////////////////////////// -template -chset -operator|(chset const& a, CharT b); - -////////////////////////////////// -template -chset -operator&(chset const& a, CharT b); - -////////////////////////////////// -template -chset -operator-(chset const& a, CharT b); - -////////////////////////////////// -template -chset -operator^(chset const& a, CharT b); - -////////////////////////////////// -template -chset -operator|(CharT a, chset const& b); - -////////////////////////////////// -template -chset -operator&(CharT a, chset const& b); - -////////////////////////////////// -template -chset -operator-(CharT a, chset const& b); - -////////////////////////////////// -template -chset -operator^(CharT a, chset const& b); - -/////////////////////////////////////////////////////////////////////////////// -// -// anychar_parser <--> chset free operators -// -// Where a is chset and b is a anychar_parser, and vice-versa, implements: -// -// a | b, a & b, a - b, a ^ b -// -/////////////////////////////////////////////////////////////////////////////// -template -chset -operator|(chset const& a, anychar_parser b); - -////////////////////////////////// -template -chset -operator&(chset const& a, anychar_parser b); - -////////////////////////////////// -template -chset -operator-(chset const& a, anychar_parser b); - -////////////////////////////////// -template -chset -operator^(chset const& a, anychar_parser b); - -////////////////////////////////// -template -chset -operator|(anychar_parser a, chset const& b); - -////////////////////////////////// -template -chset -operator&(anychar_parser a, chset const& b); - -////////////////////////////////// -template -chset -operator-(anychar_parser a, chset const& b); - -////////////////////////////////// -template -chset -operator^(anychar_parser a, chset const& b); - -/////////////////////////////////////////////////////////////////////////////// -// -// nothing_parser <--> chset free operators -// -// Where a is chset and b is nothing_parser, and vice-versa, implements: -// -// a | b, a & b, a - b, a ^ b -// -/////////////////////////////////////////////////////////////////////////////// -template -chset -operator|(chset const& a, nothing_parser b); - -////////////////////////////////// -template -chset -operator&(chset const& a, nothing_parser b); - -////////////////////////////////// -template -chset -operator-(chset const& a, nothing_parser b); - -////////////////////////////////// -template -chset -operator^(chset const& a, nothing_parser b); - -////////////////////////////////// -template -chset -operator|(nothing_parser a, chset const& b); - -////////////////////////////////// -template -chset -operator&(nothing_parser a, chset const& b); - -////////////////////////////////// -template -chset -operator-(nothing_parser a, chset const& b); - -////////////////////////////////// -template -chset -operator^(nothing_parser a, chset const& b); - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#endif - -#include diff --git a/boost/boost/spirit/utility/confix.hpp b/boost/boost/spirit/utility/confix.hpp deleted file mode 100644 index b15f88f180..0000000000 --- a/boost/boost/spirit/utility/confix.hpp +++ /dev/null @@ -1,392 +0,0 @@ -/*============================================================================= - Copyright (c) 2002-2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_CONFIX_HPP -#define BOOST_SPIRIT_CONFIX_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include -#include -#include - -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -/////////////////////////////////////////////////////////////////////////////// -// -// confix_parser class -// -// Parses a sequence of 3 sub-matches. This class may -// be used to parse structures, where the opening part is possibly -// contained in the expression part and the whole sequence is only -// parsed after seeing the closing part matching the first opening -// subsequence. Example: C-comments: -// -// /* This is a C-comment */ -// -/////////////////////////////////////////////////////////////////////////////// - -template -struct confix_parser_gen; - -template < - typename OpenT, typename ExprT, typename CloseT, typename CategoryT, - typename NestedT, typename LexemeT -> -struct confix_parser : - public parser< - confix_parser - > -{ - typedef - confix_parser - self_t; - - confix_parser(OpenT const &open_, ExprT const &expr_, CloseT const &close_) - : open(open_), expr(expr_), close(close_) - {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - return impl::confix_parser_type:: - parse(NestedT(), LexemeT(), *this, scan, open, expr, close); - } - -private: - - typename as_parser::type::embed_t open; - typename as_parser::type::embed_t expr; - typename as_parser::type::embed_t close; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// Confix parser generator template -// -// This is a helper for generating a correct confix_parser<> from -// auxiliary parameters. There are the following types supported as -// parameters yet: parsers, single characters and strings (see -// as_parser). -// -// If the body parser is an action_parser_category type parser (a parser -// with an attached semantic action) we have to do something special. This -// happens, if the user wrote something like: -// -// confix_p(open, body[f], close) -// -// where 'body' is the parser matching the body of the confix sequence -// and 'f' is a functor to be called after matching the body. If we would -// do nothing, the resulting code would parse the sequence as follows: -// -// start >> (body[f] - close) >> close -// -// what in most cases is not what the user expects. -// (If this _is_ what you've expected, then please use the confix_p -// generator function 'direct()', which will inhibit -// re-attaching the actor to the body parser). -// -// To make the confix parser behave as expected: -// -// start >> (body - close)[f] >> close -// -// the actor attached to the 'body' parser has to be re-attached to the -// (body - close) parser construct, which will make the resulting confix -// parser 'do the right thing'. This refactoring is done by the help of -// the refactoring parsers (see the files refactoring.[hi]pp). -// -// Additionally special care must be taken, if the body parser is a -// unary_parser_category type parser as -// -// confix_p(open, *anychar_p, close) -// -// which without any refactoring would result in -// -// start >> (*anychar_p - close) >> close -// -// and will not give the expected result (*anychar_p will eat up all the -// input up to the end of the input stream). So we have to refactor this -// into: -// -// start >> *(anychar_p - close) >> close -// -// what will give the correct result. -// -// The case, where the body parser is a combination of the two mentioned -// problems (i.e. the body parser is a unary parser with an attached -// action), is handled accordingly too: -// -// confix_p(start, (*anychar_p)[f], end) -// -// will be parsed as expected: -// -// start >> (*(anychar_p - end))[f] >> end. -// -/////////////////////////////////////////////////////////////////////////////// - -template -struct confix_parser_gen -{ - // Generic generator function for creation of concrete confix parsers - - template - struct paren_op_result_type - { - typedef confix_parser< - typename as_parser::type, - typename as_parser::type, - typename as_parser::type, - typename as_parser::type::parser_category_t, - NestedT, - LexemeT - > type; - }; - - template - typename paren_op_result_type::type - operator()(StartT const &start_, ExprT const &expr_, EndT const &end_) const - { - typedef typename paren_op_result_type::type - return_t; - - return return_t( - as_parser::convert(start_), - as_parser::convert(expr_), - as_parser::convert(end_) - ); - } - - // Generic generator function for creation of concrete confix parsers - // which have an action directly attached to the ExprT part of the - // parser (see comment above, no automatic refactoring) - - template - struct direct_result_type - { - typedef confix_parser< - typename as_parser::type, - typename as_parser::type, - typename as_parser::type, - plain_parser_category, // do not re-attach action - NestedT, - LexemeT - > type; - }; - - template - typename direct_result_type::type - direct(StartT const &start_, ExprT const &expr_, EndT const &end_) const - { - typedef typename direct_result_type::type - return_t; - - return return_t( - as_parser::convert(start_), - as_parser::convert(expr_), - as_parser::convert(end_) - ); - } -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// Predefined non_nested confix parser generators -// -/////////////////////////////////////////////////////////////////////////////// - -const confix_parser_gen confix_p = - confix_parser_gen(); - -/////////////////////////////////////////////////////////////////////////////// -// -// Comments are special types of confix parsers -// -// Comment parser generator template. This is a helper for generating a -// correct confix_parser<> from auxiliary parameters, which is able to -// parse comment constructs: (StartToken >> Comment text >> EndToken). -// -// There are the following types supported as parameters yet: parsers, -// single characters and strings (see as_parser). -// -// There are two diffenerent predefined comment parser generators -// (comment_p and comment_nest_p, see below), which may be used for -// creating special comment parsers in two different ways. -// -// If these are used with one parameter, a comment starting with the given -// first parser parameter up to the end of the line is matched. So for -// instance the following parser matches C++ style comments: -// -// comment_p("//"). -// -// If these are used with two parameters, a comment starting with the -// first parser parameter up to the second parser parameter is matched. -// For instance a C style comment parser should be constrcuted as: -// -// comment_p("/*", "*/"). -// -// Please note, that a comment is parsed implicitly as if the whole -// comment_p(...) statement were embedded into a lexeme_d[] directive. -// -/////////////////////////////////////////////////////////////////////////////// - -template -struct comment_parser_gen -{ - // Generic generator function for creation of concrete comment parsers - // from an open token. The newline parser eol_p is used as the - // closing token. - - template - struct paren_op1_result_type - { - typedef confix_parser< - typename as_parser::type, - kleene_star, - alternative, - unary_parser_category, // there is no action to re-attach - NestedT, - is_lexeme // insert implicit lexeme_d[] - > - type; - }; - - template - typename paren_op1_result_type::type - operator() (StartT const &start_) const - { - typedef typename paren_op1_result_type::type - return_t; - - return return_t( - as_parser::convert(start_), - *anychar_p, - eol_p | end_p - ); - } - - // Generic generator function for creation of concrete comment parsers - // from an open and a close tokens. - - template - struct paren_op2_result_type - { - typedef confix_parser< - typename as_parser::type, - kleene_star, - typename as_parser::type, - unary_parser_category, // there is no action to re-attach - NestedT, - is_lexeme // insert implicit lexeme_d[] - > type; - }; - - template - typename paren_op2_result_type::type - operator() (StartT const &start_, EndT const &end_) const - { - typedef typename paren_op2_result_type::type - return_t; - - return return_t( - as_parser::convert(start_), - *anychar_p, - as_parser::convert(end_) - ); - } -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// Predefined non_nested comment parser generator -// -/////////////////////////////////////////////////////////////////////////////// - -const comment_parser_gen comment_p = - comment_parser_gen(); - -/////////////////////////////////////////////////////////////////////////////// -// -// comment_nest_parser class -// -// Parses a nested comments. -// Example: nested PASCAL-comments: -// -// { This is a { nested } PASCAL-comment } -// -/////////////////////////////////////////////////////////////////////////////// - -template -struct comment_nest_parser: - public parser > -{ - typedef comment_nest_parser self_t; - - comment_nest_parser(OpenT const &open_, CloseT const &close_): - open(open_), close(close_) - {} - - template - typename parser_result::type - parse(ScannerT const &scan) const - { - return do_parse( - open >> *(*this | (anychar_p - close)) >> close, - scan); - } - -private: - template - typename parser_result::type - do_parse(ParserT const &p, ScannerT const &scan) const - { - return - impl::contiguous_parser_parse< - typename parser_result::type - >(p, scan, scan); - } - - typename as_parser::type::embed_t open; - typename as_parser::type::embed_t close; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// Predefined nested comment parser generator -// -/////////////////////////////////////////////////////////////////////////////// - -template -struct comment_nest_p_result -{ - typedef comment_nest_parser< - typename as_parser::type, - typename as_parser::type - > type; -}; - -template -inline typename comment_nest_p_result::type -comment_nest_p(OpenT const &open, CloseT const &close) -{ - typedef typename comment_nest_p_result::type - result_t; - - return result_t( - as_parser::convert(open), - as_parser::convert(close) - ); -} - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/utility/distinct.hpp b/boost/boost/spirit/utility/distinct.hpp deleted file mode 100644 index 9d90d0ab6d..0000000000 --- a/boost/boost/spirit/utility/distinct.hpp +++ /dev/null @@ -1,227 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2003 Vaclav Vesely - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_DISTINCT_HPP) -#define BOOST_SPIRIT_DISTINCT_HPP - -#include -#include -#include -#include -#include -#include -#include - -#include - -namespace boost { - namespace spirit { -//----------------------------------------------------------------------------- -// distinct_parser class - -template -class distinct_parser -{ -public: - typedef - contiguous< - sequence< - chseq, - negated_empty_match_parser< - TailT - > - > - > - result_t; - - distinct_parser() - : tail(chset()) - { - } - - explicit distinct_parser(parser const & tail_) - : tail(tail_.derived()) - { - } - - explicit distinct_parser(CharT const* letters) - : tail(chset_p(letters)) - { - } - - result_t operator()(CharT const* str) const - { - return lexeme_d[chseq_p(str) >> ~epsilon_p(tail)]; - } - - TailT tail; -}; - -//----------------------------------------------------------------------------- -// distinct_directive class - -template -class distinct_directive -{ -public: - template - struct result { - typedef - contiguous< - sequence< - ParserT, - negated_empty_match_parser< - TailT - > - > - > - type; - }; - - distinct_directive() - : tail(chset()) - { - } - - explicit distinct_directive(CharT const* letters) - : tail(chset_p(letters)) - { - } - - explicit distinct_directive(parser const & tail_) - : tail(tail_.derived()) - { - } - - template - typename result::type>::type - operator[](ParserT const &subject) const - { - return - lexeme_d[as_parser::convert(subject) >> ~epsilon_p(tail)]; - } - - TailT tail; -}; - -//----------------------------------------------------------------------------- -// dynamic_distinct_parser class - -template -class dynamic_distinct_parser -{ -public: - typedef typename ScannerT::value_t char_t; - - typedef - rule< - typename no_actions_scanner< - typename lexeme_scanner::type - >::type - > - tail_t; - - typedef - contiguous< - sequence< - chseq, - negated_empty_match_parser< - tail_t - > - > - > - result_t; - - dynamic_distinct_parser() - : tail(nothing_p) - { - } - - template - explicit dynamic_distinct_parser(parser const & tail_) - : tail(tail_.derived()) - { - } - - explicit dynamic_distinct_parser(char_t const* letters) - : tail(chset_p(letters)) - { - } - - result_t operator()(char_t const* str) const - { - return lexeme_d[chseq_p(str) >> ~epsilon_p(tail)]; - } - - tail_t tail; -}; - -//----------------------------------------------------------------------------- -// dynamic_distinct_directive class - -template -class dynamic_distinct_directive -{ -public: - typedef typename ScannerT::value_t char_t; - - typedef - rule< - typename no_actions_scanner< - typename lexeme_scanner::type - >::type - > - tail_t; - - template - struct result { - typedef - contiguous< - sequence< - ParserT, - negated_empty_match_parser< - tail_t - > - > - > - type; - }; - - dynamic_distinct_directive() - : tail(nothing_p) - { - } - - template - explicit dynamic_distinct_directive(parser const & tail_) - : tail(tail_.derived()) - { - } - - explicit dynamic_distinct_directive(char_t const* letters) - : tail(chset_p(letters)) - { - } - - template - typename result::type>::type - operator[](ParserT const &subject) const - { - return - lexeme_d[as_parser::convert(subject) >> ~epsilon_p(tail)]; - } - - tail_t tail; -}; - -//----------------------------------------------------------------------------- - } // namespace spirit -} // namespace boost - -#endif // !defined(BOOST_SPIRIT_DISTINCT_HPP) diff --git a/boost/boost/spirit/utility/escape_char.hpp b/boost/boost/spirit/utility/escape_char.hpp deleted file mode 100644 index 6fc1524d7e..0000000000 --- a/boost/boost/spirit/utility/escape_char.hpp +++ /dev/null @@ -1,180 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Daniel Nuffer - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_ESCAPE_CHAR_HPP -#define BOOST_SPIRIT_ESCAPE_CHAR_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include -#include -#include -#include - -#include - -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -/////////////////////////////////////////////////////////////////////////////// -// -// escape_char_action class -// -// Links an escape char parser with a user defined semantic action. -// The semantic action may be a function or a functor. A function -// should be compatible with the interface: -// -// void f(CharT ch); -// -// A functor should have a member operator() with a compatible signature -// as above. The matching character is passed into the function/functor. -// This is the default class that character parsers use when dealing with -// the construct: -// -// p[f] -// -// where p is a parser and f is a function or functor. -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename ParserT, typename ActionT, - unsigned long Flags, typename CharT -> -struct escape_char_action -: public unary > > -{ - typedef escape_char_action - self_t; - typedef action_parser_category parser_category_t; - typedef unary > base_t; - - template - struct result - { - typedef typename match_result::type type; - }; - - escape_char_action(ParserT const& p, ActionT const& a) - : base_t(p), actor(a) {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - return impl::escape_char_action_parse:: - parse(scan, *this); - } - - ActionT const& predicate() const { return actor; } - -private: - - ActionT actor; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// escape_char_parser class -// -// The escape_char_parser helps in conjunction with the escape_char_action -// template class (see above) in parsing escaped characters. There are two -// different variants of this parser: one for parsing C style escaped -// characters and one for parsing LEX style escaped characters. -// -// The C style escaped character parser is generated, when the template -// parameter 'Flags' is equal to 'c_escapes' (a constant defined in the -// file impl/escape_char.ipp). This parser recognizes all valid C escape -// character sequences: '\t', '\b', '\f', '\n', '\r', '\"', '\'', '\\' -// and the numeric style escapes '\120' (octal) and '\x2f' (hexadecimal) -// and converts these to their character equivalent, for instance the -// sequence of a backslash and a 'b' is parsed as the character '\b'. -// All other escaped characters are rejected by this parser. -// -// The LEX style escaped character parser is generated, when the template -// parameter 'Flags' is equal to 'lex_escapes' (a constant defined in the -// file impl/escape_char.ipp). This parser recognizes all the C style -// escaped character sequences (as described above) and additionally -// does not reject all other escape sequences. All not mentioned escape -// sequences are converted by the parser to the plain character, for -// instance '\a' will be parsed as 'a'. -// -// All not escaped characters are parsed without modification. -// -/////////////////////////////////////////////////////////////////////////////// - -template -struct escape_char_action_parser_gen; - -template -struct escape_char_parser : - public parser > { - - // only the values c_escapes and lex_escapes are valid for Flags - BOOST_STATIC_ASSERT(Flags == c_escapes || Flags == lex_escapes); - - typedef escape_char_parser self_t; - typedef - escape_char_action_parser_gen - action_parser_generator_t; - - template - struct result { - - typedef typename match_result::type type; - }; - - template - escape_char_action - operator[](ActionT const& actor) const - { - return escape_char_action(*this, actor); - } - - template - typename parser_result::type - parse(ScannerT const &scan) const - { - return impl::escape_char_parse::parse(scan, *this); - } -}; - -template -struct escape_char_action_parser_gen { - - template - static escape_char_action - generate (ParserT const &p, ActionT const &actor) - { - typedef - escape_char_action - action_parser_t; - return action_parser_t(p, actor); - } -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// predefined escape_char_parser objects -// -// These objects should be used for generating correct escaped character -// parsers. -// -/////////////////////////////////////////////////////////////////////////////// -const escape_char_parser lex_escape_ch_p = - escape_char_parser(); - -const escape_char_parser c_escape_ch_p = - escape_char_parser(); - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/utility/flush_multi_pass.hpp b/boost/boost/spirit/utility/flush_multi_pass.hpp deleted file mode 100644 index c33ea0a446..0000000000 --- a/boost/boost/spirit/utility/flush_multi_pass.hpp +++ /dev/null @@ -1,73 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Daniel Nuffer - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_FLUSH_MULTI_PASS_HPP -#define BOOST_SPIRIT_FLUSH_MULTI_PASS_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - - namespace impl { - - template - void flush_iterator(T &) {} - - template - void flush_iterator(boost::spirit::multi_pass< - T1, T2, T3, T4, boost::spirit::multi_pass_policies::std_deque> &i) - { - i.clear_queue(); - } - - } // namespace impl - - /////////////////////////////////////////////////////////////////////////// - // - // flush_multi_pass_parser - // - // The flush_multi_pass_parser flushes an underlying - // multi_pass_iterator during the normal parsing process. This may - // be used at certain points during the parsing process, when it is - // clear, that no backtracking is needed anymore and the input - // gathered so far may be discarded. - // - /////////////////////////////////////////////////////////////////////////// - class flush_multi_pass_parser - : public parser - { - public: - typedef flush_multi_pass_parser this_t; - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - impl::flush_iterator(scan.first); - return scan.empty_match(); - } - }; - - /////////////////////////////////////////////////////////////////////////// - // - // predefined flush_multi_pass_p object - // - // This object should may used to flush a multi_pass_iterator along - // the way during the normal parsing process. - // - /////////////////////////////////////////////////////////////////////////// - - flush_multi_pass_parser const - flush_multi_pass_p = flush_multi_pass_parser(); - -}} // namespace boost::spirit - -#endif // BOOST_SPIRIT_FLUSH_MULTI_PASS_HPP diff --git a/boost/boost/spirit/utility/functor_parser.hpp b/boost/boost/spirit/utility/functor_parser.hpp deleted file mode 100644 index fe72d4e313..0000000000 --- a/boost/boost/spirit/utility/functor_parser.hpp +++ /dev/null @@ -1,67 +0,0 @@ -/*============================================================================= - Copyright (c) 2002-2003 Joel de Guzman - Copyright (c) 2002-2003 Juan Carlos Arevalo-Baeza - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_FUNCTOR_PARSER_HPP -#define BOOST_SPIRIT_FUNCTOR_PARSER_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // functor_parser class - // - // Once a functor parser has been defined, you can build a real - // parser from it by passing it to this class as the template - // parameter. - // - /////////////////////////////////////////////////////////////////////////// - template < class FunctorT > - struct functor_parser : public parser > - { - FunctorT functor; - - functor_parser(): functor() {} - functor_parser(FunctorT const& functor_): functor(functor_) {} - - typedef typename FunctorT::result_t functor_result_t; - typedef functor_parser self_t; - - template - struct result - { - typedef typename match_result::type - type; - }; - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - typedef typename parser_result::type result_t; - typedef typename ScannerT::value_t value_t; - typedef typename ScannerT::iterator_t iterator_t; - - iterator_t const s(scan.first); - functor_result_t result; - std::ptrdiff_t len = functor(scan, result); - - if (len < 0) - return scan.no_match(); - else - return scan.create_match(std::size_t(len), result, s, scan.first); - } - }; - -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/utility/impl/chset.ipp b/boost/boost/spirit/utility/impl/chset.ipp deleted file mode 100644 index 91d11a4dcb..0000000000 --- a/boost/boost/spirit/utility/impl/chset.ipp +++ /dev/null @@ -1,362 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - Copyright (c) 2001-2003 Daniel Nuffer - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_CHSET_IPP -#define BOOST_SPIRIT_CHSET_IPP - -/////////////////////////////////////////////////////////////////////////////// -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -/////////////////////////////////////////////////////////////////////////////// -// -// chset class -// -/////////////////////////////////////////////////////////////////////////////// -namespace utility { namespace impl { - template - inline void - detach(boost::shared_ptr >& ptr) - { - if (!ptr.unique()) - ptr = boost::shared_ptr > - (new basic_chset(*ptr)); - } - - template - inline void - detach_clear(boost::shared_ptr >& ptr) - { - if (ptr.unique()) - ptr->clear(); - else - ptr.reset(new basic_chset()); - } - - template - void construct_chset(boost::shared_ptr >& ptr, - CharT2 const* definition) - { - CharT2 ch = *definition++; - while (ch) - { - CharT2 next = *definition++; - if (next == '-') - { - next = *definition++; - if (next == 0) - { - ptr->set(ch); - ptr->set('-'); - break; - } - ptr->set(ch, next); - } - else - { - ptr->set(ch); - } - ch = next; - } - } - - ////////////////////////////////// - -#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) - - template - void chset_negated_set(boost::shared_ptr > &ptr, chlit const &ch, - FakeT) - { - if(ch.ch != (std::numeric_limits::min)()) { - ptr->set((std::numeric_limits::min)(), ch.ch - 1); - } - if(ch.ch != (std::numeric_limits::max)()) { - ptr->set(ch.ch + 1, (std::numeric_limits::max)()); - } - } - - template - void chset_negated_set(boost::shared_ptr > &ptr, - spirit::range const &rng, FakeT) - { - if(rng.first != (std::numeric_limits::min)()) { - ptr->set((std::numeric_limits::min)(), rng.first - 1); - } - if(rng.last != (std::numeric_limits::max)()) { - ptr->set(rng.last + 1, (std::numeric_limits::max)()); - } - } - -#endif // BOOST_WORKAROUND(BOOST_MSVC, < 1300) - -////////////////////////////////// - -}} // namespace utility::impl - -template -inline chset::chset() -: ptr(new basic_chset()) {} - -template -inline chset::chset(chset const& arg_) -: ptr(new basic_chset(*arg_.ptr)) {} - -template -inline chset::chset(CharT arg_) -: ptr(new basic_chset()) -{ ptr->set(arg_); } - -template -inline chset::chset(anychar_parser /*arg*/) -: ptr(new basic_chset()) -{ - ptr->set( - (std::numeric_limits::min)(), - (std::numeric_limits::max)() - ); -} - -template -inline chset::chset(nothing_parser arg_) -: ptr(new basic_chset()) {} - -template -inline chset::chset(chlit const& arg_) -: ptr(new basic_chset()) -{ ptr->set(arg_.ch); } - -template -inline chset::chset(range const& arg_) -: ptr(new basic_chset()) -{ ptr->set(arg_.first, arg_.last); } - -#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) - -template -inline chset::chset(negated_char_parser > const& arg_) -: ptr(new basic_chset()) -{ - set(arg_); -} - -template -inline chset::chset(negated_char_parser > const& arg_) -: ptr(new basic_chset()) -{ - set(arg_); -} - -#endif // !BOOST_WORKAROUND(BOOST_MSVC, < 1300) - -template -inline chset::~chset() {} - -template -inline chset& -chset::operator=(chset const& rhs) -{ - ptr = rhs.ptr; - return *this; -} - -template -inline chset& -chset::operator=(CharT rhs) -{ - utility::impl::detach_clear(ptr); - ptr->set(rhs); - return *this; -} - -template -inline chset& -chset::operator=(anychar_parser rhs) -{ - utility::impl::detach_clear(ptr); - ptr->set( - (std::numeric_limits::min)(), - (std::numeric_limits::max)() - ); - return *this; -} - -template -inline chset& -chset::operator=(nothing_parser rhs) -{ - utility::impl::detach_clear(ptr); - return *this; -} - -template -inline chset& -chset::operator=(chlit const& rhs) -{ - utility::impl::detach_clear(ptr); - ptr->set(rhs.ch); - return *this; -} - -template -inline chset& -chset::operator=(range const& rhs) -{ - utility::impl::detach_clear(ptr); - ptr->set(rhs.first, rhs.last); - return *this; -} - -#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) - -template -inline chset& -chset::operator=(negated_char_parser > const& rhs) -{ - utility::impl::detach_clear(ptr); - set(rhs); - return *this; -} - -template -inline chset& -chset::operator=(negated_char_parser > const& rhs) -{ - utility::impl::detach_clear(ptr); - set(rhs); - return *this; -} - -#endif // !BOOST_WORKAROUND(BOOST_MSVC, < 1300) - -template -inline void -chset::set(range const& arg_) -{ - utility::impl::detach(ptr); - ptr->set(arg_.first, arg_.last); -} - -#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) - -template -inline void -chset::set(negated_char_parser > const& arg_) -{ - utility::impl::detach(ptr); - - if(arg_.positive.ch != (std::numeric_limits::min)()) { - ptr->set((std::numeric_limits::min)(), arg_.positive.ch - 1); - } - if(arg_.positive.ch != (std::numeric_limits::max)()) { - ptr->set(arg_.positive.ch + 1, (std::numeric_limits::max)()); - } -} - -template -inline void -chset::set(negated_char_parser > const& arg_) -{ - utility::impl::detach(ptr); - - if(arg_.positive.first != (std::numeric_limits::min)()) { - ptr->set((std::numeric_limits::min)(), arg_.positive.first - 1); - } - if(arg_.positive.last != (std::numeric_limits::max)()) { - ptr->set(arg_.positive.last + 1, (std::numeric_limits::max)()); - } -} - -#endif // !BOOST_WORKAROUND(BOOST_MSVC, < 1300) - -template -inline void -chset::clear(range const& arg_) -{ - utility::impl::detach(ptr); - ptr->clear(arg_.first, arg_.last); -} - -template -inline void -chset::clear(negated_char_parser > const& arg_) -{ - utility::impl::detach(ptr); - - if(arg_.positive.first != (std::numeric_limits::min)()) { - ptr->clear((std::numeric_limits::min)(), arg_.positive.first - 1); - } - if(arg_.positive.last != (std::numeric_limits::max)()) { - ptr->clear(arg_.positive.last + 1, (std::numeric_limits::max)()); - } -} - -template -inline bool -chset::test(CharT ch) const -{ return ptr->test(ch); } - -template -inline chset& -chset::inverse() -{ - utility::impl::detach(ptr); - ptr->inverse(); - return *this; -} - -template -inline void -chset::swap(chset& x) -{ ptr.swap(x.ptr); } - -template -inline chset& -chset::operator|=(chset const& x) -{ - utility::impl::detach(ptr); - *ptr |= *x.ptr; - return *this; -} - -template -inline chset& -chset::operator&=(chset const& x) -{ - utility::impl::detach(ptr); - *ptr &= *x.ptr; - return *this; -} - -template -inline chset& -chset::operator-=(chset const& x) -{ - utility::impl::detach(ptr); - *ptr -= *x.ptr; - return *this; -} - -template -inline chset& -chset::operator^=(chset const& x) -{ - utility::impl::detach(ptr); - *ptr ^= *x.ptr; - return *this; -} - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#endif - diff --git a/boost/boost/spirit/utility/impl/chset/basic_chset.hpp b/boost/boost/spirit/utility/impl/chset/basic_chset.hpp deleted file mode 100644 index 57413dc6ca..0000000000 --- a/boost/boost/spirit/utility/impl/chset/basic_chset.hpp +++ /dev/null @@ -1,102 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - Copyright (c) 2001-2003 Daniel Nuffer - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_BASIC_CHSET_HPP -#define BOOST_SPIRIT_BASIC_CHSET_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include -#include - -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // basic_chset: basic character set implementation using range_run - // - /////////////////////////////////////////////////////////////////////////// - template - class basic_chset - { - public: - basic_chset(); - basic_chset(basic_chset const& arg_); - - bool test(CharT v) const; - void set(CharT from, CharT to); - void set(CharT c); - void clear(CharT from, CharT to); - void clear(CharT c); - void clear(); - - void inverse(); - void swap(basic_chset& x); - - basic_chset& operator|=(basic_chset const& x); - basic_chset& operator&=(basic_chset const& x); - basic_chset& operator-=(basic_chset const& x); - basic_chset& operator^=(basic_chset const& x); - - private: utility::impl::range_run rr; - }; - - #if (CHAR_BIT == 8) - - /////////////////////////////////////////////////////////////////////////// - // - // basic_chset: specializations for 8 bit chars using std::bitset - // - /////////////////////////////////////////////////////////////////////////// - template - class basic_chset_8bit { - - public: - basic_chset_8bit(); - basic_chset_8bit(basic_chset_8bit const& arg_); - - bool test(CharT v) const; - void set(CharT from, CharT to); - void set(CharT c); - void clear(CharT from, CharT to); - void clear(CharT c); - void clear(); - - void inverse(); - void swap(basic_chset_8bit& x); - - basic_chset_8bit& operator|=(basic_chset_8bit const& x); - basic_chset_8bit& operator&=(basic_chset_8bit const& x); - basic_chset_8bit& operator-=(basic_chset_8bit const& x); - basic_chset_8bit& operator^=(basic_chset_8bit const& x); - - private: std::bitset<256> bset; - }; - - ///////////////////////////////// - template <> - class basic_chset - : public basic_chset_8bit {}; - - ///////////////////////////////// - template <> - class basic_chset - : public basic_chset_8bit {}; - - ///////////////////////////////// - template <> - class basic_chset - : public basic_chset_8bit {}; - -#endif - -}} // namespace boost::spirit - -#endif - -#include diff --git a/boost/boost/spirit/utility/impl/chset/basic_chset.ipp b/boost/boost/spirit/utility/impl/chset/basic_chset.ipp deleted file mode 100644 index 9370e3f8ad..0000000000 --- a/boost/boost/spirit/utility/impl/chset/basic_chset.ipp +++ /dev/null @@ -1,241 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - Copyright (c) 2001-2003 Daniel Nuffer - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_BASIC_CHSET_IPP -#define BOOST_SPIRIT_BASIC_CHSET_IPP - -/////////////////////////////////////////////////////////////////////////////// -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -/////////////////////////////////////////////////////////////////////////////// -// -// basic_chset: character set implementation -// -/////////////////////////////////////////////////////////////////////////////// -template -inline basic_chset::basic_chset() {} - -////////////////////////////////// -template -inline basic_chset::basic_chset(basic_chset const& arg_) -: rr(arg_.rr) {} - -////////////////////////////////// -template -inline bool -basic_chset::test(CharT v) const -{ return rr.test(v); } - -////////////////////////////////// -template -inline void -basic_chset::set(CharT from, CharT to) -{ rr.set(utility::impl::range(from, to)); } - -////////////////////////////////// -template -inline void -basic_chset::set(CharT c) -{ rr.set(utility::impl::range(c, c)); } - -////////////////////////////////// -template -inline void -basic_chset::clear(CharT from, CharT to) -{ rr.clear(utility::impl::range(from, to)); } - -////////////////////////////////// -template -inline void -basic_chset::clear() -{ rr.clear(); } - -///////////////////////////////// -template -inline void -basic_chset::inverse() -{ - basic_chset inv; - inv.set( - (std::numeric_limits::min)(), - (std::numeric_limits::max)() - ); - inv -= *this; - swap(inv); -} - -///////////////////////////////// -template -inline void -basic_chset::swap(basic_chset& x) -{ rr.swap(x.rr); } - -///////////////////////////////// -template -inline basic_chset& -basic_chset::operator|=(basic_chset const& x) -{ - typedef typename utility::impl::range_run::const_iterator const_iterator; - for (const_iterator iter = x.rr.begin(); iter != x.rr.end(); ++iter) - rr.set(*iter); - return *this; -} - -///////////////////////////////// -template -inline basic_chset& -basic_chset::operator&=(basic_chset const& x) -{ - basic_chset inv; - inv.set( - (std::numeric_limits::min)(), - (std::numeric_limits::max)() - ); - inv -= x; - *this -= inv; - return *this; -} - -///////////////////////////////// -template -inline basic_chset& -basic_chset::operator-=(basic_chset const& x) -{ - typedef typename utility::impl::range_run::const_iterator const_iterator; - for (const_iterator iter = x.rr.begin(); iter != x.rr.end(); ++iter) - rr.clear(*iter); - return *this; -} - -///////////////////////////////// -template -inline basic_chset& -basic_chset::operator^=(basic_chset const& x) -{ - basic_chset bma = x; - bma -= *this; - *this -= x; - *this |= bma; - return *this; -} - -#if (CHAR_BIT == 8) - -/////////////////////////////////////////////////////////////////////////////// -// -// basic_chset: specializations for 8 bit chars using std::bitset -// -/////////////////////////////////////////////////////////////////////////////// -template -inline basic_chset_8bit::basic_chset_8bit() {} - -///////////////////////////////// -template -inline basic_chset_8bit::basic_chset_8bit(basic_chset_8bit const& arg_) -: bset(arg_.bset) {} - -///////////////////////////////// -template -inline bool -basic_chset_8bit::test(CharT v) const -{ return bset.test((unsigned char)v); } - -///////////////////////////////// -template -inline void -basic_chset_8bit::set(CharT from, CharT to) -{ - for (int i = from; i <= to; ++i) - bset.set((unsigned char)i); -} - -///////////////////////////////// -template -inline void -basic_chset_8bit::set(CharT c) -{ bset.set((unsigned char)c); } - -///////////////////////////////// -template -inline void -basic_chset_8bit::clear(CharT from, CharT to) -{ - for (int i = from; i <= to; ++i) - bset.reset((unsigned char)i); -} - -///////////////////////////////// -template -inline void -basic_chset_8bit::clear(CharT c) -{ bset.reset((unsigned char)c); } - -///////////////////////////////// -template -inline void -basic_chset_8bit::clear() -{ bset.reset(); } - -///////////////////////////////// -template -inline void -basic_chset_8bit::inverse() -{ bset.flip(); } - -///////////////////////////////// -template -inline void -basic_chset_8bit::swap(basic_chset_8bit& x) -{ std::swap(bset, x.bset); } - -///////////////////////////////// -template -inline basic_chset_8bit& -basic_chset_8bit::operator|=(basic_chset_8bit const& x) -{ - bset |= x.bset; - return *this; -} - -///////////////////////////////// -template -inline basic_chset_8bit& -basic_chset_8bit::operator&=(basic_chset_8bit const& x) -{ - bset &= x.bset; - return *this; -} - -///////////////////////////////// -template -inline basic_chset_8bit& -basic_chset_8bit::operator-=(basic_chset_8bit const& x) -{ - bset &= ~x.bset; - return *this; -} - -///////////////////////////////// -template -inline basic_chset_8bit& -basic_chset_8bit::operator^=(basic_chset_8bit const& x) -{ - bset ^= x.bset; - return *this; -} - -#endif -}} // namespace boost::spirit - -#endif - diff --git a/boost/boost/spirit/utility/impl/chset/range_run.hpp b/boost/boost/spirit/utility/impl/chset/range_run.hpp deleted file mode 100644 index 320e949e1f..0000000000 --- a/boost/boost/spirit/utility/impl/chset/range_run.hpp +++ /dev/null @@ -1,118 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_RANGE_RUN_HPP -#define BOOST_SPIRIT_RANGE_RUN_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { namespace utility { namespace impl { - - /////////////////////////////////////////////////////////////////////////// - // - // range class - // - // Implements a closed range of values. This class is used in - // the implementation of the range_run class. - // - // { Low level implementation detail } - // { Not to be confused with boost::spirit::range } - // - /////////////////////////////////////////////////////////////////////////// - template - struct range { - - range(CharT first, CharT last); - - bool is_valid() const; - bool includes(CharT v) const; - bool includes(range const& r) const; - bool overlaps(range const& r) const; - void merge(range const& r); - - CharT first; - CharT last; - }; - - ////////////////////////////////// - template - struct range_char_compare { - - bool operator()(range const& x, const CharT y) const - { return x.first < y; } - - bool operator()(const CharT x, range const& y) const - { return x < y.first; } - - // This additional operator is required for the checked STL shipped - // with VC8 testing the ordering of the iterators passed to the - // std::lower_bound algo this range_char_compare<> predicate is passed - // to. - bool operator()(range const& x, range const& y) const - { return x.first < y.first; } - }; - - ////////////////////////////////// - template - struct range_compare { - - bool operator()(range const& x, range const& y) const - { return x.first < y.first; } - }; - - /////////////////////////////////////////////////////////////////////////// - // - // range_run - // - // An implementation of a sparse bit (boolean) set. The set uses - // a sorted vector of disjoint ranges. This class implements the - // bare minimum essentials from which the full range of set - // operators can be implemented. The set is constructed from - // ranges. Internally, adjacent or overlapping ranges are - // coalesced. - // - // range_runs are very space-economical in situations where there - // are lots of ranges and a few individual disjoint values. - // Searching is O(log n) where n is the number of ranges. - // - // { Low level implementation detail } - // - /////////////////////////////////////////////////////////////////////////// - template - class range_run { - - public: - - typedef range range_t; - typedef std::vector run_t; - typedef typename run_t::iterator iterator; - typedef typename run_t::const_iterator const_iterator; - - void swap(range_run& rr); - bool test(CharT v) const; - void set(range_t const& r); - void clear(range_t const& r); - void clear(); - - const_iterator begin() const; - const_iterator end() const; - - private: - - void merge(iterator iter, range_t const& r); - - run_t run; - }; - -}}}} // namespace boost::spirit::utility::impl - -#endif - -#include diff --git a/boost/boost/spirit/utility/impl/chset/range_run.ipp b/boost/boost/spirit/utility/impl/chset/range_run.ipp deleted file mode 100644 index 45491bc3fb..0000000000 --- a/boost/boost/spirit/utility/impl/chset/range_run.ipp +++ /dev/null @@ -1,212 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_RANGE_RUN_IPP -#define BOOST_SPIRIT_RANGE_RUN_IPP - -/////////////////////////////////////////////////////////////////////////////// -#include // for std::lower_bound -#include // for BOOST_SPIRIT_ASSERT -#include -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - - namespace utility { namespace impl { - - /////////////////////////////////////////////////////////////////////// - // - // range class implementation - // - /////////////////////////////////////////////////////////////////////// - template - inline range::range(CharT first_, CharT last_) - : first(first_), last(last_) {} - - ////////////////////////////////// - template - inline bool - range::is_valid() const - { return first <= last; } - - ////////////////////////////////// - template - inline bool - range::includes(range const& r) const - { return (first <= r.first) && (last >= r.last); } - - ////////////////////////////////// - template - inline bool - range::includes(CharT v) const - { return (first <= v) && (last >= v); } - - ////////////////////////////////// - template - inline bool - range::overlaps(range const& r) const - { - CharT decr_first = - first == (std::numeric_limits::min)() ? first : first-1; - CharT incr_last = - last == (std::numeric_limits::max)() ? last : last+1; - - return (decr_first <= r.last) && (incr_last >= r.first); - } - - ////////////////////////////////// - template - inline void - range::merge(range const& r) - { - first = (std::min)(first, r.first); - last = (std::max)(last, r.last); - } - - /////////////////////////////////////////////////////////////////////// - // - // range_run class implementation - // - /////////////////////////////////////////////////////////////////////// - template - inline bool - range_run::test(CharT v) const - { - if (!run.empty()) - { - const_iterator iter = - std::lower_bound( - run.begin(), run.end(), v, - range_char_compare() - ); - - if (iter != run.end() && iter->includes(v)) - return true; - if (iter != run.begin()) - return (--iter)->includes(v); - } - return false; - } - - ////////////////////////////////// - template - inline void - range_run::swap(range_run& rr) - { run.swap(rr.run); } - - ////////////////////////////////// - template - void - range_run::merge(iterator iter, range const& r) - { - iter->merge(r); - iterator i = iter + 1; - - while (i != run.end() && iter->overlaps(*i)) - iter->merge(*i++); - - run.erase(iter+1, i); - } - - ////////////////////////////////// - template - void - range_run::set(range const& r) - { - BOOST_SPIRIT_ASSERT(r.is_valid()); - if (!run.empty()) - { - iterator iter = - std::lower_bound( - run.begin(), run.end(), r, - range_compare() - ); - - if (iter != run.end() && iter->includes(r) || - ((iter != run.begin()) && (iter - 1)->includes(r))) - return; - - if (iter != run.begin() && (iter - 1)->overlaps(r)) - merge(--iter, r); - - else if (iter != run.end() && iter->overlaps(r)) - merge(iter, r); - - else - run.insert(iter, r); - } - else - { - run.push_back(r); - } - } - - ////////////////////////////////// - template - void - range_run::clear(range const& r) - { - BOOST_SPIRIT_ASSERT(r.is_valid()); - if (!run.empty()) - { - iterator iter = - std::lower_bound( - run.begin(), run.end(), r, - range_compare() - ); - - iterator left_iter; - - if ((iter != run.begin()) && - (left_iter = (iter - 1))->includes(r.first)) - if (left_iter->last > r.last) - { - CharT save_last = left_iter->last; - left_iter->last = r.first-1; - run.insert(iter, range(r.last+1, save_last)); - return; - } - else - { - left_iter->last = r.first-1; - } - - iterator i = iter; - while (i != run.end() && r.includes(*i)) - i++; - if (i != run.end() && i->includes(r.last)) - i->first = r.last+1; - run.erase(iter, i); - } - } - - ////////////////////////////////// - template - inline void - range_run::clear() - { run.clear(); } - - ////////////////////////////////// - template - inline typename range_run::const_iterator - range_run::begin() const - { return run.begin(); } - - ////////////////////////////////// - template - inline typename range_run::const_iterator - range_run::end() const - { return run.end(); } - - }} // namespace utility::impl - -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/utility/impl/chset_operators.ipp b/boost/boost/spirit/utility/impl/chset_operators.ipp deleted file mode 100644 index dddbcea07a..0000000000 --- a/boost/boost/spirit/utility/impl/chset_operators.ipp +++ /dev/null @@ -1,662 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Joel de Guzman - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_CHSET_OPERATORS_IPP -#define BOOST_SPIRIT_CHSET_OPERATORS_IPP - -/////////////////////////////////////////////////////////////////////////////// -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -/////////////////////////////////////////////////////////////////////////////// -// -// chset free operators implementation -// -/////////////////////////////////////////////////////////////////////////////// -template -inline chset -operator|(chset const& a, chset const& b) -{ - return chset(a) |= b; -} - -////////////////////////////////// -template -inline chset -operator-(chset const& a, chset const& b) -{ - return chset(a) -= b; -} - -////////////////////////////////// -template -inline chset -operator~(chset const& a) -{ - return chset(a).inverse(); -} - -////////////////////////////////// -template -inline chset -operator&(chset const& a, chset const& b) -{ - return chset(a) &= b; -} - -////////////////////////////////// -template -inline chset -operator^(chset const& a, chset const& b) -{ - return chset(a) ^= b; -} - -/////////////////////////////////////////////////////////////////////////////// -// -// range <--> chset free operators implementation -// -/////////////////////////////////////////////////////////////////////////////// -template -inline chset -operator|(chset const& a, range const& b) -{ - chset a_(a); - a_.set(b); - return a_; -} - -////////////////////////////////// -template -inline chset -operator&(chset const& a, range const& b) -{ - chset a_(a); - if(b.first != (std::numeric_limits::min)()) { - a_.clear(range((std::numeric_limits::min)(), b.first - 1)); - } - if(b.last != (std::numeric_limits::max)()) { - a_.clear(range(b.last + 1, (std::numeric_limits::max)())); - } - return a_; -} - -////////////////////////////////// -template -inline chset -operator-(chset const& a, range const& b) -{ - chset a_(a); - a_.clear(b); - return a_; -} - -////////////////////////////////// -template -inline chset -operator^(chset const& a, range const& b) -{ - return a ^ chset(b); -} - -////////////////////////////////// -template -inline chset -operator|(range const& a, chset const& b) -{ - chset b_(b); - b_.set(a); - return b_; -} - -////////////////////////////////// -template -inline chset -operator&(range const& a, chset const& b) -{ - chset b_(b); - if(a.first != (std::numeric_limits::min)()) { - b_.clear(range((std::numeric_limits::min)(), a.first - 1)); - } - if(a.last != (std::numeric_limits::max)()) { - b_.clear(range(a.last + 1, (std::numeric_limits::max)())); - } - return b_; -} - -////////////////////////////////// -template -inline chset -operator-(range const& a, chset const& b) -{ - return chset(a) - b; -} - -////////////////////////////////// -template -inline chset -operator^(range const& a, chset const& b) -{ - return chset(a) ^ b; -} - -/////////////////////////////////////////////////////////////////////////////// -// -// literal primitives <--> chset free operators implementation -// -/////////////////////////////////////////////////////////////////////////////// -template -inline chset -operator|(chset const& a, CharT b) -{ - return a | chset(b); -} - -////////////////////////////////// -template -inline chset -operator&(chset const& a, CharT b) -{ - return a & chset(b); -} - -////////////////////////////////// -template -inline chset -operator-(chset const& a, CharT b) -{ - return a - chset(b); -} - -////////////////////////////////// -template -inline chset -operator^(chset const& a, CharT b) -{ - return a ^ chset(b); -} - -////////////////////////////////// -template -inline chset -operator|(CharT a, chset const& b) -{ - return chset(a) | b; -} - -////////////////////////////////// -template -inline chset -operator&(CharT a, chset const& b) -{ - return chset(a) & b; -} - -////////////////////////////////// -template -inline chset -operator-(CharT a, chset const& b) -{ - return chset(a) - b; -} - -////////////////////////////////// -template -inline chset -operator^(CharT a, chset const& b) -{ - return chset(a) ^ b; -} - -/////////////////////////////////////////////////////////////////////////////// -// -// chlit <--> chset free operators implementation -// -/////////////////////////////////////////////////////////////////////////////// -template -inline chset -operator|(chset const& a, chlit const& b) -{ - return a | chset(b.ch); -} - -////////////////////////////////// -template -inline chset -operator&(chset const& a, chlit const& b) -{ - return a & chset(b.ch); -} - -////////////////////////////////// -template -inline chset -operator-(chset const& a, chlit const& b) -{ - return a - chset(b.ch); -} - -////////////////////////////////// -template -inline chset -operator^(chset const& a, chlit const& b) -{ - return a ^ chset(b.ch); -} - -////////////////////////////////// -template -inline chset -operator|(chlit const& a, chset const& b) -{ - return chset(a.ch) | b; -} - -////////////////////////////////// -template -inline chset -operator&(chlit const& a, chset const& b) -{ - return chset(a.ch) & b; -} - -////////////////////////////////// -template -inline chset -operator-(chlit const& a, chset const& b) -{ - return chset(a.ch) - b; -} - -////////////////////////////////// -template -inline chset -operator^(chlit const& a, chset const& b) -{ - return chset(a.ch) ^ b; -} - -#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) - -/////////////////////////////////////////////////////////////////////////////// -// -// negated_char_parser <--> chset free operators implementation -// -/////////////////////////////////////////////////////////////////////////////// -template -inline chset -operator|(chset const& a, negated_char_parser const& b) -{ - return a | chset(b); -} - -////////////////////////////////// -template -inline chset -operator&(chset const& a, negated_char_parser const& b) -{ - return a & chset(b); -} - -////////////////////////////////// -template -inline chset -operator-(chset const& a, negated_char_parser const& b) -{ - return a - chset(b); -} - -////////////////////////////////// -template -inline chset -operator^(chset const& a, negated_char_parser const& b) -{ - return a ^ chset(b); -} - -////////////////////////////////// -template -inline chset -operator|(negated_char_parser const& a, chset const& b) -{ - return chset(a) | b; -} - -////////////////////////////////// -template -inline chset -operator&(negated_char_parser const& a, chset const& b) -{ - return chset(a) & b; -} - -////////////////////////////////// -template -inline chset -operator-(negated_char_parser const& a, chset const& b) -{ - return chset(a) - b; -} - -////////////////////////////////// -template -inline chset -operator^(negated_char_parser const& a, chset const& b) -{ - return chset(a) ^ b; -} - -#else // BOOST_WORKAROUND(BOOST_MSVC, < 1300) - -/////////////////////////////////////////////////////////////////////////////// -// -// negated_char_parser <--> chset free operators implementation -// -/////////////////////////////////////////////////////////////////////////////// -template -inline chset -operator|(chset const& a, negated_char_parser > const& b) -{ - return a | chset(b); -} - -////////////////////////////////// -template -inline chset -operator&(chset const& a, negated_char_parser > const& b) -{ - return a & chset(b); -} - -////////////////////////////////// -template -inline chset -operator-(chset const& a, negated_char_parser > const& b) -{ - return a - chset(b); -} - -////////////////////////////////// -template -inline chset -operator^(chset const& a, negated_char_parser > const& b) -{ - return a ^ chset(b); -} - -////////////////////////////////// -template -inline chset -operator|(negated_char_parser > const& a, chset const& b) -{ - return chset(a) | b; -} - -////////////////////////////////// -template -inline chset -operator&(negated_char_parser > const& a, chset const& b) -{ - return chset(a) & b; -} - -////////////////////////////////// -template -inline chset -operator-(negated_char_parser > const& a, chset const& b) -{ - return chset(a) - b; -} - -////////////////////////////////// -template -inline chset -operator^(negated_char_parser > const& a, chset const& b) -{ - return chset(a) ^ b; -} - -/////////////////////////////////////////////////////////////////////////////// -// -// negated_char_parser <--> chset free operators implementation -// -/////////////////////////////////////////////////////////////////////////////// -template -inline chset -operator|(chset const& a, negated_char_parser > const& b) -{ - return a | chset(b); -} - -////////////////////////////////// -template -inline chset -operator&(chset const& a, negated_char_parser > const& b) -{ - return a & chset(b); -} - -////////////////////////////////// -template -inline chset -operator-(chset const& a, negated_char_parser > const& b) -{ - return a - chset(b); -} - -////////////////////////////////// -template -inline chset -operator^(chset const& a, negated_char_parser > const& b) -{ - return a ^ chset(b); -} - -////////////////////////////////// -template -inline chset -operator|(negated_char_parser > const& a, chset const& b) -{ - return chset(a) | b; -} - -////////////////////////////////// -template -inline chset -operator&(negated_char_parser > const& a, chset const& b) -{ - return chset(a) & b; -} - -////////////////////////////////// -template -inline chset -operator-(negated_char_parser > const& a, chset const& b) -{ - return chset(a) - b; -} - -////////////////////////////////// -template -inline chset -operator^(negated_char_parser > const& a, chset const& b) -{ - return chset(a) ^ b; -} - -#endif // BOOST_WORKAROUND(BOOST_MSVC, < 1300) - -/////////////////////////////////////////////////////////////////////////////// -// -// anychar_parser <--> chset free operators -// -// Where a is chset and b is a anychar_parser, and vice-versa, implements: -// -// a | b, a & b, a - b, a ^ b -// -/////////////////////////////////////////////////////////////////////////////// -namespace impl { - - template - inline boost::spirit::range const& - full() - { - static boost::spirit::range full_( - (std::numeric_limits::min)(), - (std::numeric_limits::max)()); - return full_; - } - - template - inline boost::spirit::range const& - empty() - { - static boost::spirit::range empty_; - return empty_; - } -} - -////////////////////////////////// -template -inline chset -operator|(chset const&, anychar_parser) -{ - return chset(impl::full()); -} - -////////////////////////////////// -template -inline chset -operator&(chset const& a, anychar_parser) -{ - return a; -} - -////////////////////////////////// -template -inline chset -operator-(chset const&, anychar_parser) -{ - return chset(); -} - -////////////////////////////////// -template -inline chset -operator^(chset const& a, anychar_parser) -{ - return ~a; -} - -////////////////////////////////// -template -inline chset -operator|(anychar_parser, chset const& /*b*/) -{ - return chset(impl::full()); -} - -////////////////////////////////// -template -inline chset -operator&(anychar_parser, chset const& b) -{ - return b; -} - -////////////////////////////////// -template -inline chset -operator-(anychar_parser, chset const& b) -{ - return ~b; -} - -////////////////////////////////// -template -inline chset -operator^(anychar_parser, chset const& b) -{ - return ~b; -} - -/////////////////////////////////////////////////////////////////////////////// -// -// nothing_parser <--> chset free operators implementation -// -/////////////////////////////////////////////////////////////////////////////// -template -inline chset -operator|(chset const& a, nothing_parser) -{ - return a; -} - -////////////////////////////////// -template -inline chset -operator&(chset const& /*a*/, nothing_parser) -{ - return impl::empty(); -} - -////////////////////////////////// -template -inline chset -operator-(chset const& a, nothing_parser) -{ - return a; -} - -////////////////////////////////// -template -inline chset -operator^(chset const& a, nothing_parser) -{ - return a; -} - -////////////////////////////////// -template -inline chset -operator|(nothing_parser, chset const& b) -{ - return b; -} - -////////////////////////////////// -template -inline chset -operator&(nothing_parser, chset const& /*b*/) -{ - return impl::empty(); -} - -////////////////////////////////// -template -inline chset -operator-(nothing_parser, chset const& /*b*/) -{ - return impl::empty(); -} - -////////////////////////////////// -template -inline chset -operator^(nothing_parser, chset const& b) -{ - return b; -} - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#endif - diff --git a/boost/boost/spirit/utility/impl/confix.ipp b/boost/boost/spirit/utility/impl/confix.ipp deleted file mode 100644 index 1b1b5dc21f..0000000000 --- a/boost/boost/spirit/utility/impl/confix.ipp +++ /dev/null @@ -1,217 +0,0 @@ -/*============================================================================= - Copyright (c) 2002-2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_CONFIX_IPP -#define BOOST_SPIRIT_CONFIX_IPP - -/////////////////////////////////////////////////////////////////////////////// -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -/////////////////////////////////////////////////////////////////////////////// -// -// Types to distinguish nested and non-nested confix parsers -// -/////////////////////////////////////////////////////////////////////////////// -struct is_nested {}; -struct non_nested {}; - -/////////////////////////////////////////////////////////////////////////////// -// -// Types to distinguish between confix parsers, which are implicitly lexems -// and without this behaviour -// -/////////////////////////////////////////////////////////////////////////////// -struct is_lexeme {}; -struct non_lexeme {}; - -/////////////////////////////////////////////////////////////////////////////// -// -// confix_parser_type class implementation -// -/////////////////////////////////////////////////////////////////////////////// -namespace impl { - - /////////////////////////////////////////////////////////////////////////// - // implicitly insert a lexeme_d into the parsing process - - template - struct select_confix_parse_lexeme; - - template <> - struct select_confix_parse_lexeme { - - template - static typename parser_result::type - parse(ParserT const& p, ScannerT const& scan) - { - typedef typename parser_result::type result_t; - return contiguous_parser_parse(p, scan, scan); - } - }; - - template <> - struct select_confix_parse_lexeme { - - template - static typename parser_result::type - parse(ParserT const& p, ScannerT const& scan) - { - return p.parse(scan); - } - }; - - /////////////////////////////////////////////////////////////////////////// - // parse confix sequences with refactoring - - template - struct select_confix_parse_refactor; - - template <> - struct select_confix_parse_refactor { - - template < - typename LexemeT, typename ParserT, typename ScannerT, - typename OpenT, typename ExprT, typename CloseT - > - static typename parser_result::type - parse( - LexemeT const &, ParserT const& this_, ScannerT const& scan, - OpenT const& open, ExprT const& expr, CloseT const& close) - { - typedef refactor_action_gen > refactor_t; - const refactor_t refactor_body_d = refactor_t(refactor_unary_d); - - return select_confix_parse_lexeme::parse(( - open - >> (this_ | refactor_body_d[expr - close]) - >> close - ), scan); - } - }; - - template <> - struct select_confix_parse_refactor { - - template < - typename LexemeT, typename ParserT, typename ScannerT, - typename OpenT, typename ExprT, typename CloseT - > - static typename parser_result::type - parse( - LexemeT const &, ParserT const& /*this_*/, ScannerT const& scan, - OpenT const& open, ExprT const& expr, CloseT const& close) - { - typedef refactor_action_gen > refactor_t; - const refactor_t refactor_body_d = refactor_t(refactor_unary_d); - - return select_confix_parse_lexeme::parse(( - open - >> refactor_body_d[expr - close] - >> close - ), scan); - } - }; - - /////////////////////////////////////////////////////////////////////////// - // parse confix sequences without refactoring - - template - struct select_confix_parse_no_refactor; - - template <> - struct select_confix_parse_no_refactor { - - template < - typename LexemeT, typename ParserT, typename ScannerT, - typename OpenT, typename ExprT, typename CloseT - > - static typename parser_result::type - parse( - LexemeT const &, ParserT const& this_, ScannerT const& scan, - OpenT const& open, ExprT const& expr, CloseT const& close) - { - return select_confix_parse_lexeme::parse(( - open - >> (this_ | (expr - close)) - >> close - ), scan); - } - }; - - template <> - struct select_confix_parse_no_refactor { - - template < - typename LexemeT, typename ParserT, typename ScannerT, - typename OpenT, typename ExprT, typename CloseT - > - static typename parser_result::type - parse( - LexemeT const &, ParserT const & /*this_*/, ScannerT const& scan, - OpenT const& open, ExprT const& expr, CloseT const& close) - { - return select_confix_parse_lexeme::parse(( - open - >> (expr - close) - >> close - ), scan); - } - }; - - // the refactoring is handled by the refactoring parsers, so here there - // is no need to pay attention to these issues. - - template - struct confix_parser_type { - - template < - typename NestedT, typename LexemeT, - typename ParserT, typename ScannerT, - typename OpenT, typename ExprT, typename CloseT - > - static typename parser_result::type - parse( - NestedT const &, LexemeT const &lexeme, - ParserT const& this_, ScannerT const& scan, - OpenT const& open, ExprT const& expr, CloseT const& close) - { - return select_confix_parse_refactor:: - parse(lexeme, this_, scan, open, expr, close); - } - }; - - template <> - struct confix_parser_type { - - template < - typename NestedT, typename LexemeT, - typename ParserT, typename ScannerT, - typename OpenT, typename ExprT, typename CloseT - > - static typename parser_result::type - parse( - NestedT const &, LexemeT const &lexeme, - ParserT const& this_, ScannerT const& scan, - OpenT const& open, ExprT const& expr, CloseT const& close) - { - return select_confix_parse_no_refactor:: - parse(lexeme, this_, scan, open, expr, close); - } - }; - -} // namespace impl - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#endif - diff --git a/boost/boost/spirit/utility/impl/escape_char.ipp b/boost/boost/spirit/utility/impl/escape_char.ipp deleted file mode 100644 index 85f27daba7..0000000000 --- a/boost/boost/spirit/utility/impl/escape_char.ipp +++ /dev/null @@ -1,220 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Daniel Nuffer - Copyright (c) 2002-2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_ESCAPE_CHAR_IPP -#define BOOST_SPIRIT_ESCAPE_CHAR_IPP - -#include -#include -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -/////////////////////////////////////////////////////////////////////////////// -// -// escape_char_parser class -// -/////////////////////////////////////////////////////////////////////////////// - -const unsigned long c_escapes = 1; -const unsigned long lex_escapes = c_escapes << 1; - -////////////////////////////////// -namespace impl { - - ////////////////////////////////// -#if (defined(BOOST_MSVC) && (BOOST_MSVC <= 1310)) -#pragma warning(push) -#pragma warning(disable:4127) -#endif - template - struct escape_char_action_parse { - - template - static typename parser_result::type - parse(ScannerT const& scan, ParserT const &p) - { - // Actually decode the escape char. - typedef CharT char_t; - typedef typename ScannerT::iterator_t iterator_t; - typedef typename parser_result::type result_t; - - if (scan.first != scan.last) { - - iterator_t save = scan.first; - if (result_t hit = p.subject().parse(scan)) { - - char_t unescaped; - - scan.first = save; - if (*scan.first == '\\') { - - ++scan.first; - switch (*scan.first) { - case 'b': unescaped = '\b'; ++scan.first; break; - case 't': unescaped = '\t'; ++scan.first; break; - case 'n': unescaped = '\n'; ++scan.first; break; - case 'f': unescaped = '\f'; ++scan.first; break; - case 'r': unescaped = '\r'; ++scan.first; break; - case '"': unescaped = '"'; ++scan.first; break; - case '\'': unescaped = '\''; ++scan.first; break; - case '\\': unescaped = '\\'; ++scan.first; break; - - case 'x': case 'X': - { - char_t hex = 0; - char_t const lim = - (std::numeric_limits::max)() >> 4; - - ++scan.first; - while (scan.first != scan.last) - { - char_t c = *scan.first; - if (hex > lim && impl::isxdigit_(c)) - { - // overflow detected - scan.first = save; - return scan.no_match(); - } - if (impl::isdigit_(c)) - { - hex <<= 4; - hex |= c - '0'; - ++scan.first; - } - else if (impl::isxdigit_(c)) - { - hex <<= 4; - c = impl::toupper_(c); - hex |= c - 'A' + 0xA; - ++scan.first; - } - else - { - break; // reached the end of the number - } - } - unescaped = hex; - } - break; - - case '0': case '1': case '2': case '3': - case '4': case '5': case '6': case '7': - { - char_t oct = 0; - char_t const lim = - (std::numeric_limits::max)() >> 3; - while (scan.first != scan.last) - { - char_t c = *scan.first; - if (oct > lim && (c >= '0' && c <= '7')) - { - // overflow detected - scan.first = save; - return scan.no_match(); - } - - if (c >= '0' && c <= '7') - { - oct <<= 3; - oct |= c - '0'; - ++scan.first; - } - else - { - break; // reached end of digits - } - } - unescaped = oct; - } - break; - - default: - if (Flags & c_escapes) - { - // illegal C escape sequence - scan.first = save; - return scan.no_match(); - } - else - { - unescaped = *scan.first; - ++scan.first; - } - break; - } - } - else { - unescaped = *scan.first; - ++scan.first; - } - - scan.do_action(p.predicate(), unescaped, save, scan.first); - return hit; - } - } - return scan.no_match(); // overflow detected - } - }; -#if (defined(BOOST_MSVC) && (BOOST_MSVC <= 1310)) -#pragma warning(pop) -#endif - - ////////////////////////////////// - template - struct escape_char_parse { - - template - static typename parser_result::type - parse(ScannerT const &scan, ParserT const &/*p*/) - { - typedef - uint_parser::digits / 3 + 1 - > - oct_parser_t; - typedef - uint_parser::digits / 4 + 1 - > - hex_parser_t; - - typedef alternative >, - sequence, alternative >, hex_parser_t > >, - difference > >, oct_parser_t > > > > - parser_t; - - static parser_t p = - ( (anychar_p - chlit(CharT('\\'))) - | (chlit(CharT('\\')) >> - ( oct_parser_t() - | as_lower_d[chlit(CharT('x'))] >> hex_parser_t() - | (anychar_p - as_lower_d[chlit(CharT('x'))] - oct_parser_t()) - ) - )); - - BOOST_SPIRIT_DEBUG_TRACE_NODE(p, - (BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_ESCAPE_CHAR) != 0); - - return p.parse(scan); - } - }; - -/////////////////////////////////////////////////////////////////////////////// -} // namespace impl - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#endif - diff --git a/boost/boost/spirit/utility/impl/lists.ipp b/boost/boost/spirit/utility/impl/lists.ipp deleted file mode 100644 index 43662fb15d..0000000000 --- a/boost/boost/spirit/utility/impl/lists.ipp +++ /dev/null @@ -1,164 +0,0 @@ -/*============================================================================= - Copyright (c) 2002-2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_LISTS_IPP -#define BOOST_SPIRIT_LISTS_IPP - -/////////////////////////////////////////////////////////////////////////////// -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -/////////////////////////////////////////////////////////////////////////////// -// -// list_parser_type class implementation -// -/////////////////////////////////////////////////////////////////////////////// -struct no_list_endtoken { typedef no_list_endtoken embed_t; }; - -namespace impl { - -/////////////////////////////////////////////////////////////////////////////// -// -// Refactor the original list item parser -// -/////////////////////////////////////////////////////////////////////////////// - - // match list with 'extended' syntax - template - struct select_list_parse_refactor { - - template < - typename ParserT, typename ScannerT, - typename ItemT, typename DelimT - > - static typename parser_result::type - parse(ScannerT const& scan, ParserT const& /*p*/, - ItemT const &item, DelimT const &delim, EndT const &end) - { - typedef refactor_action_gen > refactor_t; - const refactor_t refactor_item_d = refactor_t(refactor_unary_d); - - return ( - refactor_item_d[item - (end | delim)] - >> *(delim >> refactor_item_d[item - (end | delim)]) - >> !(delim >> end) - ).parse(scan); - } - }; - - // match list with 'normal' syntax (without an 'end' parser) - template <> - struct select_list_parse_refactor { - - template < - typename ParserT, typename ScannerT, - typename ItemT, typename DelimT - > - static typename parser_result::type - parse(ScannerT const& scan, ParserT const& /*p*/, - ItemT const &item, DelimT const &delim, no_list_endtoken const&) - { - typedef refactor_action_gen > refactor_t; - const refactor_t refactor_item_d = refactor_t(refactor_unary_d); - - return ( - refactor_item_d[item - delim] - >> *(delim >> refactor_item_d[item - delim]) - ).parse(scan); - } - }; - -/////////////////////////////////////////////////////////////////////////////// -// -// Do not refactor the original list item parser. -// -/////////////////////////////////////////////////////////////////////////////// - - // match list with 'extended' syntax - template - struct select_list_parse_no_refactor { - - template < - typename ParserT, typename ScannerT, - typename ItemT, typename DelimT - > - static typename parser_result::type - parse(ScannerT const& scan, ParserT const& /*p*/, - ItemT const &item, DelimT const &delim, EndT const &end) - { - return ( - (item - (end | delim)) - >> *(delim >> (item - (end | delim))) - >> !(delim >> end) - ).parse(scan); - } - }; - - // match list with 'normal' syntax (without an 'end' parser) - template <> - struct select_list_parse_no_refactor { - - template < - typename ParserT, typename ScannerT, - typename ItemT, typename DelimT - > - static typename parser_result::type - parse(ScannerT const& scan, ParserT const& /*p*/, - ItemT const &item, DelimT const &delim, no_list_endtoken const&) - { - return ( - (item - delim) - >> *(delim >> (item - delim)) - ).parse(scan); - } - }; - - // the refactoring is handled by the refactoring parsers, so here there - // is no need to pay attention to these issues. - - template - struct list_parser_type { - - template < - typename ParserT, typename ScannerT, - typename ItemT, typename DelimT, typename EndT - > - static typename parser_result::type - parse(ScannerT const& scan, ParserT const& p, - ItemT const &item, DelimT const &delim, EndT const &end) - { - return select_list_parse_refactor:: - parse(scan, p, item, delim, end); - } - }; - - template <> - struct list_parser_type { - - template < - typename ParserT, typename ScannerT, - typename ItemT, typename DelimT, typename EndT - > - static typename parser_result::type - parse(ScannerT const& scan, ParserT const& p, - ItemT const &item, DelimT const &delim, EndT const &end) - { - return select_list_parse_no_refactor:: - parse(scan, p, item, delim, end); - } - }; - -} // namespace impl - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#endif - diff --git a/boost/boost/spirit/utility/lists.hpp b/boost/boost/spirit/utility/lists.hpp deleted file mode 100644 index 7ac8f49d30..0000000000 --- a/boost/boost/spirit/utility/lists.hpp +++ /dev/null @@ -1,336 +0,0 @@ -/*============================================================================= - Copyright (c) 2002-2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#ifndef BOOST_SPIRIT_LISTS_HPP -#define BOOST_SPIRIT_LISTS_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include -#include -#include -#include - -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - -/////////////////////////////////////////////////////////////////////////////// -// -// list_parser class -// -// List parsers allow to parse constructs like -// -// item >> *(delim >> item) -// -// where 'item' is an auxiliary expression to parse and 'delim' is an -// auxiliary delimiter to parse. -// -// The list_parser class also can match an optional closing delimiter -// represented by the 'end' parser at the end of the list: -// -// item >> *(delim >> item) >> !end. -// -// If ItemT is an action_parser_category type (parser with an attached -// semantic action) we have to do something special. This happens, if the -// user wrote something like: -// -// list_p(item[f], delim) -// -// where 'item' is the parser matching one item of the list sequence and -// 'f' is a functor to be called after matching one item. If we would do -// nothing, the resulting code would parse the sequence as follows: -// -// (item[f] - delim) >> *(delim >> (item[f] - delim)) -// -// what in most cases is not what the user expects. -// (If this _is_ what you've expected, then please use one of the list_p -// generator functions 'direct()', which will inhibit re-attaching -// the actor to the item parser). -// -// To make the list parser behave as expected: -// -// (item - delim)[f] >> *(delim >> (item - delim)[f]) -// -// the actor attached to the 'item' parser has to be re-attached to the -// *(item - delim) parser construct, which will make the resulting list -// parser 'do the right thing'. -// -// Additionally special care must be taken, if the item parser is a -// unary_parser_category type parser as -// -// list_p(*anychar_p, ',') -// -// which without any refactoring would result in -// -// (*anychar_p - ch_p(',')) -// >> *( ch_p(',') >> (*anychar_p - ch_p(',')) ) -// -// and will not give the expected result (the first *anychar_p will eat up -// all the input up to the end of the input stream). So we have to -// refactor this into: -// -// *(anychar_p - ch_p(',')) -// >> *( ch_p(',') >> *(anychar_p - ch_p(',')) ) -// -// what will give the correct result. -// -// The case, where the item parser is a combination of the two mentioned -// problems (i.e. the item parser is a unary parser with an attached -// action), is handled accordingly too: -// -// list_p((*anychar_p)[f], ',') -// -// will be parsed as expected: -// -// (*(anychar_p - ch_p(',')))[f] -// >> *( ch_p(',') >> (*(anychar_p - ch_p(',')))[f] ). -// -/////////////////////////////////////////////////////////////////////////////// -template < - typename ItemT, typename DelimT, typename EndT, typename CategoryT -> -struct list_parser : - public parser > { - - typedef list_parser self_t; - typedef CategoryT parser_category_t; - - list_parser(ItemT const &item_, DelimT const &delim_, - EndT const& end_ = no_list_endtoken()) - : item(item_), delim(delim_), end(end_) - {} - - template - typename parser_result::type - parse(ScannerT const& scan) const - { - return impl::list_parser_type - ::parse(scan, *this, item, delim, end); - } - -private: - typename as_parser::type::embed_t item; - typename as_parser::type::embed_t delim; - typename as_parser::type::embed_t end; -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// List parser generator template -// -// This is a helper for generating a correct list_parser<> from -// auxiliary parameters. There are the following types supported as -// parameters yet: parsers, single characters and strings (see -// as_parser<> in meta/as_parser.hpp). -// -// The list_parser_gen by itself can be used for parsing comma separated -// lists without item formatting: -// -// list_p.parse(...) -// matches any comma separated list. -// -// If list_p is used with one parameter, this parameter is used to match -// the delimiter: -// -// list_p(';').parse(...) -// matches any semicolon separated list. -// -// If list_p is used with two parameters, the first parameter is used to -// match the items and the second parameter matches the delimiters: -// -// list_p(uint_p, ',').parse(...) -// matches comma separated unsigned integers. -// -// If list_p is used with three parameters, the first parameter is used -// to match the items, the second one is used to match the delimiters and -// the third one is used to match an optional ending token sequence: -// -// list_p(real_p, ';', eol_p).parse(...) -// matches a semicolon separated list of real numbers optionally -// followed by an end of line. -// -// The list_p in the previous examples denotes the predefined parser -// generator, which should be used to define list parsers (see below). -// -/////////////////////////////////////////////////////////////////////////////// - -template -struct list_parser_gen : - public list_parser, chlit > -{ - typedef list_parser_gen self_t; - -// construct the list_parser_gen object as an list parser for comma separated -// lists without item formatting. - list_parser_gen() - : list_parser, chlit > - (*anychar_p, chlit(',')) - {} - -// The following generator functions should be used under normal circumstances. -// (the operator()(...) functions) - - // Generic generator functions for creation of concrete list parsers, which - // support 'normal' syntax: - // - // item >> *(delim >> item) - // - // If item isn't given, everything between two delimiters is matched. - - template - list_parser< - kleene_star, - typename as_parser::type, - no_list_endtoken, - unary_parser_category // there is no action to re-attach - > - operator()(DelimT const &delim_) const - { - typedef kleene_star item_t; - typedef typename as_parser::type delim_t; - - typedef - list_parser - return_t; - - return return_t(*anychar_p, as_parser::convert(delim_)); - } - - template - list_parser< - typename as_parser::type, - typename as_parser::type, - no_list_endtoken, - typename as_parser::type::parser_category_t - > - operator()(ItemT const &item_, DelimT const &delim_) const - { - typedef typename as_parser::type item_t; - typedef typename as_parser::type delim_t; - typedef list_parser - return_t; - - return return_t( - as_parser::convert(item_), - as_parser::convert(delim_) - ); - } - - // Generic generator function for creation of concrete list parsers, which - // support 'extended' syntax: - // - // item >> *(delim >> item) >> !end - - template - list_parser< - typename as_parser::type, - typename as_parser::type, - typename as_parser::type, - typename as_parser::type::parser_category_t - > - operator()( - ItemT const &item_, DelimT const &delim_, EndT const &end_) const - { - typedef typename as_parser::type item_t; - typedef typename as_parser::type delim_t; - typedef typename as_parser::type end_t; - - typedef list_parser - return_t; - - return return_t( - as_parser::convert(item_), - as_parser::convert(delim_), - as_parser::convert(end_) - ); - } - -// The following functions should be used, if the 'item' parser has an attached -// semantic action or is a unary_parser_category type parser and the structure -// of the resulting list parser should _not_ be refactored during parser -// construction (see comment above). - - // Generic generator function for creation of concrete list parsers, which - // support 'normal' syntax: - // - // item >> *(delim >> item) - - template - list_parser< - typename as_parser::type, - typename as_parser::type, - no_list_endtoken, - plain_parser_category // inhibit action re-attachment - > - direct(ItemT const &item_, DelimT const &delim_) const - { - typedef typename as_parser::type item_t; - typedef typename as_parser::type delim_t; - typedef list_parser - return_t; - - return return_t( - as_parser::convert(item_), - as_parser::convert(delim_) - ); - } - - // Generic generator function for creation of concrete list parsers, which - // support 'extended' syntax: - // - // item >> *(delim >> item) >> !end - - template - list_parser< - typename as_parser::type, - typename as_parser::type, - typename as_parser::type, - plain_parser_category // inhibit action re-attachment - > - direct( - ItemT const &item_, DelimT const &delim_, EndT const &end_) const - { - typedef typename as_parser::type item_t; - typedef typename as_parser::type delim_t; - typedef typename as_parser::type end_t; - - typedef - list_parser - return_t; - - return return_t( - as_parser::convert(item_), - as_parser::convert(delim_), - as_parser::convert(end_) - ); - } -}; - -/////////////////////////////////////////////////////////////////////////////// -// -// Predefined list parser generator -// -// The list_p parser generator can be used -// - by itself for parsing comma separated lists without item formatting -// or -// - for generating list parsers with auxiliary parser parameters -// for the 'item', 'delim' and 'end' subsequences. -// (see comment above) -// -/////////////////////////////////////////////////////////////////////////////// -const list_parser_gen<> list_p = list_parser_gen<>(); - -/////////////////////////////////////////////////////////////////////////////// -}} // namespace boost::spirit - -#endif diff --git a/boost/boost/spirit/utility/loops.hpp b/boost/boost/spirit/utility/loops.hpp deleted file mode 100644 index f42776a029..0000000000 --- a/boost/boost/spirit/utility/loops.hpp +++ /dev/null @@ -1,313 +0,0 @@ -/*============================================================================= - Copyright (c) 1998-2003 Joel de Guzman - Copyright (c) 2002 Raghavendra Satish - Copyright (c) 2002 Jeff Westfahl - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(BOOST_SPIRIT_LOOPS_HPP) -#define BOOST_SPIRIT_LOOPS_HPP - -/////////////////////////////////////////////////////////////////////////////// -#include -#include - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // fixed_loop class - // - // This class takes care of the construct: - // - // repeat_p (exact) [p] - // - // where 'p' is a parser and 'exact' is the number of times to - // repeat. The parser iterates over the input exactly 'exact' times. - // The parse function fails if the parser does not match the input - // exactly 'exact' times. - // - // This class is parametizable and can accept constant arguments - // (e.g. repeat_p (5) [p]) as well as references to variables (e.g. - // repeat_p (ref (n)) [p]). - // - /////////////////////////////////////////////////////////////////////////// - template - class fixed_loop - : public unary > > - { - public: - - typedef fixed_loop self_t; - typedef unary > base_t; - - fixed_loop (ParserT const & subject, ExactT const & exact) - : base_t(subject), m_exact(exact) {} - - template - typename parser_result ::type - parse (ScannerT const & scan) const - { - typedef typename parser_result::type result_t; - result_t hit = scan.empty_match(); - std::size_t n = m_exact; - - for (std::size_t i = 0; i < n; ++i) - { - if (result_t next = this->subject().parse(scan)) - { - scan.concat_match(hit, next); - } - else - { - return scan.no_match(); - } - } - - return hit; - } - - template - struct result - { - typedef typename match_result::type type; - }; - - private: - - ExactT m_exact; - }; - - /////////////////////////////////////////////////////////////////////////////// - // - // finite_loop class - // - // This class takes care of the construct: - // - // repeat_p (min, max) [p] - // - // where 'p' is a parser, 'min' and 'max' specifies the minimum and - // maximum iterations over 'p'. The parser iterates over the input - // at least 'min' times and at most 'max' times. The parse function - // fails if the parser does not match the input at least 'min' times - // and at most 'max' times. - // - // This class is parametizable and can accept constant arguments - // (e.g. repeat_p (5, 10) [p]) as well as references to variables - // (e.g. repeat_p (ref (n1), ref (n2)) [p]). - // - /////////////////////////////////////////////////////////////////////////////// - template - class finite_loop - : public unary > > - { - public: - - typedef finite_loop self_t; - typedef unary > base_t; - - finite_loop (ParserT const & subject, MinT const & min, MaxT const & max) - : base_t(subject), m_min(min), m_max(max) {} - - template - typename parser_result ::type - parse(ScannerT const & scan) const - { - BOOST_SPIRIT_ASSERT(m_min <= m_max); - typedef typename parser_result::type result_t; - result_t hit = scan.empty_match(); - - std::size_t n1 = m_min; - std::size_t n2 = m_max; - - for (std::size_t i = 0; i < n2; ++i) - { - typename ScannerT::iterator_t save = scan.first; - result_t next = this->subject().parse(scan); - - if (!next) - { - if (i >= n1) - { - scan.first = save; - break; - } - else - { - return scan.no_match(); - } - } - - scan.concat_match(hit, next); - } - - return hit; - } - - template - struct result - { - typedef typename match_result::type type; - }; - - private: - - MinT m_min; - MaxT m_max; - }; - - /////////////////////////////////////////////////////////////////////////////// - // - // infinite_loop class - // - // This class takes care of the construct: - // - // repeat_p (min, more) [p] - // - // where 'p' is a parser, 'min' is the minimum iteration over 'p' - // and more specifies that the iteration should proceed - // indefinitely. The parser iterates over the input at least 'min' - // times and continues indefinitely until 'p' fails or all of the - // input is parsed. The parse function fails if the parser does not - // match the input at least 'min' times. - // - // This class is parametizable and can accept constant arguments - // (e.g. repeat_p (5, more) [p]) as well as references to variables - // (e.g. repeat_p (ref (n), more) [p]). - // - /////////////////////////////////////////////////////////////////////////////// - - struct more_t {}; - more_t const more = more_t (); - - template - class infinite_loop - : public unary > > - { - public: - - typedef infinite_loop self_t; - typedef unary > base_t; - - infinite_loop ( - ParserT const& subject, - MinT const& min, - more_t const& - ) - : base_t(subject), m_min(min) {} - - template - typename parser_result ::type - parse(ScannerT const & scan) const - { - typedef typename parser_result::type result_t; - result_t hit = scan.empty_match(); - std::size_t n = m_min; - - for (std::size_t i = 0; ; ++i) - { - typename ScannerT::iterator_t save = scan.first; - result_t next = this->subject().parse(scan); - - if (!next) - { - if (i >= n) - { - scan.first = save; - break; - } - else - { - return scan.no_match(); - } - } - - scan.concat_match(hit, next); - } - - return hit; - } - - template - struct result - { - typedef typename match_result::type type; - }; - - private: - - MinT m_min; - }; - - template - struct fixed_loop_gen - { - fixed_loop_gen (ExactT const & exact) - : m_exact (exact) {} - - template - fixed_loop - operator[](parser const & subject) const - { - return fixed_loop (subject.derived (), m_exact); - } - - ExactT m_exact; - }; - - namespace impl { - - template - struct loop_traits - { - typedef typename mpl::if_< - boost::is_same, - infinite_loop, - finite_loop - >::type type; - }; - - } // namespace impl - - template - struct nonfixed_loop_gen - { - nonfixed_loop_gen (MinT min, MaxT max) - : m_min (min), m_max (max) {} - - template - typename impl::loop_traits::type - operator[](parser const & subject) const - { - typedef typename impl::loop_traits::type ret_t; - return ret_t( - subject.derived(), - m_min, - m_max); - } - - MinT m_min; - MaxT m_max; - }; - - template - fixed_loop_gen - repeat_p(ExactT const & exact) - { - return fixed_loop_gen (exact); - } - - template - nonfixed_loop_gen - repeat_p(MinT const & min, MaxT const & max) - { - return nonfixed_loop_gen (min, max); - } - -}} // namespace boost::spirit - -#endif // #if !defined(BOOST_SPIRIT_LOOPS_HPP) diff --git a/boost/boost/spirit/utility/scoped_lock.hpp b/boost/boost/spirit/utility/scoped_lock.hpp deleted file mode 100644 index a22dd20a06..0000000000 --- a/boost/boost/spirit/utility/scoped_lock.hpp +++ /dev/null @@ -1,108 +0,0 @@ -/*============================================================================= - Copyright (c) 2003 Martin Wille - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) - =============================================================================*/ -#ifndef BOOST_SPIRIT_UTILITY_SCOPED_LOCK_HPP -#define BOOST_SPIRIT_UTILITY_SCOPED_LOCK_HPP - -/////////////////////////////////////////////////////////////////////////////// -#if !defined(BOOST_SPIRIT_COMPOSITE_HPP) -#include -#endif - -/////////////////////////////////////////////////////////////////////////////// -namespace boost { namespace spirit { - - /////////////////////////////////////////////////////////////////////////// - // - // scoped_lock_parser class - // - // implements locking of a mutex during execution of - // the parse method of an embedded parser - // - /////////////////////////////////////////////////////////////////////////// - template - struct scoped_lock_parser - : public unary< ParserT, parser< scoped_lock_parser > > - { - typedef scoped_lock_parser self_t; - typedef MutexT mutex_t; - typedef ParserT parser_t; - - template - struct result - { - typedef typename parser_result::type type; - }; - - scoped_lock_parser(mutex_t &m, parser_t const &p) - : unary< ParserT, parser< scoped_lock_parser > >(p) - , mutex(m) - {} - - - template - typename parser_result::type - parse(ScannerT const &scan) const - { - typedef typename mutex_t::scoped_lock scoped_lock_t; - scoped_lock_t lock(mutex); - return this->subject().parse(scan); - } - - mutex_t &mutex; - }; - - /////////////////////////////////////////////////////////////////////////// - // - // scoped_lock_parser_gen - // - // generator for scoped_lock_parser objects - // operator[] returns scoped_lock_parser according to its argument - // - /////////////////////////////////////////////////////////////////////////// - template - struct scoped_lock_parser_gen - { - typedef MutexT mutex_t; - explicit scoped_lock_parser_gen(mutex_t &m) : mutex(m) {} - - template - scoped_lock_parser - < - MutexT, - typename as_parser::type - > - operator[](ParserT const &p) const - { - typedef ::boost::spirit::as_parser as_parser_t; - typedef typename as_parser_t::type parser_t; - - return scoped_lock_parser - (mutex, as_parser_t::convert(p)); - } - - mutex_t &mutex; - }; - - - /////////////////////////////////////////////////////////////////////////// - // - // scoped_lock_d parser directive - // - // constructs a scoped_lock_parser generator from its argument - // - /////////////////////////////////////////////////////////////////////////// - template - scoped_lock_parser_gen - scoped_lock_d(MutexT &mutex) - { - return scoped_lock_parser_gen(mutex); - } - -}} // namespace boost::spirit -#endif // BOOST_SPIRIT_UTILITY_SCOPED_LOCK_HPP diff --git a/boost/boost/spirit/version.hpp b/boost/boost/spirit/version.hpp deleted file mode 100644 index 48c1f86b9e..0000000000 --- a/boost/boost/spirit/version.hpp +++ /dev/null @@ -1,31 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2003 Hartmut Kaiser - http://spirit.sourceforge.net/ - - Use, modification and distribution is subject to the Boost Software - License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at - http://www.boost.org/LICENSE_1_0.txt) -=============================================================================*/ -#if !defined(SPIRIT_VERSION_HPP) -#define SPIRIT_VERSION_HPP - -/////////////////////////////////////////////////////////////////////////////// -// -// This checks, whether the used Boost library is at least V1.32.0 -// -/////////////////////////////////////////////////////////////////////////////// -#include - -#if BOOST_VERSION < 103200 -#error "Spirit v1.8.x needs at least Boost V1.32.0 to compile successfully." -#endif - -/////////////////////////////////////////////////////////////////////////////// -// -// This is the version of the current Spirit distribution -// -/////////////////////////////////////////////////////////////////////////////// -#define SPIRIT_VERSION 0x1804 -#define SPIRIT_PIZZA_VERSION SPIRIT_DOUBLE_CHEESE // :-) - -#endif // defined(SPIRIT_VERSION_HPP)