FM / v1

/usr/include/boost/metaparse/v1

Name	Size	Mode	Actions
cpp11/	-	0755	rm
cpp14/	-	0755	rm
cpp98/	-	0755	rm
error/	-	0755	rm
fwd/	-	0755	rm
impl/	-	0755	rm
util/	-	0755	rm
accept.hpp	817	0644	edit dl rm
accept_tag.hpp	1067	0644	edit dl rm
accept_when.hpp	1434	0644	edit dl rm
alphanum.hpp	569	0644	edit dl rm
always.hpp	1270	0644	edit dl rm
always_c.hpp	566	0644	edit dl rm
build_parser.hpp	1844	0644	edit dl rm
change_error_message.hpp	944	0644	edit dl rm
debug_parsing_error.hpp	2848	0644	edit dl rm
define_error.hpp	621	0644	edit dl rm
digit.hpp	828	0644	edit dl rm
digit_val.hpp	605	0644	edit dl rm
empty.hpp	985	0644	edit dl rm
entire_input.hpp	837	0644	edit dl rm
except.hpp	922	0644	edit dl rm
fail.hpp	614	0644	edit dl rm
fail_at_first_char_expected.hpp	1578	0644	edit dl rm
fail_tag.hpp	888	0644	edit dl rm
first_of.hpp	500	0644	edit dl rm
foldl.hpp	1846	0644	edit dl rm
foldl1.hpp	842	0644	edit dl rm
foldl_reject_incomplete.hpp	2308	0644	edit dl rm
foldl_reject_incomplete1.hpp	950	0644	edit dl rm
foldl_reject_incomplete_start_with_parser.hpp	1597	0644	edit dl rm
foldl_start_with_parser.hpp	1224	0644	edit dl rm
foldr.hpp	630	0644	edit dl rm
foldr1.hpp	846	0644	edit dl rm
foldr_reject_incomplete.hpp	879	0644	edit dl rm
foldr_reject_incomplete1.hpp	954	0644	edit dl rm
foldr_start_with_parser.hpp	2204	0644	edit dl rm
get_col.hpp	620	0644	edit dl rm
get_line.hpp	626	0644	edit dl rm
get_message.hpp	644	0644	edit dl rm
get_position.hpp	650	0644	edit dl rm
get_prev_char.hpp	656	0644	edit dl rm
get_remaining.hpp	656	0644	edit dl rm
get_result.hpp	645	0644	edit dl rm
grammar.hpp	11007	0644	edit dl rm
if_.hpp	903	0644	edit dl rm
int_.hpp	598	0644	edit dl rm
is_error.hpp	919	0644	edit dl rm
iterate.hpp	533	0644	edit dl rm
iterate_c.hpp	588	0644	edit dl rm
keyword.hpp	2307	0644	edit dl rm
last_of.hpp	496	0644	edit dl rm
letter.hpp	695	0644	edit dl rm
lit.hpp	501	0644	edit dl rm
lit_c.hpp	869	0644	edit dl rm
look_ahead.hpp	1179	0644	edit dl rm
middle_of.hpp	1138	0644	edit dl rm
next_char.hpp	692	0644	edit dl rm
next_line.hpp	692	0644	edit dl rm
nth_of.hpp	492	0644	edit dl rm
nth_of_c.hpp	500	0644	edit dl rm
one_char.hpp	1852	0644	edit dl rm
one_char_except.hpp	528	0644	edit dl rm
one_char_except_c.hpp	536	0644	edit dl rm
one_of.hpp	492	0644	edit dl rm
one_of_c.hpp	585	0644	edit dl rm
optional.hpp	930	0644	edit dl rm
range.hpp	816	0644	edit dl rm
range_c.hpp	794	0644	edit dl rm
reject.hpp	713	0644	edit dl rm
repeated.hpp	632	0644	edit dl rm
repeated1.hpp	651	0644	edit dl rm
repeated_one_of.hpp	528	0644	edit dl rm
repeated_one_of1.hpp	532	0644	edit dl rm
repeated_reject_incomplete.hpp	729	0644	edit dl rm
repeated_reject_incomplete1.hpp	734	0644	edit dl rm
return_.hpp	692	0644	edit dl rm
sequence.hpp	500	0644	edit dl rm
sequence_apply.hpp	2146	0644	edit dl rm
source_position.hpp	3704	0644	edit dl rm
source_position_tag.hpp	1894	0644	edit dl rm
space.hpp	709	0644	edit dl rm
spaces.hpp	520	0644	edit dl rm
start.hpp	657	0644	edit dl rm
string.hpp	492	0644	edit dl rm
string_tag.hpp	471	0644	edit dl rm
swap.hpp	561	0644	edit dl rm
token.hpp	632	0644	edit dl rm
transform.hpp	1330	0644	edit dl rm
transform_error.hpp	961	0644	edit dl rm
transform_error_message.hpp	1279	0644	edit dl rm
unless_error.hpp	679	0644	edit dl rm

Edit: /usr/include/boost/metaparse/v1/grammar.hpp (11007B)

#ifndef BOOST_METAPARSE_V1_GRAMMAR_HPP
#define BOOST_METAPARSE_V1_GRAMMAR_HPP

// Copyright Abel Sinkovics (abel@sinkovics.hu)  2012.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)

#include <boost/metaparse/v1/repeated.hpp>
#include <boost/metaparse/v1/repeated1.hpp>
#include <boost/metaparse/v1/sequence.hpp>
#include <boost/metaparse/v1/one_of.hpp>
#include <boost/metaparse/v1/transform.hpp>
#include <boost/metaparse/v1/lit.hpp>
#include <boost/metaparse/v1/lit_c.hpp>
#include <boost/metaparse/v1/token.hpp>
#include <boost/metaparse/v1/keyword.hpp>
#include <boost/metaparse/v1/middle_of.hpp>
#include <boost/metaparse/v1/last_of.hpp>
#include <boost/metaparse/v1/always.hpp>
#include <boost/metaparse/v1/one_char_except_c.hpp>
#include <boost/metaparse/v1/foldr1.hpp>
#include <boost/metaparse/v1/foldl_start_with_parser.hpp>
#include <boost/metaparse/v1/alphanum.hpp>
#include <boost/metaparse/v1/build_parser.hpp>
#include <boost/metaparse/v1/entire_input.hpp>
#include <boost/metaparse/v1/string.hpp>
#include <boost/metaparse/v1/impl/front_inserter.hpp>

#include <boost/mpl/at.hpp>
#include <boost/mpl/map.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/has_key.hpp>
#include <boost/mpl/lambda.hpp>
#include <boost/mpl/front.hpp>
#include <boost/mpl/back.hpp>
#include <boost/mpl/pair.hpp>
#include <boost/mpl/insert.hpp>

/*
 * The grammar
 *
 * rule_definition ::= name_token define_token expression
 * expression ::= seq_expression (or_token seq_expression)*
 * seq_expression ::= repeated_expression+
 * repeated_expression ::= name_expression (repeated_token | repeated1_token)*
 * name_expression ::= char_token | name_token | bracket_expression
 * bracket_expression ::= open_bracket_token expression close_bracket_token
 */

namespace boost
{
  namespace metaparse
  {
    namespace v1
    {
      namespace grammar_util
      {
        template <char Op, class FState>
        struct repeated_apply_impl
        {
          typedef repeated_apply_impl type;
        
          template <class G>
          struct apply :
            repeated<typename FState::template apply<G>::type>
          {};
        };

template <class FState>
        struct repeated_apply_impl<'+', FState>
        {
          typedef repeated_apply_impl type;
        
          template <class G>
          struct apply :
            repeated1<typename FState::template apply<G>::type>
          {};
        };

struct build_repeated
        {
          typedef build_repeated type;
        
          template <class FState, class T>
          struct apply : repeated_apply_impl<T::type::value, FState> {};
        };
        
        struct build_sequence
        {
          typedef build_sequence type;
        
          template <class FState, class FP>
          struct apply_impl
          {
            typedef apply_impl type;
        
            template <class G>
            struct apply :
              sequence<
                typename FState::template apply<G>::type,
                typename FP::template apply<G>::type
              >
            {};
          };
        
          template <class FState, class FP>
          struct apply : apply_impl<FState, FP> {};
        };
        
        struct build_selection
        {
          typedef build_selection type;
        
          template <class FState, class FP>
          struct apply_impl
          {
            typedef apply_impl type;
        
            template <class G>
            struct apply :
              one_of<
                typename FState::template apply<G>::type,
                typename FP::template apply<G>::type
              >
            {};
          };
        
          template <class FState, class FP>
          struct apply : apply_impl<FState, FP> {};
        };
        
        template <class G, class Name>
        struct get_parser
        {
          typedef
            typename boost::mpl::at<typename G::rules, Name>::type
              ::template apply<G>
            p;
        
          template <class Actions>
          struct impl : transform<typename p::type, typename Actions::type> {};
        
          typedef
            typename boost::mpl::eval_if<
              typename boost::mpl::has_key<typename G::actions, Name>::type,
              impl<boost::mpl::at<typename G::actions, Name> >,
              p
            >::type
            type;
        };
        
        struct build_name
        {
          typedef build_name type;
        
          template <class Name>
          struct apply_impl
          {
            typedef apply_impl type;
        
            template <class G>
            struct apply : get_parser<G, Name> {};
          };
        
          template <class Name>
          struct apply : apply_impl<Name> {};
        };
        
        struct build_char
        {
          typedef build_char type;
        
          template <class C>
          struct apply_impl
          {
            typedef apply_impl type;
        
            template <class G>
            struct apply : lit<C> {};
          };
        
          template <class C>
          struct apply : apply_impl<C> {};
        };
        
        typedef token<lit_c<'*'> > repeated_token;
        typedef token<lit_c<'+'> > repeated1_token;
        typedef token<lit_c<'|'> > or_token;
        typedef token<lit_c<'('> > open_bracket_token;
        typedef token<lit_c<')'> > close_bracket_token;
        typedef token<keyword<string<':',':','='> > > define_token;

typedef
          middle_of<
            lit_c<'\''>,
            one_of<
              last_of<
                lit_c<'\\'>,
                one_of<
                  always<lit_c<'n'>, boost::mpl::char_<'\n'> >,
                  always<lit_c<'r'>, boost::mpl::char_<'\r'> >,
                  always<lit_c<'t'>, boost::mpl::char_<'\t'> >,
                  lit_c<'\\'>,
                  lit_c<'\''>
                >
              >,
              one_char_except_c<'\''>
            >,
            token<lit_c<'\''> >
          >
          char_token;
        
        typedef
          token<
            foldr1<
              one_of<alphanum, lit_c<'_'> >,
              string<>,
              impl::front_inserter
            >
          >
          name_token;
        
        struct expression;
        
        typedef
          middle_of<open_bracket_token, expression, close_bracket_token>
          bracket_expression;

typedef
          one_of<
            transform<char_token, build_char>,
            transform<name_token, build_name>,
            bracket_expression
          >
          name_expression;

typedef
          foldl_start_with_parser<
            one_of<repeated_token, repeated1_token>,
            name_expression,
            build_repeated
          >
          repeated_expression;
        
        typedef
          foldl_start_with_parser<
            repeated_expression,
            repeated_expression,
            build_sequence
          >
          seq_expression;
        
        struct expression :
          foldl_start_with_parser<
            last_of<or_token, seq_expression>,
            seq_expression,
            build_selection
          >
        {};
        
        typedef sequence<name_token, define_token, expression> rule_definition;

typedef build_parser<entire_input<rule_definition> > parser_parser;
        
        template <class P>
        struct build_native_parser
        {
          typedef build_native_parser type;
        
          template <class G>
          struct apply
          {
            typedef P type;
          };
        };
        
        template <class S>
        struct build_parsed_parser
        {
          typedef typename parser_parser::apply<S>::type p;
          typedef typename boost::mpl::front<p>::type name;
          typedef typename boost::mpl::back<p>::type exp;
        
          struct the_parser
          {
            typedef the_parser type;
        
            template <class G>
            struct apply : exp::template apply<G> {};
          };
        
          typedef boost::mpl::pair<name, the_parser> type;
        };
        
        typedef build_parser<name_token> name_parser;
        
        template <class S>
        struct rebuild : name_parser::template apply<S> {};
        
        struct no_action;
        
        template <class G, class P, class F>
        struct add_rule;
        
        template <class G, class Name, class P>
        struct add_import;
        
        template <class Start, class Rules, class Actions>
        struct grammar_builder
        {
          typedef grammar_builder type;
          typedef Rules rules;
          typedef Actions actions;
        
          // Make it a parser
          template <class S, class Pos>
          struct apply :
            get_parser<
              grammar_builder,
              typename rebuild<Start>::type
            >::type::template apply<S, Pos>
          {};
        
          template <class Name, class P>
          struct import :
            add_import<grammar_builder, typename rebuild<Name>::type, P>
          {};
        
          template <class Def, class Action = no_action>
          struct rule :
            add_rule<grammar_builder, build_parsed_parser<Def>, Action>
          {};
        };
        
        template <class Start, class Rules, class Actions, class P>
        struct add_rule<grammar_builder<Start, Rules, Actions>, P, no_action> :
          grammar_builder<
            Start,
            typename boost::mpl::insert<Rules, typename P::type>::type,
            Actions
          >
        {};
        
        template <class Start, class Rules, class Actions, class P, class F>
        struct add_rule<grammar_builder<Start, Rules, Actions>, P, F> :
          grammar_builder<
            Start,
            typename boost::mpl::insert<Rules, typename P::type>::type,
            typename boost::mpl::insert<
              Actions,
              boost::mpl::pair<
                typename P::name,
                typename boost::mpl::lambda<F>::type
              >
            >
            ::type
          >
        {};
        
        template <class Start, class Rules, class Actions, class Name, class P>
        struct add_import<grammar_builder<Start, Rules, Actions>, Name, P> :
          grammar_builder<
            Start,
            typename boost::mpl::insert<
              Rules,
              boost::mpl::pair<Name, build_native_parser<P> >
            >::type,
            Actions
          >
        {};
      }

template <class Start = string<'S'> >
      struct grammar :
        grammar_util::grammar_builder<
          Start,
          boost::mpl::map<>,
          boost::mpl::map<>
        >
      {};
    }
  }
}

#endif

#ifndef BOOST_METAPARSE_V1_GRAMMAR_HPP #define BOOST_METAPARSE_V1_GRAMMAR_HPP // Copyright Abel Sinkovics (abel@sinkovics.hu) 2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* * The grammar * * rule_definition ::= name_token define_token expression * expression ::= seq_expression (or_token seq_expression)* * seq_expression ::= repeated_expression+ * repeated_expression ::= name_expression (repeated_token | repeated1_token)* * name_expression ::= char_token | name_token | bracket_expression * bracket_expression ::= open_bracket_token expression close_bracket_token */ namespace boost { namespace metaparse { namespace v1 { namespace grammar_util { template struct repeated_apply_impl { typedef repeated_apply_impl type; template struct apply : repeated::type> {}; }; template struct repeated_apply_impl<'+', FState> { typedef repeated_apply_impl type; template struct apply : repeated1::type> {}; }; struct build_repeated { typedef build_repeated type; template struct apply : repeated_apply_impl {}; }; struct build_sequence { typedef build_sequence type; template struct apply_impl { typedef apply_impl type; template struct apply : sequence< typename FState::template apply::type, typename FP::template apply::type > {}; }; template struct apply : apply_impl {}; }; struct build_selection { typedef build_selection type; template struct apply_impl { typedef apply_impl type; template struct apply : one_of< typename FState::template apply::type, typename FP::template apply::type > {}; }; template struct apply : apply_impl {}; }; template struct get_parser { typedef typename boost::mpl::at::type ::template apply p; template struct impl : transform {}; typedef typename boost::mpl::eval_if< typename boost::mpl::has_key::type, impl >, p >::type type; }; struct build_name { typedef build_name type; template struct apply_impl { typedef apply_impl type; template struct apply : get_parser {}; }; template struct apply : apply_impl {}; }; struct build_char { typedef build_char type; template struct apply_impl { typedef apply_impl type; template struct apply : lit {}; }; template struct apply : apply_impl {}; }; typedef token > repeated_token; typedef token > repeated1_token; typedef token > or_token; typedef token > open_bracket_token; typedef token > close_bracket_token; typedef token > > define_token; typedef middle_of< lit_c<'\''>, one_of< last_of< lit_c<'\\'>, one_of< always, boost::mpl::char_<'\n'> >, always, boost::mpl::char_<'\r'> >, always, boost::mpl::char_<'\t'> >, lit_c<'\\'>, lit_c<'\''> > >, one_char_except_c<'\''> >, token > > char_token; typedef token< foldr1< one_of >, string<>, impl::front_inserter > > name_token; struct expression; typedef middle_of bracket_expression; typedef one_of< transform, transform, bracket_expression > name_expression; typedef foldl_start_with_parser< one_of, name_expression, build_repeated > repeated_expression; typedef foldl_start_with_parser< repeated_expression, repeated_expression, build_sequence > seq_expression; struct expression : foldl_start_with_parser< last_of, seq_expression, build_selection > {}; typedef sequence rule_definition; typedef build_parser > parser_parser; template struct build_native_parser { typedef build_native_parser type; template struct apply { typedef P type; }; }; template struct build_parsed_parser { typedef typename parser_parser::apply::type p; typedef typename boost::mpl::front
::type name; typedef typename boost::mpl::back
::type exp; struct the_parser { typedef the_parser type; template struct apply : exp::template apply {}; }; typedef boost::mpl::pair type; }; typedef build_parser name_parser; template struct rebuild : name_parser::template apply {}; struct no_action; template struct add_rule; template struct add_import; template struct grammar_builder { typedef grammar_builder type; typedef Rules rules; typedef Actions actions; // Make it a parser template struct apply : get_parser< grammar_builder, typename rebuild::type >::type::template apply {}; template struct import : add_import::type, P> {}; template struct rule : add_rule, Action> {}; }; template struct add_rule, P, no_action> : grammar_builder< Start, typename boost::mpl::insert::type, Actions > {}; template struct add_rule, P, F> : grammar_builder< Start, typename boost::mpl::insert::type, typename boost::mpl::insert< Actions, boost::mpl::pair< typename P::name, typename boost::mpl::lambda::type > > ::type > {}; template struct add_import, Name, P> : grammar_builder< Start, typename boost::mpl::insert< Rules, boost::mpl::pair > >::type, Actions > {}; } template > struct grammar : grammar_util::grammar_builder< Start, boost::mpl::map<>, boost::mpl::map<> > {}; } } } #endif