Logo Search packages:      
Sourcecode: k3d version File versions

boost::spirit Namespace Reference


Detailed Description

Namespace reserved for the spirit parser framework, see http://spirit.sourceforge.net.


Classes

struct  access_match_action
struct  access_node_action
class  action
struct  action_directive_parser
struct  action_directive_parser_gen
struct  action_identity_policy
struct  action_parser_category
struct  action_policy
struct  action_subject
struct  alnum_parser
struct  alpha_parser
struct  alternative
struct  alternative_parser_gen
struct  anychar_parser
struct  as_lower_scanner
struct  as_parser
struct  as_parser< char * >
struct  as_parser< char >
struct  as_parser< char const * >
struct  as_parser< char const [N]>
struct  as_parser< char[N]>
struct  as_parser< wchar_t * >
struct  as_parser< wchar_t >
struct  as_parser< wchar_t const * >
struct  as_parser< wchar_t const [N]>
struct  as_parser< wchar_t[N]>
struct  assertion
struct  assertive_parser
struct  assign_action
struct  assign_key_action
struct  ast_match_policy
struct  ast_tree_policy
class  attach_action_gen
class  attach_action_parser
struct  attributed_action_policy
struct  attributed_action_policy< nil_t >
class  basic_chset
class  binary
struct  binary_identity_policy
struct  binary_identity_policy_return
struct  binary_left_subject
struct  binary_parser_category
struct  binary_right_subject
struct  blank_parser
struct  bounded
struct  bounded_gen
struct  char_parser
struct  chlit
class  chseq
class  chset
struct  clear_action
struct  closure
class  closure_context
struct  closure_context_linker
struct  cntrl_parser
struct  comment_nest_parser
struct  comment_parser_gen
struct  common_tree_match_policy
struct  common_tree_tree_policy
struct  condition_parser
struct  confix_parser
struct  confix_parser_gen
struct  container_begin
struct  container_end
struct  context_aux
struct  contiguous
struct  decrement_action
struct  default_parser_context_base
struct  difference
struct  difference_parser_gen
struct  digit_parser
struct  discard_first_node_op
struct  discard_last_node_op
struct  discard_node_op
class  dynamic_parser_tag
struct  empty_match_parser
struct  empty_match_parser_gen
struct  end_parser
struct  eol_parser
struct  epsilon_parser
struct  erase_action
struct  error_status
struct  escape_char_action
struct  escape_char_action_parser_gen
struct  escape_char_parser
struct  exclusive_or
struct  exclusive_or_parser_gen
struct  f_chlit
class  f_chseq
struct  f_range
class  f_strlit
struct  fallback_parser
class  file_iterator
struct  file_position
struct  file_position_without_column
class  finite_loop
class  fixed_loop
struct  fixed_loop_gen
class  fixed_size_queue
class  flush_multi_pass_parser
struct  functor_parser
struct  gen_ast_node_parser
struct  gen_ast_node_parser_gen
struct  gen_pt_node_parser
struct  gen_pt_node_parser_gen
struct  grammar
struct  grammar_definition
struct  graph_parser
struct  guard
struct  guard_gen
struct  identity_transform
struct  increment_action
class  infinite_loop
struct  infix_node_op
struct  inhibit_case
struct  inhibit_case_iteration_policy
struct  inhibit_case_parser_gen
struct  inhibit_case_parser_gen_base
class  init_closure_context
struct  init_closure_parser
struct  inner_node_op
struct  insert_key_action
struct  int_parser
struct  intersection
struct  intersection_parser_gen
struct  is_action_parser
struct  is_alternative
struct  is_binary_composite
struct  is_composite_parser
struct  is_difference
struct  is_exclusive_or
struct  is_intersection
struct  is_kleene_star
struct  is_lexeme
struct  is_nested
struct  is_optional
struct  is_parser
struct  is_positive
struct  is_sequence
struct  is_sequential_or
struct  is_unary_composite
struct  iteration_policy
struct  kleene_star
struct  kleene_star_parser_gen
struct  leaf_count
struct  leaf_node_op
struct  lexeme_parser_gen
struct  lexeme_scanner
struct  list_parser
struct  list_parser_gen
struct  longest_alternative
struct  longest_parser_gen
class  look_ahead
struct  lower_parser
class  match
class  match< nil_t >
struct  match_policy
struct  match_result
struct  max_bounded
struct  max_bounded_gen
struct  min_bounded
struct  min_bounded_gen
struct  more_t
class  multi_pass
struct  negated_char_parser
struct  negated_empty_match_parser
struct  negated_empty_match_parser_gen
struct  nil_t
struct  no_actions_action_policy
struct  no_actions_parser
struct  no_actions_parser_gen
struct  no_actions_scanner
struct  no_list_endtoken
struct  no_skipper_iteration_policy
struct  no_tree_gen_node_parser
struct  no_tree_gen_node_parser_gen
class  node_all_val_data_factory
struct  node_count
struct  node_iter_data
class  node_iter_data_factory
struct  node_parser
struct  node_parser_gen
struct  node_val_data
class  node_val_data_factory
struct  non_lexeme
struct  non_nested
struct  non_nested_refactoring
struct  nonfixed_loop_gen
struct  nothing_parser
struct  optional
struct  optional_parser_gen
struct  parse_info
class  parse_tree_iterator
struct  parser
struct  parser_address_tag
struct  parser_context
struct  parser_context_base
struct  parser_context_linker
struct  parser_error
class  parser_error_base
class  parser_id
struct  parser_result
struct  parser_scanner_linker
struct  parser_tag
struct  parser_tag_base
struct  parser_traversal_action_result
struct  parser_traversal_binary_result
struct  parser_traversal_plain_result
struct  parser_traversal_unary_result
struct  plain_identity_policy
struct  plain_parser_category
class  position_iterator2
struct  positive
struct  positive_parser_gen
struct  post_order
struct  print_parser
struct  pt_match_policy
struct  pt_tree_policy
struct  punct_parser
struct  push_back_action
struct  push_front_action
struct  range
struct  real_parser
struct  real_parser_policies
struct  rebind_scanner_iterator
struct  rebind_scanner_policies
class  ref_actor
class  ref_const_ref_actor
class  ref_const_ref_const_ref_actor
class  ref_const_ref_value_actor
class  ref_value_actor
class  refactor_action_gen
class  refactor_action_parser
class  refactor_unary_gen
class  refactor_unary_parser
struct  root_node_op
class  rule
struct  rxstrlit
struct  safe_bool
class  scanner
struct  scanner_base
struct  scanner_policies
struct  scoped_lock_parser
struct  scoped_lock_parser_gen
struct  self_nested_refactoring
struct  semantic_action
struct  sequence
struct  sequence_parser_gen
struct  sequential_or
struct  sequential_or_parser_gen
struct  shortest_alternative
struct  shortest_parser_gen
struct  sign_parser
class  skip_parser_iteration_policy
struct  skipper_iteration_policy
struct  space_parser
struct  strict_real_parser_policies
struct  strict_ureal_parser_policies
class  strlit
struct  subrule
struct  subrule_list
struct  subrule_parser
struct  subrules_scanner
struct  subrules_scanner_finder
struct  subrules_scanner_finder< subrules_scanner< ScannerT, ListT >, ListT >
class  swap_actor
class  symbol_inserter
class  symbols
struct  transform_policies
struct  traverse_post_order_env
struct  traverse_post_order_return
class  tree_match
struct  tree_node
struct  tree_parse_info
struct  tree_policy
struct  uint_parser
class  unary
struct  unary_identity_policy
struct  unary_identity_policy_return
struct  unary_parser_category
struct  unary_subject
struct  upper_parser
struct  ureal_parser_policies
struct  xdigit_parser

Typedefs

typedef skipper_iteration_policy iter_policy_t
typedef scanner< char const
*, scanner_policies_t > 
phrase_scanner_t
typedef scanner_policies
< iter_policy_t > 
scanner_policies_t
typedef scanner< wchar_t const
*, scanner_policies_t > 
wide_phrase_scanner_t

Functions

template<typename T, typename CharT, typename SetT>
T * add (symbols< T, CharT, SetT > &table, CharT const *sym, T const &data)
template<typename T>
ref_value_actor< T,
push_back_action > 
append (T &ref_)
template<typename T>
ref_value_actor< T, assign_action > assign (T &ref_)
template<typename T, typename ValueT>
ref_const_ref_actor< T, ValueT,
assign_action > 
assign_a (T &ref_, ValueT const &value_)
template<typename T>
ref_value_actor< T, assign_action > assign_a (T &ref_)
template<typename T, typename ValueT, typename KeyT>
ref_const_ref_const_ref_actor
< T, ValueT, KeyT,
assign_key_action > 
assign_key_a (T &ref_, ValueT const &value_, KeyT const &key_)
template<typename T, typename ValueT>
ref_const_ref_value_actor< T,
ValueT, assign_key_action > 
assign_key_a (T &ref_, ValueT const &value_)
template<typename CharT, typename ParserT>
tree_parse_info< CharT const * > ast_parse (CharT const *str, parser< ParserT > const &parser)
template<typename CharT, typename ParserT, typename SkipT>
tree_parse_info< CharT const * > ast_parse (CharT const *str, parser< ParserT > const &parser, SkipT const &skip)
template<typename IteratorT, typename ParserT>
tree_parse_info< IteratorT > ast_parse (IteratorT const &first_, IteratorT const &last, parser< ParserT > const &parser)
template<typename IteratorT, typename ParserT, typename SkipT>
tree_parse_info< IteratorT > ast_parse (IteratorT const &first_, IteratorT const &last_, parser< ParserT > const &parser, SkipT const &skip_)
template<typename AstFactoryT, typename IteratorT, typename ParserT, typename SkipT>
tree_parse_info< IteratorT,
AstFactoryT > 
ast_parse (IteratorT const &first_, IteratorT const &last_, parser< ParserT > const &parser, SkipT const &skip_, AstFactoryT const &=AstFactoryT())
template<typename CharT>
chlit< CharT > ch_p (CharT ch)
template<typename IteratorT>
chseq< IteratorT > chseq_p (IteratorT first, IteratorT last)
template<typename CharT>
chseq< CharT const * > chseq_p (CharT const *str)
chset< unsigned long > chset_p (unsigned long ch)
chset< long > chset_p (long ch)
chset< unsigned short > chset_p (unsigned short ch)
chset< short > chset_p (short ch)
chset< unsigned int > chset_p (unsigned int ch)
chset< int > chset_p (int ch)
chset< wchar_t > chset_p (wchar_t ch)
chset< char > chset_p (char ch)
chset< wchar_t > chset_p (wchar_t const *init)
chset< char > chset_p (char const *init)
template<typename CharT>
chset< CharT > chset_p (negated_char_parser< range< CharT > > const &arg_)
template<typename CharT>
chset< CharT > chset_p (negated_char_parser< chlit< CharT > > const &arg_)
template<typename CharT>
chset< CharT > chset_p (range< CharT > const &arg_)
template<typename CharT>
chset< CharT > chset_p (chlit< CharT > const &arg_)
template<typename T>
ref_actor< T, clear_action > clear_a (T &ref_)
template<typename OpenT, typename CloseT>
comment_nest_parser< typename
as_parser< OpenT >::type,
typename as_parser< CloseT >
::type > 
comment_nest_p (OpenT const &open, CloseT const &close)
template<typename T>
ref_actor< T, decrement_action > decrement_a (T &ref_)
template<typename T, typename KeyT>
ref_const_ref_actor< T, KeyT,
erase_action > 
erase_a (T &ref_, KeyT const &key_)
template<typename T>
ref_value_actor< T, erase_action > erase_a (T &ref_)
template<typename ChGenT>
f_chlit< ChGenT > f_ch_p (ChGenT chgen)
template<typename IterGenAT, typename IterGenBT>
f_chseq< IterGenAT, IterGenBT > f_chseq_p (IterGenAT first, IterGenBT last)
template<typename BaseT>
f_chseq< phoenix::actor
< container_begin
< phoenix::actor< BaseT >
> >, phoenix::actor
< container_end
< phoenix::actor< BaseT > > > > 
f_chseq_p (phoenix::actor< BaseT > const &a)
template<typename ChGenAT, typename ChGenBT>
f_range< ChGenAT, ChGenBT > f_range_p (ChGenAT first, ChGenBT last)
template<typename IterGenAT, typename IterGenBT>
f_strlit< IterGenAT, IterGenBT > f_str_p (IterGenAT first, IterGenBT last)
template<typename BaseT>
f_strlit< phoenix::actor
< container_begin
< phoenix::actor< BaseT >
> >, phoenix::actor
< container_end
< phoenix::actor< BaseT > > > > 
f_str_p (phoenix::actor< BaseT > const &a)
template<typename T, typename CharT, typename SetT>
T * find (symbols< T, CharT, SetT > const &table, CharT const *sym)
template<typename T>
bool find_node (tree_node< T > const &node, parser_id node_to_search, tree_node< T > const **found_node)
template<typename InitF, typename ConditionT, typename StepF>
impl::for_parser_gen< InitF,
ConditionT, StepF > 
for_p (InitF const &init_f, ConditionT const &condition, StepF const &step_f)
template<typename ActionT>
action_subject< ActionT >
::type const & 
get_action_subject (ActionT const &action_)
template<typename BinaryT>
binary_left_subject< BinaryT >
::type const & 
get_binary_left_subject (BinaryT const &binary_)
template<typename BinaryT>
binary_right_subject< BinaryT >
::type const & 
get_binary_right_subject (BinaryT const &binary_)
template<typename T>
tree_node< T > const & get_first_leaf (tree_node< T > const &node)
template<typename T>
bool get_node_range (tree_node< T > const &node, parser_id node_to_search, std::pair< typename tree_node< T >::const_tree_iterator, typename tree_node< T >::const_tree_iterator > &nodes)
template<typename ActionT>
semantic_action< ActionT >
::type const & 
get_semantic_action (ActionT const &action_)
template<typename UnaryT>
unary_subject< UnaryT >::type
const & 
get_unary_subject (UnaryT const &unary_)
template<typename CondT>
impl::if_parser_gen< CondT > if_p (CondT const &cond)
template<typename T>
ref_actor< T, increment_action > increment_a (T &ref_)
template<typename T, typename ValueT>
ref_const_ref_value_actor< T,
ValueT, insert_key_action > 
insert_key_a (T &ref_, ValueT const &value_)
template<typename BoundsT>
bounded_gen< BoundsT > limit_d (BoundsT const &min_, BoundsT const &max_)
template<typename InputT>
multi_pass< InputT > make_multi_pass (InputT i)
template<typename BoundsT>
max_bounded_gen< BoundsT > max_limit_d (BoundsT const &max_)
template<typename BoundsT>
min_bounded_gen< BoundsT > min_limit_d (BoundsT const &min_)
template<typename CharT>
chset< CharT > operator & (nothing_parser a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator & (chset< CharT > const &a, nothing_parser b)
template<typename CharT>
chset< CharT > operator & (anychar_parser a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator & (chset< CharT > const &a, anychar_parser b)
template<typename CharT>
chset< CharT > operator & (CharT a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator & (chset< CharT > const &a, CharT b)
template<typename CharT>
chset< CharT > operator & (negated_char_parser< chlit< CharT > > const &a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator & (chset< CharT > const &a, negated_char_parser< chlit< CharT > > const &b)
template<typename CharT>
chset< CharT > operator & (negated_char_parser< range< CharT > > const &a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator & (chset< CharT > const &a, negated_char_parser< range< CharT > > const &b)
template<typename CharT>
chset< CharT > operator & (chlit< CharT > const &a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator & (chset< CharT > const &a, chlit< CharT > const &b)
template<typename CharT>
chset< CharT > operator & (range< CharT > const &a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator & (chset< CharT > const &a, range< CharT > const &b)
template<typename CharT>
chset< CharT > operator & (chset< CharT > const &a, chset< CharT > const &b)
template<typename B>
intersection< strlit< wchar_t
const * >, B > 
operator & (wchar_t const *a, parser< B > const &b)
template<typename A>
intersection< A, strlit
< wchar_t const * > > 
operator & (parser< A > const &a, wchar_t const *b)
template<typename B>
intersection< chlit< wchar_t >, B > operator & (wchar_t a, parser< B > const &b)
template<typename A>
intersection< A, chlit< wchar_t > > operator & (parser< A > const &a, wchar_t b)
template<typename B>
intersection< strlit< char
const * >, B > 
operator & (char const *a, parser< B > const &b)
template<typename A>
intersection< A, strlit< char
const * > > 
operator & (parser< A > const &a, char const *b)
template<typename B>
intersection< chlit< char >, B > operator & (char a, parser< B > const &b)
template<typename A>
intersection< A, chlit< char > > operator & (parser< A > const &a, char b)
template<typename A, typename B>
intersection< A, B > operator & (parser< A > const &a, parser< B > const &b)
template<typename B>
sequence< strlit< wchar_t
const * >, B > 
operator && (wchar_t const *a, parser< B > const &b)
template<typename A>
sequence< A, strlit< wchar_t
const * > > 
operator && (parser< A > const &a, wchar_t const *b)
template<typename B>
sequence< chlit< wchar_t >, B > operator && (wchar_t a, parser< B > const &b)
template<typename A>
sequence< A, chlit< wchar_t > > operator && (parser< A > const &a, wchar_t b)
template<typename B>
sequence< strlit< char const * >
, B > 
operator && (char const *a, parser< B > const &b)
template<typename A>
sequence< A, strlit< char
const * > > 
operator && (parser< A > const &a, char const *b)
template<typename B>
sequence< chlit< char >, B > operator && (char a, parser< B > const &b)
template<typename A>
sequence< A, chlit< char > > operator && (parser< A > const &a, char b)
template<typename A, typename B>
sequence< A, B > operator && (parser< A > const &a, parser< B > const &b)
template<typename S>
optional< S > operator! (parser< S > const &a)
template<typename InputT, typename InputPolicy, typename OwnershipPolicy, typename CheckingPolicy, typename StoragePolicy>
bool operator!= (const multi_pass< InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy > &x, const multi_pass< InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy > &y)
template<typename B>
sequence< strlit< wchar_t
const * >, kleene_star
< sequence< B, strlit< wchar_t
const * > > > > 
operator% (wchar_t const *a, parser< B > const &b)
template<typename A>
sequence< A, kleene_star
< sequence< strlit< wchar_t
const * >, A > > > 
operator% (parser< A > const &a, wchar_t const *b)
template<typename B>
sequence< chlit< wchar_t >
, kleene_star< sequence< B,
chlit< wchar_t > > > > 
operator% (wchar_t a, parser< B > const &b)
template<typename A>
sequence< A, kleene_star
< sequence< chlit< wchar_t >
, A > > > 
operator% (parser< A > const &a, wchar_t b)
template<typename B>
sequence< strlit< char const * >
, kleene_star< sequence< B,
strlit< char const * > > > > 
operator% (char const *a, parser< B > const &b)
template<typename A>
sequence< A, kleene_star
< sequence< strlit< char const * >
, A > > > 
operator% (parser< A > const &a, char const *b)
template<typename B>
sequence< chlit< char >
, kleene_star< sequence< B,
chlit< char > > > > 
operator% (char a, parser< B > const &b)
template<typename A>
sequence< A, kleene_star
< sequence< chlit< char >, A > > > 
operator% (parser< A > const &a, char b)
template<typename A, typename B>
sequence< A, kleene_star
< sequence< B, A > > > 
operator% (parser< A > const &a, parser< B > const &b)
template<typename S>
kleene_star< S > operator* (parser< S > const &a)
template<typename S>
positive< S > operator+ (parser< S > const &a)
template<typename CharT>
chset< CharT > operator- (nothing_parser a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator- (chset< CharT > const &a, nothing_parser b)
template<typename CharT>
chset< CharT > operator- (anychar_parser a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator- (chset< CharT > const &a, anychar_parser b)
template<typename CharT>
chset< CharT > operator- (CharT a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator- (chset< CharT > const &a, CharT b)
template<typename CharT>
chset< CharT > operator- (negated_char_parser< chlit< CharT > > const &a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator- (chset< CharT > const &a, negated_char_parser< chlit< CharT > > const &b)
template<typename CharT>
chset< CharT > operator- (negated_char_parser< range< CharT > > const &a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator- (chset< CharT > const &a, negated_char_parser< range< CharT > > const &b)
template<typename CharT>
chset< CharT > operator- (chlit< CharT > const &a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator- (chset< CharT > const &a, chlit< CharT > const &b)
template<typename CharT>
chset< CharT > operator- (range< CharT > const &a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator- (chset< CharT > const &a, range< CharT > const &b)
template<typename CharT>
chset< CharT > operator- (chset< CharT > const &a, chset< CharT > const &b)
template<typename B>
difference< strlit< wchar_t
const * >, B > 
operator- (wchar_t const *a, parser< B > const &b)
template<typename A>
difference< A, strlit< wchar_t
const * > > 
operator- (parser< A > const &a, wchar_t const *b)
template<typename B>
difference< chlit< wchar_t >, B > operator- (wchar_t a, parser< B > const &b)
template<typename A>
difference< A, chlit< wchar_t > > operator- (parser< A > const &a, wchar_t b)
template<typename B>
difference< strlit< char const * >
, B > 
operator- (char const *a, parser< B > const &b)
template<typename A>
difference< A, strlit< char
const * > > 
operator- (parser< A > const &a, char const *b)
template<typename B>
difference< chlit< char >, B > operator- (char a, parser< B > const &b)
template<typename A>
difference< A, chlit< char > > operator- (parser< A > const &a, char b)
template<typename A, typename B>
difference< A, B > operator- (parser< A > const &a, parser< B > const &b)
template<typename InputT, typename InputPolicy, typename OwnershipPolicy, typename CheckingPolicy, typename StoragePolicy>
bool operator<= (const multi_pass< InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy > &x, const multi_pass< InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy > &y)
template<typename InputT, typename InputPolicy, typename OwnershipPolicy, typename CheckingPolicy, typename StoragePolicy>
bool operator> (const multi_pass< InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy > &x, const multi_pass< InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy > &y)
template<typename InputT, typename InputPolicy, typename OwnershipPolicy, typename CheckingPolicy, typename StoragePolicy>
bool operator>= (const multi_pass< InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy > &x, const multi_pass< InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy > &y)
template<typename B>
sequence< strlit< wchar_t
const * >, B > 
operator>> (wchar_t const *a, parser< B > const &b)
template<typename A>
sequence< A, strlit< wchar_t
const * > > 
operator>> (parser< A > const &a, wchar_t const *b)
template<typename B>
sequence< chlit< wchar_t >, B > operator>> (wchar_t a, parser< B > const &b)
template<typename A>
sequence< A, chlit< wchar_t > > operator>> (parser< A > const &a, wchar_t b)
template<typename B>
sequence< strlit< char const * >
, B > 
operator>> (char const *a, parser< B > const &b)
template<typename A>
sequence< A, strlit< char
const * > > 
operator>> (parser< A > const &a, char const *b)
template<typename B>
sequence< chlit< char >, B > operator>> (char a, parser< B > const &b)
template<typename A>
sequence< A, chlit< char > > operator>> (parser< A > const &a, char b)
template<typename A, typename B>
sequence< A, B > operator>> (parser< A > const &a, parser< B > const &b)
template<typename CharT>
chset< CharT > operator^ (nothing_parser a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator^ (chset< CharT > const &a, nothing_parser b)
template<typename CharT>
chset< CharT > operator^ (anychar_parser a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator^ (chset< CharT > const &a, anychar_parser b)
template<typename CharT>
chset< CharT > operator^ (CharT a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator^ (chset< CharT > const &a, CharT b)
template<typename CharT>
chset< CharT > operator^ (negated_char_parser< chlit< CharT > > const &a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator^ (chset< CharT > const &a, negated_char_parser< chlit< CharT > > const &b)
template<typename CharT>
chset< CharT > operator^ (negated_char_parser< range< CharT > > const &a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator^ (chset< CharT > const &a, negated_char_parser< range< CharT > > const &b)
template<typename CharT>
chset< CharT > operator^ (chlit< CharT > const &a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator^ (chset< CharT > const &a, chlit< CharT > const &b)
template<typename CharT>
chset< CharT > operator^ (range< CharT > const &a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator^ (chset< CharT > const &a, range< CharT > const &b)
template<typename CharT>
chset< CharT > operator^ (chset< CharT > const &a, chset< CharT > const &b)
template<typename B>
exclusive_or< strlit< wchar_t
const * >, B > 
operator^ (wchar_t const *a, parser< B > const &b)
template<typename A>
exclusive_or< A, strlit
< wchar_t const * > > 
operator^ (parser< A > const &a, wchar_t const *b)
template<typename B>
exclusive_or< chlit< wchar_t >, B > operator^ (wchar_t a, parser< B > const &b)
template<typename A>
exclusive_or< A, chlit< wchar_t > > operator^ (parser< A > const &a, wchar_t b)
template<typename B>
exclusive_or< strlit< char
const * >, B > 
operator^ (char const *a, parser< B > const &b)
template<typename A>
exclusive_or< A, strlit< char
const * > > 
operator^ (parser< A > const &a, char const *b)
template<typename B>
exclusive_or< chlit< char >, B > operator^ (char a, parser< B > const &b)
template<typename A>
exclusive_or< A, chlit< char > > operator^ (parser< A > const &a, char b)
template<typename A, typename B>
exclusive_or< A, B > operator^ (parser< A > const &a, parser< B > const &b)
template<typename CharT>
chset< CharT > operator| (nothing_parser a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator| (chset< CharT > const &a, nothing_parser b)
template<typename CharT>
chset< CharT > operator| (anychar_parser a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator| (chset< CharT > const &a, anychar_parser b)
template<typename CharT>
chset< CharT > operator| (CharT a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator| (chset< CharT > const &a, CharT b)
template<typename CharT>
chset< CharT > operator| (negated_char_parser< chlit< CharT > > const &a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator| (chset< CharT > const &a, negated_char_parser< chlit< CharT > > const &b)
template<typename CharT>
chset< CharT > operator| (negated_char_parser< range< CharT > > const &a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator| (chset< CharT > const &a, negated_char_parser< range< CharT > > const &b)
template<typename CharT>
chset< CharT > operator| (chlit< CharT > const &a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator| (chset< CharT > const &a, chlit< CharT > const &b)
template<typename CharT>
chset< CharT > operator| (range< CharT > const &a, chset< CharT > const &b)
template<typename CharT>
chset< CharT > operator| (chset< CharT > const &a, range< CharT > const &b)
template<typename CharT>
chset< CharT > operator| (chset< CharT > const &a, chset< CharT > const &b)
template<typename B>
alternative< strlit< wchar_t
const * >, B > 
operator| (wchar_t const *a, parser< B > const &b)
template<typename A>
alternative< A, strlit
< wchar_t const * > > 
operator| (parser< A > const &a, wchar_t const *b)
template<typename B>
alternative< chlit< wchar_t >, B > operator| (wchar_t a, parser< B > const &b)
template<typename A>
alternative< A, chlit< wchar_t > > operator| (parser< A > const &a, wchar_t b)
template<typename B>
alternative< strlit< char
const * >, B > 
operator| (char const *a, parser< B > const &b)
template<typename A>
alternative< A, strlit< char
const * > > 
operator| (parser< A > const &a, char const *b)
template<typename B>
alternative< chlit< char >, B > operator| (char a, parser< B > const &b)
template<typename A>
alternative< A, chlit< char > > operator| (parser< A > const &a, char b)
template<typename A, typename B>
alternative< A, B > operator| (parser< A > const &a, parser< B > const &b)
template<typename B>
sequential_or< strlit< wchar_t
const * >, B > 
operator|| (wchar_t const *a, parser< B > const &b)
template<typename A>
sequential_or< A, strlit
< wchar_t const * > > 
operator|| (parser< A > const &a, wchar_t const *b)
template<typename B>
sequential_or< chlit< wchar_t >
, B > 
operator|| (wchar_t a, parser< B > const &b)
template<typename A>
sequential_or< A, chlit
< wchar_t > > 
operator|| (parser< A > const &a, wchar_t b)
template<typename B>
sequential_or< strlit< char
const * >, B > 
operator|| (char const *a, parser< B > const &b)
template<typename A>
sequential_or< A, strlit< char
const * > > 
operator|| (parser< A > const &a, char const *b)
template<typename B>
sequential_or< chlit< char >, B > operator|| (char a, parser< B > const &b)
template<typename A>
sequential_or< A, chlit< char > > operator|| (parser< A > const &a, char b)
template<typename A, typename B>
sequential_or< A, B > operator|| (parser< A > const &a, parser< B > const &b)
template<typename CharT>
chset< CharT > operator~ (chset< CharT > const &a)
nothing_parser operator~ (anychar_parser)
template<typename ParserT>
ParserT operator~ (negated_char_parser< ParserT > const &n)
template<typename ParserT>
negated_char_parser< ParserT > operator~ (char_parser< ParserT > const &p)
template<typename SubjectT>
empty_match_parser< SubjectT > operator~ (negated_empty_match_parser< SubjectT > const &p)
template<typename SubjectT>
negated_empty_match_parser
< SubjectT > 
operator~ (empty_match_parser< SubjectT > const &p)
template<typename CondT, bool positive>
condition_parser< CondT,!positive > operator~ (condition_parser< CondT, positive > const &p)
template<typename CharT, typename ParserT, typename SkipT>
parse_info< CharT const * > parse (CharT const *str, parser< ParserT > const &p, parser< SkipT > const &skip)
template<typename IteratorT, typename ParserT, typename SkipT>
parse_info< IteratorT > parse (IteratorT const &first, IteratorT const &last, parser< ParserT > const &p, parser< SkipT > const &skip)
template<typename CharT, typename DerivedT>
parse_info< CharT const * > parse (CharT const *str, parser< DerivedT > const &p)
template<typename IteratorT, typename DerivedT>
parse_info< IteratorT > parse (IteratorT const &first_, IteratorT const &last, parser< DerivedT > const &p)
strlit< char const * > const pizza_p (char const *your_favorite_pizza)
template<typename CharT, typename ParserT>
tree_parse_info< CharT const * > pt_parse (CharT const *str, parser< ParserT > const &parser)
template<typename CharT, typename ParserT, typename SkipT>
tree_parse_info< CharT const * > pt_parse (CharT const *str, parser< ParserT > const &p, SkipT const &skip)
template<typename IteratorT, typename ParserT>
tree_parse_info< IteratorT > pt_parse (IteratorT const &first_, IteratorT const &last, parser< ParserT > const &parser)
template<typename IteratorT, typename ParserT, typename SkipT>
tree_parse_info< IteratorT > pt_parse (IteratorT const &first, IteratorT const &last, parser< ParserT > const &p, SkipT const &skip)
template<typename NodeFactoryT, typename IteratorT, typename ParserT, typename SkipT>
tree_parse_info< IteratorT,
NodeFactoryT > 
pt_parse (IteratorT const &first_, IteratorT const &last, parser< ParserT > const &p, SkipT const &skip, NodeFactoryT const &=NodeFactoryT())
template<typename T, typename ValueT>
ref_const_ref_actor< T, ValueT,
push_back_action > 
push_back_a (T &ref_, ValueT const &value_)
template<typename T>
ref_value_actor< T,
push_back_action > 
push_back_a (T &ref_)
template<typename T, typename ValueT>
ref_const_ref_actor< T, ValueT,
push_front_action > 
push_front_a (T &ref_, ValueT const &value_)
template<typename T>
ref_value_actor< T,
push_front_action > 
push_front_a (T &ref_)
template<typename CharT>
range< CharT > range_p (CharT first, CharT last)
template<typename CharT>
rxstrlit< CharT > regex_p (CharT const *first, CharT const *last)
template<typename CharT>
rxstrlit< CharT > regex_p (CharT const *first)
template<typename MinT, typename MaxT>
nonfixed_loop_gen< MinT, MaxT > repeat_p (MinT const &min, MaxT const &max)
template<typename ExactT>
fixed_loop_gen< ExactT > repeat_p (ExactT const &exact)
template<typename MutexT>
scoped_lock_parser_gen< MutexT > scoped_lock_d (MutexT &mutex)
template<typename IteratorT>
strlit< IteratorT > str_p (IteratorT first, IteratorT last)
template<typename CharT>
strlit< CharT const * > str_p (CharT const *str)
template<typename T, typename V>
void swap (node_iter_data< T, V > &a, node_iter_data< T, V > &b)
template<typename T>
void swap (tree_node< T > &a, tree_node< T > &b)
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)
template<typename T>
swap_actor< T > swap_a (T &ref_, T &swap_ref_)
template<typename ErrorDescrT, typename IteratorT>
void throw_ (IteratorT where, ErrorDescrT descriptor)
template<typename TreeNodeT>
void tree_to_xml (std::ostream &ostrm, TreeNodeT const &tree, std::string const &input_line)
template<typename TreeNodeT, typename AssocContainerT>
void tree_to_xml (std::ostream &ostrm, TreeNodeT const &tree, std::string const &input_line, AssocContainerT const &id_to_name)
template<typename TreeNodeT, typename AssocContainerT, typename GetIdT, typename GetValueT>
void tree_to_xml (std::ostream &ostrm, TreeNodeT const &tree, std::string const &input_line, AssocContainerT const &id_to_name, GetIdT const &get_token_id, GetValueT const &get_token_value)
template<typename CondT>
impl::while_parser_gen< CondT > while_p (CondT const &cond)

Variables

const
action_directive_parser_gen
< access_match_action > 
access_match_d = action_directive_parser_gen<access_match_action>()
const
action_directive_parser_gen
< access_node_action > 
access_node_d = action_directive_parser_gen<access_node_action>()
alnum_parser const alnum_p = alnum_parser()
alpha_parser const alpha_p = alpha_parser()
anychar_parser const anychar_p = anychar_parser()
const inhibit_case_parser_gen as_lower_d = inhibit_case_parser_gen()
const attach_action_gen attach_action_d = attach_action_gen<>()
uint_parser< unsigned, 2 > const bin_p = uint_parser<unsigned, 2>()
blank_parser const blank_p = blank_parser()
const escape_char_parser
< c_escapes > 
c_escape_ch_p
const unsigned long c_escapes = 1
cntrl_parser const cntrl_p = cntrl_parser()
const comment_parser_gen
< non_nested > 
comment_p
const confix_parser_gen
< non_nested, non_lexeme > 
confix_p
digit_parser const digit_p = digit_parser()
const node_parser_gen
< discard_first_node_op > 
discard_first_node_d
const node_parser_gen
< discard_last_node_op > 
discard_last_node_d
const node_parser_gen
< discard_node_op > 
discard_node_d
impl::do_parser_gen const do_p = impl::do_parser_gen()
end_parser const end_p = end_parser()
eol_parser const eol_p = eol_parser()
epsilon_parser const eps_p = epsilon_parser()
epsilon_parser const epsilon_p = epsilon_parser()
flush_multi_pass_parser const flush_multi_pass_p = flush_multi_pass_parser()
const gen_ast_node_parser_gen gen_ast_node_d = gen_ast_node_parser_gen()
const gen_pt_node_parser_gen gen_pt_node_d = gen_pt_node_parser_gen()
graph_parser const graph_p = graph_parser()
uint_parser< unsigned, 16 > const hex_p = uint_parser<unsigned, 16>()
const node_parser_gen
< infix_node_op > 
infix_node_d
const node_parser_gen
< inner_node_op > 
inner_node_d
int_parser< int > const int_p = int_parser<int>()
const node_parser_gen
< leaf_node_op > 
leaf_node_d
const escape_char_parser
< lex_escapes > 
lex_escape_ch_p
const unsigned long lex_escapes = c_escapes << 1
const lexeme_parser_gen lexeme_d = lexeme_parser_gen()
const list_parser_gen list_p = list_parser_gen<>()
const longest_parser_gen longest_d = longest_parser_gen()
lower_parser const lower_p = lower_parser()
more_t const more = more_t ()
const no_actions_parser_gen no_actions_d = no_actions_parser_gen()
const no_tree_gen_node_parser_gen no_node_d = no_tree_gen_node_parser_gen()
const inhibit_case_parser_gen nocase_d = inhibit_case_parser_gen()
nothing_parser const nothing_p = nothing_parser()
uint_parser< unsigned, 8 > const oct_p = uint_parser<unsigned, 8>()
print_parser const print_p = print_parser()
punct_parser const punct_p = punct_parser()
real_parser< double,
real_parser_policies< double >
> const 
real_p = real_parser<double, real_parser_policies<double> >()
const refactor_action_gen refactor_action_d = refactor_action_gen<>()
const refactor_unary_gen refactor_unary_d = refactor_unary_gen<>()
const node_parser_gen
< root_node_op > 
root_node_d
const shortest_parser_gen shortest_d = shortest_parser_gen()
sign_parser const sign_p = sign_parser()
space_parser const space_p = space_parser()
real_parser< double,
strict_real_parser_policies
< double > > const 
strict_real_p = real_parser<double, strict_real_parser_policies<double> >()
real_parser< double,
strict_ureal_parser_policies
< double > > const 
strict_ureal_p = real_parser<double, strict_ureal_parser_policies<double> >()
const node_parser_gen
< leaf_node_op > 
token_node_d
uint_parser< unsigned > const uint_p = uint_parser<unsigned>()
upper_parser const upper_p = upper_parser()
real_parser< double,
ureal_parser_policies< double >
> const 
ureal_p = real_parser<double, ureal_parser_policies<double> >()
xdigit_parser const xdigit_p = xdigit_parser()


Generated by  Doxygen 1.6.0   Back to index