Boost  v1.57.0
doxygen for www.boost.org
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
boost::spirit Namespace Reference

Namespaces

 ascii
 
 char_class
 
 char_encoding
 
 classic
 
 detail
 
 expression
 
 fileiter_impl
 
 impl
 
 iso8859_1
 
 iterator_
 
 iterator_policies
 
 karma
 
 lex
 
 multi_pass_policies
 
 qi
 
 repository
 
 result_of
 
 standard
 
 standard_wide
 
 support
 
 tag
 
 traits
 
 type_of
 
 ucd
 
 utility
 
 x3
 

Classes

struct  access_match_action
 
struct  access_node_action
 
singleton  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
 
class  any_ptr
 
struct  anychar_parser
 
struct  argument
 
struct  arithmetic_function
 
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  attribute
 
struct  attribute_context
 
struct  attributed_action_policy
 
struct  attributed_action_policy< nil_t >
 
struct  bad_type_exception
 
struct  basic_info_walker
 
class  basic_istream_iterator
 
struct  basic_string
 
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  case_parser
 
struct  char_parser
 
struct  chlit
 
singleton  chseq
 
singleton  chset
 
struct  clear_action
 
struct  closure
 
singleton  closure_context
 
struct  closure_context_linker
 
struct  cntrl_parser
 
struct  comment_nest_p_result
 
struct  comment_nest_parser
 
struct  comment_parser_gen
 
struct  common_tree_match_policy
 
struct  common_tree_tree_policy
 
struct  compound_modifier
 
struct  compound_modifier< Current, New, typename enable_if< has_modifier< Current, New > >::type >
 
struct  compound_modifier< Current, tag::char_code< tag::lower, CharEncoding >, typename enable_if< has_modifier< Current, tag::char_code< tag::upper, CharEncoding > > >::type >
 
struct  compound_modifier< Current, tag::char_code< tag::upper, CharEncoding >, typename enable_if< has_modifier< Current, tag::char_code< tag::lower, CharEncoding > > >::type >
 
struct  compound_modifier< Current, tag::relaxed, typename enable_if< has_modifier< Current, tag::strict > >::type >
 
struct  compound_modifier< Current, tag::strict, typename enable_if< has_modifier< Current, tag::relaxed > >::type >
 
struct  compound_modifier< unused_type, New, Enable >
 
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  default_parser_gen
 
struct  difference
 
struct  difference_parser_gen
 
struct  digit_parser
 
struct  discard_first_node_op
 
struct  discard_last_node_op
 
struct  discard_node_op
 
singleton  distinct_directive
 
singleton  distinct_parser
 
singleton  dynamic_distinct_directive
 
singleton  dynamic_distinct_parser
 
class  dynamic_parser_tag
 
struct  empty_exception
 
struct  empty_match_parser
 
struct  empty_match_parser_gen
 
struct  encoding
 
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  extended_variant
 
struct  f_chlit
 
singleton  f_chseq
 
struct  f_range
 
singleton  f_strlit
 
struct  fallback_parser
 
singleton  file_iterator
 
struct  file_position_base
 
struct  file_position_without_column_base
 
singleton  finite_loop
 
singleton  fixed_loop
 
struct  fixed_loop_gen
 
singleton  fixed_size_queue
 
struct  flatten_tree
 
struct  flatten_tree< karma::domain, proto::tag::bitwise_or >
 
struct  flatten_tree< karma::domain, proto::tag::shift_left >
 
struct  flatten_tree< lex::domain, proto::tag::bitwise_or >
 
struct  flatten_tree< qi::domain, proto::tag::bitwise_or >
 
struct  flatten_tree< qi::domain, proto::tag::bitwise_xor >
 
struct  flatten_tree< qi::domain, proto::tag::divides >
 
struct  flatten_tree< qi::domain, proto::tag::greater >
 
struct  flatten_tree< qi::domain, proto::tag::logical_or >
 
struct  flatten_tree< qi::domain, proto::tag::shift_right >
 
class  flush_multi_pass_parser
 
singleton  fsq_iterator
 
struct  function_base
 
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
 
singleton  grammar_def
 
struct  graph_parser
 
struct  guard
 
struct  guard_gen
 
struct  has_modifier
 
struct  identity_transform
 
struct  if_else_parser
 
struct  if_parser
 
struct  increment_action
 
singleton  infinite_loop
 
struct  infix_node_op
 
struct  info
 
struct  inhibit_case
 
struct  inhibit_case_iteration_policy
 
struct  inhibit_case_parser_gen
 
struct  inhibit_case_parser_gen_base
 
singleton  init_closure_context
 
struct  init_closure_parser
 
struct  inner_node_op
 
struct  insert_at_action
 
struct  insert_key_action
 
struct  int_parser
 
struct  integral_function
 
struct  intersection
 
struct  intersection_parser_gen
 
struct  is_action_parser
 
struct  is_alternative
 
struct  is_binary_composite
 
struct  is_char_encoding
 
struct  is_char_encoding< spirit::char_encoding::ascii >
 
struct  is_char_encoding< spirit::char_encoding::iso8859_1 >
 
struct  is_char_encoding< spirit::char_encoding::standard >
 
struct  is_char_encoding< spirit::char_encoding::standard_wide >
 
struct  is_composite_parser
 
struct  is_difference
 
struct  is_exclusive_or
 
struct  is_intersection
 
struct  is_kleene_star
 
struct  is_modifier_directive
 
struct  is_modifier_directive< Domain, tag::lazy_eval >
 
struct  is_modifier_directive< karma::domain, tag::char_code< tag::encoding, CharEncoding > >
 
struct  is_modifier_directive< karma::domain, tag::char_code< tag::lower, CharEncoding > >
 
struct  is_modifier_directive< karma::domain, tag::char_code< tag::upper, CharEncoding > >
 
struct  is_modifier_directive< karma::domain, tag::relaxed >
 
struct  is_modifier_directive< karma::domain, tag::strict >
 
struct  is_modifier_directive< qi::domain, tag::char_code< tag::encoding, CharEncoding > >
 
struct  is_modifier_directive< qi::domain, tag::char_code< tag::no_case, CharEncoding > >
 
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  lazy_parser
 
struct  lazy_terminal
 
struct  leaf_count
 
struct  leaf_node_parser
 
struct  leaf_node_parser_gen
 
struct  lexeme_parser_gen
 
struct  lexeme_scanner
 
class  line_pos_iterator
 
struct  list_parser
 
struct  list_parser_gen
 
struct  local_variable
 
struct  locals
 
struct  logical_function
 
struct  longest_alternative
 
struct  longest_parser_gen
 
class  look_ahead
 
struct  lower_parser
 
struct  make_binary_composite
 
struct  make_component
 
struct  make_component< karma::domain, proto::tag::function >
 
struct  make_component< karma::domain, proto::tag::terminal >
 
struct  make_component< karma::domain, Tag >
 
struct  make_component< karma::domain, tag::action >
 
struct  make_component< karma::domain, tag::directive >
 
struct  make_component< lex::domain, proto::tag::terminal >
 
struct  make_component< lex::domain, Tag >
 
struct  make_component< lex::domain, tag::action >
 
struct  make_component< qi::domain, proto::tag::function >
 
struct  make_component< qi::domain, proto::tag::terminal >
 
struct  make_component< qi::domain, Tag >
 
struct  make_component< qi::domain, tag::action >
 
struct  make_component< qi::domain, tag::directive >
 
struct  make_lazy
 
struct  make_lazy< F, A0 >
 
struct  make_lazy< F, A0, A1 >
 
struct  make_lazy< F, A0, A1, A2 >
 
struct  make_nary_composite
 
struct  make_nary_proto_expr
 
struct  make_unary_composite
 
struct  make_unary_proto_expr
 
singleton  match
 
class  match< nil_t >
 
struct  match_policy
 
struct  match_result
 
struct  max_bounded
 
struct  max_bounded_gen
 
struct  meta_compiler
 
struct  min_bounded
 
struct  min_bounded_gen
 
struct  modify
 
struct  more_t
 
singleton  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_skipper_iteration_policy
 
struct  no_tree_gen_node_parser
 
struct  no_tree_gen_node_parser_gen
 
singleton  node_all_val_data_factory
 
struct  node_count
 
struct  node_iter_data
 
singleton  node_iter_data_factory
 
struct  node_parser
 
struct  node_parser_gen
 
struct  node_val_data
 
singleton  node_val_data_factory
 
struct  nonfixed_loop_gen
 
struct  nothing_parser
 
struct  optional
 
struct  optional_parser_gen
 
struct  parse_info
 
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
 
class  parser_reference
 
struct  parser_result
 
struct  parser_scanner_linker
 
struct  parser_tag
 
struct  parser_tag_base
 
struct  plain_identity_policy
 
struct  plain_parser_category
 
singleton  position_iterator
 
singleton  position_iterator2
 
singleton  position_policy
 
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
 
struct  reduced_node_op
 
singleton  ref_actor
 
singleton  ref_const_ref_actor
 
singleton  ref_const_ref_const_ref_actor
 
singleton  ref_const_ref_value_actor
 
singleton  ref_value_actor
 
class  refactor_action_gen
 
class  refactor_action_parser
 
class  refactor_unary_gen
 
class  refactor_unary_parser
 
struct  referenced_function
 
struct  root_node_op
 
singleton  rule
 
singleton  rule_alias
 
struct  rxstrlit
 
struct  safe_bool
 
struct  same
 
singleton  scanner
 
struct  scanner_base
 
struct  scanner_context_linker
 
struct  scanner_policies
 
struct  scoped_lock_parser
 
struct  scoped_lock_parser_gen
 
struct  select_default_fail
 
struct  select_default_no_fail
 
struct  select_parser
 
struct  select_parser_gen
 
struct  semantic_action
 
struct  sequence
 
struct  sequence_parser_gen
 
struct  sequential_or
 
struct  sequential_or_parser_gen
 
struct  shallow_tag
 
struct  shortest_alternative
 
struct  shortest_parser_gen
 
struct  sign_parser
 
struct  simple_printer
 
singleton  skip_parser_iteration_policy
 
struct  skipper_iteration_policy
 
struct  space_parser
 
struct  stateful_tag_type
 
struct  stored_function
 
singleton  stored_rule
 
struct  strict_real_parser_policies
 
struct  strict_ureal_parser_policies
 
singleton  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 >
 
singleton  swap_actor
 
struct  switch_cond_parser
 
struct  switch_parser
 
struct  switch_parser_gen
 
singleton  symbol_inserter
 
singleton  symbols
 
struct  terminal
 
struct  terminal_ex
 
struct  transform_policies
 
singleton  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  unused_type
 
struct  upper_parser
 
struct  ureal_parser_policies
 
struct  use_directive
 
struct  use_directive< Domain, lazy_terminal< Terminal, Actor, Arity > >
 
struct  use_directive< karma::domain, tag::as_string >
 
struct  use_directive< karma::domain, tag::as_wstring >
 
struct  use_directive< karma::domain, tag::buffer >
 
struct  use_directive< karma::domain, tag::center >
 
struct  use_directive< karma::domain, tag::char_code< tag::encoding, CharEncoding > >
 
struct  use_directive< karma::domain, tag::char_code< tag::lower, CharEncoding > >
 
struct  use_directive< karma::domain, tag::char_code< tag::upper, CharEncoding > >
 
struct  use_directive< karma::domain, tag::columns >
 
struct  use_directive< karma::domain, tag::delimit >
 
struct  use_directive< karma::domain, tag::duplicate >
 
struct  use_directive< karma::domain, tag::left_align >
 
struct  use_directive< karma::domain, tag::maxwidth >
 
struct  use_directive< karma::domain, tag::no_delimit >
 
struct  use_directive< karma::domain, tag::omit >
 
struct  use_directive< karma::domain, tag::relaxed >
 
struct  use_directive< karma::domain, tag::repeat >
 
struct  use_directive< karma::domain, tag::right_align >
 
struct  use_directive< karma::domain, tag::skip >
 
struct  use_directive< karma::domain, tag::stateful_tag< T, tag::as > >
 
struct  use_directive< karma::domain, tag::strict >
 
struct  use_directive< karma::domain, tag::verbatim >
 
struct  use_directive< karma::domain, terminal_ex< repository::tag::confix, fusion::vector2< Prefix, Suffix > > >
 
struct  use_directive< karma::domain, terminal_ex< tag::center, fusion::vector1< T > > >
 
struct  use_directive< karma::domain, terminal_ex< tag::center, fusion::vector2< Width, Padding > > >
 
struct  use_directive< karma::domain, terminal_ex< tag::columns, fusion::vector1< T > > >
 
struct  use_directive< karma::domain, terminal_ex< tag::columns, fusion::vector2< T1, T2 > > >
 
struct  use_directive< karma::domain, terminal_ex< tag::delimit, fusion::vector1< T > > >
 
struct  use_directive< karma::domain, terminal_ex< tag::left_align, fusion::vector1< T > > >
 
struct  use_directive< karma::domain, terminal_ex< tag::left_align, fusion::vector2< Width, Padding > > >
 
struct  use_directive< karma::domain, terminal_ex< tag::maxwidth, fusion::vector1< T > > >
 
struct  use_directive< karma::domain, terminal_ex< tag::maxwidth, fusion::vector2< T, RestIter > > >
 
struct  use_directive< karma::domain, terminal_ex< tag::repeat, fusion::vector1< T > > >
 
struct  use_directive< karma::domain, terminal_ex< tag::repeat, fusion::vector2< T, inf_type > > >
 
struct  use_directive< karma::domain, terminal_ex< tag::repeat, fusion::vector2< T, T > > >
 
struct  use_directive< karma::domain, terminal_ex< tag::right_align, fusion::vector1< T > > >
 
struct  use_directive< karma::domain, terminal_ex< tag::right_align, fusion::vector2< Width, Padding > > >
 
struct  use_directive< qi::domain, repository::tag::seek >
 
struct  use_directive< qi::domain, tag::as_string >
 
struct  use_directive< qi::domain, tag::as_wstring >
 
struct  use_directive< qi::domain, tag::char_code< tag::encoding, CharEncoding > >
 
struct  use_directive< qi::domain, tag::char_code< tag::no_case, CharEncoding > >
 
struct  use_directive< qi::domain, tag::hold >
 
struct  use_directive< qi::domain, tag::lexeme >
 
struct  use_directive< qi::domain, tag::matches >
 
struct  use_directive< qi::domain, tag::no_skip >
 
struct  use_directive< qi::domain, tag::omit >
 
struct  use_directive< qi::domain, tag::raw >
 
struct  use_directive< qi::domain, tag::repeat >
 
struct  use_directive< qi::domain, tag::skip >
 
struct  use_directive< qi::domain, tag::stateful_tag< T, tag::as > >
 
struct  use_directive< qi::domain, terminal_ex< repository::tag::confix, fusion::vector2< Prefix, Suffix > > >
 
struct  use_directive< qi::domain, terminal_ex< repository::tag::distinct, fusion::vector1< Tail > > >
 
struct  use_directive< qi::domain, terminal_ex< repository::tag::dkwd, fusion::vector1< T > > >
 
struct  use_directive< qi::domain, terminal_ex< repository::tag::dkwd, fusion::vector2< T1, T2 > > >
 
struct  use_directive< qi::domain, terminal_ex< repository::tag::dkwd, fusion::vector3< T1, T2, inf_type > > >
 
struct  use_directive< qi::domain, terminal_ex< repository::tag::dkwd, fusion::vector3< T1, T2, T2 > > >
 
struct  use_directive< qi::domain, terminal_ex< repository::tag::idkwd, fusion::vector1< T > > >
 
struct  use_directive< qi::domain, terminal_ex< repository::tag::idkwd, fusion::vector2< T1, T2 > > >
 
struct  use_directive< qi::domain, terminal_ex< repository::tag::idkwd, fusion::vector3< T1, T2, inf_type > > >
 
struct  use_directive< qi::domain, terminal_ex< repository::tag::idkwd, fusion::vector3< T1, T2, T2 > > >
 
struct  use_directive< qi::domain, terminal_ex< repository::tag::ikwd, fusion::vector1< T > > >
 
struct  use_directive< qi::domain, terminal_ex< repository::tag::ikwd, fusion::vector2< T1, T2 > > >
 
struct  use_directive< qi::domain, terminal_ex< repository::tag::ikwd, fusion::vector3< T1, T2, inf_type > > >
 
struct  use_directive< qi::domain, terminal_ex< repository::tag::ikwd, fusion::vector3< T1, T2, T2 > > >
 
struct  use_directive< qi::domain, terminal_ex< repository::tag::kwd, fusion::vector1< T > > >
 
struct  use_directive< qi::domain, terminal_ex< repository::tag::kwd, fusion::vector2< T1, T2 > > >
 
struct  use_directive< qi::domain, terminal_ex< repository::tag::kwd, fusion::vector3< T1, T2, inf_type > > >
 
struct  use_directive< qi::domain, terminal_ex< repository::tag::kwd, fusion::vector3< T1, T2, T2 > > >
 
struct  use_directive< qi::domain, terminal_ex< tag::in_state, fusion::vector1< A0 > > >
 
struct  use_directive< qi::domain, terminal_ex< tag::repeat, fusion::vector1< T > > >
 
struct  use_directive< qi::domain, terminal_ex< tag::repeat, fusion::vector2< T, inf_type > > >
 
struct  use_directive< qi::domain, terminal_ex< tag::repeat, fusion::vector2< T, T > > >
 
struct  use_directive< qi::domain, terminal_ex< tag::skip, fusion::vector1< T > > >
 
struct  use_function
 
struct  use_lazy_directive
 
struct  use_lazy_directive< karma::domain, repository::tag::confix, 2 >
 
struct  use_lazy_directive< karma::domain, tag::center, 1 >
 
struct  use_lazy_directive< karma::domain, tag::center, 2 >
 
struct  use_lazy_directive< karma::domain, tag::columns, 1 >
 
struct  use_lazy_directive< karma::domain, tag::columns, 2 >
 
struct  use_lazy_directive< karma::domain, tag::delimit, 1 >
 
struct  use_lazy_directive< karma::domain, tag::left_align, 1 >
 
struct  use_lazy_directive< karma::domain, tag::left_align, 2 >
 
struct  use_lazy_directive< karma::domain, tag::maxwidth, 1 >
 
struct  use_lazy_directive< karma::domain, tag::maxwidth, 2 >
 
struct  use_lazy_directive< karma::domain, tag::repeat, 1 >
 
struct  use_lazy_directive< karma::domain, tag::repeat, 2 >
 
struct  use_lazy_directive< karma::domain, tag::right_align, 1 >
 
struct  use_lazy_directive< karma::domain, tag::right_align, 2 >
 
struct  use_lazy_directive< qi::domain, repository::tag::confix, 2 >
 
struct  use_lazy_directive< qi::domain, repository::tag::distinct, 1 >
 
struct  use_lazy_directive< qi::domain, tag::in_state, 1 >
 
struct  use_lazy_directive< qi::domain, tag::repeat, 1 >
 
struct  use_lazy_directive< qi::domain, tag::repeat, 2 >
 
struct  use_lazy_directive< qi::domain, tag::skip, 1 >
 
struct  use_lazy_terminal
 
struct  use_lazy_terminal< karma::domain, tag::auto_, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::big_bin_double, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::big_bin_float, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::big_dword, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::big_word, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::bin, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::bin_double, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::bin_float, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::bool_, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::byte_, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::char_code< tag::char_, CharEncoding >, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::char_code< tag::string, CharEncoding >, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::double_, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::dword, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::eps, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::float_, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::hex, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::int_, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::int_generator< T, Radix, force_sign >, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::little_bin_double, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::little_bin_float, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::little_dword, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::little_word, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::long_, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::long_double, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::oct, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::pad, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::short_, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::stateful_tag< Policies, tag::bool_, T >, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::stateful_tag< Policies, tag::double_, T >, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::stream, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::stream_tag< Char >, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::uint_, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::uint_generator< T, Radix >, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::ulong_, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::ushort_, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::word, 1 >
 
struct  use_lazy_terminal< karma::domain, tag::wstream, 1 >
 
struct  use_lazy_terminal< qi::domain, repository::qi::tag::advance, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::attr, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::big_bin_double, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::big_bin_float, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::big_dword, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::big_word, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::bin, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::bin_double, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::bin_float, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::bool_, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::byte_, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::char_code< tag::char_, CharEncoding >, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::char_code< tag::char_, CharEncoding >, 2 >
 
struct  use_lazy_terminal< qi::domain, tag::char_code< tag::string, CharEncoding >, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::double_, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::dword, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::eps, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::float_, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::hex, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::int_, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::int_parser< T, Radix, MinDigits, MaxDigits >, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::little_bin_double, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::little_bin_float, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::little_dword, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::little_word, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::long_, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::long_double, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::oct, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::raw_token, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::set_state, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::short_, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::stateful_tag< BoolPolicies, tag::bool_, T >, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::stateful_tag< Policies, tag::double_, T >, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::token, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::token, 2 >
 
struct  use_lazy_terminal< qi::domain, tag::tokenid, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::tokenid, 2 >
 
struct  use_lazy_terminal< qi::domain, tag::tokenid_mask, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::uint_, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::uint_parser< T, Radix, MinDigits, MaxDigits >, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::ulong_, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::ushort_, 1 >
 
struct  use_lazy_terminal< qi::domain, tag::word, 1 >
 
struct  use_operator
 
struct  use_operator<karma::domain, proto::tag::address_of >
 
struct  use_operator<karma::domain, proto::tag::bitwise_or >
 
struct  use_operator<karma::domain, proto::tag::complement >
 
struct  use_operator<karma::domain, proto::tag::dereference >
 
struct  use_operator<karma::domain, proto::tag::logical_not >
 
struct  use_operator<karma::domain, proto::tag::modulus >
 
struct  use_operator<karma::domain, proto::tag::negate >
 
struct  use_operator<karma::domain, proto::tag::shift_left >
 
struct  use_operator<karma::domain, proto::tag::unary_plus >
 
struct  use_operator<lex::domain, proto::tag::bitwise_or >
 
struct  use_operator<qi::domain, proto::tag::address_of >
 
struct  use_operator<qi::domain, proto::tag::bitwise_or >
 
struct  use_operator<qi::domain, proto::tag::bitwise_xor >
 
struct  use_operator<qi::domain, proto::tag::complement >
 
struct  use_operator<qi::domain, proto::tag::dereference >
 
struct  use_operator<qi::domain, proto::tag::divides >
 
struct  use_operator<qi::domain, proto::tag::greater >
 
struct  use_operator<qi::domain, proto::tag::logical_not >
 
struct  use_operator<qi::domain, proto::tag::logical_or >
 
struct  use_operator<qi::domain, proto::tag::minus >
 
struct  use_operator<qi::domain, proto::tag::modulus >
 
struct  use_operator<qi::domain, proto::tag::negate >
 
struct  use_operator<qi::domain, proto::tag::shift_right >
 
struct  use_operator<qi::domain, proto::tag::unary_plus >
 
struct  use_terminal
 
struct  use_terminal< Domain, lazy_terminal< Terminal, Actor, Arity > >
 
struct  use_terminal< Domain, terminal< Terminal > >
 
struct  use_terminal< karma::domain, bool >
 
struct  use_terminal< karma::domain, char >
 
struct  use_terminal< karma::domain, char[2]>
 
struct  use_terminal< karma::domain, double >
 
struct  use_terminal< karma::domain, float >
 
struct  use_terminal< karma::domain, int >
 
struct  use_terminal< karma::domain, long >
 
struct  use_terminal< karma::domain, long double >
 
struct  use_terminal< karma::domain, phoenix::actor< Eval > >
 
struct  use_terminal< karma::domain, short >
 
struct  use_terminal< karma::domain, T, typename enable_if< traits::is_generator< T > >::type >
 
struct  use_terminal< karma::domain, T, typename enable_if< traits::is_string< T > >::type >
 
struct  use_terminal< karma::domain, tag::auto_ >
 
struct  use_terminal< karma::domain, tag::big_bin_double >
 
struct  use_terminal< karma::domain, tag::big_bin_float >
 
struct  use_terminal< karma::domain, tag::big_dword >
 
struct  use_terminal< karma::domain, tag::big_word >
 
struct  use_terminal< karma::domain, tag::bin >
 
struct  use_terminal< karma::domain, tag::bin_double >
 
struct  use_terminal< karma::domain, tag::bin_float >
 
struct  use_terminal< karma::domain, tag::bool_ >
 
struct  use_terminal< karma::domain, tag::byte_ >
 
struct  use_terminal< karma::domain, tag::char_code< CharClass, CharEncoding > >
 
struct  use_terminal< karma::domain, tag::char_code< tag::char_, CharEncoding > >
 
struct  use_terminal< karma::domain, tag::char_code< tag::string, CharEncoding > >
 
struct  use_terminal< karma::domain, tag::double_ >
 
struct  use_terminal< karma::domain, tag::dword >
 
struct  use_terminal< karma::domain, tag::eol >
 
struct  use_terminal< karma::domain, tag::eps >
 
struct  use_terminal< karma::domain, tag::false_ >
 
struct  use_terminal< karma::domain, tag::float_ >
 
struct  use_terminal< karma::domain, tag::hex >
 
struct  use_terminal< karma::domain, tag::int_ >
 
struct  use_terminal< karma::domain, tag::int_generator< T, Radix, force_sign > >
 
struct  use_terminal< karma::domain, tag::little_bin_double >
 
struct  use_terminal< karma::domain, tag::little_bin_float >
 
struct  use_terminal< karma::domain, tag::little_dword >
 
struct  use_terminal< karma::domain, tag::little_word >
 
struct  use_terminal< karma::domain, tag::long_ >
 
struct  use_terminal< karma::domain, tag::long_double >
 
struct  use_terminal< karma::domain, tag::oct >
 
struct  use_terminal< karma::domain, tag::short_ >
 
struct  use_terminal< karma::domain, tag::stateful_tag< Expr, tag::attr_cast, Exposed, Transformed > >
 
struct  use_terminal< karma::domain, tag::stateful_tag< Policies, tag::bool_, T > >
 
struct  use_terminal< karma::domain, tag::stateful_tag< Policies, tag::double_, T > >
 
struct  use_terminal< karma::domain, tag::stream >
 
struct  use_terminal< karma::domain, tag::stream_tag< Char > >
 
struct  use_terminal< karma::domain, tag::true_ >
 
struct  use_terminal< karma::domain, tag::uint_ >
 
struct  use_terminal< karma::domain, tag::uint_generator< T, Radix > >
 
struct  use_terminal< karma::domain, tag::ulong_ >
 
struct  use_terminal< karma::domain, tag::ushort_ >
 
struct  use_terminal< karma::domain, tag::word >
 
struct  use_terminal< karma::domain, tag::wstream >
 
struct  use_terminal< karma::domain, terminal_ex< tag::auto_, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::big_bin_double, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::big_bin_float, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::big_dword, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::big_word, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::bin, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::bin_double, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::bin_float, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::bool_, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::byte_, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::char_code< tag::char_, CharEncoding >, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::char_code< tag::char_, CharEncoding >, fusion::vector2< A0, A1 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::char_code< tag::string, CharEncoding >, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::double_, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::dword, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::eps, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::float_, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::hex, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::int_, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::int_generator< T, Radix, force_sign >, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::lit, fusion::vector1< A0 > >, typename enable_if< traits::is_bool< A0 > >::type >
 
struct  use_terminal< karma::domain, terminal_ex< tag::lit, fusion::vector1< A0 > >, typename enable_if< traits::is_char< A0 > >::type >
 
struct  use_terminal< karma::domain, terminal_ex< tag::lit, fusion::vector1< A0 > >, typename enable_if< traits::is_int< A0 > >::type >
 
struct  use_terminal< karma::domain, terminal_ex< tag::lit, fusion::vector1< A0 > >, typename enable_if< traits::is_real< A0 > >::type >
 
struct  use_terminal< karma::domain, terminal_ex< tag::lit, fusion::vector1< A0 > >, typename enable_if< traits::is_string< A0 > >::type >
 
struct  use_terminal< karma::domain, terminal_ex< tag::lit, fusion::vector1< A0 > >, typename enable_if< traits::is_uint< A0 > >::type >
 
struct  use_terminal< karma::domain, terminal_ex< tag::little_bin_double, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::little_bin_float, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::little_dword, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::little_word, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::long_, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::long_double, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::oct, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::pad, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::short_, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::stateful_tag< Policies, tag::bool_, T >, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::stateful_tag< Policies, tag::double_, T >, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::stream, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::stream_tag< Char >, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::uint_, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::uint_generator< T, Radix >, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::ulong_, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::ushort_, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::word, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, terminal_ex< tag::wstream, fusion::vector1< A0 > > >
 
struct  use_terminal< karma::domain, unsigned int >
 
struct  use_terminal< karma::domain, unsigned long >
 
struct  use_terminal< karma::domain, unsigned short >
 
struct  use_terminal< karma::domain, wchar_t >
 
struct  use_terminal< karma::domain, wchar_t[2]>
 
struct  use_terminal< lex::domain, char >
 
struct  use_terminal< lex::domain, char[2]>
 
struct  use_terminal< lex::domain, T, typename enable_if< traits::is_lexer< T > >::type >
 
struct  use_terminal< lex::domain, T, typename enable_if< traits::is_string< T > >::type >
 
struct  use_terminal< lex::domain, terminal_ex< tag::char_code< tag::char_, CharEncoding >, fusion::vector1< A0 > > >
 
struct  use_terminal< lex::domain, terminal_ex< tag::char_code< tag::char_, CharEncoding >, fusion::vector2< A0, A1 > > >
 
struct  use_terminal< lex::domain, terminal_ex< tag::char_code< tag::string, CharEncoding >, fusion::vector1< A0 > > >
 
struct  use_terminal< lex::domain, terminal_ex< tag::char_code< tag::string, CharEncoding >, fusion::vector2< A0, A1 > > >
 
struct  use_terminal< lex::domain, wchar_t >
 
struct  use_terminal< lex::domain, wchar_t[2]>
 
struct  use_terminal< qi::domain, char >
 
struct  use_terminal< qi::domain, char[2]>
 
struct  use_terminal< qi::domain, phoenix::actor< Eval > >
 
struct  use_terminal< qi::domain, repository::qi::tag::iter_pos >
 
struct  use_terminal< qi::domain, repository::tag::flush_multi_pass >
 
struct  use_terminal< qi::domain, T, typename enable_if< traits::is_parser< T > >::type >
 
struct  use_terminal< qi::domain, T, typename enable_if< traits::is_string< T > >::type >
 
struct  use_terminal< qi::domain, tag::auto_ >
 
struct  use_terminal< qi::domain, tag::big_bin_double >
 
struct  use_terminal< qi::domain, tag::big_bin_float >
 
struct  use_terminal< qi::domain, tag::big_dword >
 
struct  use_terminal< qi::domain, tag::big_word >
 
struct  use_terminal< qi::domain, tag::bin >
 
struct  use_terminal< qi::domain, tag::bin_double >
 
struct  use_terminal< qi::domain, tag::bin_float >
 
struct  use_terminal< qi::domain, tag::bool_ >
 
struct  use_terminal< qi::domain, tag::byte_ >
 
struct  use_terminal< qi::domain, tag::char_code< CharClass, CharEncoding > >
 
struct  use_terminal< qi::domain, tag::double_ >
 
struct  use_terminal< qi::domain, tag::dword >
 
struct  use_terminal< qi::domain, tag::eoi >
 
struct  use_terminal< qi::domain, tag::eol >
 
struct  use_terminal< qi::domain, tag::eps >
 
struct  use_terminal< qi::domain, tag::false_ >
 
struct  use_terminal< qi::domain, tag::float_ >
 
struct  use_terminal< qi::domain, tag::hex >
 
struct  use_terminal< qi::domain, tag::int_ >
 
struct  use_terminal< qi::domain, tag::int_parser< T, Radix, MinDigits, MaxDigits > >
 
struct  use_terminal< qi::domain, tag::little_bin_double >
 
struct  use_terminal< qi::domain, tag::little_bin_float >
 
struct  use_terminal< qi::domain, tag::little_dword >
 
struct  use_terminal< qi::domain, tag::little_word >
 
struct  use_terminal< qi::domain, tag::long_ >
 
struct  use_terminal< qi::domain, tag::long_double >
 
struct  use_terminal< qi::domain, tag::oct >
 
struct  use_terminal< qi::domain, tag::raw_token >
 
struct  use_terminal< qi::domain, tag::short_ >
 
struct  use_terminal< qi::domain, tag::stateful_tag< BoolPolicies, tag::bool_, T > >
 
struct  use_terminal< qi::domain, tag::stateful_tag< Expr, tag::attr_cast, Exposed, Transformed > >
 
struct  use_terminal< qi::domain, tag::stateful_tag< Policies, tag::double_, T > >
 
struct  use_terminal< qi::domain, tag::stream >
 
struct  use_terminal< qi::domain, tag::token >
 
struct  use_terminal< qi::domain, tag::tokenid >
 
struct  use_terminal< qi::domain, tag::true_ >
 
struct  use_terminal< qi::domain, tag::uint_ >
 
struct  use_terminal< qi::domain, tag::uint_parser< T, Radix, MinDigits, MaxDigits > >
 
struct  use_terminal< qi::domain, tag::ulong_ >
 
struct  use_terminal< qi::domain, tag::ushort_ >
 
struct  use_terminal< qi::domain, tag::word >
 
struct  use_terminal< qi::domain, tag::wstream >
 
struct  use_terminal< qi::domain, terminal< tag::char_code< tag::char_, CharEncoding > > >
 
struct  use_terminal< qi::domain, terminal_ex< repository::qi::tag::advance, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::attr, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::big_bin_double, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::big_bin_float, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::big_dword, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::big_word, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::bin, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::bin_double, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::bin_float, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::bool_, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::byte_, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::char_code< tag::char_, CharEncoding >, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::char_code< tag::char_, CharEncoding >, fusion::vector2< A0, A1 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::char_code< tag::string, CharEncoding >, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::double_, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::dword, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::eps, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::float_, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::hex, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::int_, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::int_parser< T, Radix, MinDigits, MaxDigits >, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::lit, fusion::vector1< A0 > >, typename enable_if< is_same< A0, bool > >::type >
 
struct  use_terminal< qi::domain, terminal_ex< tag::lit, fusion::vector1< A0 > >, typename enable_if< is_same< A0, double > >::type >
 
struct  use_terminal< qi::domain, terminal_ex< tag::lit, fusion::vector1< A0 > >, typename enable_if< is_same< A0, float > >::type >
 
struct  use_terminal< qi::domain, terminal_ex< tag::lit, fusion::vector1< A0 > >, typename enable_if< is_same< A0, long double > >::type >
 
struct  use_terminal< qi::domain, terminal_ex< tag::lit, fusion::vector1< A0 > >, typename enable_if< is_same< A0, signed > >::type >
 
struct  use_terminal< qi::domain, terminal_ex< tag::lit, fusion::vector1< A0 > >, typename enable_if< is_same< A0, signed long > >::type >
 
struct  use_terminal< qi::domain, terminal_ex< tag::lit, fusion::vector1< A0 > >, typename enable_if< is_same< A0, signed short > >::type >
 
struct  use_terminal< qi::domain, terminal_ex< tag::lit, fusion::vector1< A0 > >, typename enable_if< is_same< A0, unsigned > >::type >
 
struct  use_terminal< qi::domain, terminal_ex< tag::lit, fusion::vector1< A0 > >, typename enable_if< is_same< A0, unsigned long > >::type >
 
struct  use_terminal< qi::domain, terminal_ex< tag::lit, fusion::vector1< A0 > >, typename enable_if< is_same< A0, unsigned short > >::type >
 
struct  use_terminal< qi::domain, terminal_ex< tag::lit, fusion::vector1< A0 > >, typename enable_if< traits::is_char< A0 > >::type >
 
struct  use_terminal< qi::domain, terminal_ex< tag::lit, fusion::vector1< A0 > >, typename enable_if< traits::is_string< A0 > >::type >
 
struct  use_terminal< qi::domain, terminal_ex< tag::little_bin_double, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::little_bin_float, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::little_dword, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::little_word, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::long_, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::long_double, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::oct, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::raw_token, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::set_state, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::short_, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::stateful_tag< BoolPolicies, tag::bool_, T >, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::stateful_tag< Policies, tag::double_, T >, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::token, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::token, fusion::vector2< A0, A1 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::tokenid, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::tokenid, fusion::vector2< A0, A1 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::tokenid_mask, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::uint_, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::uint_parser< T, Radix, MinDigits, MaxDigits >, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::ulong_, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::ushort_, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, terminal_ex< tag::word, fusion::vector1< A0 > > >
 
struct  use_terminal< qi::domain, wchar_t >
 
struct  use_terminal< qi::domain, wchar_t[2]>
 
class  utree
 
struct  utree_exception
 
struct  utree_is_equal
 
struct  utree_is_less_than
 
struct  utree_print
 
struct  utree_type
 
struct  while_parser
 
struct  xdigit_parser
 

Typedefs

typedef skipper_iteration_policy iter_policy_t
 
typedef scanner_policies
< iter_policy_t
scanner_policies_t
 
typedef scanner< char const
*, scanner_policies_t
phrase_scanner_t
 
typedef scanner< wchar_t const
*, scanner_policies_t
wide_phrase_scanner_t
 
typedef file_position_base
< std::string > 
file_position
 
typedef
file_position_without_column_base
< std::string > 
file_position_without_column
 
typedef mpl::vector
< spirit::char_encoding::ascii,
spirit::char_encoding::iso8859_1,
spirit::char_encoding::standard,
spirit::char_encoding::standard_wide
char_encodings
 
typedef basic_istream_iterator
< char > 
istream_iterator
 
typedef
karma::ostream_iterator< char,
char > 
ostream_iterator
 
typedef ::boost::uint32_t ucs4_char
 
typedef char utf8_char
 
typedef std::basic_string
< ucs4_char
ucs4_string
 
typedef std::basic_string
< utf8_char
utf8_string
 
typedef basic_string
< boost::iterator_range< char
const * >
, utree_type::binary_type
binary_range_type
 
typedef basic_string
< std::string,
utree_type::binary_type
binary_string_type
 
typedef basic_string
< boost::iterator_range< char
const * >
, utree_type::string_type
utf8_string_range_type
 
typedef basic_string
< std::string,
utree_type::string_type
utf8_string_type
 
typedef basic_string
< boost::iterator_range< char
const * >
, utree_type::symbol_type
utf8_symbol_range_type
 
typedef basic_string
< std::string,
utree_type::symbol_type
utf8_symbol_type
 

Functions

template<typename T >
ref_value_actor< T, assign_actionassign (T &ref_)
 
template<typename T >
ref_value_actor< T, assign_actionassign_a (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 , typename ValueT >
ref_const_ref_value_actor< T,
ValueT, assign_key_action
assign_key_a (T &ref_, ValueT const &value_)
 
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 >
ref_actor< T, clear_actionclear_a (T &ref_)
 
template<typename T >
ref_actor< T, decrement_actiondecrement_a (T &ref_)
 
template<typename T >
ref_value_actor< T, erase_actionerase_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_actor< T, increment_actionincrement_a (T &ref_)
 
template<typename T , typename ReferentT >
ref_const_ref_value_actor< T,
ReferentT, insert_at_action
insert_at_a (T &ref_, ReferentT const &key_)
 
template<typename T , typename ReferentT , typename ValueT >
ref_const_ref_const_ref_actor
< T, ReferentT, ValueT,
insert_at_action
insert_at_a (T &ref_, ReferentT const &key_, ValueT const &value_)
 
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 T >
ref_value_actor< T,
push_back_action
append (T &ref_)
 
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_back_action
push_back_a (T &ref_, ValueT const &value_)
 
template<typename T >
ref_value_actor< T,
push_front_action
push_front_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 >
swap_actor< Tswap_a (T &ref_, T &swap_ref_)
 
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 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 ChGenT >
f_chlit< ChGenT > f_ch_p (ChGenT chgen)
 
template<typename ChGenAT , typename ChGenBT >
f_range< ChGenAT, ChGenBT > f_range_p (ChGenAT first, ChGenBT last)
 
template<typename IterGenAT , typename IterGenBT >
f_chseq< IterGenAT, IterGenBT > f_chseq_p (IterGenAT first, IterGenBT last)
 
template<typename IterGenAT , typename IterGenBT >
f_strlit< IterGenAT, IterGenBT > f_str_p (IterGenAT first, IterGenBT last)
 
template<typename A , typename B >
alternative< A, B > operator| (parser< A > const &a, parser< B > const &b)
 
template<typename A >
alternative< A, chlit< char > > operator| (parser< A > const &a, char b)
 
template<typename B >
alternative< chlit< char >, B > operator| (char 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< strlit< char
const * >, B > 
operator| (char const *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< chlit< wchar_t >, B > operator| (wchar_t 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< strlit< wchar_t
const * >, B > 
operator| (wchar_t const *a, parser< B > const &b)
 
template<typename A , typename B >
difference< A, B > operator- (parser< A > const &a, parser< B > const &b)
 
template<typename A >
difference< A, chlit< char > > operator- (parser< A > const &a, char b)
 
template<typename B >
difference< chlit< char >, B > operator- (char 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< strlit< char const * >
, B > 
operator- (char const *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< chlit< wchar_t >, B > operator- (wchar_t 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< strlit< wchar_t
const * >, B > 
operator- (wchar_t const *a, parser< B > const &b)
 
template<typename BoundsT >
min_bounded_gen< BoundsT > min_limit_d (BoundsT const &min_)
 
template<typename BoundsT >
max_bounded_gen< BoundsT > max_limit_d (BoundsT const &max_)
 
template<typename BoundsT >
bounded_gen< BoundsT > limit_d (BoundsT const &min_, BoundsT const &max_)
 
template<typename CondT , bool positive>
condition_parser< CondT,!positiveoperator~ (condition_parser< CondT, positive > const &p)
 
template<typename SubjectT >
negated_empty_match_parser
< SubjectT > 
operator~ (empty_match_parser< SubjectT > const &p)
 
template<typename SubjectT >
empty_match_parser< SubjectT > operator~ (negated_empty_match_parser< SubjectT > const &p)
 
template<typename A , typename B >
exclusive_or< A, B > operator^ (parser< A > const &a, parser< B > const &b)
 
template<typename A >
exclusive_or< A, chlit< char > > operator^ (parser< A > const &a, char b)
 
template<typename B >
exclusive_or< chlit< char >, B > operator^ (char 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< strlit< char
const * >, B > 
operator^ (char const *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< chlit< wchar_t >, B > operator^ (wchar_t 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< strlit< wchar_t
const * >, B > 
operator^ (wchar_t const *a, parser< B > const &b)
 
template<typename A , typename B >
intersection< A, B > operator& (parser< A > const &a, parser< B > const &b)
 
template<typename A >
intersection< A, chlit< char > > operator& (parser< A > const &a, char b)
 
template<typename B >
intersection< chlit< char >, B > operator& (char 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< strlit< char
const * >, B > 
operator& (char const *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< chlit< wchar_t >, B > operator& (wchar_t 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< strlit< wchar_t
const * >, B > 
operator& (wchar_t const *a, parser< B > const &b)
 
template<typename S >
kleene_star< S > operator* (parser< S > const &a)
 
template<typename A , typename B >
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
sequence< A, kleene_star
< sequence< B, A > > > 
operator% (parser< A > const &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 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< strlit< char const * >
, A > > > 
operator% (parser< A > const &a, char const *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< chlit< wchar_t >
, A > > > 
operator% (parser< A > const &a, wchar_t 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< strlit< wchar_t
const * >, A > > > 
operator% (parser< A > const &a, wchar_t const *b)
 
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 S >
optional< S > operator! (parser< S > const &a)
 
template<typename S >
positive< S > operator+ (parser< S > const &a)
 
template<typename A , typename B >
sequence< A, B > operator>> (parser< A > const &a, parser< B > const &b)
 
template<typename A >
sequence< A, chlit< char > > operator>> (parser< A > const &a, char b)
 
template<typename B >
sequence< chlit< char >, B > operator>> (char 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< strlit< char const * >
, B > 
operator>> (char const *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< chlit< wchar_t >, B > operator>> (wchar_t 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< strlit< wchar_t
const * >, B > 
operator>> (wchar_t const *a, parser< B > const &b)
 
template<typename A , typename B >
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
sequence< A, B > 
operator&& (parser< A > const &a, parser< B > const &b)
 
template<typename A >
sequence< A, chlit< char > > operator&& (parser< A > const &a, char b)
 
template<typename B >
sequence< chlit< char >, B > operator&& (char 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< strlit< char const * >
, B > 
operator&& (char const *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< chlit< wchar_t >, B > operator&& (wchar_t 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< strlit< wchar_t
const * >, B > 
operator&& (wchar_t const *a, parser< B > const &b)
 
template<typename A , typename B >
sequential_or< A, B > operator|| (parser< A > const &a, parser< B > const &b)
 
template<typename A >
sequential_or< A, chlit< char > > operator|| (parser< A > const &a, char b)
 
template<typename B >
sequential_or< chlit< char >, B > operator|| (char 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< strlit< char
const * >, B > 
operator|| (char const *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< chlit< wchar_t >
, B > 
operator|| (wchar_t 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< strlit< wchar_t
const * >, B > 
operator|| (wchar_t const *a, parser< B > const &b)
 
template<typename IteratorT , typename DerivedT >
parse_info< IteratorT > parse (IteratorT const &first, IteratorT const &last, parser< DerivedT > const &p)
 
template<typename CharT , typename DerivedT >
parse_info< CharT const * > parse (CharT const *str, parser< DerivedT > const &p)
 
template<typename ParserT >
negated_char_parser< ParserT > operator~ (char_parser< ParserT > const &p)
 
template<typename ParserT >
ParserT operator~ (negated_char_parser< ParserT > const &n)
 
template<typename CharT >
chlit< CharT > ch_p (CharT ch)
 
template<typename CharT , std::size_t N>
chlit< CharT > ch_p (CharT const (&str)[N])
 
template<typename CharT >
range< CharT > range_p (CharT first, CharT last)
 
template<typename CharT >
chseq< CharT const * > chseq_p (CharT const *str)
 
template<typename IteratorT >
chseq< IteratorT > chseq_p (IteratorT first, IteratorT last)
 
template<typename CharT >
strlit< CharT const * > str_p (CharT const *str)
 
template<typename CharT >
strlit< CharT * > str_p (CharT *str)
 
template<typename IteratorT >
strlit< IteratorT > str_p (IteratorT first, IteratorT last)
 
template<typename CharT >
chlit< CharT > str_p (CharT ch)
 
nothing_parser operator~ (anychar_parser)
 
strlit< char const * > const pizza_p (char const *your_favorite_pizza)
 
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 ParserT , typename SkipT >
parse_info< CharT const * > parse (CharT const *str, parser< ParserT > const &p, parser< SkipT > const &skip)
 
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 CondT >
impl::if_parser_gen< CondT > if_p (CondT const &cond)
 
template<class ActorT >
lazy_parser< ActorT > lazy_p (ActorT const &actor)
 
template<int N, typename ParserT >
case_parser< N, ParserT, false > case_p (parser< ParserT > const &p)
 
template<typename CondT >
impl::while_parser_gen< CondT > while_p (CondT const &cond)
 
template<typename ErrorDescrT , typename IteratorT >
void throw_ (IteratorT where, ErrorDescrT descriptor)
 
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 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 >
multi_pass< InputT,
multi_pass_policies::input_iterator,
multi_pass_policies::ref_counted,
multi_pass_policies::buf_id_check,
multi_pass_policies::std_deque
make_multi_pass (InputT i)
 
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 UnaryT >
unary_subject< UnaryT >::type
const & 
get_unary_subject (UnaryT const &unary_)
 
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 ActionT >
action_subject< ActionT >
::type const & 
get_action_subject (ActionT const &action_)
 
template<typename ActionT >
semantic_action< ActionT >
::type const & 
get_semantic_action (ActionT const &action_)
 
template<typename T , typename CharT , typename SetT >
Tadd (symbols< T, CharT, SetT > &table, CharT const *sym, T const &data=T())
 
template<typename T , typename CharT , typename SetT >
Tfind (symbols< T, CharT, SetT > const &table, CharT const *sym)
 
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 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 IteratorT , typename ParserT >
tree_parse_info< IteratorT > ast_parse (IteratorT const &first_, IteratorT const &last, 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 CharT , typename ParserT >
tree_parse_info< CharT const * > ast_parse (CharT const *str, parser< ParserT > const &parser)
 
template<typename T >
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
void 
swap (tree_node< T > &a, tree_node< T > &b)
 
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 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 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 IteratorT , typename ParserT >
tree_parse_info< IteratorT > pt_parse (IteratorT const &first_, IteratorT const &last, 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 CharT , typename ParserT >
tree_parse_info< CharT const * > pt_parse (CharT const *str, parser< ParserT > const &parser)
 
template<typename T >
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
tree_node< T > const & 
get_first_leaf (tree_node< T > const &node)
 
template<typename T >
bool find_node (tree_node< T > const &node, parser_id node_to_search, tree_node< T > const **found_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 CharT , typename TreeNodeT , typename AssocContainerT , typename GetIdT , typename GetValueT >
void basic_tree_to_xml (std::basic_ostream< CharT > &ostrm, TreeNodeT const &tree, std::basic_string< CharT > const &input_line, AssocContainerT const &id_to_name, GetIdT const &get_token_id, GetValueT const &get_token_value)
 
template<typename CharT , typename TreeNodeT , typename AssocContainerT >
void basic_tree_to_xml (std::basic_ostream< CharT > &ostrm, TreeNodeT const &tree, std::basic_string< CharT > const &input_line, AssocContainerT const &id_to_name)
 
template<typename CharT , typename TreeNodeT >
void basic_tree_to_xml (std::basic_ostream< CharT > &ostrm, TreeNodeT const &tree, std::basic_string< CharT > const &input_line=impl::default_string< CharT >::get())
 
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 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 >
void tree_to_xml (std::ostream &ostrm, TreeNodeT const &tree, std::string const &input_line="")
 
template<typename CharT >
chset< CharT > chset_p (chlit< CharT > const &arg_)
 
template<typename CharT >
chset< CharT > chset_p (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 (negated_char_parser< range< CharT > > const &arg_)
 
chset< char > chset_p (char const *init)
 
chset< wchar_t > chset_p (wchar_t const *init)
 
chset< char > chset_p (char ch)
 
chset< wchar_t > chset_p (wchar_t ch)
 
chset< int > chset_p (int ch)
 
chset< unsigned int > chset_p (unsigned int ch)
 
chset< short > chset_p (short ch)
 
chset< unsigned short > chset_p (unsigned short ch)
 
chset< long > chset_p (long ch)
 
chset< unsigned long > chset_p (unsigned long ch)
 
template<typename CharT >
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
chset< CharT > 
operator~ (chset< CharT > const &a)
 
template<typename CharT >
chset< CharT > operator| (chset< CharT > const &a, chset< CharT > const &b)
 
template<typename CharT >
chset< CharT > operator& (chset< CharT > const &a, chset< CharT > const &b)
 
template<typename CharT >
chset< CharT > operator- (chset< CharT > const &a, chset< CharT > const &b)
 
template<typename CharT >
chset< CharT > operator^ (chset< 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, range< 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, range< CharT > const &b)
 
template<typename CharT >
chset< CharT > operator| (range< CharT > const &a, chset< CharT > const &b)
 
template<typename CharT >
chset< CharT > operator& (range< CharT > const &a, chset< CharT > const &b)
 
template<typename CharT >
chset< CharT > operator- (range< CharT > const &a, chset< 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, chlit< CharT > const &b)
 
template<typename CharT >
chset< CharT > operator& (chset< CharT > const &a, chlit< CharT > const &b)
 
template<typename CharT >
chset< CharT > operator- (chset< CharT > const &a, chlit< CharT > const &b)
 
template<typename CharT >
chset< CharT > operator^ (chset< CharT > const &a, chlit< CharT > const &b)
 
template<typename CharT >
chset< CharT > operator| (chlit< CharT > const &a, chset< CharT > const &b)
 
template<typename CharT >
chset< CharT > operator& (chlit< CharT > const &a, chset< CharT > const &b)
 
template<typename CharT >
chset< CharT > operator- (chlit< CharT > const &a, chset< 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, negated_char_parser< range< 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- (chset< CharT > const &a, negated_char_parser< range< 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| (negated_char_parser< range< CharT > > const &a, chset< 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- (negated_char_parser< range< CharT > > const &a, chset< 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< chlit< 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- (chset< CharT > const &a, negated_char_parser< chlit< 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< chlit< CharT > > const &a, chset< CharT > const &b)
 
template<typename CharT >
chset< CharT > operator& (negated_char_parser< chlit< CharT > > const &a, chset< CharT > const &b)
 
template<typename CharT >
chset< CharT > operator- (negated_char_parser< chlit< CharT > > const &a, chset< CharT > const &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, CharT b)
 
template<typename CharT >
chset< CharT > operator& (chset< CharT > const &a, CharT b)
 
template<typename CharT >
chset< CharT > operator- (chset< CharT > const &a, CharT b)
 
template<typename CharT >
chset< CharT > operator^ (chset< CharT > const &a, CharT b)
 
template<typename CharT >
chset< CharT > operator| (CharT a, chset< CharT > const &b)
 
template<typename CharT >
chset< CharT > operator& (CharT a, chset< CharT > const &b)
 
template<typename CharT >
chset< CharT > operator- (CharT a, chset< CharT > const &b)
 
template<typename CharT >
chset< CharT > operator^ (CharT a, chset< CharT > const &b)
 
template<typename CharT >
chset< CharT > operator| (chset< CharT > const &a, anychar_parser b)
 
template<typename CharT >
chset< CharT > operator& (chset< CharT > const &a, anychar_parser b)
 
template<typename CharT >
chset< CharT > operator- (chset< CharT > const &a, anychar_parser b)
 
template<typename CharT >
chset< CharT > operator^ (chset< CharT > const &a, anychar_parser b)
 
template<typename CharT >
chset< CharT > operator| (anychar_parser a, chset< CharT > const &b)
 
template<typename CharT >
chset< CharT > operator& (anychar_parser a, chset< CharT > const &b)
 
template<typename CharT >
chset< CharT > operator- (anychar_parser a, chset< CharT > const &b)
 
template<typename CharT >
chset< CharT > operator^ (anychar_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& (chset< CharT > const &a, nothing_parser b)
 
template<typename CharT >
chset< CharT > operator- (chset< CharT > const &a, nothing_parser b)
 
template<typename CharT >
chset< CharT > operator^ (chset< CharT > const &a, nothing_parser b)
 
template<typename CharT >
chset< CharT > operator| (nothing_parser a, chset< CharT > const &b)
 
template<typename CharT >
chset< CharT > operator& (nothing_parser a, chset< CharT > const &b)
 
template<typename CharT >
chset< CharT > operator- (nothing_parser a, chset< CharT > const &b)
 
template<typename CharT >
chset< CharT > operator^ (nothing_parser a, chset< CharT > const &b)
 
template<typename OpenT , typename CloseT >
comment_nest_p_result< OpenT,
CloseT >::type 
comment_nest_p (OpenT const &open, CloseT const &close)
 
template<typename ExactT >
fixed_loop_gen< ExactT > repeat_p (ExactT const &exact)
 
template<typename MinT , typename MaxT >
nonfixed_loop_gen< MinT, MaxT > repeat_p (MinT const &min, MaxT const &max)
 
template<typename CharT >
rxstrlit< CharT > regex_p (CharT const *first)
 
template<typename CharT >
rxstrlit< CharT > regex_p (CharT const *first, CharT const *last)
 
template<class P >
parser_reference< P > embed_by_reference (parser< P > const &)
 
template<class P >
parser_reference< P > embed_by_reference (::BOOST_SPIRIT_CLASSIC_NS::parser< P > &p)
 
template<typename MutexT >
scoped_lock_parser_gen< MutexT > scoped_lock_d (MutexT &mutex)
 
template<typename Sequence1 , typename Sequence2 , typename F >
bool any (Sequence1 const &seq1, Sequence2 &seq2, F f)
 
template<typename Sequence , typename F >
bool any (Sequence const &seq, unused_type, F f)
 
template<typename Pred , typename Sequence1 , typename Sequence2 , typename F >
bool any_if (Sequence1 const &seq1, Sequence2 &seq2, F f, Pred)
 
template<typename Pred , typename Sequence , typename F >
bool any_if (Sequence const &seq, unused_type const, F f, Pred)
 
template<typename Pred , typename Sequence1 , typename Sequence2 , typename F >
bool any_if_ns (Sequence1 const &seq1, Sequence2 &seq2, F f, Pred)
 
template<typename Pred , typename Sequence , typename F >
bool any_if_ns (Sequence const &seq, unused_type const, F f, Pred)
 
template<typename Sequence1 , typename Sequence2 , typename F >
bool any_ns (Sequence1 const &seq1, Sequence2 &seq2, F f)
 
template<typename Sequence , typename F >
bool any_ns (Sequence const &seq, unused_type, F f)
 
template<typename Expr >
enable_if< proto::is_expr
< Expr >, stateful_tag_type
< Expr, tag::attr_cast >
>::type 
attr_cast (Expr const &expr)
 
template<typename Exposed , typename Expr >
enable_if< proto::is_expr
< Expr >, stateful_tag_type
< Expr, tag::attr_cast,
Exposed > >::type 
attr_cast (Expr const &expr)
 
template<typename Exposed , typename Transformed , typename Expr >
enable_if< proto::is_expr
< Expr >, stateful_tag_type
< Expr, tag::attr_cast,
Exposed, Transformed > >::type 
attr_cast (Expr const &expr)
 
 BOOST_SPIRIT_DEFINE_TERMINALS_NAME ((verbatim, verbatim_type)(no_delimit, no_delimit_type)(lexeme, lexeme_type)(no_skip, no_skip_type)(omit, omit_type)(raw, raw_type)(as_string, as_string_type)(as_wstring, as_wstring_type)(inf, inf_type)(eol, eol_type)(eoi, eoi_type)(buffer, buffer_type)(true_, true_type)(false_, false_type)(matches, matches_type)(hold, hold_type)(strict, strict_type)(relaxed, relaxed_type)(duplicate, duplicate_type)) BOOST_SPIRIT_DEFINE_TERMINALS_NAME_EX((lit
 
 lit_type (bin, bin_type)(oct
 
 oct_type (hex, hex_type)(bool_
 
 bool_type (ushort_, ushort_type)(ulong_
 
 ulong_type (uint_, uint_type)(short_
 
 short_type (long_, long_type)(int_
 
 int_type (ulong_long, ulong_long_type)(long_long
 
 long_long_type (float_, float_type)(double_
 
 double_type (long_double, long_double_type)(repeat
 
 repeat_type (eps, eps_type)(pad
 
 pad_type (byte_, byte_type)(word
 
 word_type (big_word, big_word_type)(little_word
 
 little_word_type (dword, dword_type)(big_dword
 
 big_dword_type (little_dword, little_dword_type)(qword
 
 qword_type (big_qword, big_qword_type)(little_qword
 
 little_qword_type (bin_float, bin_float_type)(big_bin_float
 
 big_bin_float_type (little_bin_float, little_bin_float_type)(bin_double
 
 bin_double_type (big_bin_double, big_bin_double_type)(little_bin_double
 
 little_bin_double_type (skip, skip_type)(delimit
 
 delimit_type (stream, stream_type)(wstream
 
 wstream_type (left_align, left_align_type)(right_align
 
 right_align_type (center, center_type)(maxwidth
 
 maxwidth_type (set_state, set_state_type)(in_state
 
 in_state_type (token, token_type)(tokenid
 
 tokenid_type (raw_token, raw_token_type)(tokenid_mask
 
 tokenid_mask_type (attr, attr_type)(columns
 
 columns_type (auto_, auto_type)) namespace tag
 
template<typename Out >
Out & operator<< (Out &out, info const &what)
 
template<class Iterator >
std::size_t get_line (Iterator)
 
template<class Iterator >
Iterator get_line_start (Iterator lower_bound, Iterator current)
 
template<class Iterator >
iterator_range< Iterator > get_current_line (Iterator lower_bound, Iterator current, Iterator upper_bound)
 
template<class Iterator >
std::size_t get_column (Iterator lower_bound, Iterator current, std::size_t tabs=4)
 
template<class Iterator >
std::size_t get_line (line_pos_iterator< Iterator > i)
 
template<typename Policies , typename T >
multi_pass< T, Policies > make_multi_pass (T &i)
 
template<typename Policies , typename T >
multi_pass< T, Policies > make_multi_pass (T const &i)
 
template<typename T >
multi_pass< Tmake_default_multi_pass (T &i)
 
template<typename T >
multi_pass< Tmake_default_multi_pass (T const &i)
 
template<typename T , typename Policies >
void swap (multi_pass< T, Policies > &x, multi_pass< T, Policies > &y)
 
template<typename Eval >
proto::terminal
< phoenix::actor< Eval >
>::type 
lazy (phoenix::actor< Eval > const &f)
 
template<typename Domain , typename Expr >
result_of::compile< Domain,
Expr, unused_type >::type 
compile (Expr const &expr)
 
template<typename Domain , typename Expr , typename Modifiers >
result_of::compile< Domain,
Expr, Modifiers >::type 
compile (Expr const &expr, Modifiers modifiers)
 
template<typename Out >
Out & operator<< (Out &out, detail::unused_only const &)
 
template<typename In >
In & operator>> (In &in, unused_type &)
 
template<typename Char >
utf8_string to_utf8 (Char value)
 
template<typename Char >
utf8_string to_utf8 (Char const *str)
 
template<typename Char , typename Traits , typename Allocator >
utf8_string to_utf8 (std::basic_string< Char, Traits, Allocator > const &str)
 
bool operator== (utree const &a, utree const &b)
 
bool operator< (utree const &a, utree const &b)
 
bool operator!= (utree const &a, utree const &b)
 
bool operator> (utree const &a, utree const &b)
 
bool operator<= (utree const &a, utree const &b)
 
bool operator>= (utree const &a, utree const &b)
 
std::ostream & operator<< (std::ostream &out, utree const &x)
 
std::ostream & operator<< (std::ostream &out, utree::invalid_type const &x)
 
std::ostream & operator<< (std::ostream &out, utree::nil_type const &x)
 
utree operator&& (utree const &a, utree const &b)
 
utree operator|| (utree const &a, utree const &b)
 
utree operator! (utree const &a)
 
utree operator+ (utree const &a, utree const &b)
 
utree operator- (utree const &a, utree const &b)
 
utree operator* (utree const &a, utree const &b)
 
utree operator/ (utree const &a, utree const &b)
 
utree operator% (utree const &a, utree const &b)
 
utree operator- (utree const &a)
 
utree operator& (utree const &a, utree const &b)
 
utree operator| (utree const &a, utree const &b)
 
utree operator^ (utree const &a, utree const &b)
 
utree operator<< (utree const &a, utree const &b)
 
utree operator>> (utree const &a, utree const &b)
 
utree operator~ (utree const &a)
 
struct BOOST_PP_CAT (function_impl_, and_)
 
logical_function< BOOST_PP_CAT(function_impl_,
and_)> const 
BOOST_PP_CAT (logical_function, BOOST_PP_CAT(_, and_))
 
struct BOOST_PP_CAT (function_impl_, or_)
 
logical_function< BOOST_PP_CAT(function_impl_,
or_)> const 
BOOST_PP_CAT (logical_function, BOOST_PP_CAT(_, or_))
 
struct BOOST_PP_CAT (function_impl_, not_)
 
logical_function< BOOST_PP_CAT(function_impl_,
not_)> const 
BOOST_PP_CAT (logical_function, BOOST_PP_CAT(_, not_))
 
struct BOOST_PP_CAT (function_impl_, plus)
 
arithmetic_function
< BOOST_PP_CAT(function_impl_,
plus)> const 
BOOST_PP_CAT (arithmetic_function, BOOST_PP_CAT(_, plus))
 
struct BOOST_PP_CAT (function_impl_, minus)
 
arithmetic_function
< BOOST_PP_CAT(function_impl_,
minus)> const 
BOOST_PP_CAT (arithmetic_function, BOOST_PP_CAT(_, minus))
 
struct BOOST_PP_CAT (function_impl_, times)
 
arithmetic_function
< BOOST_PP_CAT(function_impl_,
times)> const 
BOOST_PP_CAT (arithmetic_function, BOOST_PP_CAT(_, times))
 
struct BOOST_PP_CAT (function_impl_, divides)
 
arithmetic_function
< BOOST_PP_CAT(function_impl_,
divides)> const 
BOOST_PP_CAT (arithmetic_function, BOOST_PP_CAT(_, divides))
 
struct BOOST_PP_CAT (function_impl_, modulus)
 
integral_function
< BOOST_PP_CAT(function_impl_,
modulus)> const 
BOOST_PP_CAT (integral_function, BOOST_PP_CAT(_, modulus))
 
struct BOOST_PP_CAT (function_impl_, negate)
 
arithmetic_function
< BOOST_PP_CAT(function_impl_,
negate)> const 
BOOST_PP_CAT (arithmetic_function, BOOST_PP_CAT(_, negate))
 
struct BOOST_PP_CAT (function_impl_, bitand_)
 
integral_function
< BOOST_PP_CAT(function_impl_,
bitand_)> const 
BOOST_PP_CAT (integral_function, BOOST_PP_CAT(_, bitand_))
 
struct BOOST_PP_CAT (function_impl_, bitor_)
 
integral_function
< BOOST_PP_CAT(function_impl_,
bitor_)> const 
BOOST_PP_CAT (integral_function, BOOST_PP_CAT(_, bitor_))
 
struct BOOST_PP_CAT (function_impl_, bitxor_)
 
integral_function
< BOOST_PP_CAT(function_impl_,
bitxor_)> const 
BOOST_PP_CAT (integral_function, BOOST_PP_CAT(_, bitxor_))
 
struct BOOST_PP_CAT (function_impl_, shift_left)
 
integral_function
< BOOST_PP_CAT(function_impl_,
shift_left)> const 
BOOST_PP_CAT (integral_function, BOOST_PP_CAT(_, shift_left))
 
struct BOOST_PP_CAT (function_impl_, shift_right)
 
integral_function
< BOOST_PP_CAT(function_impl_,
shift_right)> const 
BOOST_PP_CAT (integral_function, BOOST_PP_CAT(_, shift_right))
 
struct BOOST_PP_CAT (function_impl_, invert)
 
integral_function
< BOOST_PP_CAT(function_impl_,
invert)> const 
BOOST_PP_CAT (integral_function, BOOST_PP_CAT(_, invert))
 
std::ostream & operator<< (std::ostream &out, utree_type::info t)
 
inline utree::reference get (utree::reference, utree::size_type)
 
inline utree::const_reference get (utree::const_reference, utree::size_type)
 

Variables

const lexeme_parser_gen lexeme_d = lexeme_parser_gen()
 
const inhibit_case_parser_gen nocase_d = inhibit_case_parser_gen()
 
const inhibit_case_parser_gen as_lower_d = inhibit_case_parser_gen()
 
const longest_parser_gen longest_d = longest_parser_gen()
 
const shortest_parser_gen shortest_d = shortest_parser_gen()
 
epsilon_parser const epsilon_p = epsilon_parser()
 
epsilon_parser const eps_p = epsilon_parser()
 
const no_actions_parser_gen no_actions_d = no_actions_parser_gen()
 
int_parser< int > const int_p = int_parser<int>()
 
uint_parser< unsigned > const uint_p = uint_parser<unsigned>()
 
uint_parser< unsigned, 2 > const bin_p = uint_parser<unsigned, 2>()
 
uint_parser< unsigned, 8 > const oct_p = uint_parser<unsigned, 8>()
 
uint_parser< unsigned, 16 > const hex_p = uint_parser<unsigned, 16>()
 
sign_parser const sign_p = sign_parser()
 
real_parser< double,
ureal_parser_policies< double >
> const 
ureal_p = real_parser<double, ureal_parser_policies<double> >()
 
real_parser< double,
real_parser_policies< double >
> const 
real_p = real_parser<double, real_parser_policies<double> >()
 
real_parser< double,
strict_ureal_parser_policies
< double > > const 
strict_ureal_p = real_parser<double, strict_ureal_parser_policies<double> >()
 
real_parser< double,
strict_real_parser_policies
< double > > const 
strict_real_p = real_parser<double, strict_real_parser_policies<double> >()
 
nothing_parser const nothing_p = nothing_parser()
 
anychar_parser const anychar_p = anychar_parser()
 
alnum_parser const alnum_p = alnum_parser()
 
alpha_parser const alpha_p = alpha_parser()
 
cntrl_parser const cntrl_p = cntrl_parser()
 
digit_parser const digit_p = digit_parser()
 
graph_parser const graph_p = graph_parser()
 
lower_parser const lower_p = lower_parser()
 
print_parser const print_p = print_parser()
 
punct_parser const punct_p = punct_parser()
 
blank_parser const blank_p = blank_parser()
 
space_parser const space_p = space_parser()
 
upper_parser const upper_p = upper_parser()
 
xdigit_parser const xdigit_p = xdigit_parser()
 
eol_parser const eol_p = eol_parser()
 
end_parser const end_p = end_parser()
 
select_parser_gen
< select_default_no_fail >
const 
select_p
 
select_parser_gen
< select_default_fail > const 
select_fail_p
 
switch_parser_gen const switch_p = switch_parser_gen()
 
default_parser_gen const default_p = default_parser_gen()
 
impl::do_parser_gen const do_p = impl::do_parser_gen()
 
const refactor_unary_gen refactor_unary_d = refactor_unary_gen<>()
 
const refactor_action_gen refactor_action_d = refactor_action_gen<>()
 
const attach_action_gen attach_action_d = attach_action_gen<>()
 
const gen_ast_node_parser_gen gen_ast_node_d = gen_ast_node_parser_gen()
 
const node_parser_gen
< root_node_op
root_node_d
 
const no_tree_gen_node_parser_gen no_node_d = no_tree_gen_node_parser_gen()
 
const leaf_node_parser_gen leaf_node_d = leaf_node_parser_gen()
 
const leaf_node_parser_gen token_node_d = leaf_node_parser_gen()
 
const node_parser_gen
< reduced_node_op
reduced_node_d
 
const node_parser_gen
< discard_node_op
discard_node_d
 
const node_parser_gen
< infix_node_op
infix_node_d
 
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
< inner_node_op
inner_node_d
 
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>()
 
const gen_pt_node_parser_gen gen_pt_node_d = gen_pt_node_parser_gen()
 
const confix_parser_gen
< non_nested, non_lexeme > 
confix_p
 
const comment_parser_gen
< non_nested > 
comment_p
 
const escape_char_parser
< lex_escapes > 
lex_escape_ch_p
 
const escape_char_parser
< c_escapes > 
c_escape_ch_p
 
flush_multi_pass_parser const flush_multi_pass_p = flush_multi_pass_parser()
 
const list_parser_gen list_p = list_parser_gen<>()
 
more_t const more = more_t ()
 
unused_type const unused = unused_type()
 
shallow_tag const shallow = {}
 
utree::invalid_type const invalid = {}
 
utree::nil_type const nil = {}
 
utree::list_type const empty_list = utree::list_type()
 

Typedef Documentation

typedef ::boost::uint32_t boost::spirit::ucs4_char
typedef std::basic_string<ucs4_char> boost::spirit::ucs4_string
typedef std::basic_string<utf8_char> boost::spirit::utf8_string

Function Documentation

template<typename T , typename CharT , typename SetT >
T* boost::spirit::add ( symbols< T, CharT, SetT > &  table,
CharT const *  sym,
T const &  data = T() 
)
template<typename Sequence1 , typename Sequence2 , typename F >
bool boost::spirit::any ( Sequence1 const &  seq1,
Sequence2 &  seq2,
f 
)
inline
template<typename Sequence , typename F >
bool boost::spirit::any ( Sequence const &  seq,
unused_type  ,
f 
)
inline

References boost::fusion::any().

Referenced by boost::fusion::any().

template<typename Pred , typename Sequence1 , typename Sequence2 , typename F >
bool boost::spirit::any_if ( Sequence1 const &  seq1,
Sequence2 &  seq2,
f,
Pred   
)
inline
template<typename Pred , typename Sequence , typename F >
bool boost::spirit::any_if ( Sequence const &  seq,
unused_type  const,
f,
Pred   
)
inline

References boost::fusion::any().

template<typename Pred , typename Sequence1 , typename Sequence2 , typename F >
bool boost::spirit::any_if_ns ( Sequence1 const &  seq1,
Sequence2 &  seq2,
f,
Pred   
)
inline
template<typename Pred , typename Sequence , typename F >
bool boost::spirit::any_if_ns ( Sequence const &  seq,
unused_type  const,
f,
Pred   
)
inline
template<typename Sequence1 , typename Sequence2 , typename F >
bool boost::spirit::any_ns ( Sequence1 const &  seq1,
Sequence2 &  seq2,
f 
)
inline
template<typename Sequence , typename F >
bool boost::spirit::any_ns ( Sequence const &  seq,
unused_type  ,
f 
)
inline
template<typename T >
ref_value_actor<T,push_back_action> boost::spirit::append ( T ref_)
inline
template<typename T >
ref_value_actor<T,assign_action> boost::spirit::assign ( T ref_)
inline
template<typename T >
ref_value_actor<T,assign_action> boost::spirit::assign_a ( T ref_)
inline
template<typename T , typename ValueT >
ref_const_ref_actor<T,ValueT,assign_action> boost::spirit::assign_a ( T ref_,
ValueT const &  value_ 
)
inline
template<typename T , typename ValueT >
ref_const_ref_value_actor<T,ValueT,assign_key_action> boost::spirit::assign_key_a ( T ref_,
ValueT const &  value_ 
)
inline
template<typename T , typename ValueT , typename KeyT >
ref_const_ref_const_ref_actor< T, ValueT, KeyT, assign_key_action > boost::spirit::assign_key_a ( T ref_,
ValueT const &  value_,
KeyT const &  key_ 
)
inline

References T.

template<typename AstFactoryT , typename IteratorT , typename ParserT , typename SkipT >
tree_parse_info<IteratorT, AstFactoryT> boost::spirit::ast_parse ( IteratorT const &  first_,
IteratorT const &  last_,
parser< ParserT > const &  parser,
SkipT const &  skip_,
AstFactoryT const &  = AstFactoryT() 
)
inline
template<typename IteratorT , typename ParserT , typename SkipT >
tree_parse_info<IteratorT> boost::spirit::ast_parse ( IteratorT const &  first_,
IteratorT const &  last_,
parser< ParserT > const &  parser,
SkipT const &  skip_ 
)
inline

References ast_parse().

template<typename IteratorT , typename ParserT >
tree_parse_info<IteratorT> boost::spirit::ast_parse ( IteratorT const &  first_,
IteratorT const &  last,
parser< ParserT > const &  parser 
)
inline
template<typename CharT , typename ParserT , typename SkipT >
tree_parse_info<CharT const*> boost::spirit::ast_parse ( CharT const *  str,
parser< ParserT > const &  parser,
SkipT const &  skip 
)
inline
template<typename CharT , typename ParserT >
tree_parse_info<CharT const*> boost::spirit::ast_parse ( CharT const *  str,
parser< ParserT > const &  parser 
)
inline
template<typename Expr >
enable_if<proto::is_expr<Expr> , stateful_tag_type<Expr, tag::attr_cast> >::type boost::spirit::attr_cast ( Expr const &  expr)

Referenced by columns_type().

template<typename Exposed , typename Expr >
enable_if<proto::is_expr<Expr> , stateful_tag_type<Expr, tag::attr_cast, Exposed> >::type boost::spirit::attr_cast ( Expr const &  expr)
template<typename CharT , typename TreeNodeT , typename AssocContainerT , typename GetIdT , typename GetValueT >
void boost::spirit::basic_tree_to_xml ( std::basic_ostream< CharT > &  ostrm,
TreeNodeT const &  tree,
std::basic_string< CharT > const &  input_line,
AssocContainerT const &  id_to_name,
GetIdT const &  get_token_id,
GetValueT const &  get_token_value 
)
inline
template<typename CharT , typename TreeNodeT , typename AssocContainerT >
void boost::spirit::basic_tree_to_xml ( std::basic_ostream< CharT > &  ostrm,
TreeNodeT const &  tree,
std::basic_string< CharT > const &  input_line,
AssocContainerT const &  id_to_name 
)
inline
template<typename CharT , typename TreeNodeT >
void boost::spirit::basic_tree_to_xml ( std::basic_ostream< CharT > &  ostrm,
TreeNodeT const &  tree,
std::basic_string< CharT > const &  input_line = impl::default_string< CharT >::get() 
)
inline
boost::spirit::big_bin_float_type ( little_bin_float  ,
little_bin_float_type   
)
boost::spirit::big_dword_type ( little_dword  ,
little_dword_type   
)
boost::spirit::bin_double_type ( big_bin_double  ,
big_bin_double_type   
)
boost::spirit::bool_type ( ushort_  ,
ushort_type   
)
struct boost::spirit::BOOST_PP_CAT ( function_impl_  ,
and_   
)
logical_function<BOOST_PP_CAT(function_impl_, and_ )> const boost::spirit::BOOST_PP_CAT ( logical_function  ,
BOOST_PP_CAT(_, and_)   
)
struct boost::spirit::BOOST_PP_CAT ( function_impl_  ,
or_   
)
logical_function<BOOST_PP_CAT(function_impl_, or_ )> const boost::spirit::BOOST_PP_CAT ( logical_function  ,
BOOST_PP_CAT(_, or_)   
)
struct boost::spirit::BOOST_PP_CAT ( function_impl_  ,
not_   
)
struct boost::spirit::BOOST_PP_CAT ( function_impl_  ,
plus   
)
logical_function<BOOST_PP_CAT(function_impl_, not_ )> const boost::spirit::BOOST_PP_CAT ( logical_function  ,
BOOST_PP_CAT(_, not_)   
)
arithmetic_function<BOOST_PP_CAT(function_impl_, plus )> const boost::spirit::BOOST_PP_CAT ( arithmetic_function  ,
BOOST_PP_CAT(_, plus)   
)
struct boost::spirit::BOOST_PP_CAT ( function_impl_  ,
minus   
)
arithmetic_function<BOOST_PP_CAT(function_impl_, minus )> const boost::spirit::BOOST_PP_CAT ( arithmetic_function  ,
BOOST_PP_CAT(_, minus)   
)
struct boost::spirit::BOOST_PP_CAT ( function_impl_  ,
times   
)
arithmetic_function<BOOST_PP_CAT(function_impl_, times )> const boost::spirit::BOOST_PP_CAT ( arithmetic_function  ,
BOOST_PP_CAT(_, times  
)
struct boost::spirit::BOOST_PP_CAT ( function_impl_  ,
divides   
)
struct boost::spirit::BOOST_PP_CAT ( function_impl_  ,
modulus   
)
arithmetic_function<BOOST_PP_CAT(function_impl_, divides )> const boost::spirit::BOOST_PP_CAT ( arithmetic_function  ,
BOOST_PP_CAT(_, divides)   
)
integral_function<BOOST_PP_CAT(function_impl_, modulus )> const boost::spirit::BOOST_PP_CAT ( integral_function  ,
BOOST_PP_CAT(_, modulus)   
)
struct boost::spirit::BOOST_PP_CAT ( function_impl_  ,
negate   
)
struct boost::spirit::BOOST_PP_CAT ( function_impl_  ,
bitand_   
)
arithmetic_function<BOOST_PP_CAT(function_impl_, negate )> const boost::spirit::BOOST_PP_CAT ( arithmetic_function  ,
BOOST_PP_CAT(_, negate)   
)
integral_function<BOOST_PP_CAT(function_impl_, bitand_ )> const boost::spirit::BOOST_PP_CAT ( integral_function  ,
BOOST_PP_CAT(_, bitand_)   
)
struct boost::spirit::BOOST_PP_CAT ( function_impl_  ,
bitor_   
)
struct boost::spirit::BOOST_PP_CAT ( function_impl_  ,
bitxor_   
)
integral_function<BOOST_PP_CAT(function_impl_, bitor_ )> const boost::spirit::BOOST_PP_CAT ( integral_function  ,
BOOST_PP_CAT(_, bitor_)   
)
integral_function<BOOST_PP_CAT(function_impl_, bitxor_ )> const boost::spirit::BOOST_PP_CAT ( integral_function  ,
BOOST_PP_CAT(_, bitxor_)   
)
struct boost::spirit::BOOST_PP_CAT ( function_impl_  ,
shift_left   
)
integral_function<BOOST_PP_CAT(function_impl_, shift_left )> const boost::spirit::BOOST_PP_CAT ( integral_function  ,
BOOST_PP_CAT(_, shift_left)   
)
struct boost::spirit::BOOST_PP_CAT ( function_impl_  ,
shift_right   
)
integral_function<BOOST_PP_CAT(function_impl_, shift_right )> const boost::spirit::BOOST_PP_CAT ( integral_function  ,
BOOST_PP_CAT(_, shift_right)   
)
struct boost::spirit::BOOST_PP_CAT ( function_impl_  ,
invert   
)
integral_function<BOOST_PP_CAT(function_impl_, invert )> const boost::spirit::BOOST_PP_CAT ( integral_function  ,
BOOST_PP_CAT(_, invert)   
)
boost::spirit::BOOST_SPIRIT_DEFINE_TERMINALS_NAME ( (verbatim, verbatim_type)(no_delimit, no_delimit_type)(lexeme, lexeme_type)(no_skip, no_skip_type)(omit, omit_type)(raw, raw_type)(as_string, as_string_type)(as_wstring, as_wstring_type)(inf, inf_type)(eol, eol_type)(eoi, eoi_type)(buffer, buffer_type)(true_, true_type)(false_, false_type)(matches, matches_type)(hold, hold_type)(strict, strict_type)(relaxed, relaxed_type)(duplicate, duplicate_type)  )
template<int N, typename ParserT >
case_parser<N, ParserT, false> boost::spirit::case_p ( parser< ParserT > const &  p)
inline
template<typename CharT , std::size_t N>
chlit<CharT> boost::spirit::ch_p ( CharT const (&)  str[N])
inline
template<typename CharT >
chseq<CharT const*> boost::spirit::chseq_p ( CharT const *  str)
inline
template<typename IteratorT >
chseq<IteratorT> boost::spirit::chseq_p ( IteratorT  first,
IteratorT  last 
)
inline
template<typename CharT >
chset<CharT> boost::spirit::chset_p ( chlit< CharT > const &  arg_)
inline
template<typename CharT >
chset<CharT> boost::spirit::chset_p ( range< CharT > const &  arg_)
inline
template<typename CharT >
chset<CharT> boost::spirit::chset_p ( negated_char_parser< chlit< CharT > > const &  arg_)
inline
template<typename CharT >
chset<CharT> boost::spirit::chset_p ( negated_char_parser< range< CharT > > const &  arg_)
inline
chset<char> boost::spirit::chset_p ( char const *  init)
inline
chset<wchar_t> boost::spirit::chset_p ( wchar_t const *  init)
inline
chset<char> boost::spirit::chset_p ( char  ch)
inline
chset<wchar_t> boost::spirit::chset_p ( wchar_t  ch)
inline
chset<int> boost::spirit::chset_p ( int  ch)
inline
chset<unsigned int> boost::spirit::chset_p ( unsigned int  ch)
inline
chset<short> boost::spirit::chset_p ( short  ch)
inline
chset<unsigned short> boost::spirit::chset_p ( unsigned short  ch)
inline
chset<long> boost::spirit::chset_p ( long  ch)
inline
chset<unsigned long> boost::spirit::chset_p ( unsigned long  ch)
inline
template<typename T >
ref_actor<T,clear_action> boost::spirit::clear_a ( T ref_)
inline
boost::spirit::columns_type ( auto_  ,
auto_type   
)
template<typename OpenT , typename CloseT >
comment_nest_p_result<OpenT,CloseT>::type boost::spirit::comment_nest_p ( OpenT const &  open,
CloseT const &  close 
)
inline
template<typename Domain , typename Expr >
result_of::compile<Domain, Expr, unused_type>::type boost::spirit::compile ( Expr const &  expr)
inline
template<typename Domain , typename Expr , typename Modifiers >
result_of::compile<Domain, Expr, Modifiers>::type boost::spirit::compile ( Expr const &  expr,
Modifiers  modifiers 
)
inline
template<typename T >
ref_actor<T,decrement_action> boost::spirit::decrement_a ( T ref_)
inline
boost::spirit::delimit_type ( stream  ,
stream_type   
)
boost::spirit::double_type ( long_double  ,
long_double_type   
)
template<class P >
parser_reference<P> boost::spirit::embed_by_reference ( parser< P > const &  )
template<class P >
parser_reference<P> boost::spirit::embed_by_reference ( ::BOOST_SPIRIT_CLASSIC_NS::parser< P > &  p)
template<typename T >
ref_value_actor<T,erase_action> boost::spirit::erase_a ( T ref_)
inline
template<typename T , typename KeyT >
ref_const_ref_actor<T,KeyT,erase_action> boost::spirit::erase_a ( T ref_,
KeyT const &  key_ 
)
inline
template<typename ChGenT >
f_chlit<ChGenT> boost::spirit::f_ch_p ( ChGenT  chgen)
inline
template<typename IterGenAT , typename IterGenBT >
f_chseq<IterGenAT, IterGenBT> boost::spirit::f_chseq_p ( IterGenAT  first,
IterGenBT  last 
)
inline
template<typename BaseT >
f_chseq< ::phoenix::actor<container_begin< ::phoenix::actor<BaseT> > >, ::phoenix::actor<container_end< ::phoenix::actor<BaseT> > > > boost::spirit::f_chseq_p ( ::phoenix::actor< BaseT > const &  a)
inline
template<typename ChGenAT , typename ChGenBT >
f_range<ChGenAT, ChGenBT> boost::spirit::f_range_p ( ChGenAT  first,
ChGenBT  last 
)
inline
template<typename IterGenAT , typename IterGenBT >
f_strlit<IterGenAT, IterGenBT> boost::spirit::f_str_p ( IterGenAT  first,
IterGenBT  last 
)
inline
template<typename BaseT >
f_strlit< ::phoenix::actor<container_begin< ::phoenix::actor<BaseT> > >, ::phoenix::actor<container_end< ::phoenix::actor<BaseT> > > > boost::spirit::f_str_p ( ::phoenix::actor< BaseT > const &  a)
inline
template<typename T , typename CharT , typename SetT >
T* boost::spirit::find ( symbols< T, CharT, SetT > const &  table,
CharT const *  sym 
)
template<typename T >
bool boost::spirit::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> boost::spirit::for_p ( InitF const &  init_f,
ConditionT const &  condition,
StepF const &  step_f 
)
inline utree::reference boost::spirit::get ( utree::reference  ,
utree::size_type   
)
inline utree::const_reference boost::spirit::get ( utree::const_reference  ,
utree::size_type   
)
template<typename ActionT >
action_subject<ActionT>::type const& boost::spirit::get_action_subject ( ActionT const &  action_)
inline
template<typename BinaryT >
binary_left_subject<BinaryT>::type const& boost::spirit::get_binary_left_subject ( BinaryT const &  binary_)
inline
template<typename BinaryT >
binary_right_subject<BinaryT>::type const& boost::spirit::get_binary_right_subject ( BinaryT const &  binary_)
inline
template<class Iterator >
std::size_t boost::spirit::get_column ( Iterator  lower_bound,
Iterator  current,
std::size_t  tabs = 4 
)
inline
template<class Iterator >
iterator_range< Iterator > boost::spirit::get_current_line ( Iterator  lower_bound,
Iterator  current,
Iterator  upper_bound 
)
inline
template<typename T >
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN tree_node<T> const& boost::spirit::get_first_leaf ( tree_node< T > const &  node)
template<class Iterator >
std::size_t boost::spirit::get_line ( Iterator  )
inline
template<class Iterator >
std::size_t boost::spirit::get_line ( line_pos_iterator< Iterator >  i)
inline
template<class Iterator >
Iterator boost::spirit::get_line_start ( Iterator  lower_bound,
Iterator  current 
)
inline
template<typename T >
bool boost::spirit::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& boost::spirit::get_semantic_action ( ActionT const &  action_)
inline
template<typename UnaryT >
unary_subject<UnaryT>::type const& boost::spirit::get_unary_subject ( UnaryT const &  unary_)
inline
boost::spirit::in_state_type ( token  ,
token_type   
)
template<typename T >
ref_actor<T,increment_action> boost::spirit::increment_a ( T ref_)
inline
template<typename T , typename ReferentT >
ref_const_ref_value_actor<T,ReferentT,insert_at_action> boost::spirit::insert_at_a ( T ref_,
ReferentT const &  key_ 
)
inline

References T.

template<typename T , typename ReferentT , typename ValueT >
ref_const_ref_const_ref_actor<T,ReferentT,ValueT,insert_at_action> boost::spirit::insert_at_a ( T ref_,
ReferentT const &  key_,
ValueT const &  value_ 
)
inline

References T.

template<typename T , typename ValueT >
ref_const_ref_value_actor<T,ValueT,insert_key_action> boost::spirit::insert_key_a ( T ref_,
ValueT const &  value_ 
)
inline

References T.

boost::spirit::int_type ( ulong_long  ,
ulong_long_type   
)
template<typename Eval >
proto::terminal<phoenix::actor<Eval> >::type boost::spirit::lazy ( phoenix::actor< Eval > const &  f)
template<class ActorT >
lazy_parser<ActorT> boost::spirit::lazy_p ( ActorT const &  actor)
template<typename BoundsT >
bounded_gen<BoundsT> boost::spirit::limit_d ( BoundsT const &  min_,
BoundsT const &  max_ 
)
inline
boost::spirit::lit_type ( bin  ,
bin_type   
)
boost::spirit::little_bin_double_type ( skip  ,
skip_type   
)
boost::spirit::little_qword_type ( bin_float  ,
bin_float_type   
)
boost::spirit::little_word_type ( dword  ,
dword_type   
)
boost::spirit::long_long_type ( float_  ,
float_type   
)
template<typename T >
multi_pass<T> boost::spirit::make_default_multi_pass ( T i)
inline
template<typename T >
multi_pass<T> boost::spirit::make_default_multi_pass ( T const &  i)
inline
template<typename Policies , typename T >
multi_pass<T, Policies> boost::spirit::make_multi_pass ( T i)
inline
template<typename Policies , typename T >
multi_pass<T, Policies> boost::spirit::make_multi_pass ( T const &  i)
inline
template<typename BoundsT >
max_bounded_gen<BoundsT> boost::spirit::max_limit_d ( BoundsT const &  max_)
inline
boost::spirit::maxwidth_type ( set_state  ,
set_state_type   
)
template<typename BoundsT >
min_bounded_gen<BoundsT> boost::spirit::min_limit_d ( BoundsT const &  min_)
inline
boost::spirit::oct_type ( hex  ,
hex_type   
)
utree boost::spirit::operator! ( utree const &  a)
inline
template<typename S >
optional<S> boost::spirit::operator! ( parser< S > const &  a)
bool boost::spirit::operator!= ( utree const &  a,
utree const &  b 
)
inline

References boost::asio::b.

template<typename InputT , typename InputPolicy , typename OwnershipPolicy , typename CheckingPolicy , typename StoragePolicy >
bool boost::spirit::operator!= ( const multi_pass< InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy > &  x,
const multi_pass< InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy > &  y 
)
inline
template<typename A , typename B >
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN sequence<A, kleene_star<sequence<B, A> > > boost::spirit::operator% ( parser< A > const &  a,
parser< B > const &  b 
)
template<typename A >
sequence<A, kleene_star<sequence<chlit<char>, A> > > boost::spirit::operator% ( parser< A > const &  a,
char  b 
)
template<typename B >
sequence<chlit<char>, kleene_star<sequence<B, chlit<char> > > > boost::spirit::operator% ( char  a,
parser< B > const &  b 
)
template<typename A >
sequence<A, kleene_star<sequence<strlit<char const*>, A> > > boost::spirit::operator% ( parser< A > const &  a,
char const *  b 
)
template<typename B >
sequence<strlit<char const*>, kleene_star<sequence<B, strlit<char const*> > > > boost::spirit::operator% ( char const *  a,
parser< B > const &  b 
)
template<typename A >
sequence<A, kleene_star<sequence<chlit<wchar_t>, A> > > boost::spirit::operator% ( parser< A > const &  a,
wchar_t  b 
)
template<typename B >
sequence<chlit<wchar_t>, kleene_star<sequence<B, chlit<wchar_t> > > > boost::spirit::operator% ( wchar_t  a,
parser< B > const &  b 
)
utree boost::spirit::operator% ( utree const &  a,
utree const &  b 
)
inline
template<typename A >
sequence<A, kleene_star<sequence<strlit<wchar_t const*>, A> > > boost::spirit::operator% ( parser< A > const &  a,
wchar_t const *  b 
)
template<typename B >
sequence<strlit<wchar_t const*>, kleene_star<sequence<B, strlit<wchar_t const*> > > > boost::spirit::operator% ( wchar_t const *  a,
parser< B > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator& ( chset< CharT > const &  a,
chset< CharT > const &  b 
)
utree boost::spirit::operator& ( utree const &  a,
utree const &  b 
)
inline
template<typename CharT >
chset<CharT> boost::spirit::operator& ( chset< CharT > const &  a,
range< CharT > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator& ( range< CharT > const &  a,
chset< CharT > const &  b 
)
template<typename A , typename B >
intersection<A, B> boost::spirit::operator& ( parser< A > const &  a,
parser< B > const &  b 
)
template<typename A >
intersection<A, chlit<char> > boost::spirit::operator& ( parser< A > const &  a,
char  b 
)
template<typename B >
intersection<chlit<char>, B> boost::spirit::operator& ( char  a,
parser< B > const &  b 
)
template<typename A >
intersection<A, strlit<char const*> > boost::spirit::operator& ( parser< A > const &  a,
char const *  b 
)
template<typename B >
intersection<strlit<char const*>, B> boost::spirit::operator& ( char const *  a,
parser< B > const &  b 
)
template<typename A >
intersection<A, chlit<wchar_t> > boost::spirit::operator& ( parser< A > const &  a,
wchar_t  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator& ( chset< CharT > const &  a,
chlit< CharT > const &  b 
)
template<typename B >
intersection<chlit<wchar_t>, B> boost::spirit::operator& ( wchar_t  a,
parser< B > const &  b 
)
template<typename A >
intersection<A, strlit<wchar_t const*> > boost::spirit::operator& ( parser< A > const &  a,
wchar_t const *  b 
)
template<typename B >
intersection<strlit<wchar_t const*>, B> boost::spirit::operator& ( wchar_t const *  a,
parser< B > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator& ( chlit< CharT > const &  a,
chset< CharT > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator& ( chset< CharT > const &  a,
negated_char_parser< range< CharT > > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator& ( negated_char_parser< range< CharT > > const &  a,
chset< CharT > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator& ( chset< CharT > const &  a,
negated_char_parser< chlit< CharT > > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator& ( negated_char_parser< chlit< CharT > > const &  a,
chset< CharT > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator& ( chset< CharT > const &  a,
CharT  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator& ( CharT  a,
chset< CharT > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator& ( chset< CharT > const &  a,
anychar_parser  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator& ( anychar_parser  a,
chset< CharT > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator& ( chset< CharT > const &  a,
nothing_parser  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator& ( nothing_parser  a,
chset< CharT > const &  b 
)
template<typename A , typename B >
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN sequence<A, B> boost::spirit::operator&& ( parser< A > const &  a,
parser< B > const &  b 
)
template<typename A >
sequence<A, chlit<char> > boost::spirit::operator&& ( parser< A > const &  a,
char  b 
)
template<typename B >
sequence<chlit<char>, B> boost::spirit::operator&& ( char  a,
parser< B > const &  b 
)
utree boost::spirit::operator&& ( utree const &  a,
utree const &  b 
)
inline
template<typename A >
sequence<A, strlit<char const*> > boost::spirit::operator&& ( parser< A > const &  a,
char const *  b 
)
template<typename B >
sequence<strlit<char const*>, B> boost::spirit::operator&& ( char const *  a,
parser< B > const &  b 
)
template<typename A >
sequence<A, chlit<wchar_t> > boost::spirit::operator&& ( parser< A > const &  a,
wchar_t  b 
)
template<typename B >
sequence<chlit<wchar_t>, B> boost::spirit::operator&& ( wchar_t  a,
parser< B > const &  b 
)
template<typename A >
sequence<A, strlit<wchar_t const*> > boost::spirit::operator&& ( parser< A > const &  a,
wchar_t const *  b 
)
template<typename B >
sequence<strlit<wchar_t const*>, B> boost::spirit::operator&& ( wchar_t const *  a,
parser< B > const &  b 
)
utree boost::spirit::operator* ( utree const &  a,
utree const &  b 
)
inline
template<typename S >
kleene_star<S> boost::spirit::operator* ( parser< S > const &  a)
utree boost::spirit::operator+ ( utree const &  a,
utree const &  b 
)
inline
template<typename S >
positive<S> boost::spirit::operator+ ( parser< S > const &  a)
inline
template<typename CharT >
chset<CharT> boost::spirit::operator- ( chset< CharT > const &  a,
chset< CharT > const &  b 
)
utree boost::spirit::operator- ( utree const &  a,
utree const &  b 
)
inline
template<typename CharT >
chset<CharT> boost::spirit::operator- ( chset< CharT > const &  a,
range< CharT > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator- ( range< CharT > const &  a,
chset< CharT > const &  b 
)
template<typename A , typename B >
difference<A, B> boost::spirit::operator- ( parser< A > const &  a,
parser< B > const &  b 
)
template<typename A >
difference<A, chlit<char> > boost::spirit::operator- ( parser< A > const &  a,
char  b 
)
template<typename B >
difference<chlit<char>, B> boost::spirit::operator- ( char  a,
parser< B > const &  b 
)
template<typename A >
difference<A, strlit<char const*> > boost::spirit::operator- ( parser< A > const &  a,
char const *  b 
)
template<typename B >
difference<strlit<char const*>, B> boost::spirit::operator- ( char const *  a,
parser< B > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator- ( chset< CharT > const &  a,
chlit< CharT > const &  b 
)
template<typename A >
difference<A, chlit<wchar_t> > boost::spirit::operator- ( parser< A > const &  a,
wchar_t  b 
)
template<typename B >
difference<chlit<wchar_t>, B> boost::spirit::operator- ( wchar_t  a,
parser< B > const &  b 
)
template<typename A >
difference<A, strlit<wchar_t const*> > boost::spirit::operator- ( parser< A > const &  a,
wchar_t const *  b 
)
template<typename B >
difference<strlit<wchar_t const*>, B> boost::spirit::operator- ( wchar_t const *  a,
parser< B > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator- ( chlit< CharT > const &  a,
chset< CharT > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator- ( chset< CharT > const &  a,
negated_char_parser< range< CharT > > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator- ( negated_char_parser< range< CharT > > const &  a,
chset< CharT > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator- ( chset< CharT > const &  a,
negated_char_parser< chlit< CharT > > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator- ( negated_char_parser< chlit< CharT > > const &  a,
chset< CharT > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator- ( chset< CharT > const &  a,
CharT  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator- ( CharT  a,
chset< CharT > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator- ( chset< CharT > const &  a,
anychar_parser  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator- ( anychar_parser  a,
chset< CharT > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator- ( chset< CharT > const &  a,
nothing_parser  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator- ( nothing_parser  a,
chset< CharT > const &  b 
)
utree boost::spirit::operator/ ( utree const &  a,
utree const &  b 
)
inline
bool boost::spirit::operator< ( utree const &  a,
utree const &  b 
)
inline
std::ostream & boost::spirit::operator<< ( std::ostream &  out,
utree const &  x 
)
inline
std::ostream & boost::spirit::operator<< ( std::ostream &  out,
utree::invalid_type const &  x 
)
inline

References boost::out.

std::ostream & boost::spirit::operator<< ( std::ostream &  out,
utree::nil_type const &  x 
)
inline

References boost::out.

utree boost::spirit::operator<< ( utree const &  a,
utree const &  b 
)
inline
template<typename Out >
Out& boost::spirit::operator<< ( Out &  out,
detail::unused_only const &   
)
inline

References boost::out.

template<typename Out >
Out& boost::spirit::operator<< ( Out &  out,
info const &  what 
)
bool boost::spirit::operator<= ( utree const &  a,
utree const &  b 
)
inline

References boost::a.

template<typename InputT , typename InputPolicy , typename OwnershipPolicy , typename CheckingPolicy , typename StoragePolicy >
bool boost::spirit::operator<= ( const multi_pass< InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy > &  x,
const multi_pass< InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy > &  y 
)
inline
bool boost::spirit::operator== ( utree const &  a,
utree const &  b 
)
inline
bool boost::spirit::operator> ( utree const &  a,
utree const &  b 
)
inline

References boost::a.

template<typename InputT , typename InputPolicy , typename OwnershipPolicy , typename CheckingPolicy , typename StoragePolicy >
bool boost::spirit::operator> ( const multi_pass< InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy > &  x,
const multi_pass< InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy > &  y 
)
inline
bool boost::spirit::operator>= ( utree const &  a,
utree const &  b 
)
inline

References boost::asio::b.

template<typename InputT , typename InputPolicy , typename OwnershipPolicy , typename CheckingPolicy , typename StoragePolicy >
bool boost::spirit::operator>= ( const multi_pass< InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy > &  x,
const multi_pass< InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy > &  y 
)
inline
utree boost::spirit::operator>> ( utree const &  a,
utree const &  b 
)
inline
template<typename In >
In& boost::spirit::operator>> ( In &  in,
unused_type &   
)
inline

References boost::flyweights::in.

template<typename A , typename B >
sequence<A, B> boost::spirit::operator>> ( parser< A > const &  a,
parser< B > const &  b 
)
template<typename A >
sequence<A, chlit<char> > boost::spirit::operator>> ( parser< A > const &  a,
char  b 
)
template<typename B >
sequence<chlit<char>, B> boost::spirit::operator>> ( char  a,
parser< B > const &  b 
)
template<typename A >
sequence<A, strlit<char const*> > boost::spirit::operator>> ( parser< A > const &  a,
char const *  b 
)
template<typename B >
sequence<strlit<char const*>, B> boost::spirit::operator>> ( char const *  a,
parser< B > const &  b 
)
template<typename A >
sequence<A, chlit<wchar_t> > boost::spirit::operator>> ( parser< A > const &  a,
wchar_t  b 
)
template<typename B >
sequence<chlit<wchar_t>, B> boost::spirit::operator>> ( wchar_t  a,
parser< B > const &  b 
)
template<typename A >
sequence<A, strlit<wchar_t const*> > boost::spirit::operator>> ( parser< A > const &  a,
wchar_t const *  b 
)
template<typename B >
sequence<strlit<wchar_t const*>, B> boost::spirit::operator>> ( wchar_t const *  a,
parser< B > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator^ ( chset< CharT > const &  a,
chset< CharT > const &  b 
)
utree boost::spirit::operator^ ( utree const &  a,
utree const &  b 
)
inline
template<typename CharT >
chset<CharT> boost::spirit::operator^ ( chset< CharT > const &  a,
range< CharT > const &  b 
)
template<typename A , typename B >
exclusive_or<A, B> boost::spirit::operator^ ( parser< A > const &  a,
parser< B > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator^ ( range< CharT > const &  a,
chset< CharT > const &  b 
)
template<typename A >
exclusive_or<A, chlit<char> > boost::spirit::operator^ ( parser< A > const &  a,
char  b 
)
template<typename B >
exclusive_or<chlit<char>, B> boost::spirit::operator^ ( char  a,
parser< B > const &  b 
)
template<typename A >
exclusive_or<A, strlit<char const*> > boost::spirit::operator^ ( parser< A > const &  a,
char const *  b 
)
template<typename B >
exclusive_or<strlit<char const*>, B> boost::spirit::operator^ ( char const *  a,
parser< B > const &  b 
)
template<typename A >
exclusive_or<A, chlit<wchar_t> > boost::spirit::operator^ ( parser< A > const &  a,
wchar_t  b 
)
template<typename B >
exclusive_or<chlit<wchar_t>, B> boost::spirit::operator^ ( wchar_t  a,
parser< B > const &  b 
)
template<typename A >
exclusive_or<A, strlit<wchar_t const*> > boost::spirit::operator^ ( parser< A > const &  a,
wchar_t const *  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator^ ( chset< CharT > const &  a,
chlit< CharT > const &  b 
)
template<typename B >
exclusive_or<strlit<wchar_t const*>, B> boost::spirit::operator^ ( wchar_t const *  a,
parser< B > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator^ ( chlit< CharT > const &  a,
chset< CharT > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator^ ( chset< CharT > const &  a,
negated_char_parser< range< CharT > > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator^ ( negated_char_parser< range< CharT > > const &  a,
chset< CharT > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator^ ( chset< CharT > const &  a,
negated_char_parser< chlit< CharT > > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator^ ( negated_char_parser< chlit< CharT > > const &  a,
chset< CharT > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator^ ( chset< CharT > const &  a,
CharT  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator^ ( CharT  a,
chset< CharT > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator^ ( chset< CharT > const &  a,
anychar_parser  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator^ ( anychar_parser  a,
chset< CharT > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator^ ( chset< CharT > const &  a,
nothing_parser  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator^ ( nothing_parser  a,
chset< CharT > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator| ( chset< CharT > const &  a,
chset< CharT > const &  b 
)
utree boost::spirit::operator| ( utree const &  a,
utree const &  b 
)
inline
template<typename CharT >
chset<CharT> boost::spirit::operator| ( chset< CharT > const &  a,
range< CharT > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator| ( range< CharT > const &  a,
chset< CharT > const &  b 
)
template<typename A , typename B >
alternative<A, B> boost::spirit::operator| ( parser< A > const &  a,
parser< B > const &  b 
)
template<typename A >
alternative<A, chlit<char> > boost::spirit::operator| ( parser< A > const &  a,
char  b 
)
template<typename B >
alternative<chlit<char>, B> boost::spirit::operator| ( char  a,
parser< B > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator| ( chset< CharT > const &  a,
chlit< CharT > const &  b 
)
template<typename A >
alternative<A, strlit<char const*> > boost::spirit::operator| ( parser< A > const &  a,
char const *  b 
)
template<typename B >
alternative<strlit<char const*>, B> boost::spirit::operator| ( char const *  a,
parser< B > const &  b 
)
template<typename A >
alternative<A, chlit<wchar_t> > boost::spirit::operator| ( parser< A > const &  a,
wchar_t  b 
)
template<typename B >
alternative<chlit<wchar_t>, B> boost::spirit::operator| ( wchar_t  a,
parser< B > const &  b 
)
template<typename A >
alternative<A, strlit<wchar_t const*> > boost::spirit::operator| ( parser< A > const &  a,
wchar_t const *  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator| ( chlit< CharT > const &  a,
chset< CharT > const &  b 
)
template<typename B >
alternative<strlit<wchar_t const*>, B> boost::spirit::operator| ( wchar_t const *  a,
parser< B > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator| ( chset< CharT > const &  a,
negated_char_parser< range< CharT > > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator| ( negated_char_parser< range< CharT > > const &  a,
chset< CharT > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator| ( chset< CharT > const &  a,
negated_char_parser< chlit< CharT > > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator| ( negated_char_parser< chlit< CharT > > const &  a,
chset< CharT > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator| ( chset< CharT > const &  a,
CharT  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator| ( CharT  a,
chset< CharT > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator| ( chset< CharT > const &  a,
anychar_parser  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator| ( anychar_parser  a,
chset< CharT > const &  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator| ( chset< CharT > const &  a,
nothing_parser  b 
)
template<typename CharT >
chset<CharT> boost::spirit::operator| ( nothing_parser  a,
chset< CharT > const &  b 
)
utree boost::spirit::operator|| ( utree const &  a,
utree const &  b 
)
inline
template<typename A , typename B >
sequential_or<A, B> boost::spirit::operator|| ( parser< A > const &  a,
parser< B > const &  b 
)
template<typename A >
sequential_or<A, chlit<char> > boost::spirit::operator|| ( parser< A > const &  a,
char  b 
)
template<typename B >
sequential_or<chlit<char>, B> boost::spirit::operator|| ( char  a,
parser< B > const &  b 
)
template<typename A >
sequential_or<A, strlit<char const*> > boost::spirit::operator|| ( parser< A > const &  a,
char const *  b 
)
template<typename B >
sequential_or<strlit<char const*>, B> boost::spirit::operator|| ( char const *  a,
parser< B > const &  b 
)
template<typename A >
sequential_or<A, chlit<wchar_t> > boost::spirit::operator|| ( parser< A > const &  a,
wchar_t  b 
)
template<typename B >
sequential_or<chlit<wchar_t>, B> boost::spirit::operator|| ( wchar_t  a,
parser< B > const &  b 
)
template<typename A >
sequential_or<A, strlit<wchar_t const*> > boost::spirit::operator|| ( parser< A > const &  a,
wchar_t const *  b 
)
template<typename B >
sequential_or<strlit<wchar_t const*>, B> boost::spirit::operator|| ( wchar_t const *  a,
parser< B > const &  b 
)
template<typename CharT >
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN chset<CharT> boost::spirit::operator~ ( chset< CharT > const &  a)
template<typename CondT , bool positive>
condition_parser<CondT, !positive> boost::spirit::operator~ ( condition_parser< CondT, positive > const &  p)
inline
template<typename ParserT >
negated_char_parser<ParserT> boost::spirit::operator~ ( char_parser< ParserT > const &  p)
inline
template<typename ParserT >
ParserT boost::spirit::operator~ ( negated_char_parser< ParserT > const &  n)
inline
template<typename SubjectT >
negated_empty_match_parser<SubjectT> boost::spirit::operator~ ( empty_match_parser< SubjectT > const &  p)
inline
template<typename SubjectT >
empty_match_parser<SubjectT> boost::spirit::operator~ ( negated_empty_match_parser< SubjectT > const &  p)
inline
nothing_parser boost::spirit::operator~ ( anychar_parser  )
inline

References nothing_p.

boost::spirit::pad_type ( byte_  ,
byte_type   
)
template<typename IteratorT , typename ParserT , typename SkipT >
parse_info<IteratorT> boost::spirit::parse ( IteratorT const &  first,
IteratorT const &  last,
parser< ParserT > const &  p,
parser< SkipT > const &  skip 
)
template<typename CharT , typename ParserT , typename SkipT >
parse_info<CharT const*> boost::spirit::parse ( CharT const *  str,
parser< ParserT > const &  p,
parser< SkipT > const &  skip 
)
template<typename IteratorT , typename DerivedT >
parse_info<IteratorT> boost::spirit::parse ( IteratorT const &  first,
IteratorT const &  last,
parser< DerivedT > const &  p 
)

Referenced by boost::spirit::qi::extract_uint< T, Radix, MinDigits, MaxDigits, Accumulate >::call(), boost::spirit::qi::extract_int< T, Radix, MinDigits, MaxDigits >::call(), boost::wave::grammars::intlit_grammar_gen< TokenT >::evaluate(), boost::wave::grammars::expression_grammar_gen< TokenT >::evaluate(), boost::wave::grammars::chlit_grammar_gen< IntegralResult, TokenT >::evaluate(), boost::wave::util::interpret_pragma(), boost::aux::match_traits< ExpressionT, boost_spirit_classic_expression_tag >::matches(), boost::spirit::confix_parser< OpenT, ExprT, CloseT, CategoryT, NestedT, LexemeT >::parse(), boost::spirit::escape_char_action< ParserT, ActionT, Flags, CharT >::parse(), boost::spirit::refactor_unary_parser< BinaryT, NestedT >::parse(), boost::spirit::list_parser< kleene_star< anychar_parser >, chlit< CharT > >::parse(), boost::spirit::escape_char_parser< Flags, CharT >::parse(), boost::spirit::qi::any_bool_parser< T, BoolPolicies >::parse(), boost::spirit::refactor_action_parser< BinaryT, NestedT >::parse(), boost::spirit::qi::any_real_parser< T, RealPolicies >::parse(), boost::spirit::case_parser< 0x15F97A7, epsilon_parser, true >::parse(), boost::spirit::qi::literal_bool_parser< T, BoolPolicies, no_attribute >::parse(), boost::spirit::qi::literal_real_parser< T, RealPolicies, no_attribute >::parse(), boost::spirit::attach_action_parser< ActionT, NestedT >::parse(), boost::spirit::real_parser< T, RealPoliciesT >::parse(), boost::wave::grammars::defined_grammar_gen< LexIteratorT >::parse_operator_defined(), boost::wave::impl::impl::retrieve_line_info(), boost::wave::util::time_conversion::time_conversion_helper::time_conversion_helper(), boost::spirit::lex::tokenize_and_parse(), and boost::spirit::lex::tokenize_and_phrase_parse().

template<typename CharT , typename DerivedT >
parse_info<CharT const*> boost::spirit::parse ( CharT const *  str,
parser< DerivedT > const &  p 
)
strlit<char const*> const boost::spirit::pizza_p ( char const *  your_favorite_pizza)
inline
template<typename NodeFactoryT , typename IteratorT , typename ParserT , typename SkipT >
tree_parse_info<IteratorT, NodeFactoryT> boost::spirit::pt_parse ( IteratorT const &  first_,
IteratorT const &  last,
parser< ParserT > const &  p,
SkipT const &  skip,
NodeFactoryT const &  = NodeFactoryT() 
)
inline
template<typename IteratorT , typename ParserT , typename SkipT >
tree_parse_info<IteratorT> boost::spirit::pt_parse ( IteratorT const &  first,
IteratorT const &  last,
parser< ParserT > const &  p,
SkipT const &  skip 
)
inline

References pt_parse().

template<typename IteratorT , typename ParserT >
tree_parse_info<IteratorT> boost::spirit::pt_parse ( IteratorT const &  first_,
IteratorT const &  last,
parser< ParserT > const &  parser 
)
inline
template<typename CharT , typename ParserT , typename SkipT >
tree_parse_info<CharT const*> boost::spirit::pt_parse ( CharT const *  str,
parser< ParserT > const &  p,
SkipT const &  skip 
)
inline

References pt_parse(), and boost::str().

template<typename CharT , typename ParserT >
tree_parse_info<CharT const*> boost::spirit::pt_parse ( CharT const *  str,
parser< ParserT > const &  parser 
)
inline

References pt_parse(), and boost::str().

template<typename T >
ref_value_actor<T,push_back_action> boost::spirit::push_back_a ( T ref_)
inline
template<typename T , typename ValueT >
ref_const_ref_actor<T,ValueT,push_back_action> boost::spirit::push_back_a ( T ref_,
ValueT const &  value_ 
)
inline
template<typename T >
ref_value_actor<T,push_front_action> boost::spirit::push_front_a ( T ref_)
inline
template<typename T , typename ValueT >
ref_const_ref_actor<T,ValueT,push_front_action> boost::spirit::push_front_a ( T ref_,
ValueT const &  value_ 
)
inline
boost::spirit::qword_type ( big_qword  ,
big_qword_type   
)
template<typename CharT >
range<CharT> boost::spirit::range_p ( CharT  first,
CharT  last 
)
inline
template<typename CharT >
rxstrlit<CharT> boost::spirit::regex_p ( CharT const *  first)
inline
template<typename CharT >
rxstrlit<CharT> boost::spirit::regex_p ( CharT const *  first,
CharT const *  last 
)
inline
template<typename ExactT >
fixed_loop_gen<ExactT> boost::spirit::repeat_p ( ExactT const &  exact)
template<typename MinT , typename MaxT >
nonfixed_loop_gen<MinT, MaxT> boost::spirit::repeat_p ( MinT const &  min,
MaxT const &  max 
)
boost::spirit::repeat_type ( eps  ,
eps_type   
)
boost::spirit::right_align_type ( center  ,
center_type   
)
template<typename MutexT >
scoped_lock_parser_gen<MutexT> boost::spirit::scoped_lock_d ( MutexT &  mutex)
boost::spirit::short_type ( long_  ,
long_type   
)
template<typename CharT >
strlit<CharT const*> boost::spirit::str_p ( CharT const *  str)
inline

References boost::str().

template<typename CharT >
strlit<CharT *> boost::spirit::str_p ( CharT *  str)
inline

References boost::str().

template<typename IteratorT >
strlit<IteratorT> boost::spirit::str_p ( IteratorT  first,
IteratorT  last 
)
inline
template<typename CharT >
chlit<CharT> boost::spirit::str_p ( CharT  ch)
inline
template<typename T , typename V >
void boost::spirit::swap ( node_iter_data< T, V > &  a,
node_iter_data< T, V > &  b 
)
inline
template<typename InputT , typename InputPolicy , typename OwnershipPolicy , typename CheckingPolicy , typename StoragePolicy >
void boost::spirit::swap ( multi_pass< InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy > &  x,
multi_pass< InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy > &  y 
)
template<typename T >
swap_actor<T> boost::spirit::swap_a ( T ref_,
T swap_ref_ 
)
inline
template<typename ErrorDescrT , typename IteratorT >
void boost::spirit::throw_ ( IteratorT  where,
ErrorDescrT  descriptor 
)
inline
template<typename Char >
utf8_string boost::spirit::to_utf8 ( Char const *  str)
inline

References boost::detail::type.

template<typename Char , typename Traits , typename Allocator >
utf8_string boost::spirit::to_utf8 ( std::basic_string< Char, Traits, Allocator > const &  str)
inline
boost::spirit::tokenid_mask_type ( attr  ,
attr_type   
)
boost::spirit::tokenid_type ( raw_token  ,
raw_token_type   
)
template<typename TreeNodeT , typename AssocContainerT , typename GetIdT , typename GetValueT >
void boost::spirit::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 
)
inline
template<typename TreeNodeT , typename AssocContainerT >
void boost::spirit::tree_to_xml ( std::ostream &  ostrm,
TreeNodeT const &  tree,
std::string const &  input_line,
AssocContainerT const &  id_to_name 
)
inline
template<typename TreeNodeT >
void boost::spirit::tree_to_xml ( std::ostream &  ostrm,
TreeNodeT const &  tree,
std::string const &  input_line = "" 
)
inline
boost::spirit::ulong_type ( uint_  ,
uint_type   
)
template<typename CondT >
impl::while_parser_gen<CondT> boost::spirit::while_p ( CondT const &  cond)
boost::spirit::word_type ( big_word  ,
big_word_type   
)
boost::spirit::wstream_type ( left_align  ,
left_align_type   
)

Variable Documentation

alnum_parser const boost::spirit::alnum_p = alnum_parser()
alpha_parser const boost::spirit::alpha_p = alpha_parser()
const attach_action_gen boost::spirit::attach_action_d = attach_action_gen<>()
uint_parser<unsigned, 2> const boost::spirit::bin_p = uint_parser<unsigned, 2>()
blank_parser const boost::spirit::blank_p = blank_parser()
const escape_char_parser<c_escapes> boost::spirit::c_escape_ch_p
Initial value:
=
escape_char_parser<c_escapes>()
cntrl_parser const boost::spirit::cntrl_p = cntrl_parser()
const comment_parser_gen<non_nested> boost::spirit::comment_p
Initial value:
=
comment_parser_gen<non_nested>()
const confix_parser_gen<non_nested, non_lexeme> boost::spirit::confix_p
default_parser_gen const boost::spirit::default_p = default_parser_gen()
digit_parser const boost::spirit::digit_p = digit_parser()
const node_parser_gen<discard_first_node_op> boost::spirit::discard_first_node_d
Initial value:
=
node_parser_gen<discard_first_node_op>()
const node_parser_gen<discard_last_node_op> boost::spirit::discard_last_node_d
Initial value:
=
node_parser_gen<discard_last_node_op>()
const node_parser_gen<discard_node_op> boost::spirit::discard_node_d
Initial value:
=
node_parser_gen<discard_node_op>()
impl::do_parser_gen const boost::spirit::do_p = impl::do_parser_gen()
flush_multi_pass_parser const boost::spirit::flush_multi_pass_p = flush_multi_pass_parser()
const gen_ast_node_parser_gen boost::spirit::gen_ast_node_d = gen_ast_node_parser_gen()
const gen_pt_node_parser_gen boost::spirit::gen_pt_node_d = gen_pt_node_parser_gen()
graph_parser const boost::spirit::graph_p = graph_parser()
uint_parser<unsigned, 16> const boost::spirit::hex_p = uint_parser<unsigned, 16>()
const node_parser_gen<infix_node_op> boost::spirit::infix_node_d
Initial value:
=
node_parser_gen<infix_node_op>()
const node_parser_gen<inner_node_op> boost::spirit::inner_node_d
Initial value:
=
node_parser_gen<inner_node_op>()
utree::invalid_type const boost::spirit::invalid = {}
const leaf_node_parser_gen boost::spirit::leaf_node_d = leaf_node_parser_gen()
const escape_char_parser<lex_escapes> boost::spirit::lex_escape_ch_p
Initial value:
=
escape_char_parser<lex_escapes>()
const longest_parser_gen boost::spirit::longest_d = longest_parser_gen()
lower_parser const boost::spirit::lower_p = lower_parser()
more_t const boost::spirit::more = more_t ()
const no_actions_parser_gen boost::spirit::no_actions_d = no_actions_parser_gen()
const inhibit_case_parser_gen boost::spirit::nocase_d = inhibit_case_parser_gen()
nothing_parser const boost::spirit::nothing_p = nothing_parser()

Referenced by operator~().

uint_parser<unsigned, 8> const boost::spirit::oct_p = uint_parser<unsigned, 8>()
print_parser const boost::spirit::print_p = print_parser()
punct_parser const boost::spirit::punct_p = punct_parser()
real_parser<double, real_parser_policies<double> > const boost::spirit::real_p = real_parser<double, real_parser_policies<double> >()
const node_parser_gen<reduced_node_op> boost::spirit::reduced_node_d
Initial value:
=
node_parser_gen<reduced_node_op>()
const refactor_action_gen boost::spirit::refactor_action_d = refactor_action_gen<>()
const refactor_unary_gen boost::spirit::refactor_unary_d = refactor_unary_gen<>()
const node_parser_gen<root_node_op> boost::spirit::root_node_d
Initial value:
=
node_parser_gen<root_node_op>()
select_parser_gen<select_default_fail> const boost::spirit::select_fail_p
Initial value:
=
select_parser_gen<select_default_fail>()
select_parser_gen<select_default_no_fail> const boost::spirit::select_p
Initial value:
=
select_parser_gen<select_default_no_fail>()
shallow_tag const boost::spirit::shallow = {}
const shortest_parser_gen boost::spirit::shortest_d = shortest_parser_gen()
sign_parser const boost::spirit::sign_p = sign_parser()
real_parser<double, strict_real_parser_policies<double> > const boost::spirit::strict_real_p = real_parser<double, strict_real_parser_policies<double> >()
real_parser<double, strict_ureal_parser_policies<double> > const boost::spirit::strict_ureal_p = real_parser<double, strict_ureal_parser_policies<double> >()
switch_parser_gen const boost::spirit::switch_p = switch_parser_gen()
const leaf_node_parser_gen boost::spirit::token_node_d = leaf_node_parser_gen()
uint_parser<unsigned> const boost::spirit::uint_p = uint_parser<unsigned>()
unused_type const boost::spirit::unused = unused_type()

Referenced by boost::spirit::karma::symbols< Attribute, unused_type, Lookup, CharEncoding, Tag >::at(), boost::spirit::traits::begin(), boost::spirit::detail::expand_arg< Context >::call(), boost::spirit::traits::symbols_value< Attribute, T, Enable >::call(), boost::spirit::karma::detail::duplicate_attribute< Attribute, T, 0, false >::call(), boost::spirit::traits::symbols_value< Attribute, Attribute >::call(), boost::spirit::detail::result_of::attribute_value< Iterator1, Iterator2, Last2, Pred >::call(), boost::spirit::make_nary_proto_expr< Sequence, OpTag, Domain >::call(), boost::spirit::traits::make_attribute< unused_type, ActualAttribute >::call(), compile(), boost::spirit::karma::delimit_out(), boost::spirit::traits::deref(), boost::spirit::traits::end(), boost::spirit::lex::value_context::eval(), boost::spirit::lex::state_context::eval(), boost::spirit::karma::symbols< Attribute, unused_type, Lookup, CharEncoding, Tag >::find(), boost::spirit::karma::format(), boost::spirit::karma::generate(), boost::spirit::karma::reference< Subject >::generate(), boost::spirit::repository::karma::confix_generator< Subject, Prefix, Suffix >::generate(), boost::spirit::karma::base_list< Left, Right, mpl::true_, strict_list< Left, Right > >::generate(), boost::spirit::karma::lazy_generator< Function, Modifiers >::generate(), boost::spirit::karma::lazy_directive< Function, Subject, Modifiers >::generate(), boost::spirit::karma::symbols< Attribute, unused_type, Lookup, CharEncoding, Tag >::generate(), boost::spirit::karma::detail::lazy_generate_impl(), boost::spirit::qi::detail::lazy_parse_impl(), boost::spirit::qi::match(), boost::spirit::karma::make_directive< terminal_ex< tag::maxwidth, fusion::vector1< T > >, Subject, Modifiers >::operator()(), boost::spirit::karma::operator<<(), boost::spirit::qi::operator>>(), boost::spirit::traits::optional_value(), boost::spirit::qi::not_predicate< Subject >::parse(), boost::spirit::qi::and_predicate< Subject >::parse(), boost::spirit::qi::difference< Left, Right >::parse(), boost::spirit::qi::matches_directive< Subject >::parse(), boost::spirit::qi::raw_directive< Subject >::parse(), boost::spirit::qi::parse(), boost::spirit::repository::qi::confix_parser< Subject, Prefix, Suffix >::parse(), boost::spirit::repository::qi::distinct_parser< Subject, Tail, Modifier >::parse(), boost::spirit::qi::lazy_parser< Function, Modifiers >::parse(), boost::spirit::qi::lazy_directive< Function, Subject, Modifiers >::parse(), boost::spirit::repository::qi::kwd_parser< Subject, KeywordType, LoopIter, NoCase, Distinct >::parse(), boost::spirit::repository::qi::complex_kwd_parser< Subject, KeywordType, LoopIter, Distinct >::parse(), boost::spirit::qi::list< Left, Right >::parse_container(), boost::spirit::qi::bool_policies< T >::parse_false(), boost::spirit::qi::no_case_bool_policies< T >::parse_false(), boost::spirit::qi::ureal_policies< T >::parse_inf(), boost::spirit::qi::ureal_policies< T >::parse_nan(), boost::spirit::qi::bool_policies< T >::parse_true(), boost::spirit::qi::no_case_bool_policies< T >::parse_true(), boost::spirit::qi::skip_over(), boost::spirit::lex::tokenize_and_parse(), boost::spirit::lex::tokenize_and_phrase_parse(), boost::spirit::lex::lexertl::token< Iterator, lex::omit, mpl::false_, Idtype >::value(), boost::spirit::lex::lexertl::position_token< Iterator, lex::omit, mpl::false_, Idtype >::value(), boost::spirit::karma::what(), boost::spirit::qi::what(), boost::spirit::qi::lazy_parser< Function, Modifiers >::what(), boost::spirit::karma::lazy_generator< Function, Modifiers >::what(), boost::spirit::qi::lazy_directive< Function, Subject, Modifiers >::what(), and boost::spirit::karma::lazy_directive< Function, Subject, Modifiers >::what().

upper_parser const boost::spirit::upper_p = upper_parser()
real_parser<double, ureal_parser_policies<double> > const boost::spirit::ureal_p = real_parser<double, ureal_parser_policies<double> >()
xdigit_parser const boost::spirit::xdigit_p = xdigit_parser()