FM / impl

/usr/include/boost/spirit/home/classic/core/composite/impl/

/usr/include/boost/spirit/home/classic/core/composite/impl

Name	Size	Mode	Actions
alternative.ipp	2752	0644	edit dl rm
difference.ipp	2731	0644	edit dl rm
directives.ipp	6738	0644	edit dl rm
exclusive_or.ipp	2773	0644	edit dl rm
intersection.ipp	2773	0644	edit dl rm
kleene_star.ipp	1093	0644	edit dl rm
list.ipp	2908	0644	edit dl rm
optional.ipp	1071	0644	edit dl rm
positive.ipp	1078	0644	edit dl rm
sequence.ipp	2702	0644	edit dl rm
sequential_and.ipp	2724	0644	edit dl rm
sequential_or.ipp	2803	0644	edit dl rm

Edit: /usr/include/boost/spirit/home/classic/core/composite/impl/sequential_or.ipp (2803B)

/*=============================================================================
    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 {

BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN

///////////////////////////////////////////////////////////////////////////
 //
 // sequential-or class implementation
 //
 ///////////////////////////////////////////////////////////////////////////
 template <typename A, typename B>
 inline sequential_or<A, B>
 operator||(parser<A> const& a, parser const& b)
 {
 return sequential_or<A, B>(a.derived(), b.derived());
 }
 
 template <typename A>
 inline sequential_or<A, chlit<char> >
 operator||(parser<A> const& a, char b)
 {
 return sequential_or<A, chlit<char> >(a.derived(), b);
 }
 
 template <typename B>
 inline sequential_or<chlit<char>, B>
 operator||(char a, parser const& b)
 {
 return sequential_or<chlit<char>, B>(a, b.derived());
 }
 
 template <typename A>
 inline sequential_or<A, strlit<char const*> >
 operator||(parser<A> const& a, char const* b)
 {
 return sequential_or<A, strlit<char const*> >(a.derived(), b);
 }
 
 template <typename B>
 inline sequential_or<strlit<char const*>, B>
 operator||(char const* a, parser const& b)
 {
 return sequential_or<strlit<char const*>, B>(a, b.derived());
 }
 
 template <typename A>
 inline sequential_or<A, chlit<wchar_t> >
 operator||(parser<A> const& a, wchar_t b)
 {
 return sequential_or<A, chlit<wchar_t> >(a.derived(), b);
 }
 
 template <typename B>
 inline sequential_or<chlit<wchar_t>, B>
 operator||(wchar_t a, parser const& b)
 {
 return sequential_or<chlit<wchar_t>, B>(a, b.derived());
 }
 
 template <typename A>
 inline sequential_or<A, strlit<wchar_t const*> >
 operator||(parser<A> const& a, wchar_t const* b)
 {
 return sequential_or<A, strlit<wchar_t const*> >(a.derived(), b);
 }
 
 template <typename B>
 inline sequential_or<strlit<wchar_t const*>, B>
 operator||(wchar_t const* a, parser const& b)
 {
 return sequential_or<strlit<wchar_t const*>, B>(a, b.derived());
 }

BOOST_SPIRIT_CLASSIC_NAMESPACE_END

}} // namespace boost::spirit

#endif

cmd: