Boost C++ Libraries Home Libraries People FAQ More

PrevUpHomeNext

Headers

Header <boost/parser/config.hpp>
Header <boost/parser/error_handling.hpp>
Header <boost/parser/error_handling_fwd.hpp>
Header <boost/parser/parser.hpp>
Header <boost/parser/parser_fwd.hpp>
Header <boost/parser/replace.hpp>
Header <boost/parser/search.hpp>
Header <boost/parser/split.hpp>
Header <boost/parser/subrange.hpp>
Header <boost/parser/transcode_view.hpp>
Header <boost/parser/transform_replace.hpp>
Header <boost/parser/tuple.hpp>

BOOST_PARSER_NO_RUNTIME_ASSERTIONS
BOOST_PARSER_ASSERT(condition)
BOOST_PARSER_DISABLE_CONCEPTS
BOOST_PARSER_USE_HANA_TUPLE
BOOST_PARSER_MAX_AGGREGATE_SIZE
BOOST_PARSER_SUBRANGE
BOOST_PARSER_TRACE_TO_VS_OUTPUT
BOOST_PARSER_ALGO_CONSTEXPR
BOOST_PARSER_USE_CONCEPTS
BOOST_PARSER_USE_STD_TUPLE
BOOST_PARSER_CONSTEXPR
BOOST_PARSER_TRACE_OSTREAM

  
    struct callback_error_handler;
    struct rethrow_error_handler;
    struct vs_output_error_handler;
    template<typename Iter, typename Sentinel> 
       
      (, , Iter, Iter, 
                              Sentinel, , int64_t = , 
                              int64_t = );
    template<typename Iter, typename Sentinel> 
       
      (, 
                                                        , 
                                                        Iter, Sentinel, 
                                                        parse_error< Iter > const &, 
                                                        int64_t = , 
                                                        int64_t = );
    template<typename Iter> 
      line_position< Iter > (Iter, Iter);
    template<typename Iter, typename Sentinel> 
      Iter (Iter, Sentinel);
  }
}

  
    struct default_error_handler;
    template<typename Iter> struct line_position;
    template<typename Iter> struct parse_error;
    struct stream_error_handler;

    enum error_handler_result;
    enum diagnostic_kind;
    template<typename Iter, typename Sentinel> 
       
      (, , Iter, Iter, 
                              Sentinel, , int64_t = , 
                              int64_t = );
    template<typename Iter, typename Sentinel> 
       
      (, 
                                                        , 
                                                        Iter, Sentinel, 
                                                        parse_error< Iter > const &, 
                                                        int64_t = , 
                                                        int64_t = );
  }
}

BOOST_PARSER_DEFINE_RULES(...)

  
    template<typename R, typename Parser> struct attribute;
    template<typename Parser, typename DelimiterParser> 
      struct delimited_seq_parser;
    template<typename DelimiterParser> struct delimiter_directive;
    template< Parser> struct directive;
    template<typename Predicate> struct if_directive;
    struct merge_directive;
    struct none;
    template<typename Parser> struct one_plus_parser;
    template<typename Parser> struct opt_parser;
    template<typename ParserTuple> struct or_parser;
    template<typename Parser, typename GlobalState, typename ErrorHandler> 
      struct parser_interface;
    template<typename ParserTuple, typename DelimiterParser> struct perm_parser;
    template<typename Quotes, typename Escapes, typename CharParser> 
      struct quoted_string_parser;
    template<typename MinType, typename MaxType> struct repeat_directive;
    struct separate_directive;
    template<typename SkipParser> struct skip_directive;
    template<typename T> struct symbols;
    template<typename F> struct transform_directive;
    template<typename Parser> struct zero_plus_parser;

    enum trace;

     _p;
    int64_t  const Inf;
    constexpr  directive< omit_parser > omit;
    constexpr  directive< raw_parser > raw;
    constexpr  directive< string_view_parser > string_view;
    constexpr  directive< lexeme_parser > lexeme;
    constexpr  directive< no_case_parser > no_case;
    constexpr  skip_directive skip;
    constexpr  merge_directive merge;
    constexpr  separate_directive separate;
     eps;
    constexpr  parser_interface< eoi_parser > eoi;
     char_;
     cp;
     cu;
    constexpr  parser_interface< quoted_string_parser<> > quoted_string;
    constexpr  parser_interface< ws_parser< true, false > > eol;
    constexpr  parser_interface< ws_parser< false, false > > ws;
    constexpr  parser_interface< ws_parser< false, true > > blank;
    constexpr  parser_interface< digit_parser > digit;
     hex_digit;
     control;
     punct;
     symb;
     lower;
     upper;
    constexpr  parser_interface< bool_parser > bool_;
    constexpr  parser_interface< uint_parser< unsigned  int,  bin;
    constexpr  parser_interface< uint_parser< unsigned  int,  oct;
    constexpr  parser_interface< uint_parser< unsigned  int,  hex;
    constexpr  parser_interface< uint_parser< unsigned  short > > ushort_;
    constexpr  parser_interface< uint_parser< unsigned  int > > uint_;
    constexpr  parser_interface< uint_parser< unsigned  long > > ulong_;
    constexpr  parser_interface< uint_parser< unsigned  long  long > > ulong_long;
    constexpr  parser_interface< int_parser< short > > short_;
    constexpr  parser_interface< int_parser< int > > int_;
    constexpr  parser_interface< int_parser< long > > long_;
    constexpr  parser_interface< int_parser< long  long > > long_long;
    constexpr  parser_interface< float_parser< float > > float_;
    constexpr  parser_interface< float_parser< double > > double_;
    template<typename Parser, typename GlobalState, typename ErrorHandler> 
      auto (, GlobalState &);
    template<typename Parser, typename GlobalState, typename ErrorHandler> 
      auto (parser_interface< Parser, GlobalState, default_error_handler > const &, 
                              ErrorHandler &);
    template<typename T> constexpr  repeat_directive< T, T > (T);
    template<typename MinType, typename MaxType> 
      constexpr  repeat_directive< MinType, MaxType > (MinType, MaxType);
    template<typename DelimiterParser> 
      constexpr  delimiter_directive< DelimiterParser > 
      (parser_interface< DelimiterParser >);
    template<typename F> auto ();
    template<typename Attribute> constexpr  auto (Attribute);
    constexpr  auto (char);
    constexpr  auto (char8_t);
    constexpr  auto (char32_t);
    template< R> constexpr  auto (R &&);
    template< R> constexpr  auto (R &&);
    template<typename Predicate> constexpr  auto (Predicate);
    template<typename T> constexpr  auto (T);
    template<typename Parser> 
      constexpr  auto (char, parser_interface< Parser >);
    template<typename Parser> 
      constexpr  auto (char32_t, parser_interface< Parser >);
    template< R, typename Parser> 
      constexpr  auto (R &&, parser_interface< Parser >);
    template<typename Parser> 
      constexpr  auto (char, parser_interface< Parser >);
    template<typename Parser> 
      constexpr  auto (char32_t, parser_interface< Parser >);
    template< R, typename Parser> 
      constexpr  auto (R &&, parser_interface< Parser >);
    template<typename Parser> 
      constexpr  auto (char, parser_interface< Parser >);
    template<typename Parser> 
      constexpr  auto (char32_t, parser_interface< Parser >);
    template< R, typename Parser> 
      constexpr  auto (R &&, parser_interface< Parser >);
    template<typename Parser> 
      constexpr  auto (char, parser_interface< Parser >);
    template<typename Parser> 
      constexpr  auto (char32_t, parser_interface< Parser >);
    template< R, typename Parser> 
      constexpr  auto (R &&, parser_interface< Parser >);
    template<typename Parser> 
      constexpr  auto (char, parser_interface< Parser >);
    template<typename Parser> 
      constexpr  auto (char32_t, parser_interface< Parser >);
    template< R, typename Parser> 
      constexpr  auto (R &&, parser_interface< Parser >);
    template< I,  S, typename Parser, 
             typename GlobalState, 
              ErrorHandler, typename Attr> 
      bool (, , 
                        parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                        Attr &,  = );
    template< R, typename Parser, typename GlobalState, 
             typename ErrorHandler, typename Attr> 
      bool (R  const &, 
                 parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                 Attr &,  = );
    template< I,  S, typename Parser, 
             typename GlobalState, 
              ErrorHandler> 
      auto (, , 
                        parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                         = );
    template< R, typename Parser, typename GlobalState, 
             typename ErrorHandler> 
      auto (R  const &, 
                 parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                  = );
    template< I,  S, typename Parser, 
             typename GlobalState, 
              ErrorHandler, 
             typename SkipParser, typename Attr> 
      bool (, , 
                        parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                        parser_interface< SkipParser > const &, Attr &, 
                         = );
    template< R, typename Parser, typename GlobalState, 
             typename ErrorHandler, typename SkipParser, typename Attr> 
      bool (R  const &, 
                 parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                 parser_interface< SkipParser > const &, Attr &,  = );
    template< I,  S, typename Parser, 
             typename GlobalState, 
              ErrorHandler, 
             typename SkipParser> 
      auto (, , 
                        parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                        parser_interface< SkipParser > const &,  = );
    template< R, typename Parser, typename GlobalState, 
             typename ErrorHandler, typename SkipParser> 
      auto (R  const &, 
                 parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                 parser_interface< SkipParser > const &,  = );
    template< I,  S, typename Parser, 
             typename GlobalState, 
              ErrorHandler, 
             typename Callbacks> 
      bool (, , 
                                 parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                                 Callbacks  const &,  = );
    template< R, typename Parser, typename GlobalState, 
             typename ErrorHandler, typename Callbacks> 
      bool (R  const &, 
                          parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                          Callbacks  const &,  = );
    template< I,  S, typename Parser, 
             typename GlobalState, 
              ErrorHandler, 
             typename SkipParser, typename Callbacks> 
      bool (, , 
                                 parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                                 parser_interface< SkipParser > const &, 
                                 Callbacks  const &,  = );
    template< R, typename Parser, typename GlobalState, 
             typename ErrorHandler, typename SkipParser, typename Callbacks> 
      bool (R  const &, 
                          parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                          parser_interface< SkipParser > const &, 
                          Callbacks  const &,  = );
    
      constexpr  auto (char);
      constexpr  auto (char8_t);
      constexpr  auto (char32_t);
      constexpr  auto (char  const *, );
      constexpr  auto (char8_t  const *, );
      constexpr  auto (char32_t  const *, );
      constexpr  auto (char);
      constexpr  auto (char8_t);
      constexpr  auto (char32_t);
      constexpr  auto (char  const *, );
      constexpr  auto (char8_t  const *, );
      constexpr  auto (char32_t  const *, );
    }
  }
}

  
    template<typename Parser, typename Action> struct action_parser;
    template<typename Attribute> struct attr_parser;
    template<typename TagType, typename Attribute, 
             typename LocalState, 
             typename ParamsTuple> 
      struct callback_rule;
    template<typename Expected, typename AttributeType> struct char_parser;
    template<typename Tag> struct char_set_parser;
    template<typename Tag> struct char_subrange_parser;
    template<typename Predicate> struct eps_parser;
    template<typename Parser,  FailOnMatch> struct expect_parser;
    template<typename T> struct float_parser;
    template<typename T,  Radix = ,  MinDigits = , 
              MaxDigits = -, typename Expected> 
      struct int_parser;
    template<typename Parser> struct lexeme_parser;
    template<typename Parser> struct no_case_parser;
    template<typename Parser> struct omit_parser;
    template<typename Parser> struct raw_parser;
    template<typename Parser, typename DelimiterParser, 
             typename MinType, typename MaxType> 
      struct repeat_parser;
    template<typename TagType, typename Attribute, 
             typename LocalState, 
             typename ParamsTuple> 
      struct rule;
    template< CanUseCallbacks, typename TagType, typename Attribute, 
             typename LocalState, typename ParamsTuple> 
      struct rule_parser;
    template<typename ParserTuple, typename BacktrackingTuple, 
             typename CombiningGroups> 
      struct seq_parser;
    template<typename Parser, typename SkipParser> struct skip_parser;
    struct sorted_t;
    template<typename StrIter, typename StrSentinel> struct string_parser;
    template<typename Parser> struct string_view_parser;
    template<typename SwitchValue, typename OrParser> struct switch_parser;
    template<typename T> struct symbol_parser;
    template<typename Parser, typename F> struct transform_parser;
    template<typename T,  Radix = ,  MinDigits = , 
              MaxDigits = -, typename Expected> 
      struct uint_parser;
    template< NewlinesOnly,  NoNewlines> struct ws_parser;
    typedef  ;
    typedef typename  attribute< R, Parser >:: ;
    typedef  ;
    typedef  ;
    typedef  ;

    constexpr  bool enable_optional;
    constexpr  bool enable_variant;
    constexpr  sorted_t sorted;
    template<typename CharT> constexpr  auto (CharT *);
    decltype(auto) (Context  const &);
    template<typename Context> decltype(auto) (Context  const &);
    template<typename Context> decltype(auto) (Context  const &);
    template<typename Context> decltype(auto) (Context  const &);
    template<typename Context> decltype(auto) (Context  const &);
    template<typename Context> decltype(auto) (Context  const &);
    template<typename Context> decltype(auto) (Context  const &);
    template<typename Context> decltype(auto) (Context  const &);
    template<typename Context> decltype(auto) (Context  const &);
    template<typename Context> decltype(auto) (Context  const &);
    template< I, typename Context> 
      void (Context  const &, , );
    template<typename Context> 
      void (Context  const &, );
    template< I, typename Context> 
      void (Context  const &, , );
    template<typename Context> 
      void (Context  const &, );
  }
}

  
    template< V, 
              ReplacementV, typename Parser, 
             typename GlobalState, typename ErrorHandler, typename SkipParser> 
      struct replace_view;

     replace;
    template<typename V, typename ReplacementV, typename Parser, 
             typename GlobalState, typename ErrorHandler, typename SkipParser> 
       (, 
                    parser_interface< Parser, GlobalState, ErrorHandler >, 
                    parser_interface< SkipParser >, , );
    template<typename V, typename ReplacementV, typename Parser, 
             typename GlobalState, typename ErrorHandler, typename SkipParser> 
       (, 
                    parser_interface< Parser, GlobalState, ErrorHandler >, 
                    parser_interface< SkipParser >, );
    template<typename V, typename ReplacementV, typename Parser, 
             typename GlobalState, typename ErrorHandler> 
       (, 
                    parser_interface< Parser, GlobalState, ErrorHandler >, 
                    , );
    template<typename V, typename ReplacementV, typename Parser, 
             typename GlobalState, typename ErrorHandler> 
       (, 
                    parser_interface< Parser, GlobalState, ErrorHandler >, 
                    );
  }
}

  
    template< V, typename Parser, 
             typename GlobalState, typename ErrorHandler, typename SkipParser> 
      struct search_all_view;

     search_all;
    template< R, typename Parser, typename GlobalState, 
             typename ErrorHandler, typename SkipParser> 
      auto (R &&, 
                  parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                  parser_interface< SkipParser > const &,  = );
    template< I,  S, typename Parser, 
             typename SkipParser, typename GlobalState, 
              ErrorHandler> 
      auto (, , 
                  parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                  parser_interface< SkipParser > const &,  = );
    template< R, typename Parser, typename GlobalState, 
             typename ErrorHandler> 
      auto (R &&, 
                  parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                   = );
    template< I,  S, typename Parser, 
             typename GlobalState, 
              ErrorHandler> 
      auto (, , 
                  parser_interface< Parser, GlobalState, ErrorHandler > const &, 
                   = );
    template<typename V, typename Parser, typename GlobalState, 
             typename ErrorHandler, typename SkipParser> 
       (, 
                       parser_interface< Parser, GlobalState, ErrorHandler >, 
                       parser_interface< SkipParser >, );
    template<typename V, typename Parser, typename GlobalState, 
             typename ErrorHandler, typename SkipParser> 
       (, 
                       parser_interface< Parser, GlobalState, ErrorHandler >, 
                       parser_interface< SkipParser >);
    template<typename V, typename Parser, typename GlobalState, 
             typename ErrorHandler> 
       (, 
                       parser_interface< Parser, GlobalState, ErrorHandler >, 
                       );
    template<typename V, typename Parser, typename GlobalState, 
             typename ErrorHandler> 
       (, 
                       parser_interface< Parser, GlobalState, ErrorHandler >);
  }
}

  
    template< V, typename Parser, 
             typename GlobalState, typename ErrorHandler, typename SkipParser> 
      struct split_view;

     split;
    template<typename V, typename Parser, typename GlobalState, 
             typename ErrorHandler, typename SkipParser> 
       (, parser_interface< Parser, GlobalState, ErrorHandler >, 
                  parser_interface< SkipParser >, );
    template<typename V, typename Parser, typename GlobalState, 
             typename ErrorHandler, typename SkipParser> 
       (, parser_interface< Parser, GlobalState, ErrorHandler >, 
                  parser_interface< SkipParser >);
    template<typename V, typename Parser, typename GlobalState, 
             typename ErrorHandler> 
       (, parser_interface< Parser, GlobalState, ErrorHandler >, 
                  );
    template<typename V, typename Parser, typename GlobalState, 
             typename ErrorHandler> 
       (, parser_interface< Parser, GlobalState, ErrorHandler >);
  }
}

  
    template< I,  S = > struct subrange;
    template< I,  S = > 
      constexpr  subrange<  (, );
  }
}
  
  }
}

  
    template< V> class utf16_view;
    template< V> class utf32_view;
    template< V> class utf8_view;

    typedef  ;

    constexpr  auto as_utf8;
    constexpr  auto as_utf16;
    constexpr  auto as_utf32;
  }
}

  
    template< V,  F, 
             typename Parser, typename GlobalState, typename ErrorHandler, 
             typename SkipParser> 
      struct transform_replace_view;

     transform_replace;
    template<typename V, typename F, typename Parser, typename GlobalState, 
             typename ErrorHandler, typename SkipParser> 
       (, 
                              parser_interface< Parser, GlobalState, ErrorHandler >, 
                              parser_interface< SkipParser >, , );
    template<typename V, typename F, typename Parser, typename GlobalState, 
             typename ErrorHandler, typename SkipParser> 
       (, 
                              parser_interface< Parser, GlobalState, ErrorHandler >, 
                              parser_interface< SkipParser >, );
    template<typename V, typename F, typename Parser, typename GlobalState, 
             typename ErrorHandler> 
       (, 
                              parser_interface< Parser, GlobalState, ErrorHandler >, 
                              , );
    template<typename V, typename F, typename Parser, typename GlobalState, 
             typename ErrorHandler> 
       (, 
                              parser_interface< Parser, GlobalState, ErrorHandler >, 
                              );
  }
}

  
    typedef  ;
    typedef T,  ;
    typedef long  long,  ;
    template<typename T, typename U,  I> 
      constexpr  decltype(auto) (T &&, U, );
    
      template< chars> constexpr  auto ();
    }
  }
}

PrevUpHomeNext