x
Yes
No
Do you want to visit DriveHQ English website?
Inicio
Características
Precios
Prueba gratuita
Software cliente
Acerca de nosotros
Servidor de archivos
|
Solución de copias de seguridad
|
Servidor FTP
|
Servidor de correo electrónico
|
Alojamiento web
|
Software cliente
Servidor de archivos
Solución de copia de seguridad
Servidor FTP
Servidor de correo electrónico
Alojamiento web
Software cliente
parse_tree.hpp - Hosted on DriveHQ Cloud IT Platform
Arriba
Subir
Descargar
Compartir
Publicar
Nueva carpeta
Nuevo archivo
Copiar
Cortar
Eliminar
Pegar
Clasificación
Actualizar
Ruta de la carpeta: \\game3dprogramming\materials\GameFactory\GameFactoryDemo\references\boost_1_35_0\boost\spirit\tree\parse_tree.hpp
Girar
Efecto
Propiedad
Historial
/*============================================================================= Copyright (c) 2001-2003 Daniel Nuffer Copyright (c) 2001-2007 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_TREE_PARSE_TREE_HPP #define BOOST_SPIRIT_TREE_PARSE_TREE_HPP #include
#include
#include
/////////////////////////////////////////////////////////////////////////////// namespace boost { namespace spirit { ////////////////////////////////// // pt_match_policy is simply an id so the correct specialization of tree_policy can be found. template < typename IteratorT, typename NodeFactoryT, typename T > struct pt_match_policy : public common_tree_match_policy< pt_match_policy
, IteratorT, NodeFactoryT, pt_tree_policy< pt_match_policy
, NodeFactoryT, T >, T > { typedef common_tree_match_policy< pt_match_policy
, IteratorT, NodeFactoryT, pt_tree_policy< pt_match_policy
, NodeFactoryT, T >, T > common_tree_match_policy_; pt_match_policy() { } template
pt_match_policy(PolicyT const & policies) : common_tree_match_policy_(policies) { } }; ////////////////////////////////// template
struct pt_tree_policy : public common_tree_tree_policy
{ typedef typename MatchPolicyT::match_t match_t; typedef typename MatchPolicyT::iterator_t iterator_t; template
static void concat(MatchAT& a, MatchBT const& b) { typedef typename match_t::attr_t attr_t; BOOST_SPIRIT_ASSERT(a && b); std::copy(b.trees.begin(), b.trees.end(), std::back_insert_iterator
(a.trees)); } template
static void group_match(MatchT& m, parser_id const& id, Iterator1T const& first, Iterator2T const& last) { if (!m) return; typedef typename NodeFactoryT::template factory
factory_t; typedef typename tree_match
::container_t container_t; typedef typename container_t::iterator cont_iterator_t; match_t newmatch(m.length(), factory_t::create_node(first, last, false)); std::swap(newmatch.trees.begin()->children, m.trees); // set this node and all it's unset children's rule_id newmatch.trees.begin()->value.id(id); for (cont_iterator_t i = newmatch.trees.begin()->children.begin(); i != newmatch.trees.begin()->children.end(); ++i) { if (i->value.id() == 0) i->value.id(id); } m = newmatch; } template
static void apply_op_to_match(FunctorT const& op, MatchT& m) { op(m); } }; namespace impl { template
struct tree_policy_selector
> { typedef pt_tree_policy< pt_match_policy
, NodeFactoryT, T > type; }; } // namespace impl ////////////////////////////////// struct gen_pt_node_parser_gen; template
struct gen_pt_node_parser : public unary
> > { typedef gen_pt_node_parser
self_t; typedef gen_pt_node_parser_gen parser_generator_t; typedef unary_parser_category parser_category_t; gen_pt_node_parser(T const& a) : unary
> >(a) {} template
typename parser_result
::type parse(ScannerT const& scan) const { typedef typename ScannerT::iteration_policy_t iteration_policy_t; typedef typename ScannerT::match_policy_t::iterator_t iterator_t; typedef typename ScannerT::match_policy_t::factory_t factory_t; typedef pt_match_policy
match_policy_t; typedef typename ScannerT::action_policy_t action_policy_t; typedef scanner_policies< iteration_policy_t, match_policy_t, action_policy_t > policies_t; return this->subject().parse(scan.change_policies(policies_t(scan))); } }; ////////////////////////////////// struct gen_pt_node_parser_gen { template
struct result { typedef gen_pt_node_parser
type; }; template
static gen_pt_node_parser
generate(parser
const& s) { return gen_pt_node_parser
(s.derived()); } template
gen_pt_node_parser
operator[](parser
const& s) const { return gen_pt_node_parser
(s.derived()); } }; ////////////////////////////////// const gen_pt_node_parser_gen gen_pt_node_d = gen_pt_node_parser_gen(); /////////////////////////////////////////////////////////////////////////////// // // Parse functions for parse trees // /////////////////////////////////////////////////////////////////////////////// template < typename NodeFactoryT, typename IteratorT, typename ParserT, typename SkipT > inline tree_parse_info
pt_parse( IteratorT const& first_, IteratorT const& last, parser
const& p, SkipT const& skip, NodeFactoryT const& /*dummy_*/ = NodeFactoryT()) { typedef skip_parser_iteration_policy
iter_policy_t; typedef pt_match_policy
pt_match_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); tree_match
hit = p.derived().parse(scan); return tree_parse_info
( first, hit, hit && (first == last), hit.length(), hit.trees); } template
inline tree_parse_info
pt_parse( IteratorT const& first, IteratorT const& last, parser
const& p, SkipT const& skip) { typedef node_val_data_factory
default_node_factory_t; return pt_parse(first, last, p, skip, default_node_factory_t()); } ////////////////////////////////// template
inline tree_parse_info
pt_parse( IteratorT const& first_, IteratorT const& last, parser
const& parser) { typedef pt_match_policy
pt_match_policy_t; IteratorT first = first_; scanner< IteratorT, scanner_policies
> scan(first, last); tree_match
hit = parser.derived().parse(scan); return tree_parse_info
( first, hit, hit && (first == last), hit.length(), hit.trees); } ////////////////////////////////// template
inline tree_parse_info
pt_parse( CharT const* str, parser
const& p, SkipT const& skip) { CharT const* last = str; while (*last) last++; return pt_parse(str, last, p, skip); } ////////////////////////////////// template
inline tree_parse_info
pt_parse( CharT const* str, parser
const& parser) { CharT const* last = str; while (*last) { last++; } return pt_parse(str, last, parser); } /////////////////////////////////////////////////////////////////////////////// }} // namespace boost::spirit #endif
parse_tree.hpp
Dirección de la página
Dirección del archivo
Anterior
5/10
Siguiente
Descargar
( 8 KB )
Comments
Total ratings:
0
Average rating:
No clasificado
of 10
Would you like to comment?
Join now
, or
Logon
if you are already a member.