Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for an old version of Boost. Click here to view this page for the latest version.
PrevUpHomeNext

Reference

Parsers and combinators provided by the library
Compile-time data structures and values
String
Errors
Tags
Utilities
Terms used by the library
Alphabetical

Metaparse uses a number of general purpose metafunctions and metafunction classes.

accept
accept_tag
accept_when
alphanum
always_c
always
BOOST_METAPARSE_DEFINE_ERROR
BOOST_METAPARSE_STRING
BOOST_METAPARSE_VERSION
Boxed value
build_parser
change_error_message
Currying
debug_parsing_error
digit_expected
digit
digit_to_int_c
digit_to_int
digit_val
empty
end_of_input_expected
entire_input
except
expected_to_fail
fail_at_first_char_expected
fail
fail_tag
first_of
foldl1
foldl_reject_incomplete
foldl_reject_incomplete1
foldl_reject_incomplete_start_with_parser
foldl_start_with_parser
foldl
foldr1
foldr_reject_incomplete
foldr_reject_incomplete1
foldr_start_with_parser
foldr
get_col
get_line
get_message
get_position
get_prev_char
get_remaining
get_result
grammar
if_
index_out_of_range
in_range_c
in_range
int_
int_to_digit_c
int_to_digit
is_digit
is_error
is_lcase_letter
is_letter
is_ucase_letter
is_whitespace_c
is_whitespace
iterate_c
iterate
keyword
last_of
Lazy template metafunction
letter_expected
letter
lit_c
literal_expected
lit
look_ahead
Template metafunction class
Template metafunction
Template metaprogramming value
middle_of
next_char
next_line
none_of_the_expected_cases_found
nth_of_c
nth_of
Nullary template metafunction
one_char_except_c
one_char_except
one_char
one_of_c
one_of
optional
Parser combinator
Parser
Parsing error message
Predicate
range_c
range
reject
repeated1
repeated_reject_incomplete1
repeated_reject_incomplete
repeated_one_of1
repeated_one_of
repeated
return_
sequence
sequence_apply
source_position
source_position_tag
space
spaces
start
string
string_tag
Tag
token
transform_error_message
transform_error
transform
unexpected_character
unexpected_end_of_input
unless_error
unpaired
whitespace_expected

Synopsis

template <class Result, class Remaining, class Pos>
struct accept;

This is a template metaprogramming value.

Table 23.2. Arguments

Name

Type

Result

template metaprogramming value

Remaining

string

Pos

source position


Description

Values representing a successful parser application. It behaves as a lazy template metafunction: when it is evaluated as a metafunction, it returns itself with its arguments evaluated. See expression semantics for further details.

[Note] Note

Note that for backward compatibility when Result::type is not defined, accept<....>::type does not evaluate Result. For example accept<int, BOOST_METAPARSE_STRING("foo"), start>::type is accept<int, BOOST_METAPARSE_STRING("foo")::type, start::type>. Using types that are not template metaprogramming values as Result is deprecated and will not work in future versions of the library.

Expressions semantics

For any r template metaprogramming value, s compile-time string and p source position the following are equivalent:

accept<r, s, p>::type

accept<r, s::type, p::type>

Header

#include <boost/metaparse/accept.hpp>

Operations

Synopsis

struct accept_tag;

This is a tag.

Description

This is the tag of the values returned by a parser when parsing was successful.

Header

#include <boost/metaparse/accept_tag.hpp>

Synopsis

template <class P, class Pred, class Msg>
struct accept_when;

This is a parser combinator.

Table 23.3. Arguments

Name

Type

P

parser

Pred

predicate

Msg

parsing error message


Description

It parses the input with P. When P rejects the input, accept_when rejects it as well. When P accepts it, accept_when evaluates Pred with the result of parsing the input with P. When Pred returns true, accept_when accepts the input and the result of parsing will be what P returned. Otherwise accept_when rejects the input and Msg is used as the error reason.

Header

#include <boost/metaparse/accept_when.hpp>

Expression semantics

For any p parser, pred predicate, msg parsing error message, s compile-time string and pos source position

accept_when<p, pred, msg>i::apply<s, pos>::type

is equivalent to

p::apply<s, pos>::type

when p::apply<s, pos> doesn't return an error and pred::apply<get_result<p::apply<s, pos>>>::type is true. Otherwise it is equivalent to

fail<msg>

Example

#include <boost/metaparse/accept_when.hpp>
#include <boost/metaparse/one_char.hpp>
#include <boost/metaparse/util/is_digit.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/get_result.hpp>
#include <boost/metaparse/define_error.hpp>

using namespace boost::metaparse;

BOOST_METAPARSE_DEFINE_ERROR(digit_expected, "Digit expected");

using accept_digit = accept_when<one_char, util::is_digit<>, digit_expected>;

static_assert(
  !is_error<
    accept_digit::apply<BOOST_METAPARSE_STRING("0"), start>
  >::type::value,
  "accept_digit should accept a digit"
);

static_assert(
  get_result<
    accept_digit::apply<BOOST_METAPARSE_STRING("0"), start>
  >::type::value == '0',
  "the result of parsing should be the character value"
);

static_assert(
  is_error<
    accept_digit::apply<BOOST_METAPARSE_STRING("x"), start>
  >::type::value,
  "accept_digit should reject a character that is not a digit"
);

Synopsis

struct alphanum;

This is a parser.

Description

It accepts one character in the range a-z, A-Z or 0-9. The result of the parser is the accepted character.

Header

#include <boost/metaparse/alphanum.hpp>

Expression semantics

The following are equivalent:

alphanum

one_of<digit, letter>

Example

#include <boost/metaparse/alphanum.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/get_result.hpp>

using namespace boost::metaparse;

static_assert(
  !is_error<alphanum::apply<BOOST_METAPARSE_STRING("0"), start>>::type::value,
  "alphanum should accept a digit"
);

static_assert(
  !is_error<alphanum::apply<BOOST_METAPARSE_STRING("x"), start>>::type::value,
  "alphanum should accept a character"
);

static_assert(
  get_result<
    alphanum::apply<BOOST_METAPARSE_STRING("x"), start>
  >::type::value == 'x',
  "the result of parsing should be the character value"
);

static_assert(
  is_error<alphanum::apply<BOOST_METAPARSE_STRING(","), start>>::type::value,
  "alphanum should reject a comma"
);

Synopsis

template <char C, class T>
struct always_c;

This is a parser combinator.

Table 23.4. Arguments

Name

Type

C

character

T

template metaprogramming value


Description

It accepts inputs beginning with the C character. It consumes that character and the result of parsing is T. Other inputs as rejected.

Header

#include <boost/metaparse/always_c.hpp>

Expression semantics

For any c character and t class the following are equivalent:

always_c<c, t>

always<lit_c<c>, t>

Example

#include <boost/metaparse/always_c.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/get_result.hpp>

#include <type_traits>

using namespace boost::metaparse;

using always13 = always_c<'x', std::integral_constant<int, 13>>;

static_assert(
  !is_error<always13::apply<BOOST_METAPARSE_STRING("x"), start>>::type::value,
  "always13 should accept x"
);

static_assert(
  std::is_same<
    get_result<always13::apply<BOOST_METAPARSE_STRING("x"), start>>::type,
    std::integral_constant<int, 13>
  >::type::value,
  "the result of parsing should be the integral_constant type"
);

static_assert(
  is_error<always13::apply<BOOST_METAPARSE_STRING("y"), start>>::type::value,
  "always13 should reject characters other than x"
);

Synopsis

template <class P, class T>
struct always;

This is a parser combinator.

Table 23.5. Arguments


Description

It accepts an input if and only if P accepts it, but the result of parsing will be T instead of the result P returned.

Header

#include <boost/metaparse/always.hpp>

Expression semantics

For any p parser and t class the following are equivalent:

always<p, t>

last_of<p, return_<t>>

Example

#include <boost/metaparse/always.hpp>
#include <boost/metaparse/lit_c.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/get_result.hpp>

#include <type_traits>

using namespace boost::metaparse;

using always13 = always<lit_c<'x'>, std::integral_constant<int, 13>>;

static_assert(
  !is_error<always13::apply<BOOST_METAPARSE_STRING("x"), start>>::type::value,
  "always13 should accept x"
);

static_assert(
  std::is_same<
    get_result<always13::apply<BOOST_METAPARSE_STRING("x"), start>>::type,
    std::integral_constant<int, 13>
  >::type::value,
  "the result of parsing should be the integral_constant type"
);

static_assert(
  is_error<always13::apply<BOOST_METAPARSE_STRING("y"), start>>::type::value,
  "always13 should reject characters other than x"
);

Synopsis

#define BOOST_METAPARSE_DEFINE_ERROR(name, msg) \
  // unspecified

This is a macro.

Table 23.6. Arguments

Name

Type

name

identifier token

msg

string literal


Description

Macro for defining a parsing error message class. name is the name of the class representing the error message and msg is a string literal containing the description of the error.

Header

#include <boost/metaparse/define_error.hpp>

Expression semantics

For any n name and m string literal, given the following is defined:

BOOST_METAPARSE_DEFINE_ERROR(n, m);

the following pairs of expressions are equivalent:

n::get_value()
std::string(m)

n::type
n

Example

#include <boost/metaparse/define_error.hpp>
#include <boost/metaparse/repeated1.hpp>
#include <boost/metaparse/letter.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/token.hpp>
#include <boost/metaparse/sequence.hpp>
#include <boost/metaparse/change_error_message.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/get_message.hpp>
#include <boost/metaparse/string.hpp>

#include <type_traits>

using namespace boost::metaparse;

BOOST_METAPARSE_DEFINE_ERROR(age_expected, "Age expected");

using name_token = token<repeated1<letter>>;
using age_token = token<change_error_message<int_, age_expected>>;

using name_age = sequence<name_token, age_token>;

static_assert(
  std::is_same<
    age_expected,
    get_message<name_age::apply<BOOST_METAPARSE_STRING("Joe "), start>>::type
  >::type::value,
  "the error message should be age_expected when the age is missing"
);

Synopsis

#define BOOST_METAPARSE_STRING(s) \
  // unspecified

This is a macro.

Table 23.7. Arguments

Name

Type

s

string literal


Description

Macro for defining string values. s is expected to be a string literal. The macro requires C++11.

The maximal length of the string is limited. This limit is defined by the BOOST_METAPARSE_LIMIT_STRING_SIZE macro.

On platforms where BOOST_METAPARSE_STRING is not supported, the string.hpp header defines the BOOST_METAPARSE_V1_CONFIG_NO_BOOST_METAPARSE_STRING macro. Defining this macro before including the header disables the BOOST_METAPARSE_STRING macro.

The upper limit for the maximum length, which can be used is 2048. The implementation of the BOOST_METAPARSE_STRING macro is generated using tools/string_headers.py and can be regenerated to extend this upper limit. Note that for Oracle Developer Studio the string length limit is 127.

Metaparse supports changing the string length limit within a compilation unit. To change the length limit, redefine the BOOST_METAPARSE_LIMIT_STRING_SIZE macro.

You can find benchmarks of this macro here.

Header

#include <boost/metaparse/string.hpp>

Expression semantics

The semantics of this macro is demonstrated by an example. The following

BOOST_METAPARSE_STRING("hello")

is equivalent to

string<'h','e','l','l','o'>

Example

#define BOOST_METAPARSE_LIMIT_STRING_SIZE 8
#include <boost/metaparse/string.hpp>

#include <type_traits>

using namespace boost::metaparse;

using hello1 = string<'H','e','l','l','o'>;
using hello2 = BOOST_METAPARSE_STRING("Hello");

static_assert(
  std::is_same<
    string<'H', 'e', 'l', 'l', 'o'>,
    BOOST_METAPARSE_STRING("Hello")
  >::type::value,
  "The type generated by the macro should be identical to the hand-crafted one."
);

#undef BOOST_METAPARSE_LIMIT_STRING_SIZE
#define BOOST_METAPARSE_LIMIT_STRING_SIZE 32

static_assert(
  std::is_same<
    string<
      'A', ' ', 'l', 'o', 'n', 'g', 'e', 'r',
      ' ', 's', 't', 'r', 'i', 'n', 'g'
    >,
    BOOST_METAPARSE_STRING("A longer string")
  >::type::value,
  "The type generated by the macro should be identical to the hand-crafted one."
);

Synopsis

#define BOOST_METAPARSE_VERSION \\ unspecified

This is a macro.

Description

Macro containing the version number of Boost.Metaparse.

Header

#include <boost/metaparse/version.hpp>

Expression semantics

It has major, minor and release components:

major   == BOOST_METAPARSE_VERSION / 10000000
minor   == (BOOST_METAPARSE_VERSION % 10000000) / 100000
release == BOOST_METAPARSE_VERSION % 100000

A boxed value is a type representing a constant value. It has a public static const or constexpr member called value. The class represents that value as a type, so it can be manipulated by template metafunctions. It has to be a template metaprogramming value.

For example the following struct represents the true value of type bool:

struct true_type
{
  static constexpr bool value = true;
  using type = true_type;
};

The value member is the wrapped value. true_type::type is an alias of true_type which makes it a template metaprogramming value.

Synopsis

template <class P>
struct build_parser;

This is a template metafunction.

Table 23.8. Arguments

Name

Type

P

parser


Description

It generates a simple interface for parser. It returns a metafunction class that takes an input string, parses it with P and returns the result of parsing. It generates a compilation error when parsing fails.

Return value

It returns a template metafunction class:

struct
{
  template <class S>
  struct apply;
};

Table 23.9. Arguments

Name

Type

S

string


Header

#include <boost/metaparse/build_parser.hpp>

Expression semantics

For any p parser and s compile-time string

build_parser<p>::type::apply<s>

is equivalent to

get_result<p::apply<s>>

Example

#include <boost/metaparse/build_parser.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/string.hpp>

using namespace boost::metaparse;

using string_to_int = build_parser<int_>::type;

static_assert(
  string_to_int::apply<BOOST_METAPARSE_STRING("1113")>::type::value == 1113,
  "string_to_int should be a metafunction turning a string into an int"
);

Synopsis

template <class P, class Msg>
struct change_error_message;

This is a parser combinator.

Table 23.10. Arguments

Name

Type

P

parser

Msg

parsing error message


Description

It applies P on the input. When P succeeds, change_error_message returns the result P returns, otherwise change_error_message rejects the input and the reason will be Msg.

Header

#include <boost/metaparse/change_error_message.hpp>

Expression semantics

For any p parser and m parsing error message, s compile-time string and pos source position

change_error_message<p, msg>::apply<s, pos>

is equivalent to p::apply<s, pos> when p accepts the input. It is equivalent to fail<msg>::apply<s, pos> otherwise.

Example

#include <boost/metaparse/change_error_message.hpp>
#include <boost/metaparse/repeated1.hpp>
#include <boost/metaparse/letter.hpp>
#include <boost/metaparse/keyword.hpp>
#include <boost/metaparse/last_of.hpp>
#include <boost/metaparse/token.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/get_message.hpp>
#include <boost/metaparse/define_error.hpp>

#include <type_traits>

using namespace boost::metaparse;

BOOST_METAPARSE_DEFINE_ERROR(name_expected, "Name expected");

using keyword_name = token<keyword<BOOST_METAPARSE_STRING("name")>>;
using name_token = token<repeated1<letter>>;

using name_parser =
  last_of<keyword_name, change_error_message<name_token, name_expected>>;

static_assert(
  !is_error<
    name_parser::apply<BOOST_METAPARSE_STRING("name Bela"), start>
  >::type::value,
  "name_parser should accept \"name <a name>\""
);

static_assert(
  is_error<
    name_parser::apply<BOOST_METAPARSE_STRING("name ?"), start>
  >::type::value,
  "name_parser should reject input when name is a question mark"
);

static_assert(
  std::is_same<
    get_message<
      name_parser::apply<BOOST_METAPARSE_STRING("name ?"), start>
    >::type,
    name_expected
  >::type::value,
  "the error message should be the one specified by change_error_message"
);

A template metafunction supports currying when it accepts less arguments than it normally expects. When less arguments are provided, then it returns a template metafunction class expecting the remaining arguments. That template metafunction class is also expected to support currying.

For example assuming the following metafunction is given:

template <class A, class B>
struct plus;

It takes two values, adds them and returns their result. For example:

static_assert(
  plus<
    std::integral_constant<int, 11>,
    std::integral_constant<int, 2>
  >::type::value == 13,
  "This should work"
);

If it supports currying, then the following should also work:

using inc = plus<std::integral_constant<int, 1>>;

static_assert(
  inc::apply<std::integral_constant<int, 12>>::type::value == 13,
  "This should work"
);

The above example defines the inc template metafunction class by calling plus with just one argument: the boxed 1 value.

Synopsis

template <class P, class S>
struct debug_parsing_error
{
  debug_parsing_error();
};

This is a template class.

Table 23.11. Arguments

Name

Type

P

parser

S

string


Description

Utility to debug errors generated by a compile-time parser. An instance of the instantiated template class has to be created and initialised using the default constructor. When parsing the input string using the parser generates an error, the default constructor of debug_parsing_error prints the error message to the standard output at run-time and calls exit.

[Note] Note

Note that more powerful debugging utilities, like Metashell are also available.

Header

#include <boost/metaparse/debug_parsing_error.hpp>

Expression semantics

For any p compile-time parser and s compile-time string

debug_parsing_error<p, s>()

Tries to parse s using p at compile-time. At run-time the constructor prints the result of parsing to the standard output and calls exit.

Example

#include <boost/metaparse/debug_parsing_error.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/string.hpp>

#include <type_traits>

using namespace boost::metaparse;

debug_parsing_error<int_, BOOST_METAPARSE_STRING("not an int")> do_debugging;

int main() {}

By running the compiled executable you get the following:

Compile-time parsing results ---------------------------- Input text: not an int

Parsing failed: line 1, col 1: Digit expected

Synopsis

namespace error
{
  struct digit_expected;
}

This is a parsing error message.

Description

Class representing the error that a digit character was expected at a specific location.

Header

#include <boost/metaparse/error/digit_expected.hpp>

Synopsis

struct digit;

This is a parser.

Description

Parser accepting one character in the range 0-9. The result of the parser is the accepted character.

Header

#include <boost/metaparse/digit.hpp>

Expression semantics

The following are equivalent:

digit

accept_when<one_char, util::is_digit, error::digit_expected>

Example

#include <boost/metaparse/digit.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/get_result.hpp>

using namespace boost::metaparse;

static_assert(
  !is_error<digit::apply<BOOST_METAPARSE_STRING("0"), start>>::type::value,
  "digit should accept a digit"
);

static_assert(
  is_error<digit::apply<BOOST_METAPARSE_STRING("x"), start>>::type::value,
  "digit should reject a character"
);

static_assert(
  get_result<
    digit::apply<BOOST_METAPARSE_STRING("0"), start>
  >::type::value == '0',
  "the result of parsing should be the character value"
);

Synopsis

namespace util
{
  template <char D>
  struct digit_to_int_c;
}

This is a template class similar to a template metafunction but taking a char value as argument.

Table 23.12. Arguments

Name

Type

D

character value


Description

Converts a character containing a value in the range ['0'..'9'] to an integer.

Return value

It returns a boxed integer value.

Header

#include <boost/metaparse/util/digit_to_int_c.hpp>

Expression semantics

The following pairs of expressions are equivalent

digit_to_int_c<'0'>::type
boost::mpl::int_<0>

digit_to_int_c<'9'>::type
boost::mpl::int_<9>

Example

#include <boost/metaparse/util/digit_to_int_c.hpp>

using namespace boost::metaparse;

static_assert(
  util::digit_to_int_c<'0'>::type::value == 0,
  "it should convert a character to the corresponding integer value"
);

static_assert(
  util::digit_to_int_c<'3'>::type::value == 3,
  "it should convert a character to the corresponding integer value"
);

static_assert(
  util::digit_to_int_c<'9'>::type::value == 9,
  "it should convert a character to the corresponding integer value"
);

Synopsis

namespace util
{
  template <class D>
  struct digit_to_int;
}

This is a lazy template metafunction that supports currying.

Table 23.13. Arguments

Name

Type

D

boxed character value


Description

Converts a boxed character containing a value in the range ['0'..'9'] to an integer.

Return value

It returns a boxed integer value.

Header

#include <boost/metaparse/util/digit_to_int.hpp>

Expression semantics

For any C boxed character value in the range ['0'..'9'] the following expressions are equivalent

digit_to_int<>::apply<C>::type
digit_to_int<C>::type
digit_to_int_c<C::type::value>::type

Example

#include <boost/metaparse/util/digit_to_int.hpp>

#include <type_traits>

using namespace boost::metaparse;

struct nullary_metafunction_returning_4
{
  using type = std::integral_constant<char, '4'>;
};

static_assert(
  util::digit_to_int<std::integral_constant<char, '0'>>::type::value == 0,
  "it should convert a character to the corresponding integer value"
);

static_assert(
  util::digit_to_int<>::type
    ::apply<std::integral_constant<char, '7'>>::type::value == 7,
  "it should support currying"
);

static_assert(
  util::digit_to_int<nullary_metafunction_returning_4>::type::value == 4,
  "it should support lazy evaluation"
);

Synopsis

struct digit_val;

This is a parser.

Description

It accepts one character in the range 0-9. The result of the parser is the value represented by the accepted character.

Header

#include <boost/metaparse/digit_val.hpp>

Expression semantics

The following are equivalent:

digit_val

transform<digit, util::digit_to_int<>>

Example

#include <boost/metaparse/digit_val.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/get_result.hpp>

using namespace boost::metaparse;

static_assert(
  !is_error<digit_val::apply<BOOST_METAPARSE_STRING("0"), start>>::type::value,
  "digit_val should accept a digit"
);

static_assert(
  is_error<digit_val::apply<BOOST_METAPARSE_STRING("x"), start>>::type::value,
  "digit_val should reject a character"
);

static_assert(
  get_result<
    digit_val::apply<BOOST_METAPARSE_STRING("0"), start>
  >::type::value == 0,
  "the result of parsing should be the int value"
);

Synopsis

template <class Result>
struct empty;

This is a parser.

Table 23.14. Arguments


Description

It accepts empty input only. The result of parsing is the Result argument.

Header

#include <boost/metaparse/empty.hpp>

Expression semantics

For any c class the following are equivalent:

empty<c>

except<one_char, c, error::end_of_input_expected>

Example

#include <boost/metaparse/empty.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/get_result.hpp>

#include <type_traits>

using namespace boost::metaparse;

using want_empty = empty<BOOST_METAPARSE_STRING("result")>;

static_assert(
  !is_error<want_empty::apply<BOOST_METAPARSE_STRING(""), start>>::type::value,
  "empty accepts the empty input"
);

static_assert(
  is_error<want_empty::apply<BOOST_METAPARSE_STRING("x"), start>>::type::value,
  "empty should reject non-empty input"
);

static_assert(
  std::is_same<
    get_result<want_empty::apply<BOOST_METAPARSE_STRING(""), start>>::type,
    BOOST_METAPARSE_STRING("result")
  >::type::value,
  "the result of parsing should be the given value"
);

Synopsis

namespace error
{
  struct end_of_input_expected;
}

This is a parsing error message.

Description

Class representing the error that the input contains more characters than it should.

Header

#include <boost/metaparse/error/end_of_input_expected.hpp>

Synopsis

template <class P, class Msg = error::end_of_input_expected>
struct entire_input;

This is a parser combinator.

Table 23.15. Arguments

Name

Type

P

parser

Msg

parsing error message


Description

It parses the input using P and checks if it consumes the entire input. If P fails or doesn't consume the entire input, entire_input fails. Otherwise entire_input returns the result of P. When P does not consume the entire input, the error message returned by entire_input is Msg.

Header

#include <boost/metaparse/entire_input.hpp>

Expression semantics

For any p parser and e parsing error message the following are equivalent

entire_input<p, e>

first_of<
  p,
  change_error_message<empty</* some metaprogramming value */>, e>
>

Example

#include <boost/metaparse/entire_input.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/get_result.hpp>
#include <boost/metaparse/get_message.hpp>
#include <boost/metaparse/define_error.hpp>

using namespace boost::metaparse;

BOOST_METAPARSE_DEFINE_ERROR(extra_chars_at_end, "Extra chars at end");

using int_parser = entire_input<int_, extra_chars_at_end>;

static_assert(
  get_result<
    int_parser::apply<BOOST_METAPARSE_STRING("1113"), start>
  >::type::value == 1113,
  "it should parse the input if it contains only an integer"
);

static_assert(
  std::is_same<
    get_message<
      int_parser::apply<BOOST_METAPARSE_STRING("1113mm"), start>
    >::type,
    extra_chars_at_end
  >::type::value,
  "it should return the specified error message when there are extra characters"
);

Synopsis

template <class P, class Result, class ErrorMsg>
struct except;

This is a parser combinator.

Table 23.16. Arguments


Description

except accepts the input when P rejects it and the result of parsing is the Result argument. When P accepts the input, except rejects it and the reason is ErrorMsg.

Header

#include <boost/metaparse/except.hpp>

Expression semantics

For any p parser, c class, msg parsing error message, s compile-time string and pos source position the following are equivalent

get_result<except<p, c, msg>, s, pos>::type
c

get_remaining<except<p, c, msg>, s, pos>::type
s

get_position<except<p, c, msg>, s, pos>::type
pos

when p rejects the input. The result of the parser is an error with the error message msg otherwise.

Example

#include <boost/metaparse/except.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/get_result.hpp>
#include <boost/metaparse/get_message.hpp>
#include <boost/metaparse/define_error.hpp>

#include <type_traits>

using namespace boost::metaparse;

BOOST_METAPARSE_DEFINE_ERROR(
  number_is_not_allowed,
  "numbers are not allowed here"
);

using except_int =
  except<int_, std::integral_constant<int, 1>, number_is_not_allowed>;

static_assert(
  get_result<
    except_int::apply<BOOST_METAPARSE_STRING("foo"), start>
  >::type::value == 1,
  "it should accept the input when it is not an integer"
);

static_assert(
  std::is_same<
    number_is_not_allowed,
    get_message<except_int::apply<BOOST_METAPARSE_STRING("13"), start>>::type
  >::type::value,
  "it should reject the input when it is an integer"
);

Synopsis

namespace error
{
  struct expected_to_fail;
}

This is a parsing error message.

Description

Class representing the error that a parser was expected to fail but it did not fail.

Header

#include <boost/metaparse/error/expected_to_fail.hpp>

Synopsis

template <class P>
struct fail_at_first_char_expected;

This is a parser combinator.

Table 23.17. Arguments

Name

Type

P

parser


Description

It tries to parse the input using P. When P rejects the input without consuming any character, fail_at_first_char_expected accepts the input. Otherwise (when P accepts the input or when it consumes characters before rejecting the input) fail_at_first_char_expected rejects the input.

Header

#include <boost/metaparse/fail_at_first_char_expected.hpp>

Expression semantics

For any p parser, s compile-time string and pos source position:

When is_error<p::apply<s, pos>>::type is false, the following are equivalent:

fail_at_first_char_expected<p>::apply<s, pos>::type
reject<error::expected_to_fail, pos>

When is_error<p::apply<s, pos>>::type is true and boost::mpl::equal_to<pos, get_position<p::apply<s, pos>>::type>::type is also true, the following are equivalent:

get_remaining<except<p, c, msg>, s, pos>::type
accept</* unspecified */, s, pos>

Otherwise the following are equivalent:

get_remaining<except<p, c, msg>, s, pos>::type
p::apply<s, pos>::type

Example

#include <boost/metaparse/fail_at_first_char_expected.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/lit_c.hpp>
#include <boost/metaparse/foldl_start_with_parser.hpp>
#include <boost/metaparse/first_of.hpp>
#include <boost/metaparse/last_of.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/get_result.hpp>

#include <boost/mpl/lambda.hpp>
#include <boost/mpl/plus.hpp>

using namespace boost::metaparse;

using plus_int = last_of<lit_c<'+'>, int_>;

using plus_exp =
  first_of<
    foldl_start_with_parser<
      plus_int,
      int_,
      boost::mpl::lambda<boost::mpl::plus<boost::mpl::_1, boost::mpl::_2>>::type
    >,
    fail_at_first_char_expected<plus_int>
  >;

static_assert(
  get_result<
    plus_exp::apply<BOOST_METAPARSE_STRING("1+2+3"), start>
  >::type::value == 6,
  "it should accept the input when it is a list of '+' separated ints"
);

static_assert(
  is_error<
    plus_exp::apply<BOOST_METAPARSE_STRING("1+2+3+"), start>
  >::type::value,
  "it should reject the input when it has an extra +"
);

Synopsis

template <class Msg>
struct fail;

This is a parser.

Table 23.18. Arguments

Name

Type

Msg

parsing error message


Description

Parser rejecting every input.

Header

#include <boost/metaparse/fail.hpp>

Expression semantics

For any msg parsing error message, s compile-time string and pos source position

fail<msg>::apply<s, pos>::type

returns an error with msg as the error message.

Example

#include <boost/metaparse/fail.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/get_message.hpp>
#include <boost/metaparse/define_error.hpp>

using namespace boost::metaparse;

BOOST_METAPARSE_DEFINE_ERROR(sample_error, "This is an example parsing error");

using fail_p = fail<sample_error>;

static_assert(
  is_error<fail_p::apply<BOOST_METAPARSE_STRING("foo"), start>>::type::value,
  "it should reject every input"
);

static_assert(
  std::is_same<
    get_message<fail_p::apply<BOOST_METAPARSE_STRING("foo"), start>>::type,
    sample_error
  >::type::value,
  "the error message should be the type specified"
);

Synopsis

struct fail_tag;

This is a tag.

Description

This is the tag of the values returned by a parser when parsing was not successful.

Header

#include <boost/metaparse/fail_tag.hpp>

Synopsis

template <class... Ps>
struct first_of;

This is a parser combinator.

Table 23.19. Arguments

Name

Type

Ps

parsers


Description

first_of applies the Ps... parsers in sequence. It accepts an input when all parsers accept it. The result of parsing is the result of the first parser.

On compilers, which are not C++11-compliant, the maximum number of parsers first_of accepts can be specified with the BOOST_METAPARSE_LIMIT_SEQUENCE_SIZE macro. Its default value is 5.

Header

#include <boost/metaparse/first_of.hpp>

Expression semantics

For any p1, ... pn parsers

first_of<p1, ..., pn>

is equivalent to

nth_of_c<0, p1, ..., pn>

Example

#include <boost/metaparse/first_of.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/lit_c.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/get_result.hpp>

#include <type_traits>

using namespace boost::metaparse;

using int_with_semicolon = first_of<int_, lit_c<';'>>;

static_assert(
  is_error<
    int_with_semicolon::apply<BOOST_METAPARSE_STRING("13"), start>
  >::type::value,
  "int without semicolon is rejected"
);

static_assert(
  get_result<
    int_with_semicolon::apply<BOOST_METAPARSE_STRING("13;"), start>
  >::type::value,
  "the result is the result of the first parser"
);

Synopsis

template <class P, class State, class ForwardOp>
struct foldl1;

This is a parser combinator.

Table 23.20. Arguments

Name

Type

P

parser

State

template metaprogramming value

ForwardOp

template metafunction class taking two arguments


Description

foldl1 applies P on the input string repeatedly as long as P accepts the input. The result of parsing is equivalent to boost::mpl::fold<Sequence, State, ForwardOp>, where Sequence is the sequence of the results of the applications of P.

When P rejects the input for the first time, foldl1 rejects it as well. At least one successful application of P is required for foldl1 to accept the input.

Header

#include <boost/metaparse/foldl1.hpp>

Expression semantics

For any p parser, t class, f metafunction class taking two arguments the following are equivalent:

foldl1<p, t, f>

last_of<look_ahead<p>, foldl<p, t, f>>

Example

#include <boost/metaparse/foldl1.hpp>
#include <boost/metaparse/token.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/get_result.hpp>
#include <boost/metaparse/is_error.hpp>

#include <boost/mpl/lambda.hpp>
#include <boost/mpl/plus.hpp>

using namespace boost::metaparse;

using int_token = token<int_>;
using sum_op =
  boost::mpl::lambda<boost::mpl::plus<boost::mpl::_1, boost::mpl::_2>>::type;

using ints = foldl1<int_token, boost::mpl::int_<0>, sum_op>;

static_assert(
  get_result<
    ints::apply<BOOST_METAPARSE_STRING("11 13 3 21"), start>
  >::type::value == 48,
  "ints should sum the numbers"
);

static_assert(
  is_error<ints::apply<BOOST_METAPARSE_STRING(""), start>>::type::value,
  "when no numbers are provided, it should be an error"
);

Synopsis

template <class P, class State, class ForwardOp>
struct foldl_reject_incomplete;

This is a parser combinator.

Table 23.21. Arguments

Name

Type

P

parser

State

template metaprogramming value

ForwardOp

template metafunction class taking two arguments


Description

The same as foldl, but once P rejects the input, foldl_reject_incomplete checks if P consumes any characters before rejecting the input. If so, foldl_reject_incomplete rejects the input with the same error message this last application of P returned. Otherwise foldl_reject_incomplete accepts the input and gives the same result as foldl.

Here is a diagram showing how foldl_reject_incomplete works by example:

using int_token = token<int_>;
using plus_token = token<lit_c<'+'>>;
using plus_int = last_of<plus_token, int_token>;
using sum_op = mpl::lambda<mpl::plus<mpl::_1, mpl::_2>>::type;

Header

#include <boost/metaparse/foldl_reject_incomplete.hpp>

Expression semantics

For any p parser, t class, f metafunction class taking two arguments, s compile-time string and pos source position

foldl_reject_incomplete<p, t, f>::apply<s, pos>

is equivalent to

first_of<foldl<p, t, f>, fail_at_first_char_expected<p> >::apply<s, pos>

Example

#include <boost/metaparse/foldl_reject_incomplete.hpp>
#include <boost/metaparse/lit_c.hpp>
#include <boost/metaparse/last_of.hpp>
#include <boost/metaparse/token.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/get_result.hpp>
#include <boost/metaparse/is_error.hpp>

#include <boost/mpl/lambda.hpp>
#include <boost/mpl/plus.hpp>
#include <boost/mpl/int.hpp>

using namespace boost::metaparse;

using int_token = token<int_>;
using plus_token = token<lit_c<'+'>>;
using plus_int = last_of<plus_token, int_token>;
using sum_op =
  boost::mpl::lambda<boost::mpl::plus<boost::mpl::_1, boost::mpl::_2>>::type;

using ints = foldl_reject_incomplete<plus_int, boost::mpl::int_<11>, sum_op>;

static_assert(
  get_result<
    ints::apply<BOOST_METAPARSE_STRING("+ 13 + 3 + 21"), start>
  >::type::value == 48,
  "ints should sum the numbers"
);

static_assert(
  is_error<
    ints::apply<BOOST_METAPARSE_STRING("+ 13 + 3 +"), start>
  >::type::value,
  "when the last number is missing, it should be an error"
);

Synopsis

template <class P, class State, class ForwardOp>
struct foldl_reject_incomplete1;

This is a parser combinator.

Table 23.22. Arguments

Name

Type

P

parser

State

template metaprogramming value

ForwardOp

template metafunction class taking two arguments


Description

The same as foldl1, but once P rejects the input, foldl_reject_incomplete1 checks if P consumes any characters before rejecting the input. If so, foldl_reject_incomplete1 rejects the input with the same error message this last application of P returned. Otherwise foldl_reject_incomplete1 accepts the input and gives the same result as foldl1.

Header

#include <boost/metaparse/foldl_reject_incomplete1.hpp>

Expression semantics

For any p parser, t class, f metafunction class taking two arguments, s compile-time string and pos source position

foldl_reject_incomplete1<p, t, f>::apply<s, pos>

is equivalent to

first_of<foldl1<p, t, f>, fail_at_first_char_expected<p> >::apply<s, pos>

Example

#include <boost/metaparse/foldl_reject_incomplete1.hpp>
#include <boost/metaparse/lit_c.hpp>
#include <boost/metaparse/last_of.hpp>
#include <boost/metaparse/token.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/get_result.hpp>
#include <boost/metaparse/is_error.hpp>

#include <boost/mpl/lambda.hpp>
#include <boost/mpl/plus.hpp>
#include <boost/mpl/int.hpp>

using namespace boost::metaparse;

using int_token = token<int_>;
using plus_token = token<lit_c<'+'>>;
using plus_int = last_of<plus_token, int_token>;
using sum_op =
  boost::mpl::lambda<boost::mpl::plus<boost::mpl::_1, boost::mpl::_2>>::type;

using ints = foldl_reject_incomplete1<plus_int, boost::mpl::int_<11>, sum_op>;

static_assert(
  get_result<
    ints::apply<BOOST_METAPARSE_STRING("+ 13 + 3 + 21"), start>
  >::type::value == 48,
  "ints should sum the numbers"
);

static_assert(
  is_error<
    ints::apply<BOOST_METAPARSE_STRING("+ 13 + 3 +"), start>
  >::type::value,
  "when the last number is missing, it should be an error"
);

static_assert(
  is_error<ints::apply<BOOST_METAPARSE_STRING(""), start>>::type::value,
  "when no numbers are provided, it should be an error"
);

Synopsis

template <class P, class StateP, class ForwardOp>
struct foldl_reject_incomplete_start_with_parser;

This is a parser combinator.

Table 23.23. Arguments

Name

Type

P

parser

StateP

parser

ForwardOp

template metafunction class taking two arguments


Description

The same as foldl_start_with_parser, but once P rejects the input, foldl_reject_incomplete_start_with_parser checks if P consumes any characters before rejecting the input. If so, foldl_reject_incomplete_start_with_parser rejects the input with the same error message this last application of P returned. Otherwise foldl_reject_incomplete_start_with_parser accepts the input and gives the same result as foldl_start_with_parser.

Here is a diagram showing how foldl_reject_incomplete_start_with_parser works by example:

using int_token = token<int_>;
using plus_token = token<lit_c<'+'>>;
using plus_int = last_of<plus_token, int_token>;
using sum_op = mpl::lambda<mpl::plus<mpl::_1, mpl::_2>>::type;

Further details can be found in the Introducing foldl_reject_incomplete_start_with_parser section of the User Manual.

Header

#include <boost/metaparse/foldl_reject_incomplete_start_with_parser.hpp>

Expression semantics

For any p parser, pt class, f metafunction class taking two arguments, s compile-time string and pos source position

foldl_reject_incomplete_start_with_parser<p, pt, f>::apply<s, pos>

is equivalent to

first_of<
  foldl_start_with_parser<p, pt, f>,
  fail_at_first_char_expected<p>
>::apply<s, pos>

Example

#include <boost/metaparse/foldl_reject_incomplete_start_with_parser.hpp>
#include <boost/metaparse/lit_c.hpp>
#include <boost/metaparse/last_of.hpp>
#include <boost/metaparse/token.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/get_result.hpp>
#include <boost/metaparse/is_error.hpp>

#include <boost/mpl/lambda.hpp>
#include <boost/mpl/plus.hpp>

using namespace boost::metaparse;

using int_token = token<int_>;
using plus_token = token<lit_c<'+'>>;
using plus_int = last_of<plus_token, int_token>;
using sum_op =
  boost::mpl::lambda<boost::mpl::plus<boost::mpl::_1, boost::mpl::_2>>::type;

using ints =
  foldl_reject_incomplete_start_with_parser<plus_int, int_token, sum_op>;

static_assert(
  get_result<
    ints::apply<BOOST_METAPARSE_STRING("11 + 13 + 3 + 21"), start>
  >::type::value == 48,
  "ints should sum the numbers"
);

static_assert(
  is_error<
    ints::apply<BOOST_METAPARSE_STRING("11 + 13 + 3 +"), start>
  >::type::value,
  "when the last number is missing, it should be an error"
);

Synopsis

template <class P, class StateP, class ForwardOp>
struct foldl_start_with_parser;

This is a parser combinator.

Table 23.24. Arguments

Name

Type

P

parser

StateP

parser

ForwardOp

template metafunction class taking two arguments


Description

The same as foldl, but before folding it applies a parser, StateP on the input. If it fails, foldl_start_with_parser fails. If it succeeds, foldl_start_with_parser works as foldl taking the result of StateP as the initial state.

Here is a diagram showing how foldl_start_with_parser works by example:

using int_token = token<int_>;
using plus_token = token<lit_c<'+'>>;
using plus_int = last_of<plus_token, int_token>;
using sum_op = mpl::lambda<mpl::plus<mpl::_1, mpl::_2>>::type;

Further details can be found in the Introducing foldl_start_with_parser section of the User Manual.

Header

#include <boost/metaparse/foldl_start_with_parser.hpp>

Expression semantics

For any p parser, pt class, f metafunction class taking two arguments, s compile-time string and pos source position

foldl_start_with_parser<p, pt, f>::apply<s, pos>

is equivalent to

pt::apply<s, pos>

when the above expression returns a parsing error. It is

foldl<p, get_result<pt::apply<s, pos>>::type, f>::apply<
  get_remaining<pt::apply<s, pos>>::type,
  get_position<pt::apply<s, pos>>::type
>

otherwise.

Example

#include <boost/metaparse/foldl_start_with_parser.hpp>
#include <boost/metaparse/lit_c.hpp>
#include <boost/metaparse/last_of.hpp>
#include <boost/metaparse/token.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/get_result.hpp>
#include <boost/metaparse/is_error.hpp>

#include <boost/mpl/lambda.hpp>
#include <boost/mpl/plus.hpp>

using namespace boost::metaparse;

using int_token = token<int_>;
using plus_token = token<lit_c<'+'>>;
using plus_int = last_of<plus_token, int_token>;
using sum_op =
  boost::mpl::lambda<boost::mpl::plus<boost::mpl::_1, boost::mpl::_2>>::type;

using ints = foldl_start_with_parser<plus_int, int_token, sum_op>;

static_assert(
  get_result<
    ints::apply<BOOST_METAPARSE_STRING("11 + 13 + 3 + 21"), start>
  >::type::value == 48,
  "ints should sum the numbers"
);

static_assert(
  is_error<ints::apply<BOOST_METAPARSE_STRING(""), start>>::type::value,
  "when no numbers are provided, it should be an error"
);

Synopsis

template <class P, class State, class ForwardOp>
struct foldl;

This is a parser combinator.

Table 23.25. Arguments

Name

Type

P

parser

State

template metaprogramming value

ForwardOp

template metafunction class taking two arguments


Description

foldl applies P on the input string repeatedly as long as P accepts the input. The result of parsing is equivalent to boost::mpl::fold<Sequence, State, ForwardOp>, where Sequence is the sequence of the results of the applications of P.

When P rejects the input for the first time, foldl still accepts the input and the result of parsing is State.

Here is a diagram showing how foldl works by example:

using int_token = token<int_>;
using sum_op = mpl::lambda<mpl::plus<mpl::_1, mpl::_2>>::type;

Further details can be found in the Introducing foldl section of the User Manual.

Header

#include <boost/metaparse/foldl.hpp>

Expression semantics

For any p parser, t class, f metafunction class taking two arguments, s compile-time string and pos source position

foldl<p, t, f>::apply<s, pos>

is equivalent to

return_<t>::apply<s, pos>

when p::apply<s, pos> returns an error. It is

foldl<p, f::apply<t, get_result<p::apply<s, pos>>::type>::type, f>::apply<
  get_remaining<p::apply<s, pos>>,
  get_position<p::apply<s, pos>>
>

otherwise.

Example

#include <boost/metaparse/foldl.hpp>
#include <boost/metaparse/token.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/get_result.hpp>

#include <boost/mpl/lambda.hpp>
#include <boost/mpl/plus.hpp>

using namespace boost::metaparse;

using int_token = token<int_>;
using sum_op =
  boost::mpl::lambda<boost::mpl::plus<boost::mpl::_1, boost::mpl::_2>>::type;

using ints = foldl<int_token, boost::mpl::int_<0>, sum_op>;

static_assert(
  get_result<
    ints::apply<BOOST_METAPARSE_STRING("11 13 3 21"), start>
  >::type::value == 48,
  "ints should sum the numbers"
);

static_assert(
  get_result<
    ints::apply<BOOST_METAPARSE_STRING(""), start>
  >::type::value == 0,
  "the sum of no elements is 0"
);

Synopsis

template <class P, class State, class BackwardOp>
struct foldr1;

This is a parser combinator.

Table 23.26. Arguments

Name

Type

P

parser

State

template metaprogramming value

BackwardOp

template metafunction class taking two arguments


Description

foldr1 applies P on the input string repeatedly as long as P accepts the input. The result of parsing is equivalent to boost::reverse_fold<Sequence, State, BackwardOp>, where Sequence is the sequence of the results of the applications of P.

When P rejects the input for the first time, foldr1 rejects it as well. At least one successful application of P is required for foldr1 to accept the input.

Header

#include <boost/metaparse/foldr1.hpp>

Expression semantics

For any p parser, t class, f metafunction class taking two arguments the following are equivalent:

foldr1<p, t, f>

last_of<look_ahead<p>, foldr<p, t, f>>

Example

#include <boost/metaparse/foldr1.hpp>
#include <boost/metaparse/token.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/get_result.hpp>
#include <boost/metaparse/is_error.hpp>

#include <boost/mpl/lambda.hpp>
#include <boost/mpl/plus.hpp>

using namespace boost::metaparse;

using int_token = token<int_>;
using sum_op =
  boost::mpl::lambda<boost::mpl::plus<boost::mpl::_1, boost::mpl::_2>>::type;

using ints = foldr1<int_token, boost::mpl::int_<0>, sum_op>;

static_assert(
  get_result<
    ints::apply<BOOST_METAPARSE_STRING("11 13 3 21"), start>
  >::type::value == 48,
  "ints should sum the numbers"
);

static_assert(
  is_error<ints::apply<BOOST_METAPARSE_STRING(""), start>>::type::value,
  "when no numbers are provided, it should be an error"
);

Synopsis

template <class P, class State, class BackwardOp>
struct foldr_reject_incomplete;

This is a parser combinator.

Table 23.27. Arguments

Name

Type

P

parser

State

template metaprogramming value

BackwardOp

template metafunction class taking two arguments


Description

The same as foldr, but once P rejects the input, foldr_reject_incomplete checks if P consumes any characters before rejecting the input. If so, foldr_reject_incomplete rejects the input with the same error message this last application of P returned. Otherwise foldr_reject_incomplete accepts the input and gives the same result as foldr.

Here is a diagram showing how foldr_reject_incomplete works by example:

using int_token = token<int_>;
using plus_token = token<lit_c<'+'>>;
using plus_int = last_of<plus_token, int_token>;
using sum_op = mpl::lambda<mpl::plus<mpl::_1, mpl::_2>>::type;

Note that foldr_reject_incomplete folds from right to left and therefore does not start folding until it reaches the end of the sequence. Since at the end of the sequence it finds an error, folding does not happen at all.

Header

#include <boost/metaparse/foldr_reject_incomplete.hpp>

Expression semantics

For any p parser, t class, f metafunction class taking two arguments, s compile-time string and pos source position

foldr_reject_incomplete<p, t, f>::apply<s, pos>

is equivalent to

first_of<foldr<p, t, f>, fail_at_first_char_expected<p> >::apply<s, pos>

Example

#include <boost/metaparse/foldr_reject_incomplete.hpp>
#include <boost/metaparse/lit_c.hpp>
#include <boost/metaparse/last_of.hpp>
#include <boost/metaparse/token.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/get_result.hpp>
#include <boost/metaparse/is_error.hpp>

#include <boost/mpl/lambda.hpp>
#include <boost/mpl/plus.hpp>
#include <boost/mpl/int.hpp>

using namespace boost::metaparse;

using int_token = token<int_>;
using plus_token = token<lit_c<'+'>>;
using plus_int = last_of<plus_token, int_token>;
using sum_op =
  boost::mpl::lambda<boost::mpl::plus<boost::mpl::_1, boost::mpl::_2>>::type;

using ints = foldr_reject_incomplete<plus_int, boost::mpl::int_<11>, sum_op>;

static_assert(
  get_result<
    ints::apply<BOOST_METAPARSE_STRING("+ 13 + 3 + 21"), start>
  >::type::value == 48,
  "ints should sum the numbers"
);

static_assert(
  is_error<
    ints::apply<BOOST_METAPARSE_STRING("+ 13 + 3 +"), start>
  >::type::value,
  "when the last number is missing, it should be an error"
);

Synopsis

template <class P, class State, class BackwardOp>
struct foldr_reject_incomplete1;

This is a parser combinator.

Table 23.28. Arguments

Name

Type

P

parser

State

template metaprogramming value

BackwardOp

template metafunction class taking two arguments


Description

The same as foldr1, but once P rejects the input, foldr_reject_incomplete1 checks if P consumes any characters before rejecting the input. If so, foldr_reject_incomplete1 rejects the input with the same error message this last application of P returned. Otherwise foldr_reject_incomplete1 accepts the input and gives the same result as foldr1.

Header

#include <boost/metaparse/foldr_reject_incomplete1.hpp>

Expression semantics

For any p parser, t class, f metafunction class taking two arguments, s compile-time string and pos source position

foldr_reject_incomplete1<p, t, f>::apply<s, pos>

is equivalent to

first_of<foldr1<p, t, f>, fail_at_first_char_expected<p> >::apply<s, pos>

Example

#include <boost/metaparse/foldr_reject_incomplete1.hpp>
#include <boost/metaparse/lit_c.hpp>
#include <boost/metaparse/last_of.hpp>
#include <boost/metaparse/token.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/get_result.hpp>
#include <boost/metaparse/is_error.hpp>

#include <boost/mpl/lambda.hpp>
#include <boost/mpl/plus.hpp>
#include <boost/mpl/int.hpp>

using namespace boost::metaparse;

using int_token = token<int_>;
using plus_token = token<lit_c<'+'>>;
using plus_int = last_of<plus_token, int_token>;
using sum_op =
  boost::mpl::lambda<boost::mpl::plus<boost::mpl::_1, boost::mpl::_2>>::type;

using ints = foldr_reject_incomplete1<plus_int, boost::mpl::int_<11>, sum_op>;

static_assert(
  get_result<
    ints::apply<BOOST_METAPARSE_STRING("+ 13 + 3 + 21"), start>
  >::type::value == 48,
  "ints should sum the numbers"
);

static_assert(
  is_error<
    ints::apply<BOOST_METAPARSE_STRING("+ 13 + 3 +"), start>
  >::type::value,
  "when the last number is missing, it should be an error"
);

static_assert(
  is_error<ints::apply<BOOST_METAPARSE_STRING(""), start>>::type::value,
  "when no numbers are provided, it should be an error"
);

Synopsis

template <class P, class StateP, class BackwardOp>
struct foldr_start_with_parser;

This is a parser combinator.

Table 23.29. Arguments

Name

Type

P

parser

StateP

parser

BackwardOp

template metafunction class taking two arguments


Description

The same as foldr, but after folding it applies a parser, StateP on the input. If StateP fails, foldr_start_with_parser fails. If it succeeds, the result of parsing is equivalent to boost::reverse_fold<Sequence, State, BackwardOp>, where Sequence is the sequence of the results of the applications of P and State is the result StateP returned after the repeated application of P on the input.

Here is a diagram showing how foldr_start_with_parser works by example:

using int_token = token<int_>;
using plus_token = token<lit_c<'+'>>;
using int_plus = first_of<int_token, plus_token>;
using sum_op = mpl::lambda<mpl::plus<mpl::_1, mpl::_2>>::type;

Further details can be found in the Introducing foldr_start_with_parser section of the User Manual.

Header

#include <boost/metaparse/foldr_start_with_parser.hpp>

Expression semantics

For any p parser, pt class, f metafunction class taking two arguments, s compile-time string and pos source position let pos_ be the position where the repeated application of p on s fails for the first time. Let s_ be the postfix of s starting at that position.

foldr_start_with_parser<p, pt, f>::apply<s, pos>

is equivalent to

pt::apply<s_, pos_>

when the above expression returns a parsing error. It is

return_<
  foldr<p, get_result<pt::apply<s_, pos_>>::type, f>::apply<s, pos>
>::apply<
  get_remaining<pt::apply<s_, pos_>>::type,
  get_position<pt::apply<s_, pos_>>::type
>

otherwise.

Example

#include <boost/metaparse/foldr_start_with_parser.hpp>
#include <boost/metaparse/lit_c.hpp>
#include <boost/metaparse/first_of.hpp>
#include <boost/metaparse/token.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/get_result.hpp>
#include <boost/metaparse/is_error.hpp>

#include <boost/mpl/lambda.hpp>
#include <boost/mpl/plus.hpp>

using namespace boost::metaparse;

using int_token = token<int_>;
using plus_token = token<lit_c<'+'>>;
using int_plus = first_of<int_token, plus_token>;
using sum_op =
  boost::mpl::lambda<boost::mpl::plus<boost::mpl::_1, boost::mpl::_2>>::type;

using ints = foldr_start_with_parser<int_plus, int_token, sum_op>;

static_assert(
  get_result<
    ints::apply<BOOST_METAPARSE_STRING("11 + 13 + 3 + 21"), start>
  >::type::value == 48,
  "ints should sum the numbers"
);

static_assert(
  is_error<ints::apply<BOOST_METAPARSE_STRING(""), start>>::type::value,
  "when no numbers are provided, it should be an error"
);

Synopsis

template <class P, class State, class BackwardOp>
struct foldr;

This is a parser combinator.

Table 23.30. Arguments

Name

Type

P

parser

State

template metaprogramming value

BackwardOp

template metafunction class taking two arguments


Description

foldr applies P on the input string repeatedly as long as P accepts the input. The result of parsing is equivalent to boost::reverse_fold<Sequence, State, BackwardOp>, where Sequence is the sequence of the results of the applications of P.

When P rejects the input for the first time, foldr still accepts the input and the result of parsing is State.

Here is a diagram showing how foldr works by example:

using int_token = token<int_>;
using sum_op = mpl::lambda<mpl::plus<mpl::_1, mpl::_2>>::type;

Further details can be found in the Introducing foldr section of the User Manual.

Header

#include <boost/metaparse/foldr.hpp>

Expression semantics

For any p parser, t class, f metafunction class taking two arguments, s compile-time string and pos source position

foldr<p, t, f>::apply<s, pos>

is equivalent to

return_<t>::apply<s, pos>

when p::apply<s, pos> returns an error. It is

f::apply<
  get_result<
    foldr<p, t, f>::apply<
      get_remaining<p::apply<s, pos>>,
      get_position<p::apply<s, pos>>
    >
  >::type,
  get_result<p::apply<s, pos>>::type
>

otherwise.

Example

#include <boost/metaparse/foldr.hpp>
#include <boost/metaparse/token.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/get_result.hpp>

#include <boost/mpl/lambda.hpp>
#include <boost/mpl/plus.hpp>

using namespace boost::metaparse;

using int_token = token<int_>;
using sum_op =
  boost::mpl::lambda<boost::mpl::plus<boost::mpl::_1, boost::mpl::_2>>::type;

using ints = foldr<int_token, boost::mpl::int_<0>, sum_op>;

static_assert(
  get_result<
    ints::apply<BOOST_METAPARSE_STRING("11 13 3 21"), start>
  >::type::value == 48,
  "ints should sum the numbers"
);

static_assert(
  get_result<
    ints::apply<BOOST_METAPARSE_STRING(""), start>
  >::type::value == 0,
  "the sum of no elements is 0"
);

Synopsis

template <class SourcePosition>
struct get_col;

This is a lazy template metafunction.

Table 23.31. Arguments

Name

Type

SourcePosition

source position


Description

Returns the column of a source position.

Header

#include <boost/metaparse/get_col.hpp>

Expression semantics

For any l, c compile-time wrapped integral values and ch compile-time wrapped character the following are equivalent

get_col<source_position<l, c, ch>>::type

c::type

Example

#include <boost/metaparse/get_col.hpp>
#include <boost/metaparse/source_position.hpp>

#include <type_traits>

using namespace boost::metaparse;

struct returns_source_position
{
  using type =
    source_position<
      std::integral_constant<int, 11>,
      std::integral_constant<int, 13>,
      std::integral_constant<char, 0>
    >;
};

static_assert(
  get_col<
    source_position<
      std::integral_constant<int, 11>,
      std::integral_constant<int, 13>,
      std::integral_constant<char, 0>
    >
  >::type::value == 13,
  "It should return the column of a source position"
);

static_assert(
  get_col<returns_source_position>::type::value == 13,
  "It should support lazy evaluation"
);

Synopsis

template <class SourcePosition>
struct get_line;

This is a lazy template metafunction.

Table 23.32. Arguments

Name

Type

SourcePosition

source position


Description

Returns the line of a source position.

Header

#include <boost/metaparse/get_line.hpp>

Expression semantics

For any l, c compile-time wrapped integral values and ch compile-time wrapped character the following are equivalent

get_line<source_position<l, c, ch>>::type

l::type

Example

#include <boost/metaparse/get_line.hpp>
#include <boost/metaparse/source_position.hpp>

#include <type_traits>

using namespace boost::metaparse;

struct returns_source_position
{
  using type =
    source_position<
      std::integral_constant<int, 11>,
      std::integral_constant<int, 13>,
      std::integral_constant<char, 0>
    >;
};

static_assert(
  get_line<
    source_position<
      std::integral_constant<int, 11>,
      std::integral_constant<int, 13>,
      std::integral_constant<char, 0>
    >
  >::type::value == 11,
  "It should return the line of a source position"
);

static_assert(
  get_line<returns_source_position>::type::value == 11,
  "It should support lazy evaluation"
);

Synopsis

template <class E>
struct get_message;

This is a lazy template metafunction.

Table 23.33. Arguments

Name

Type

E

reject value


Description

Returns the error message of a parsing failure.

Header

#include <boost/metaparse/get_message.hpp>

Example

#include <boost/metaparse/get_message.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/reject.hpp>
#include <boost/metaparse/define_error.hpp>

#include <type_traits>

using namespace boost::metaparse;

BOOST_METAPARSE_DEFINE_ERROR(sample_error, "Sample error message");

struct returns_reject
{
  using type = reject<sample_error, start>;
};

static_assert(
  std::is_same<
    sample_error,
    get_message<reject<sample_error, start>>::type
  >::type::value,
  "It should return the message"
);

static_assert(
  std::is_same<sample_error, get_message<returns_reject>::type>::type::value,
  "It should support lazy evaluation"
);

Synopsis

template <class D>
struct get_position;

This is a lazy template metafunction.

Table 23.34. Arguments

Name

Type

D

accept or reject value


Description

Returns the source position information of a parsing result.

Header

#include <boost/metaparse/get_position.hpp>

Example

#include <boost/metaparse/get_position.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/accept.hpp>
#include <boost/metaparse/reject.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/define_error.hpp>

#include <type_traits>

using namespace boost::metaparse;

BOOST_METAPARSE_DEFINE_ERROR(sample_error, "Sample error message");

struct returns_reject
{
  using type = reject<sample_error, start>;
};

static_assert(
  std::is_same<
    start,
    get_position<reject<sample_error, start>>::type
  >::type::value,
  "It should return the position of a reject"
);

static_assert(
  std::is_same<
    start,
    get_position<
      accept<sample_error, BOOST_METAPARSE_STRING("foo"), start>
    >::type
  >::type::value,
  "It should return the position of an accept"
);

static_assert(
  std::is_same<start, get_position<returns_reject>::type>::type::value,
  "It should support lazy evaluation"
);

Synopsis

template <class SourcePosition>
struct get_prev_char;

This is a lazy template metafunction.

Table 23.35. Arguments

Name

Type

SourcePosition

source position


Description

Returns the last character the source position was updated with. The value it returns for start is unspecified.

Header

#include <boost/metaparse/get_prev_char.hpp>

Expression semantics

For any l, c compile-time wrapped integral values and ch compile-time wrapped character the following are equivalent

get_prev_char<source_position<l, c, ch>>::type

ch::type

Example

#include <boost/metaparse/get_prev_char.hpp>
#include <boost/metaparse/source_position.hpp>

#include <type_traits>

using namespace boost::metaparse;

struct returns_source_position
{
  using type =
    source_position<
      std::integral_constant<int, 11>,
      std::integral_constant<int, 13>,
      std::integral_constant<char, 'x'>
    >;
};

static_assert(
  get_prev_char<
    source_position<
      std::integral_constant<int, 11>,
      std::integral_constant<int, 13>,
      std::integral_constant<char, 'x'>
    >
  >::type::value == 'x',
  "It should return the prev. char of a source position"
);

static_assert(
  get_prev_char<returns_source_position>::type::value == 'x',
  "It should support lazy evaluation"
);

Synopsis

template <class D>
struct get_remaining;

This is a lazy template metafunction.

Table 23.36. Arguments

Name

Type

D

accept value


Description

Returns the remaining string information of a parsing result.

Header

#include <boost/metaparse/get_remaining.hpp>

Example

#include <boost/metaparse/get_remaining.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/accept.hpp>
#include <boost/metaparse/string.hpp>

#include <type_traits>

using namespace boost::metaparse;

struct returns_accept
{
  using type =
    accept<
      std::integral_constant<int, 13>,
      BOOST_METAPARSE_STRING("foo"),
      start
    >;
};

static_assert(
  std::is_same<
    BOOST_METAPARSE_STRING("foo"),
    get_remaining<
      accept<
        std::integral_constant<int, 13>,
        BOOST_METAPARSE_STRING("foo"),
        start
      >
    >::type
  >::type::value,
  "It should return the remaining input"
);

static_assert(
  std::is_same<
    BOOST_METAPARSE_STRING("foo"),
    get_remaining<returns_accept>::type
  >::type::value,
  "It should support lazy evaluation"
);

Synopsis

template <class D>
struct get_result;

This is a lazy template metafunction.

Table 23.37. Arguments

Name

Type

D

accept value


Description

Returns the result information of a parsing result.

Header

#include <boost/metaparse/get_result.hpp>

Example

#include <boost/metaparse/get_result.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/accept.hpp>
#include <boost/metaparse/string.hpp>

using namespace boost::metaparse;

struct returns_accept
{
  using type =
    accept<
      std::integral_constant<int, 13>,
      BOOST_METAPARSE_STRING("foo"),
      start
    >;
};

static_assert(
  get_result<
    accept<
      std::integral_constant<int, 13>,
      BOOST_METAPARSE_STRING("foo"),
      start
    >
  >::type::value == 13,
  "It should return the result of parsing"
);

static_assert(
  get_result<returns_accept>::type::value == 13,
  "It should support lazy evaluation"
);

Synopsis

template <class StartSymbol = BOOST_METAPARSE_STRING("S")>
struct grammar
{
  template <class S, class Pos>
  struct apply;

  template <class Name, class P>
  struct import;

  template <class S, class Action = /* unspecified */>
  struct rule;
};

Description

[Note] Note

Note that using this adds a significant overhead to your builds. When someone uses your parser, the compiler will have to build your grammar parser, use it to parse your grammar and build your parser and then it can parse the input the user would like to parse with your parser. You might consider using the parser combinators the library provides.

Parser combinator for constructing parsers based on an embedded DSL similar to EBNF. It can be used the following way:

grammar<>
  // definitions

where a definition can be a rule or an import command.

Rules look like on of the following:

::rule<BOOST_METAPARSE_STRING("name ::= def")>
::rule<BOOST_METAPARSE_STRING("name ::= def"), semantic_action>

name consists of letters, digits and the _ character. It is the name of the symbol being defined. def describes the rule. It can be

  • the name of a symbol
  • a terminal, which is a character between single quotes. \ can be used for escaping. The following are accepted: \n, \r, \t, \\, \'
  • a sequence of definitions
  • a definition followed by the * character, which means repetition accepting 0 match
  • a definition followed by the + character, which means repetition expecting at least one match
  • a definition in brackets

Rules take an optional semantic_action argument. It is a placeholder expression taking one argument. When this is given, this is used to transform the result of the rule.

Imports can be used to turn an arbitrary parser into a symbol available for the rules. Import definitions look like the following:

::import<BOOST_METAPARSE_STRING("name"), parser>

name is the name of the symbol, parser is the parser to bind the name to.

The start symbol of the grammar is specified by the template argument of the grammar template. This is optional, the default value is S.

Note that the current implementation "inlines" the referenced symbols while parsing the grammar and recursion is not supported because of this.

Header

#include <boost/metaparse/grammar.hpp>

Example

#define BOOST_METAPARSE_LIMIT_STRING_SIZE 64

#include <boost/metaparse/grammar.hpp>
#include <boost/metaparse/token.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/entire_input.hpp>
#include <boost/metaparse/build_parser.hpp>
#include <boost/metaparse/string.hpp>

#include <boost/mpl/front.hpp>
#include <boost/mpl/back.hpp>
#include <boost/mpl/plus.hpp>
#include <boost/mpl/fold.hpp>
#include <boost/mpl/lambda.hpp>

using boost::metaparse::token;
using boost::metaparse::int_;
using boost::metaparse::build_parser;
using boost::metaparse::entire_input;
using boost::metaparse::grammar;

using boost::mpl::front;
using boost::mpl::back;
using boost::mpl::plus;
using boost::mpl::fold;
using boost::mpl::lambda;
using boost::mpl::_1;
using boost::mpl::_2;

template <class A, class B>
struct lazy_plus : boost::mpl::plus<typename A::type, typename B::type> {};

template <class Sequence, class State, class ForwardOp>
struct lazy_fold :
  fold<typename Sequence::type, typename State::type, typename ForwardOp::type>
{};

using plus_action =
  lazy_fold<back<_1>, front<_1>, lambda<lazy_plus<_1, back<_2>>>::type>;

using plus_grammar =
  grammar<BOOST_METAPARSE_STRING("plus_exp")>
    ::import<BOOST_METAPARSE_STRING("int_token"), token<int_>>::type

    ::rule<BOOST_METAPARSE_STRING("ws ::= (' ' | '\n' | '\r' | '\t')*")>::type
    ::rule<BOOST_METAPARSE_STRING("plus_token ::= '+' ws"), front<_1>>::type
    ::rule<BOOST_METAPARSE_STRING("plus_exp ::= int_token (plus_token int_token)*"), plus_action>::type
  ;

using plus_parser = build_parser<entire_input<plus_grammar>>;

static_assert(
  plus_parser::apply<BOOST_METAPARSE_STRING("1 + 2 + 3 + 4")>::type::value == 10,
  "Arithmetic expression should be evaluated"
);

if_

Synopsis

template <class P, class T, class F>
struct if_;

This is a parser combinator.

Table 23.38. Arguments


Description

if_ always accepts the input string. The result of parsing is T, when P accepts the input and F otherwise.

Header

#include <boost/metaparse/if_.hpp>

Expression semantics

For any p parser, t and f classes the following are equivalent:

if_<p, t, f>

one_of<last_of<p, return_<t>>, return_<f>>

Example

#include <boost/metaparse/if_.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/get_result.hpp>

#include <type_traits>

using namespace boost::metaparse;

using int11 = std::integral_constant<int, 11>;
using int13 = std::integral_constant<int, 13>;

static_assert(
  get_result<
    if_<int_, int11, int13>::apply<BOOST_METAPARSE_STRING("1234"), start>
  >::type::value == 11,
  "When the int_ parser succeeds, the result of parsing should be 11"
);

static_assert(
  get_result<
    if_<int_, int11, int13>::apply<BOOST_METAPARSE_STRING("foo"), start>
  >::type::value == 13,
  "When the int_ parser fails, the result of parsing should be 13"
);

Synopsis

namespace error
{
  template <int From, int To, int N>
  struct index_out_of_range;
}

This is a parsing error message.

Table 23.39. Arguments

Name

Type

From

int value. The lower bound of the range.

To

int value. The upper bound of the range.

N

int value. The value outside of the range.


Description

Template class representing an over or under indexing error. From and To represent the range and N is the value outside of the range.

Header

#include <boost/metaparse/error/index_out_of_range.hpp>

Synopsis

namespace util
{
  template <class T, T LowerBound, T UpperBound>
  struct in_range_c
  {
    template <class U>
    struct apply;
  };
}

This is a template metafunction class.

Table 23.40. Arguments

Name

Type

T

integral type

LowerBound

value of type T

UpperBound

value of type T

U

boxed integral value


Description

Metafunction class verifying that U is in the [LowerBound..UpperBound] range or not.

Header

#include <boost/metaparse/util/in_range_c.hpp>

Expression semantics

For any T integral type, A, B values of type T and C wrapped value the following are equivalent:

in_range_c<T, A, B>::apply<C>::type::value

A <= C::type::value && C::type::value <= B

Example

#include <boost/metaparse/util/in_range_c.hpp>

#include <type_traits>

using namespace boost::metaparse;

static_assert(
  !util::in_range_c<int, 11, 13>
    ::apply<std::integral_constant<int, 10>>::type::value,
  "A value below the lower bound should not be in the range"
);

static_assert(
  !util::in_range_c<int, 11, 13>
    ::apply<std::integral_constant<int, 14>>::type::value,
  "A value above the upper bound should not be in the range"
);

static_assert(
  util::in_range_c<int, 11, 13>
    ::apply<std::integral_constant<int, 11>>::type::value,
  "The lower bound should be in the range"
);

static_assert(
  util::in_range_c<int, 11, 13>
    ::apply<std::integral_constant<int, 13>>::type::value,
  "The upper bound should be in the range"
);

static_assert(
  util::in_range_c<int, 11, 13>
    ::apply<std::integral_constant<int, 12>>::type::value,
  "A value between the bounds should be in the range"
);

Synopsis

namespace util
{
  template <class LowerBound, class UpperBound, class Item>
  struct in_range;
}

This is a template metafunction supporting currying.

Table 23.41. Arguments

Name

Type

LowerBound

boxed integral value

UpperBound

boxed integral value

Item

boxed integral value


Description

It returns a boxed boolean value. The value is true when Item is in the range [LowerBound..UpperBound] and false otherwise. boost::mpl::less_equal is used for comparison.

Header

#include <boost/metaparse/util/in_range.hpp>

Expression semantics

For any L, U and T classes the following are equivalent:

in_range<L, U>::apply<T>::type::value

boost::mpl::less_equal<L, T>::type::value
  && boost::mpl::less_equal<T, U>::type::value

Example

#include <boost/metaparse/util/in_range.hpp>

#include <boost/mpl/int.hpp>

using namespace boost::metaparse;

static_assert(
  !util::in_range<
    boost::mpl::int_<11>,
    boost::mpl::int_<13>,
    boost::mpl::int_<10>
  >::type::value,
  "A value below the lower bound should not be in the range"
);

static_assert(
  !util::in_range<
    boost::mpl::int_<11>,
    boost::mpl::int_<13>,
    boost::mpl::int_<14>
  >::type::value,
  "A value above the upper bound should not be in the range"
);

static_assert(
  util::in_range<
    boost::mpl::int_<11>,
    boost::mpl::int_<13>,
    boost::mpl::int_<11>
  >::type::value,
  "The lower bound should be in the range"
);

static_assert(
  util::in_range<
    boost::mpl::int_<11>,
    boost::mpl::int_<13>,
    boost::mpl::int_<13>
  >::type::value,
  "The upper bound should be in the range"
);

static_assert(
  util::in_range<
    boost::mpl::int_<11>,
    boost::mpl::int_<13>,
    boost::mpl::int_<12>
  >::type::value,
  "A value between the bounds should be in the range"
);

static_assert(
  util::in_range<>
    ::apply<boost::mpl::int_<11>>::type
    ::apply<boost::mpl::int_<13>>::type
    ::apply<boost::mpl::int_<12>>::type
    ::type::value,
  "It should support currying"
);

Synopsis

struct int_;

This is a parser.

Description

It accepts a non-empty sequence of characters in the range 0-9. The result of the parser is the decimal value represented by the accepted character sequence.

Header

#include <boost/metaparse/int_.hpp>

Expression semantics

The following are equivalent:

int_

foldl1<
  digit_val,
  boost::mpl::int_<0>,
  boost::mpl::lambda<
    boost::mpl::plus<
      boost::mpl::times<boost::mpl::_2, boost::mpl::int_<10>>,
      boost::mpl::_1
    >
  >::type
>

Example

#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/get_result.hpp>

using namespace boost::metaparse;

static_assert(
  get_result<
    int_::apply<BOOST_METAPARSE_STRING("13"), start>
  >::type::value == 13,
  "It should parse an integer value"
);

static_assert(
  is_error<int_::apply<BOOST_METAPARSE_STRING("six"), start>>::type::value,
  "It should reject the input if it is not a number"
);

Synopsis

namespace util
{
  template <int C>
  struct int_to_digit_c;
}

This is a template class similar to a template metafunction but taking an int value as argument.

Table 23.42. Arguments

Name

Type

C

int value in the range [0-9]


Description

Converts an integer value in the range [0-9] to a character representing that decimal value.

Header

#include <boost/metaparse/util/int_to_digit_c.hpp>

Expression semantics

The following pairs of expressions are equivalent

int_to_digit_c<0>::type
boost::mpl::char_<'0'>

int_to_digit<9>::type
boost::mpl::char_<'9'>

Example

#include <boost/metaparse/util/int_to_digit_c.hpp>

using namespace boost::metaparse;

static_assert(
  util::int_to_digit_c<0>::type::value == '0',
  "it should convert an integer value to the corresponding character"
);

static_assert(
  util::int_to_digit_c<3>::type::value == '3',
  "it should convert an integer to the corresponding character"
);

static_assert(
  util::int_to_digit_c<9>::type::value == '9',
  "it should convert an integer value to the corresponding character"
);

Synopsis

namespace util
{
  template <class D>
  struct int_to_digit;
}

This is a lazy template metafunction that supports currying.

Table 23.43. Arguments

Name

Type

D

boxed integer value


Description

Converts a boxed integer value in the range [0-9] to a character representing that decimal value.

Header

#include <boost/metaparse/util/int_to_digit.hpp>

Expression semantics

The following pairs of expressions are equivalent

int_to_digit<boost::mpl::int_<0>>::type
boost::mpl::char_<'0'>

int_to_digit<boost::mpl::int_<9>>::type
boost::mpl::char_<'9'>

Example

#include <boost/metaparse/util/int_to_digit.hpp>

#include <type_traits>

using namespace boost::metaparse;

struct nullary_metafunction_returning_4
{
  using type = std::integral_constant<int, 4>;
};

static_assert(
  util::int_to_digit<std::integral_constant<int, 0>>::type::value == '0',
  "it should convert an integer value to the corresponding character"
);

static_assert(
  util::int_to_digit<>::type
    ::apply<std::integral_constant<int, 7>>::type::value == '7',
  "it should support currying"
);

static_assert(
  util::int_to_digit<nullary_metafunction_returning_4>::type::value == '4',
  "it should support lazy evaluation"
);

Synopsis

namespace util
{
  template <class C>
  struct is_digit;
}

This is a lazy template metafunction that supports currying.

Table 23.44. Arguments

Name

Type

C

boxed character value


Description

Checks if C is a digit value or not. Returns a boxed boolean value.

Header

#include <boost/metaparse/util/is_digit.hpp>

Expression semantics

The following expressions are equivalent:

is_digit<boost::mpl::char_<'0'>>::type
is_digit<>::apply<boost::mpl::char_<'0'>>::type
boost::mpl::true_

The following expressions are also equivalent:

is_digit<>::apply<c>::type
boost::mpl::false_

Example

#include <boost/metaparse/util/is_digit.hpp>

#include <type_traits>

using namespace boost::metaparse;

struct returns_char
{
  using type = std::integral_constant<char, '0'>;
};

static_assert(
  util::is_digit<std::integral_constant<char, '0'>>::type::value,
  "digit character should be a digit"
);

static_assert(
  !util::is_digit<std::integral_constant<char, 'x'>>::type::value,
  "letter should not be a digit"
);

static_assert(
  util::is_digit<>::type::apply<std::integral_constant<char, '0'>>::type::value,
  "it should support currying"
);

static_assert(
  util::is_digit<returns_char>::type::value,
  "it should support lazy evaluation"
);

Synopsis

template <class C>
struct is_error;

This is a lazy template metafunction that supports currying.

Table 23.45. Arguments

Name

Type

C

accept or reject value


Description

Determines if C is a parsing error or not. Returns a boxed boolean value.

Header

#include <boost/metaparse/is_error.hpp>

Expression semantics

For any e parsing error is_error<c>::type is a wrapped compile-time true value, for any other c class is_error<c>::type is a wrapped compile-time false value.

Example

#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/accept.hpp>
#include <boost/metaparse/reject.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/define_error.hpp>

#include <type_traits>

using namespace boost::metaparse;

BOOST_METAPARSE_DEFINE_ERROR(sample_error, "Sample error message");

struct returns_reject
{
  typedef reject<sample_error, start> type;
};

static_assert(
  !is_error<
    accept<
      std::integral_constant<int, 13>,
      BOOST_METAPARSE_STRING("foo"),
      start
    >
  >::type::value,
  "an accept should not be an error"
);

static_assert(
  is_error<reject<sample_error, start>>::type::value,
  "an reject should be an error"
);

static_assert(
  is_error<>::type::apply<reject<sample_error, start>>::type::value,
  "it should support currying"
);

static_assert(
  is_error<returns_reject>::type::value,
  "it should support lazy evaluation"
);

Synopsis

namespace util
{
  template <class C>
  struct is_lcase_letter;
}

This is a lazy template metafunction that supports currying.

Table 23.46. Arguments

Name

Type

C

boxed character value


Description

Checks if C is a lower case letter. Returns a boxed boolean value.

Header

#include <boost/metaparse/util/is_lcase_letter.hpp>

Expression semantics

The following expressions are equivalent:

is_lcase_letter<>::apply<boost::mpl::char_<'a'>>::type
boost::mpl::true_

is_lcase_letter<>::apply<boost::mpl::char_<'z'>>::type
boost::mpl::true_

is_lcase_letter<>::apply<c>::type
boost::mpl::false_

Example

#include <boost/metaparse/util/is_lcase_letter.hpp>

#include <type_traits>

using namespace boost::metaparse;

struct returns_char
{
  using type = std::integral_constant<char, 'a'>;
};

static_assert(
  util::is_lcase_letter<std::integral_constant<char, 'a'>>::type::value,
  "a should be a lower case letter"
);

static_assert(
  !util::is_lcase_letter<std::integral_constant<char, 'A'>>::type::value,
  "A should not be a lower case letter"
);

static_assert(
  util::is_lcase_letter<>::type
    ::apply<std::integral_constant<char, 'a'>>::type::value,
  "it should support currying"
);

static_assert(
  util::is_lcase_letter<returns_char>::type::value,
  "it should support lazy evaluation"
);

Synopsis

namespace util
{
  template <class C>
  struct is_letter;
}

This is a lazy template metafunction that supports currying.

Table 23.47. Arguments

Name

Type

C

boxed character value


Description

Checks if C is a letter. Returns a boxed boolean value.

Header

#include <boost/metaparse/util/is_letter.hpp>

Expression semantics

The following expressions are equivalent:

is_letter<>::apply<boost::mpl::char_<'a'>>::type
boost::mpl::true_

is_letter<>::apply<boost::mpl::char_<'z'>>::type
boost::mpl::true_

is_letter<>::apply<boost::mpl::char_<'A'>>::type
boost::mpl::true_

is_letter<>::apply<boost::mpl::char_<'Z'>>::type
boost::mpl::true_

is_letter<>::apply<c>::type
boost::mpl::false_

Example

#include <boost/metaparse/util/is_letter.hpp>

#include <type_traits>

using namespace boost::metaparse;

struct returns_char
{
  using type = std::integral_constant<char, 'A'>;
};

static_assert(
  util::is_letter<std::integral_constant<char, 'A'>>::type::value,
  "A should be a letter"
);

static_assert(
  !util::is_letter<std::integral_constant<char, '0'>>::type::value,
  "a number should not be a letter"
);

static_assert(
  util::is_letter<>::type
    ::apply<std::integral_constant<char, 'A'>>::type::value,
  "it should support currying"
);

static_assert(
  util::is_letter<returns_char>::type::value,
  "it should support lazy evaluation"
);

Synopsis

namespace util
{
  template <class C>
  struct is_ucase_letter;
}

This is a lazy template metafunction that supports currying.

Table 23.48. Arguments

Name

Type

C

boxed character value


Description

Checks if C is an upper case letter. Returns a boxed boolean value.

Header

#include <boost/metaparse/util/is_ucase_letter.hpp>

Expression semantics

The following expressions are equivalent:

is_ucase_letter<>::apply<boost::mpl::char_<'A'>>::type
boost::mpl::true_

is_ucase_letter<>::apply<boost::mpl::char_<'Z'>>::type
boost::mpl::true_

is_ucase_letter<>::apply<c>::type
boost::mpl::false_

Example

#include <boost/metaparse/util/is_ucase_letter.hpp>

#include <type_traits>

using namespace boost::metaparse;

struct returns_char
{
  using type = std::integral_constant<char, 'A'>;
};

static_assert(
  util::is_ucase_letter<std::integral_constant<char, 'A'>>::type::value,
  "A should be an upper case letter"
);

static_assert(
  !util::is_ucase_letter<std::integral_constant<char, 'a'>>::type::value,
  "a should not be an upper case letter"
);

static_assert(
  util::is_ucase_letter<>::type
    ::apply<std::integral_constant<char, 'A'>>::type::value,
  "it should support currying"
);

static_assert(
  util::is_ucase_letter<returns_char>::type::value,
  "it should support lazy evaluation"
);

Synopsis

namespace util
{
  template <char C>
  struct is_whitespace_c;
}

This is a template class similar to a template metafunction but taking a char value as argument.

Table 23.49. Arguments

Name

Type

D

char value


Description

Checks if C is a whitespace character. Returns a boxed boolean value.

Header

#include <boost/metaparse/util/is_whitespace_c.hpp>

Expression semantics

The following expressions are equivalent:

is_whitespace_c<' '>::type
boost::mpl::true_

is_whitespace_c<'\t'>::type
boost::mpl::true_

is_whitespace_c<'\r'>::type
boost::mpl::true_

is_whitespace_c<'\n'>::type
boost::mpl::true_

For any c character other than the above listed ones the following are equivalent:

is_whitespace_c<c>::type
boost::mpl::false_

Example

#include <boost/metaparse/util/is_whitespace_c.hpp>

#include <type_traits>

using namespace boost::metaparse;

static_assert(
  util::is_whitespace_c<' '>::type::value,
  "a space should be a whitespace character"
);

static_assert(
  !util::is_whitespace_c<'0'>::type::value,
  "a number should not be a whitespace character"
);

Synopsis

namespace util
{
  template <class C>
  struct is_whitespace;
}

This is a lazy template metafunction that supports currying.

Table 23.50. Arguments

Name

Type

C

boxed character value


Description

Checks if C is a whitespace character. Returns a boxed boolean value.

Header

#include <boost/metaparse/util/is_whitespace.hpp>

Expression semantics

For any C nullary template metafunction returning a wrapped character value the following are equivalent:

is_whitespace<C>::type
is_whitespace<>::type::apply<C>::type
is_whitespace_c<C::type::value>::type

Example

#include <boost/metaparse/util/is_whitespace.hpp>

#include <type_traits>

using namespace boost::metaparse;

struct returns_char
{
  using type = std::integral_constant<char, ' '>;
};

static_assert(
  util::is_whitespace<std::integral_constant<char, ' '>>::type::value,
  "a space should be a whitespace character"
);

static_assert(
  !util::is_whitespace<std::integral_constant<char, '0'>>::type::value,
  "a number should not be a whitespace character"
);

static_assert(
  util::is_whitespace<>::type
    ::apply<std::integral_constant<char, '\t'>>::type::value,
  "it should support currying"
);

static_assert(
  util::is_whitespace<returns_char>::type::value,
  "it should support lazy evaluation"
);

Synopsis

template <class P, int N>
struct iterate_c;

This is a parser combinator.

Table 23.51. Arguments

Name

Type

P

parser

N

non-negative integer value


Description

It applies P on the input string N times. The result of parsing is a sequence of the results of the individual applications of P. P has to accept the input N times for iterate_c to accept it.

Header

#include <boost/metaparse/iterate_c.hpp>

Expression semantics

For any p parser, n integer value the following are equivalent:

iterate_c<p, n>

sequence<
  p, // 1.
  p, // 2.
  // ...
  p  // n.
>

Example

#include <boost/metaparse/iterate_c.hpp>
#include <boost/metaparse/digit.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/get_result.hpp>
#include <boost/metaparse/is_error.hpp>

#include <boost/mpl/vector.hpp>
#include <boost/mpl/equal.hpp>
#include <boost/mpl/char.hpp>

using namespace boost::metaparse;

static_assert(
  boost::mpl::equal<
    boost::mpl::vector<
      boost::mpl::char_<'1'>,
      boost::mpl::char_<'2'>,
      boost::mpl::char_<'3'>
    >,
    get_result<
      iterate_c<digit, 3>::apply<BOOST_METAPARSE_STRING("123"), start>
    >::type
  >::type::value,
  "the result should be the sequence of the individual applications of digit"
);

static_assert(
  boost::mpl::equal<
    boost::mpl::vector<
      boost::mpl::char_<'1'>,
      boost::mpl::char_<'2'>,
      boost::mpl::char_<'3'>
    >,
    get_result<
      iterate_c<digit, 3>::apply<BOOST_METAPARSE_STRING("1234"), start>
    >::type
  >::type::value,
  "only three iterations should be made"
);

static_assert(
  is_error<
    iterate_c<digit, 3>::apply<BOOST_METAPARSE_STRING("12"), start>
  >::type::value,
  "it should fail when digit can not be applied three times"
);

Synopsis

template <class P, class N>
struct iterate;

This is a parser combinator.

Table 23.52. Arguments

Name

Type

P

parser

N

boxed non-negative integer value


Description

It applies P on the input string N times. The result of parsing is a sequence of the results of the individual applications of P. P has to accept the input N times for iterate to accept it.

Header

#include <boost/metaparse/iterate.hpp>

Expression semantics

For any p parser, n wrapped integer the following are equivalent:

iterate<p, n>

iterate_c<p, n::type::value>

Example

#include <boost/metaparse/iterate.hpp>
#include <boost/metaparse/digit.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/get_result.hpp>
#include <boost/metaparse/is_error.hpp>

#include <boost/mpl/vector.hpp>
#include <boost/mpl/equal.hpp>
#include <boost/mpl/char.hpp>

#include <type_traits>

using namespace boost::metaparse;

static_assert(
  boost::mpl::equal<
    boost::mpl::vector<
      boost::mpl::char_<'1'>,
      boost::mpl::char_<'2'>,
      boost::mpl::char_<'3'>
    >,
    get_result<
      iterate<digit, std::integral_constant<int, 3>>::apply<
        BOOST_METAPARSE_STRING("123"),
        start
      >
    >::type
  >::type::value,
  "the result should be the sequence of the individual applications of digit"
);

static_assert(
  boost::mpl::equal<
    boost::mpl::vector<
      boost::mpl::char_<'1'>,
      boost::mpl::char_<'2'>,
      boost::mpl::char_<'3'>
    >,
    get_result<
      iterate<digit, std::integral_constant<int, 3>>::apply<
        BOOST_METAPARSE_STRING("1234"),
        start
      >
    >::type
  >::type::value,
  "only three iterations should be made"
);

static_assert(
  is_error<
    iterate<digit, std::integral_constant<int, 3>>::apply<
      BOOST_METAPARSE_STRING("12"),
      start
    >
  >::type::value,
  "it should fail when digit can not be applied three times"
);

Synopsis

template <class S, class ResultType = /* unspecified */>
struct keyword;

This is a parser.

Table 23.53. Arguments

Name

Type

S

string

ResultType

template metaprogramming value


Description

Parser accepting the keyword S. The result of parsing is ResultType, which is optional; when not given, the result of successful parsing is undefined.

Header

#include <boost/metaparse/keyword.hpp>

Expression semantics

For any r class and s compile-time string that is built from the characters c1 ... cn the following are equivalent:

keyword<s, r>

last_of<lit<c1>, /* ... */, lit<cn>, return_<r>>

Example

#include <boost/metaparse/keyword.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/get_result.hpp>
#include <boost/metaparse/is_error.hpp>

#include <type_traits>

using namespace boost::metaparse;

static_assert(
  get_result<
    keyword<BOOST_METAPARSE_STRING("for"), std::integral_constant<int, 13>>
      ::apply<BOOST_METAPARSE_STRING("for"), start>
  >::type::value == 13,
  "the result of parsing the keyword is keyword's second argument"
);

static_assert(
  is_error<
    keyword<BOOST_METAPARSE_STRING("for"), std::integral_constant<int, 13>>
      ::apply<BOOST_METAPARSE_STRING("if"), start>
  >::type::value,
  "a word other than the keyword is an error"
);

Synopsis

template <class... Ps>
struct last_of;

This is a parser combinator.

Table 23.54. Arguments

Name

Type

Ps...

parsers


Description

last_of applies the Ps... parsers in sequence. It accepts an input when all parsers accept it. The result of parsing is the result of the last parser.

On compilers, which are not C++11-compliant, the maximum number of parsers last_of accepts can be specified with the BOOST_METAPARSE_LIMIT_SEQUENCE_SIZE macro. Its default value is 5.

Header

#include <boost/metaparse/last_of.hpp>

Expression semantics

For any p1, ... pn parsers

first_of<p1, ..., pn>

is equivalent to

nth_of_c<n, p1, ..., pn>

Example

#include <boost/metaparse/last_of.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/lit_c.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/get_result.hpp>

#include <type_traits>

using namespace boost::metaparse;

using comma_int = last_of<lit_c<','>, int_>;

static_assert(
  is_error<comma_int::apply<BOOST_METAPARSE_STRING("13"), start>>::type::value,
  "int without comma is rejected"
);

static_assert(
  get_result<
    comma_int::apply<BOOST_METAPARSE_STRING(",13"), start>
  >::type::value,
  "the result is the result of the last parser"
);

A lazy template metafunction is a template metafunction that accepts nullary metafunctions as arguments, that need to be evaluated first to get the value of the argument.

For example here is a plus metafunction for int values:

template <class A, class B>
struct plus :
  std::integral_constant<int, A::value + B::value>
{};

This metafunction takes two boxed numbers as arguments, unboxes them, adds their values and boxed the result again.

It works when it is called with boxed numbers. For example:

static_assert(
  plus<
    std::intgeral_constant<int, 2>,
    std::integral_constant<int, 2>
  >::type::value == 4,
  "This should work"
);

However, when it is called with a nullary metafunction returning the boxed value, it breaks:

struct nullary_metafunction_returning_2
{
  using type = std::integral_constant<int, 2>;
};

// Fails to compile
plus<nullary_metafunction_returning_2, nullary_metafunction_returning_2>::type

So plus is not a lazy template metafunction. To make it lazy, it has to evaluate its arguments before using them:

template <class A, class B>
struct lazy_plus :
  std::integral_constant<int, A::type::value + B::type::value>
{};

Note that it uses A::type::value and B::type::value instead of A::value and B::value. It works when it is called with nullary metafunctions as well:

static_assert(
  plus<
    nullary_metafunction_returning_2,
    nullary_metafunction_returning_2
  >::type::value == 4,
  "This should work"
);

Because it works with nullary metafunctions as arguments, it is a lazy template metafunction.

Synopsis

namespace error
{
  struct letter_expected;
}

This is a parsing error message.

Description

Class representing the error that a letter character was expected at a specific location.

Header

#include <boost/metaparse/error/letter_expected.hpp>

Synopsis

struct letter;

This is a parser.

Description

Parser accepting one character in the range a-z or A-Z. The result of the parser is the accepted character.

Header

#include <boost/metaparse/letter.hpp>

Expression semantics

The following are equivalent:

letter

accept_when<one_char, util::is_letter<>, error::letter_expected>

Example

#include <boost/metaparse/letter.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/get_result.hpp>

using namespace boost::metaparse;

static_assert(
  !is_error<letter::apply<BOOST_METAPARSE_STRING("a"), start>>::type::value,
  "letter should accept a letter"
);

static_assert(
  is_error<letter::apply<BOOST_METAPARSE_STRING("0"), start>>::type::value,
  "letter should reject a digit"
);

static_assert(
  get_result<
    letter::apply<BOOST_METAPARSE_STRING("z"), start>
  >::type::value == 'z',
  "the result of parsing should be the character value"
);

Synopsis

template <char C>
struct lit;

This is a parser.

Table 23.55. Arguments

Name

Type

C

char value


Description

Parser accepting only the C character. The result of parsing is the accepted character.

Header

#include <boost/metaparse/lit_c.hpp>

Expression semantics

For any c character the following are equivalent:

lit_c<c>

lit<boost::mpl::char_<c>>

Example

#include <boost/metaparse/lit_c.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/get_result.hpp>

using namespace boost::metaparse;

static_assert(
  is_error<lit_c<'x'>::apply<BOOST_METAPARSE_STRING("a"), start>>::type::value,
  "a different character should be an error"
);

static_assert(
  is_error<lit_c<'x'>::apply<BOOST_METAPARSE_STRING(""), start>>::type::value,
  "empty input should be an error"
);

static_assert(
  get_result<
    lit_c<'x'>::apply<BOOST_METAPARSE_STRING("x"), start>
  >::type::value == 'x',
  "result of parsing should be the accepted character"
);

Synopsis

namespace error
{
  template <char C>
  struct literal_expected;
}

This is a parsing error message.

Table 23.56. Arguments

Name

Type

C

char value


Description

Template class representing the error that a specific literal was expected. C is the literal that was expected but not found.

Header

#include <boost/metaparse/error/literal_expected.hpp>

lit

Synopsis

template <class C>
struct lit;

This is a parser.

Table 23.57. Arguments

Name

Type

C

boxed character value


Description

Parser accepting only the C character. The result of parsing is the accepted character.

Header

#include <boost/metaparse/lit.hpp>

Expression semantics

For any c boxed character the following are equivalent:

lit<c>

accept_when<
  one_char,
  boost::mpl::lambda<boost::mpl::equal_to<boost::mpl::_1, c>>::type,
  error::literal_expected<c::type::value>
>

Example

#include <boost/metaparse/lit.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/get_result.hpp>

#include <type_traits>

using namespace boost::metaparse;

static_assert(
  is_error<
    lit<std::integral_constant<char, 'x'>>
      ::apply<BOOST_METAPARSE_STRING("a"), start>
  >::type::value,
  "a different character should be an error"
);

static_assert(
  is_error<
    lit<std::integral_constant<char, 'x'>>
      ::apply<BOOST_METAPARSE_STRING(""), start>
  >::type::value,
  "empty input should be an error"
);

static_assert(
  get_result<
    lit<std::integral_constant<char, 'x'>>
      ::apply<BOOST_METAPARSE_STRING("x"), start>
  >::type::value == 'x',
  "result of parsing should be the accepted character"
);

Synopsis

template <class P>
struct look_ahead;

This is a parser combinator.

Table 23.58. Arguments

Name

Type

P

parser


Description

Parses the input using parser P. When P returns an error, look_ahead returns the error. When P returns a result, look_ahead returns the result without consuming anything from the input string.

Header

#include <boost/metaparse/look_ahead.hpp>

Expression semantics

For any p parser, s compile-time string and pos source position

look_ahead<p>::apply<s, pos>

is equivalent to

return_<get_result<p::apply<s, pos>>::type>::apply<s, pos>

when p::apply<s, pos> succeeds. It is

p::apply<s, pos>

otherwise.

Example

#include <boost/metaparse/look_ahead.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/get_result.hpp>
#include <boost/metaparse/get_remaining.hpp>

#include <type_traits>

using namespace boost::metaparse;

static_assert(
  get_result<
    look_ahead<int_>::apply<BOOST_METAPARSE_STRING("13"), start>
  >::type::value == 13,
  "it should return the same result as the wrapped parser"
);

static_assert(
  std::is_same<
    BOOST_METAPARSE_STRING("13"),
    get_remaining<
      look_ahead<int_>::apply<BOOST_METAPARSE_STRING("13"), start>
    >::type
  >::type::value,
  "it should not consume any input"
);

static_assert(
  is_error<
    look_ahead<int_>::apply<BOOST_METAPARSE_STRING("six"), start>
  >::type::value,
  "it should fail when the wrapped parser fails"
);

A template metafunction class is a type with a public nested template metafunction called apply. Since it is a type, it can be passed to template metafunctions as arguments and metafunctions can return it as their result. This makes it possible to implement higher-order template metafunctions, which are template metafunctions taking template metafunctions as arguments or returning template metafunctions as their result.

For example this is the identity template metafunction class:

struct identity
{
  template <class T>
  struct apply
  {
    using type = T;
  };
  using type = identity;
};

This metafunction class is called identity. It takes one argument, T. The result of calling this metafunction class is its argument, T. Note that the identity metafunction class is also a template metaprogramming value, so it can be an argument or the result of a template metafunction.

To call this metafunction, one has to call the nested template metafunction. For example:

identity::apply<std::integral_constant<int, 13>>::type

The above example calls the metafunction class identity with std::integral_constant<int, 13> as its argument.

A template metafunction represents a function over types that is evaluated at compile-time. It is implemented by a template class.

The template arguments of that class are expected to be types (class or typename template arguments). They represent the arguments of the metafunction.

Instances of the template class are expected to have a public nested type called type. This type is the type the metafunction returns.

Template metafunction are expected to be called with template metaprogramming values as arguments only.

Template metafunctions are expected to return template metaprogramming values.

For example this is the identity template metafunction:

template <class T>
struct identity
{
  using type = T;
};

This metafunction is called identity. It takes one argument, T. The result of calling this metafunction is its argument, T.

To call this metafunction, one has to instantiate the template class. The template arguments it is instantiated with are the arguments the metafunction is called with. For example:

identity<std::integral_constant<int, 13>>::type

The above example calls the metafunction identity with std::integral_constant<int, 13> as its argument.

A template metaprogramming value is a nullary template metafunction returning itself. For example:

struct void_
{
  using type = void_;
};

This template metaprogramming value is called void_. It is a nullary metafunction returning itself as its result. Because of this, it can be treated as a nullary metafunction and evaluated any number of times. For example void_::type::type::type is still void_.

Synopsis

template <class P1, class P2, class P3>
struct middle_of;

This is a parser combinator.

Table 23.59. Arguments

Name

Type

P1

parser

P2

parser

P3

parser


Description

middle_of applies P1, P2 and P3 in sequence. It accepts an input when all of these three parsers accept it. The result of parsing is the result of P2.

Header

#include <boost/metaparse/middle_of.hpp>

Expression semantics

For any p1, p2 and p3 parsers

middle_of<p1, p2, p3>

is equivalent to

nth_of<1, p1, p2, p3>

Example

#include <boost/metaparse/middle_of.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/lit_c.hpp>
#include <boost/metaparse/token.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/get_result.hpp>

using namespace boost::metaparse;

using int_token = token<int_>;
using left_paren_token = token<lit_c<'('>>;
using right_paren_token = token<lit_c<')'>>;

using int_in_parens = middle_of<left_paren_token, int_token, right_paren_token>;

static_assert(
  get_result<
    int_in_parens::apply<BOOST_METAPARSE_STRING("(13)"), start>
  >::type::value == 13,
  "it should return the result of the middle parser"
);

static_assert(
  is_error<
    int_in_parens::apply<BOOST_METAPARSE_STRING("13"), start>
  >::type::value,
  "it should reject the input when there are no parens"
);

static_assert(
  is_error<
    int_in_parens::apply<BOOST_METAPARSE_STRING("(13"), start>
  >::type::value,
  "it should reject the input when there is no closing paren"
);

Synopsis

template <class SourcePosition, class Ch>
struct next_char;

This is a lazy template metafunction.

Table 23.60. Arguments

Name

Type

SourcePosition

source position

Ch

boxed character value. The character SourcePosition points to in the input.


Description

Returns a new source position, pointing to the next character of the same line.

Header

#include <boost/metaparse/next_char.hpp>

Expression semantics

For any s source position and c wrapped character the following are equivalent

get_col<next_char<s, c>>

boost::mpl::plus<get_col<s>::type, boost::mpl::int_<1>>

get_line<next_char<s, c>>

get_line<s>

get_prev_char<next_char<s, c>>::type

c

Example

#include <boost/metaparse/next_char.hpp>
#include <boost/metaparse/source_position.hpp>
#include <boost/metaparse/get_col.hpp>
#include <boost/metaparse/get_line.hpp>
#include <boost/metaparse/get_prev_char.hpp>

#include <type_traits>

using namespace boost::metaparse;

struct returns_source_position
{
  using type =
    source_position<
      std::integral_constant<int, 11>,
      std::integral_constant<int, 13>,
      std::integral_constant<char, 'a'>
    >;
};

struct returns_char
{
  using type = std::integral_constant<char, 'x'>;
};

static_assert(
  get_col<
    next_char<
      source_position<
        std::integral_constant<int, 11>,
        std::integral_constant<int, 13>,
        std::integral_constant<char, 'a'>
      >,
      std::integral_constant<char, 'x'>
    >
  >::type::value == 14,
  "it should increase the column component of the source position"
);

static_assert(
  get_line<
    next_char<
      source_position<
        std::integral_constant<int, 11>,
        std::integral_constant<int, 13>,
        std::integral_constant<char, 'a'>
      >,
      std::integral_constant<char, 'x'>
    >
  >::type::value == 11,
  "it should not increase the line component of the source position"
);

static_assert(
  get_prev_char<
    next_char<
      source_position<
        std::integral_constant<int, 11>,
        std::integral_constant<int, 13>,
        std::integral_constant<char, 'a'>
      >,
      std::integral_constant<char, 'x'>
    >
  >::type::value == 'x',
  "it should update the prev char component of the source position"
);

static_assert(
  get_col<next_char<returns_source_position, returns_char>>::type::value == 14,
  "it should support lazy evaluation"
);

Synopsis

template <class SourcePosition, class Ch>
struct next_line;

This is a lazy template metafunction.

Table 23.61. Arguments

Name

Type

SourcePosition

source position

Ch

boxed character value. The character SourcePosition points to in the input.


Description

Returns a new source position, pointing to the beginning of the next line.

Header

#include <boost/metaparse/next_line.hpp>

Expression semantics

For any s source position and c wrapped character the following are equivalent

get_col<next_line<s, c>>::type

boost::mpl::int_<1>

get_line<next_line<s, c>>

boost::mpl::plus<get_line<s>::type, boost::mpl::int_<1>>

get_prev_char<next_line<s, c>>::type

c

Example

#include <boost/metaparse/next_line.hpp>
#include <boost/metaparse/source_position.hpp>
#include <boost/metaparse/get_col.hpp>
#include <boost/metaparse/get_line.hpp>
#include <boost/metaparse/get_prev_char.hpp>

#include <type_traits>

using namespace boost::metaparse;

struct returns_source_position
{
  using type =
    source_position<
      std::integral_constant<int, 11>,
      std::integral_constant<int, 13>,
      std::integral_constant<char, 'a'>
    >;
};

struct returns_char
{
  using type = std::integral_constant<char, '\n'>;
};

static_assert(
  get_col<
    next_line<
      source_position<
        std::integral_constant<int, 11>,
        std::integral_constant<int, 13>,
        std::integral_constant<char, 'a'>
      >,
      std::integral_constant<char, '\n'>
    >
  >::type::value == 1,
  "it should set the column to 1"
);

static_assert(
  get_line<
    next_line<
      source_position<
        std::integral_constant<int, 11>,
        std::integral_constant<int, 13>,
        std::integral_constant<char, 'a'>
      >,
      std::integral_constant<char, '\n'>
    >
  >::type::value == 12,
  "it should increase the line component of the source position"
);

static_assert(
  get_prev_char<
    next_line<
      source_position<
        std::integral_constant<int, 11>,
        std::integral_constant<int, 13>,
        std::integral_constant<char, 'a'>
      >,
      std::integral_constant<char, '\n'>
    >
  >::type::value == '\n',
  "it should update the prev char component of the source position"
);

static_assert(
  get_col<next_line<returns_source_position, returns_char>>::type::value == 1,
  "it should support lazy evaluation"
);

Synopsis

namespace error
{
  struct none_of_the_expected_cases_found;
}

This is a parsing error message.

Description

Class representing the error that none of a list of parsers could parse the input.

Header

#include <boost/metaparse/error/none_of_the_expected_cases_found.hpp>

Synopsis

template <int N, class... Ps>
struct nth_of_c;

This is a parser combinator.

Table 23.62. Arguments

Name

Type

N

int value in the range [0..sizeof...(Ps)]

Ps

parsers


Description

nth_of_c applies the Ps... parsers in sequence. It accepts an input when all of these parsers accept it. The result of parsing is the result of the N. parser.

On compilers, which are not C++11-compliant, the maximum number of parsers nth_of_c accepts can be specified with the BOOST_METAPARSE_LIMIT_SEQUENCE_SIZE macro. Its default value is 5.

Header

#include <boost/metaparse/nth_of.hpp>

Expression semantics

For any p0, ..., pn parsers and k integer value, where 0 <= k < n the following are equivalent

nth_of_c<k, p0, ..., pn>

transform<sequence<p0, ..., pn>, boost::mpl::at_c<boost::mpl::_1, k>>

Example

#include <boost/metaparse/nth_of_c.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/lit_c.hpp>
#include <boost/metaparse/token.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/get_result.hpp>

using namespace boost::metaparse;

using int_token = token<int_>;
using left_paren_token = token<lit_c<'('>>;
using right_paren_token = token<lit_c<')'>>;

using int_in_parens =
  nth_of_c<1, left_paren_token, int_token, right_paren_token>;

static_assert(
  get_result<
    int_in_parens::apply<BOOST_METAPARSE_STRING("(13)"), start>
  >::type::value == 13,
  "it should return the result of the second parser"
);

static_assert(
  is_error<
    int_in_parens::apply<BOOST_METAPARSE_STRING("13"), start>
  >::type::value,
  "it should reject the input when there are no parens"
);

static_assert(
  is_error<
    int_in_parens::apply<BOOST_METAPARSE_STRING("(13"), start>
  >::type::value,
  "it should reject the input when there is no closing paren"
);

Synopsis

template <class N, class... Ps>
struct nth_of;

This is a parser combinator.

Table 23.63. Arguments

Name

Type

N

boxed integer value in the range [0..sizeof...(Ps)]

Ps

parsers


Description

nth_of applies the Ps... parsers in sequence. It accepts an input when all of these parsers accept it. The result of parsing is the result of the N. parser.

On compilers, which are not C++11-compliant, the maximum number of parsers nth_of accepts can be specified with the BOOST_METAPARSE_LIMIT_SEQUENCE_SIZE macro. Its default value is 5.

Header

#include <boost/metaparse/nth_of.hpp>

Expression semantics

For any p0, ..., pn parsers and k boxed integer value the following are equivalent

nth_of<k, p0, ..., pn>

nth_of_c<k::type::value, p0, ..., pn>

Example

#include <boost/metaparse/nth_of.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/lit_c.hpp>
#include <boost/metaparse/token.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/get_result.hpp>

#include <type_traits>

using namespace boost::metaparse;

using int_token = token<int_>;
using left_paren_token = token<lit_c<'('>>;
using right_paren_token = token<lit_c<')'>>;

using int_in_parens =
  nth_of<
    std::integral_constant<int, 1>,
    left_paren_token, int_token, right_paren_token
  >;

static_assert(
  get_result<
    int_in_parens::apply<BOOST_METAPARSE_STRING("(13)"), start>
  >::type::value == 13,
  "it should return the result of the second parser"
);

static_assert(
  is_error<
    int_in_parens::apply<BOOST_METAPARSE_STRING("13"), start>
  >::type::value,
  "it should reject the input when there are no parens"
);

static_assert(
  is_error<
    int_in_parens::apply<BOOST_METAPARSE_STRING("(13"), start>
  >::type::value,
  "it should reject the input when there is no closing paren"
);

A nullary template metafuncion is a template metafunction taking 0 arguments. It is a type with a nested type called type, which is the return value of the nullary metafunction. For example:

struct always13
{
  using type = std::integral_constant<int, 13>;
};

This metafunction is called always13. It is a nullary metafunction, because it takes no arguments. It always returns std::integral_constant<int, 13>.

To call this metafunction, one has to access its ::type. For example:

always13::type

The above example calls the metafunction to get std::integral_constant<int, 13>.

Synopsis

template <char C1, char C2, /* ... */, char Cn>
struct one_char_except_c;

This is a parser.

Table 23.64. Arguments

Name

Type

C1..Cn

character values


Description

one_char_except_c accepts one character except any of C1 ... Cn. When the input is empty or begins with one of the non-accepted characters, one_char_except_c rejects the input. Otherwise it accepts the input and the result of parsing is the character value.

The maximum number of template arguments this class can have is the value the macro BOOST_METAPARSE_LIMIT_ONE_CHAR_EXCEPT_SIZE expands to. Its default value is 10.

Header

#include <boost/metaparse/one_char_except_c.hpp>

Expression semantics

For any s compile-time string and c1, ..., cn characters the following are equivalent

one_char_except_c<c1, ..., cn>::apply<s, pos>

boost::metaparse::one_char::apply<s, pos>

when s is empty or it begins with a character other than c1, ..., cn. Otherwise one_char_except_c<c1, ..., cn>::appl<s, pos> returns a parsing error.

Example

#include <boost/metaparse/one_char_except_c.hpp>
#include <boost/metaparse/lit_c.hpp>
#include <boost/metaparse/middle_of.hpp>
#include <boost/metaparse/repeated.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/get_result.hpp>

#include <boost/mpl/vector.hpp>
#include <boost/mpl/char.hpp>
#include <boost/mpl/equal.hpp>

using namespace boost::metaparse;

using string_literal_parser =
  middle_of<lit_c<'"'>, repeated<one_char_except_c<'"'>>, lit_c<'"'>>;

static_assert(
  boost::mpl::equal<
    boost::mpl::vector<
      boost::mpl::char_<'h'>,
      boost::mpl::char_<'e'>,
      boost::mpl::char_<'l'>,
      boost::mpl::char_<'l'>,
      boost::mpl::char_<'o'>
    >,
    get_result<
      string_literal_parser::apply<BOOST_METAPARSE_STRING("\"hello\""), start>
    >::type
  >::type::value,
  "it should return the content of the string literal"
);

Synopsis

template <class C1, class C2, /* ... */, class Cn>
struct one_char_except;

This is a parser.

Table 23.65. Arguments

Name

Type

C1..Cn

boxed character values


Description

one_char_except accepts one character except any of C1 ... Cn. When the input is empty or begins with one of the non-accepted characters, one_char_except rejects the input. Otherwise it accepts the input and the result of parsing is the character value.

The maximum number of template arguments this class can have is the value the macro BOOST_METAPARSE_LIMIT_ONE_CHAR_EXCEPT_SIZE expands to. Its default value is 10.

Header

#include <boost/metaparse/one_char_except.hpp>

Expression semantics

For any c1, ..., cn boxed characters the following are equivalent

one_char_except<c1, ..., cn>

one_char_except_c<c1::type::value, ..., cn::type::value>

Example

#include <boost/metaparse/one_char_except.hpp>
#include <boost/metaparse/lit_c.hpp>
#include <boost/metaparse/middle_of.hpp>
#include <boost/metaparse/repeated.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/get_result.hpp>

#include <boost/mpl/vector.hpp>
#include <boost/mpl/char.hpp>
#include <boost/mpl/equal.hpp>

#include <type_traits>

using namespace boost::metaparse;

using string_literal_parser =
  middle_of<
    lit_c<'"'>,
    repeated<one_char_except<std::integral_constant<char, '"'>>>,
    lit_c<'"'>
  >;

static_assert(
  boost::mpl::equal<
    boost::mpl::vector<
      boost::mpl::char_<'h'>,
      boost::mpl::char_<'e'>,
      boost::mpl::char_<'l'>,
      boost::mpl::char_<'l'>,
      boost::mpl::char_<'o'>
    >,
    get_result<
      string_literal_parser::apply<BOOST_METAPARSE_STRING("\"hello\""), start>
    >::type
  >::type::value,
  "it should return the content of the string literal"
);

Synopsis

struct one_char;

This is a parser.

Description

one_char accepts one character. The result of parsing is the accepted character. It fails for empty input.

Header

#include <boost/metaparse/one_char.hpp>

Expression semantics

For any s non-empty compile-time string and pos source position the following are equivalent

get_result<one_char::apply<s, pos>>

boost::mpl::front<s>

get_remaining<one_char::apply<s, pos>>

boost::mpl::pop_front<s>

The value of get_position<one_char::apply<s, pos>> depends on the first character of the sequence and the value of the one parsed before that (which is stored in the source position). one_char updates the source position's col and line values based on the new line characters. It detects Linux (\n), Windows (\r\n) and Mac (\r) line endings.

one_char::apply<BOOST_METAPARSE_STRING(""), pos> returns an error for every pos source position.

Example

#include <boost/metaparse/one_char.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/get_result.hpp>
#include <boost/metaparse/get_remaining.hpp>
#include <boost/metaparse/is_error.hpp>

#include <type_traits>

using namespace boost::metaparse;

static_assert(
  get_result<
    one_char::apply<BOOST_METAPARSE_STRING("foo"), start>
  >::type::value == 'f',
  "the result of parsing should be the first character of the input"
);

static_assert(
  std::is_same<
    BOOST_METAPARSE_STRING("oo"),
    get_remaining<one_char::apply<BOOST_METAPARSE_STRING("foo"), start>>::type
  >::type::value,
  "one_char should consume the first character of the input"
);

static_assert(
  is_error<one_char::apply<BOOST_METAPARSE_STRING(""), start>>::type::value,
  "it should return an error for empty input"
);

Synopsis

template <long P1, long P2, /* ... */ long Pn>
struct one_of_c;

This is a parser.

Table 23.66. Arguments

Name

Type

P1 .. Pn

character values


Description

It accepts inputs beginning with any of the P1, ..., Pn characters. The result of parsing is the first character of the input.

The maximum number of characters that can be provided is defined by the BOOST_METAPARSE_LIMIT_ONE_OF_SIZE macro. Its default value is 20.

Header

#include <boost/metaparse/one_of_c.hpp>

Expression semantics

For any c1, ..., cn characters

one_of_c<c1, ..., cn>

is equivalent to

one_of<lit_c<c1>, /* ... */, lit_c<cn>>

Example

#include <boost/metaparse/one_of_c.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/get_result.hpp>
#include <boost/metaparse/is_error.hpp>

using namespace boost::metaparse;

using whitespace = one_of_c<' ', '\n', '\r', '\t', '\v'>;

static_assert(
  get_result<
    whitespace::apply<BOOST_METAPARSE_STRING(" "), start>
  >::type::value == ' ',
  "the result of parsing should be the first character of the input"
);

static_assert(
  is_error<whitespace::apply<BOOST_METAPARSE_STRING("x"), start>>::type::value,
  "it should return an error when the input does not begin with a whitespace"
);

Synopsis

template <class P1, class P2, /* ... */, class Pn>
struct one_of;

This is a parser combinator.

Table 23.67. Arguments

Name

Type

P1 .. Pn

parsers


Description

It accepts an input when any of the P1, ... Pn parsers accept it. The result of parsing is the result of applying the first parser that accepts the input. The parsers are tried in order, therefore in case of ambiguous grammars the result of parsing depends on the order of the P1 ... Pn parsers.

The maximum number of accepted parsers is defined by the BOOST_METAPARSE_LIMIT_ONE_OF_SIZE macro. Its default value is 20.

Header

#include <boost/metaparse/one_of.hpp>

Expression semantics

For any p1, ..., pn parsers, s compile-time string and pos source position

one_of<p1, ..., pn>::apply<s, pos>

is equivalent to

pk::apply<s, pos>

when there is a k, that pi::apply<s, pos>::type returns an error for every i in the range [1..k) and pk::apply<s, pos>::type doesn't return an error.

The parser combinator returns an error when there is no such k.

Example

#include <boost/metaparse/one_of.hpp>
#include <boost/metaparse/lit_c.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/get_result.hpp>
#include <boost/metaparse/is_error.hpp>

using namespace boost::metaparse;

using whitespace =
  one_of<lit_c<' '>, lit_c<'\n'>, lit_c<'\r'>, lit_c<'\t'>, lit_c<'\v'>>;

static_assert(
  get_result<
    whitespace::apply<BOOST_METAPARSE_STRING(" "), start>
  >::type::value == ' ',
  "the result of parsing should be the first character of the input"
);

static_assert(
  is_error<whitespace::apply<BOOST_METAPARSE_STRING("x"), start>>::type::value,
  "it should return an error when the input does not begin with a whitespace"
);

Synopsis

template <class P, class Default = /* unspecified */>
struct optional;

This is a parser combinator.

Table 23.68. Arguments


Description

It tries parsing the input with P. When P succeeds, the result of parsing is the result of P. Otherwise no characters are consumed and the result of parsing is Default.

Header

#include <boost/metaparse/optional.hpp>

Expression semantics

For any p parser and d template metaprogramming value

optional<p, d>

is equivalent to

one_of<p, return_<d>>

Example

#include <boost/metaparse/optional.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/middle_of.hpp>
#include <boost/metaparse/sequence.hpp>
#include <boost/metaparse/lit_c.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/get_result.hpp>

#include <boost/mpl/int.hpp>
#include <boost/mpl/equal.hpp>
#include <boost/mpl/equal_to.hpp>
#include <boost/mpl/vector_c.hpp>

using namespace boost::metaparse;

using complex_number =
  sequence<
    // Real
    int_,

    // Imaginary
    optional<
      middle_of<lit_c<'+'>, int_, lit_c<'i'>>,
      boost::mpl::int_<0>
    >
  >
;

static_assert(
  boost::mpl::equal<
    boost::mpl::vector_c<int, 1, 0>,
    get_result<
      complex_number::apply<BOOST_METAPARSE_STRING("1"), start>
    >::type,

    boost::mpl::equal_to<boost::mpl::_, boost::mpl::_>
  >::type::value,
  "No imaginary"
);

static_assert(
  boost::mpl::equal<
    boost::mpl::vector_c<int, 1, 0>,
    get_result<
      complex_number::apply<BOOST_METAPARSE_STRING("1+0i"), start>
    >::type,

    boost::mpl::equal_to<boost::mpl::_, boost::mpl::_>
  >::type::value,
  "0 as imaginary"
);

static_assert(
  boost::mpl::equal<
    boost::mpl::vector_c<int, 0, 1>,
    get_result<
      complex_number::apply<BOOST_METAPARSE_STRING("0+1i"), start>
    >::type,

    boost::mpl::equal_to<boost::mpl::_, boost::mpl::_>
  >::type::value,
  "Non-null imaginary"
);

A parser combinator is a parser implemented as a template class taking one or more parsers as arguments.

A parser is a template metafunction class that takes the following arguments:

  • a suffix of the input text, a string
  • a source position describing at which position of the entire input text the suffix begins at

The function parses a prefix of the input string. When the parsing is successful, it returns an accept value. When there is a parsing error, the parser returns a reject value. The is_error metafunction can be used to determine about the result of a parser if it succeeded or failed.

The documentation refers often to the result of a parser. This means that the parser accepts the input and refers to what get_result returns for the value returned by the parser.

A parsing error message is a template metaprogramming value with a static std::string get_value() member function. This function returns the pretty-printed version of the error the class represents. For example:

struct example_error
{
  using type = example_error;

  static std::string get_value()
  {
    return "This is a formatted example error."
  }
};

Failing parsers return parsing error messages as error messages.

A predicate (or unary predicate) is a template metafunction class taking one argument and returning a boxed value of type bool.

For example the following predicate checks if its argument is the boxed char value x:

struct is_x
{
  template <class C>
  struct apply
  {
    static constexpr bool value = (C::value == 'x');
    using type = apply;
  };

  using type = is_x;
};

Synopsis

template <char From, char To>
struct range_c;

This is a parser.

Table 23.69. Arguments

Name

Type

From

character value

To

character value


Description

range_c accepts one character in the range [From..To]. The result of the parser is the accepted character.

Header

#include <boost/metaparse/range_c.hpp>

Expression semantics

For any A, B characters the following are equivalent:

range_c<A, B>

accept_when<
  one_char,
  util::in_range_c<char, A, B>,
  errors::unexpected_character
>

Example

#include <boost/metaparse/range_c.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/get_result.hpp>

using namespace boost::metaparse;

using one_digit = range_c<'0', '9'>;

static_assert(
  !is_error<one_digit::apply<BOOST_METAPARSE_STRING("0"), start>>::type::value,
  "one_digit should accept a digit"
);

static_assert(
  is_error<one_digit::apply<BOOST_METAPARSE_STRING("x"), start>>::type::value,
  "one_digit should reject a value outside of ['0'..'9']"
);

static_assert(
  get_result<
    one_digit::apply<BOOST_METAPARSE_STRING("0"), start>
  >::type::value == '0',
  "the result of parsing should be the character value"
);

Synopsis

template <class From, class To>
struct range;

This is a parser.

Table 23.70. Arguments

Name

Type

From

boxed character value

To

boxed character value


Description

range accepts one character in the range [From..To]. The result of the parser is the accepted character.

Header

#include <boost/metaparse/range.hpp>

Expression semantics

For any A, B wrapped characters the following are equivalent:

range<A, B>

accept_when<one_char, util::in_range<A, B>, errors::unexpected_character>

Example

#include <boost/metaparse/range.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/get_result.hpp>

#include <type_traits>

using namespace boost::metaparse;

using one_digit =
  range<std::integral_constant<char, '0'>, std::integral_constant<char, '9'>>;

static_assert(
  !is_error<one_digit::apply<BOOST_METAPARSE_STRING("0"), start>>::type::value,
  "one_digit should accept a digit"
);

static_assert(
  is_error<one_digit::apply<BOOST_METAPARSE_STRING("x"), start>>::type::value,
  "one_digit should reject a value outside of ['0'..'9']"
);

static_assert(
  get_result<
    one_digit::apply<BOOST_METAPARSE_STRING("0"), start>
  >::type::value == '0',
  "the result of parsing should be the character value"
);

Synopsis

template <class Msg, class Pos>
struct reject;

This is a template metaprogramming value.

Table 23.71. Arguments


Description

Values representing a failed parser application. It behaves as a lazy template metafunction: when it is evaluated as a metafunction, it returns itself with its arguments evaluated. See expression semantics for further details.

[Note] Note

Note that for backward compatibility when Msg::type is not defined, reject<....>::type does not evaluate Msg. For example reject<int, start>::type is reject<int, start::type>. Using types that are not template metaprogramming values as Msg is deprecated and will not work in future versions of the library.

Expressions semantics

For any m template metaprogramming value and p source position the following are equivalent:

reject<m, p>::type

reject<m, p::type>

Header

#include <boost/metaparse/reject.hpp>

Operations

Synopsis

template <class P>
struct repeated1;

This is a parser combinator.

Table 23.72. Arguments

Name

Type

P

parser


Description

It applies P on the input string repeatedly as long as the parser accepts the input. The result of parsing is a sequence of the results of the individual applications of P.

When P rejects the input for the first time, repeated1 rejects it as well. At least one successful application of P is required for repeated1 to accept the input.

Header

#include <boost/metaparse/repeated1.hpp>

Expression semantics

For any p parser the following are equivalent:

repeated1<p>

last_of<look_ahead<p>, repeated<p>>

Example

#include <boost/metaparse/repeated1.hpp>
#include <boost/metaparse/digit_val.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/get_result.hpp>
#include <boost/metaparse/is_error.hpp>

#include <boost/mpl/equal.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/int.hpp>

using namespace boost::metaparse;

using digits = repeated1<digit_val>;

static_assert(
  boost::mpl::equal<
    get_result<digits::apply<BOOST_METAPARSE_STRING("1234"), start>>::type,
    boost::mpl::vector<
      boost::mpl::int_<1>,
      boost::mpl::int_<2>,
      boost::mpl::int_<3>,
      boost::mpl::int_<4>
    >
  >::type::value,
  "the result of parsing should be the list of digit values"
);

static_assert(
  is_error<digits::apply<BOOST_METAPARSE_STRING("x"), start>>::type::value,
  "repeated1 should reject the input when it can't parse anything with digit_val"
);

Synopsis

template <class P>
struct repeated_reject_incomplete1;

This is a parser combinator.

Table 23.73. Arguments

Name

Type

P

parser


Description

The same as repeated1, but once P rejects the input, repeated_reject_incomplete1 checks if P consumes any characters before rejecting the input. If so, repeated_reject_incomplete1 rejects the input with the same error message this last application of P returned. Otherwise _reject_incompleterepeated1 accepts the input and gives the same result as repeated1.

Header

#include <boost/metaparse/repeated_reject_incomplete1.hpp>

Expression semantics

For any p parser, s compile-time string and pos source position

repeated_reject_incomplete1<p>::apply<s, pos>

is equivalent to

first_of<repeated1<p>, fail_at_first_char_expected<p> >::apply<s, pos>

Example

#include <boost/metaparse/repeated_reject_incomplete1.hpp>
#include <boost/metaparse/lit_c.hpp>
#include <boost/metaparse/last_of.hpp>
#include <boost/metaparse/token.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/get_result.hpp>
#include <boost/metaparse/is_error.hpp>

#include <boost/mpl/equal.hpp>
#include <boost/mpl/vector_c.hpp>

using namespace boost::metaparse;

using int_token = token<int_>;
using plus_token = token<lit_c<'+'>>;
using plus_int = last_of<plus_token, int_token>;

using ints = repeated_reject_incomplete1<plus_int>;

static_assert(
  boost::mpl::equal<
    boost::mpl::vector_c<int, 13, 3, 21>,
    get_result<
      ints::apply<BOOST_METAPARSE_STRING("+ 13 + 3 + 21"), start>
    >::type
  >::type::value,
  "ints should parse the numbers"
);

static_assert(
  is_error<
    ints::apply<BOOST_METAPARSE_STRING("+ 13 + 3 +"), start>
  >::type::value,
  "when the last number is missing, it should be an error"
);

static_assert(
  is_error<ints::apply<BOOST_METAPARSE_STRING(""), start>>::type::value,
  "when no numbers are provided, it should be an error"
);

Synopsis

template <class P>
struct repeated_reject_incomplete;

This is a parser combinator.

Table 23.74. Arguments

Name

Type

P

parser


Description

The same as repeated, but once P rejects the input, repeated_reject_incomplete checks if P consumes any characters before rejecting the input. If so, repeated_reject_incomplete rejects the input with the same error message this last application of P returned. Otherwise repeated_reject_incomplete accepts the input and gives the same result as repeated.

Here is a diagram showing how repeated_reject_incomplete works by example:

using int_token = token<int_>;
using plus_token = token<lit_c<'+'>>;
using plus_int = last_of<plus_token, int_token>;
using sum_op = mpl::lambda<mpl::plus<mpl::_1, mpl::_2>>::type;

Header

#include <boost/metaparse/repeated_reject_incomplete.hpp>

Expression semantics

For any p parser, s compile-time string and pos source position

repeated_reject_incomplete<p>::apply<s, pos>

is equivalent to

first_of<repeated<p>, fail_at_first_char_expected<p> >::apply<s, pos>

Example

#include <boost/metaparse/repeated_reject_incomplete.hpp>
#include <boost/metaparse/lit_c.hpp>
#include <boost/metaparse/last_of.hpp>
#include <boost/metaparse/token.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/get_result.hpp>
#include <boost/metaparse/is_error.hpp>

#include <boost/mpl/equal.hpp>
#include <boost/mpl/vector_c.hpp>

using namespace boost::metaparse;

using int_token = token<int_>;
using plus_token = token<lit_c<'+'>>;
using plus_int = last_of<plus_token, int_token>;

using ints = repeated_reject_incomplete<plus_int>;

static_assert(
  boost::mpl::equal<
    boost::mpl::vector_c<int, 13, 3, 21>,
    get_result<
      ints::apply<BOOST_METAPARSE_STRING("+ 13 + 3 + 21"), start>
    >::type
  >::type::value,
  "ints should parse the numbers"
);

static_assert(
  is_error<
    ints::apply<BOOST_METAPARSE_STRING("+ 13 + 3 +"), start>
  >::type::value,
  "when the last number is missing, it should be an error"
);

Synopsis

template <class P1, class P2, /* ... */, class Pn>
struct repeated_one_of1;

This is a parser combinator.

Table 23.75. Arguments

Name

Type

P1 .. Pn

parsers


Description

It applies the P1 ... Pn parsers repeatedly as long as any of them accepts the input. In each iteration the parsers are tried in order and the first one accepting the input is used, therefore in case of ambiguous grammars the result of parsing depends on the order of the P1 ... Pn parsers. The result of parsing with this parser combinator is a sequence of the individual parsing results.

When none of the P1 ... Pn parsers accept the input in the first iteration, repeated_one_of1 rejects the input.

The maximum number of accepted parsers is defined by the BOOST_METAPARSE_LIMIT_ONE_OF_SIZE macro. Its default value is 20.

Header

#include <boost/metaparse/repeated_one_of1.hpp>

Expression semantics

For any p1, ..., pn parsers

repeated_one_of1<p1, /* ... */, pn>

is equivalent to

repeated1<one_of<p1, /* ... */, pn>>

Example

#include <boost/metaparse/repeated_one_of1.hpp>
#include <boost/metaparse/lit_c.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/get_result.hpp>
#include <boost/metaparse/is_error.hpp>

#include <boost/mpl/equal.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/char.hpp>

using namespace boost::metaparse;

using as_and_bs = repeated_one_of1<lit_c<'a'>, lit_c<'b'>>;

static_assert(
  boost::mpl::equal<
    get_result<as_and_bs::apply<BOOST_METAPARSE_STRING("abaab"), start>>::type,
    boost::mpl::vector<
      boost::mpl::char_<'a'>,
      boost::mpl::char_<'b'>,
      boost::mpl::char_<'a'>,
      boost::mpl::char_<'a'>,
      boost::mpl::char_<'b'>
    >
  >::type::value,
  "the result of parsing should be the list of results"
);

static_assert(
  is_error<as_and_bs::apply<BOOST_METAPARSE_STRING("x"), start>>::type::value,
  "repeated_one_of1 should reject the input when it"
  " can't parse anything with digit_val"
);

Synopsis

template <class P1, class P2, /* ... */, class Pn>
struct repeated_one_of1;

Table 23.76. Arguments

Name

Type

P1 .. Pn

parsers


This is a parser combinator.

Description

It applies the P1 ... Pn parsers repeatedly as long as any of them accepts the input. In each iteration the parsers are tried in order and the first one accepting the input is used, therefore in case of ambiguous grammars the result of parsing depends on the order of the P1 ... Pn parsers. The result of parsing with this parser combinator is a sequence of the individual parsing results.

When none of the P1 ... Pn parsers accept the input in the first iteration, repeated_one_of accepts the input and the result of parsing is an empty sequence.

The maximum number of accepted parsers is defined by the BOOST_METAPARSE_LIMIT_ONE_OF_SIZE macro. Its default value is 20.

Header

#include <boost/metaparse/repeated_one_of.hpp>

Expression semantics

For any p1, ..., pn parsers

repeated_one_of<p1, /* ... */, pn>

is equivalent to

repeated<one_of<p1, /* ... */, pn>>

Example

#include <boost/metaparse/repeated_one_of.hpp>
#include <boost/metaparse/lit_c.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/get_result.hpp>

#include <boost/mpl/equal.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/char.hpp>

using namespace boost::metaparse;

using as_and_bs = repeated_one_of<lit_c<'a'>, lit_c<'b'>>;

static_assert(
  boost::mpl::equal<
    get_result<as_and_bs::apply<BOOST_METAPARSE_STRING("abaab"), start>>::type,
    boost::mpl::vector<
      boost::mpl::char_<'a'>,
      boost::mpl::char_<'b'>,
      boost::mpl::char_<'a'>,
      boost::mpl::char_<'a'>,
      boost::mpl::char_<'b'>
    >
  >::type::value,
  "the result of parsing should be the list of results"
);

static_assert(
  boost::mpl::equal<
    get_result<as_and_bs::apply<BOOST_METAPARSE_STRING("x"), start>>::type,
    boost::mpl::vector<>
  >::type::value,
  "repeated_one_of should accept the input when it"
  " can't parse anything with digit_val"
);

Synopsis

template <class P>
struct repeated;

This is a parser combinator.

Table 23.77. Arguments

Name

Type

P

parser


Description

It applies P on the input string repeatedly as long as P accepts the input. The result of parsing is a sequence of the results of the individual applications of P.

When P rejects the input for the first time, repeated still accepts the input and the result of parsing is an empty sequence.

Here is a diagram showing how repeated works by example:

using int_token = token<int_>;

Further details can be found in the Repetition section of the User Manual.

Header

#include <boost/metaparse/repeated.hpp>

Expression semantics

For any p parser the following are equivalent:

repeated<p>

foldl<
  p,
  /* unspecified empty sequence */,
  boost::mpl::push_back<_2, _1>
>

Example

#include <boost/metaparse/repeated.hpp>
#include <boost/metaparse/digit_val.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/get_result.hpp>

#include <boost/mpl/equal.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/int.hpp>

using namespace boost::metaparse;

using digits = repeated<digit_val>;

static_assert(
  boost::mpl::equal<
    get_result<digits::apply<BOOST_METAPARSE_STRING("1234"), start>>::type,
    boost::mpl::vector<
      boost::mpl::int_<1>,
      boost::mpl::int_<2>,
      boost::mpl::int_<3>,
      boost::mpl::int_<4>
    >
  >::type::value,
  "the result of parsing should be the list of digit values"
);

static_assert(
  boost::mpl::equal<
    get_result<digits::apply<BOOST_METAPARSE_STRING("x"), start>>::type,
    boost::mpl::vector<>
  >::type::value,
  "repeated should accept the input when it can't parse anything with digit_val"
);

Synopsis

template <class C>
struct return_;

This is a parser.

Table 23.78. Arguments


Description

return_ accepts every input. The result of parsing is C, the remaining string is the input string.

Header

#include <boost/metaparse/return_.hpp>

Expression semantics

For any c class, s compile-time string and pos source position the following are equivalent

get_result<return_<c>::apply<s, pos>>::type

c

get_remaining<return_<c>::apply<s, pos>>::type

s

get_position<return_<c>::apply<s, pos>>::type

pos

Example

#include <boost/metaparse/return_.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/one_of.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/get_result.hpp>

#include <type_traits>

using namespace boost::metaparse;

using default_value = std::integral_constant<int, 13>;

using optional_number = one_of<int_, return_<default_value>>;

static_assert(
  get_result<
    optional_number::apply<BOOST_METAPARSE_STRING("11"), start>
  >::type::value == 11,
  "when a number is provided, it is the result of parsing"
);

static_assert(
  get_result<
    optional_number::apply<BOOST_METAPARSE_STRING(""), start>
  >::type::value == 13,
  "when no number is provided, the default value is the result of parsing"
);

Synopsis

template <class P1, /* ... */, class Pn>
struct sequence;

This is a parser combinator.

Table 23.79. Arguments

Name

Type

P1 .. Pn

parser


Description

sequence applies the P1, ..., Pn parsers in sequence on the input. It accepts an input when all of these parsers accept it. The result of parsing is a sequence of the results of the parsers.

The maximum number of parsers sequence accepts can be specified with the BOOST_METAPARSE_LIMIT_SEQUENCE_SIZE macro. Its default value is 5.

Header

#include <boost/metaparse/sequence.hpp>

Expression semantics

For any n > 0, p0, ..., pn parsers the result of sequence<p0, ..., p1> is a compile-time sequence of the results of the parsers, applied after each other in order on the input string when none of them returns an error. The remaining string is the remaining string the last parser returns.

When one of the parsers returns an error, the combinator returns that error.

Example

#include <boost/metaparse/sequence.hpp>
#include <boost/metaparse/token.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/lit_c.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/get_result.hpp>

#include <boost/mpl/at.hpp>

using namespace boost::metaparse;

using int_token = token<int_>;
using plus_token = token<lit_c<'+'>>;

using a_plus_b = sequence<int_token, plus_token, int_token>;

static_assert(
  boost::mpl::at_c<
    get_result<a_plus_b::apply<BOOST_METAPARSE_STRING("1 + 2"), start>>::type,
    0
  >::type::value == 1,
  "the first element of the sequence should be the first number"
);

static_assert(
  boost::mpl::at_c<
    get_result<a_plus_b::apply<BOOST_METAPARSE_STRING("1 + 2"), start>>::type,
    1
  >::type::value == '+',
  "the second element of the sequence should be the plus"
);

static_assert(
  boost::mpl::at_c<
    get_result<a_plus_b::apply<BOOST_METAPARSE_STRING("1 + 2"), start>>::type,
    2
  >::type::value == 2,
  "the third element of the sequence should be the second number"
);

static_assert(
  is_error<a_plus_b::apply<BOOST_METAPARSE_STRING("1 +"), start>>::type::value,
  "when not all of the parsers accept the input, sequence should fail"
);

Synopsis

template <template <class, ..., class> class T, class P1, ..., class Pn>
struct sequence_applyn;

This is a parser combinator.

Table 23.80. Arguments

T

Template class taking n arguments

P1..Pn

parsers


Description

It applies the P1 ... Pn parsers on the input in order. When all of them succeed, the result of parsing with sequence_applyn is the T template class instantiated with the results of the P1 ... Pn parsers. When any of the P1 ... Pn parsers reject the input, the error is propagated.

n has to be in the [1..BOOST_METAPARSE_LIMIT_SEQUENCE_SIZE) range.

Header

#include <boost/metaparse/sequence_apply.hpp>

Expression semantics

For any n > 0, p1 ... pn parsers, t template class with n class arguments, s compile-time string and pos source position the following are equivalent:

sequence_apply<t, p1, ..., pn>::apply<s, pos>::type

when sequence<p1, ..., pn> accepts the input:

return_<
  t<
    mpl::at_c<0, get_result<sequence<p1,...,pn>::apply<s, pos>>::type>::type,
    ...
    mpl::at_c<n, get_result<sequence<p1,...,pn>::apply<s, pos>>::type>::type,
  >
>::apply<s, pos>::type

when sequence<p1, ..., pn> rejects the input:

sequence<p1, ..., pn>::apply<s, pos>::type

Example

#include <boost/metaparse/sequence_apply.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/middle_of.hpp>
#include <boost/metaparse/lit_c.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/get_result.hpp>

#include <boost/type_traits/is_same.hpp>

using namespace boost::metaparse;

template <int Real, int Imaginary>
struct complex_c { typedef complex_c type; };

template <class Real, class Imaginary>
struct complex : complex_c<Real::type::value, Imaginary::type::value> {};

typedef
  sequence_apply2<complex, int_, middle_of<lit_c<'+'>, int_, lit_c<'i'>>>
  complex_parser;

static_assert(
  boost::is_same<
    complex_c<1, 2>,
    get_result<
      complex_parser::apply<BOOST_METAPARSE_STRING("1+2i"), start>
    >::type::type
  >::type::value,
  "the result of parsing should be the list of digit values"
);

Synopsis

template <class Line, class Col, class PrevChar>
struct source_position;

This is a template metaprogramming value.

Table 23.81. Arguments

Name

Type

Line

boxed integer value

Col

boxed integer value

PrevChar

boxed character value


Description

Compile-time data-structure describing a position of the input text.

The values of this data-structure store the last character that was parsed before reaching the position of the input described by the source_position value.

Its tag is source_position_tag.

The beginning of the input text is represented by start.

Header

#include <boost/metaparse/source_position.hpp>

Expression semantics

For any l, c compile-time boxed integral values and p compile-time boxed character value, the following are equivalent

get_col<source_position<l, c, p>>::type
c::type

get_line<source_position<l, c, p>>::type
l::type

get_prev_char<source_position<l, c, p>>::type
p::type

Constant values of this type

Operations

Synopsis

struct source_position_tag;

This is a tag.

Description

This is the tag of the source_position values.

Header

#include <boost/metaparse/source_position_tag.hpp>

Synopsis

struct space;

This is a parser.

Description

space accepts one white space character. The result of parsing is the parsed character.

Header

#include <boost/metaparse/space.hpp>

Expression semantics

The following are equivalent:

space

accept_when<one_char, util::is_whitespace<>, errors::whitespace_expected>

Example

#include <boost/metaparse/space.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/get_remaining.hpp>

#include <type_traits>

using namespace boost::metaparse;

static_assert(
  std::is_same<
    BOOST_METAPARSE_STRING(" foo"),
    get_remaining<space::apply<BOOST_METAPARSE_STRING("  foo"), start>>::type
  >::type::value,
  "it should consume the first space of the input"
);

static_assert(
  is_error<space::apply<BOOST_METAPARSE_STRING("x"), start>>::type::value,
  "it should return an error when the input does not begin with a whitespace"
);

Synopsis

struct spaces;

This is a parser.

Description

spaces accepts any number of whitespace characters. It requires at least one to be present.

Header

#include <boost/metaparse/spaces.hpp>

Expression semantics

spaces

is equivalent to

repeated1<space>

Example

#include <boost/metaparse/spaces.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/get_remaining.hpp>

#include <type_traits>

using namespace boost::metaparse;

static_assert(
  std::is_same<
    BOOST_METAPARSE_STRING("foo"),
    get_remaining<spaces::apply<BOOST_METAPARSE_STRING("  foo"), start>>::type
  >::type::value,
  "it should consume all whitespaces at the beginning of the input"
);

static_assert(
  is_error<spaces::apply<BOOST_METAPARSE_STRING("x"), start>>::type::value,
  "it should return an error when the input does not begin with a whitespace"
);

Synopsis

struct start;

This is a template metaprogramming value of type source position.

Description

It represents the beginning of an input text.

Header

#include <boost/metaparse/start.hpp>

Synopsis

template <char C1, ..., char Cn>
struct string;

This is a template metaprogramming value.

Table 23.82. Arguments

Name

Type

C1..Cn

character values


Description

Compile-time data-structure describing a string object. These string objects are compatible with boost::mpl::string, but they accept only individual characters as arguments. When constexpr is available, they can be constructed using the BOOST_METAPARSE_STRING macro.

The tag of the strings is string_tag.

C++98: The maximum length of these strings is controlled by the BOOST_METAPARSE_LIMIT_STRING_SIZE macro.

C++11: The strings use variadic templates.

Header

#include <boost/metaparse/string.hpp>

Example

#include <boost/metaparse/string.hpp>

#include <type_traits>

using namespace boost::metaparse;

using hello1 = string<'H','e','l','l','o'>;
using hello2 = BOOST_METAPARSE_STRING("Hello");

static_assert(
  std::is_same<
    string<'H', 'e', 'l', 'l', 'o'>,
    BOOST_METAPARSE_STRING("Hello")
  >::type::value,
  "The type generated by the macro should be identical to the hand-crafted one."
);

Synopsis

struct string_tag;

This is a tag.

Description

This is the tag of the string values.

Header

#include <boost/metaparse/string_tag.hpp>

Tag

A tag is a template metaprogramming value used to identify groups of values.

Synopsis

template <class P>
struct token;

This is a parser combinator.

Table 23.83. Arguments

Name

Type

P

parser


Description

token parses the input using P when it succeeds, token consumes all whitespaces afterwards. The result of parsing is the result of P.

Header

#include <boost/metaparse/token.hpp>

Expression semantics

For any p parser the following are equivalent:

token<p>

first_of<p, spaces>

Example

#include <boost/metaparse/token.hpp>
#include <boost/metaparse/int_.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/get_result.hpp>
#include <boost/metaparse/get_remaining.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/string.hpp>

#include <type_traits>

using namespace boost::metaparse;

using int_token = token<int_>;

static_assert(
  get_result<
    int_token::apply<BOOST_METAPARSE_STRING("13 "), start>
  >::type::value,
  "the result of int_token is the number"
);

static_assert(
  std::is_same<
    BOOST_METAPARSE_STRING(""),
    get_remaining<int_token::apply<BOOST_METAPARSE_STRING("13 "), start>>::type
  >::type::value,
  "token consumes whitespaces after the number"
);

static_assert(
  get_result<
    int_token::apply<BOOST_METAPARSE_STRING("13"), start>
  >::type::value,
  "whitespaces after the number are optional"
);

static_assert(
  is_error<int_token::apply<BOOST_METAPARSE_STRING("foo"), start>>::type::value,
  "when there is no number, token fails"
);

Synopsis

template <class P, class F>
struct transform_error_message;

This is a parser combinator.

Table 23.84. Arguments

Name

Type

P

parser

F

template metafunction class taking one argument


Description

It parses the input with P. When this succeeds, the result of parsing with transform_error_message will be the result of parsing with P. When it fails, the error P returns is forwarded to the caller of transform_error_message, but the message of it is transformed with F.

Header

#include <boost/metaparse/transform_error_message.hpp>

Expression semantics

For any p parser and f metafunction class accepting one argument

transform_error_message<p, f>::apply<s, pos>

is equivalent to p::apply<s, pos> when p accepts the input. It is equivalent to reject<f::apply<get_message<p::apply<s, pos>>::type>, get_position<p::apply<s, pos>>> otherwise.

Example

#include <boost/metaparse/transform_error_message.hpp>
#include <boost/metaparse/repeated1.hpp>
#include <boost/metaparse/letter.hpp>
#include <boost/metaparse/keyword.hpp>
#include <boost/metaparse/last_of.hpp>
#include <boost/metaparse/token.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/get_message.hpp>
#include <boost/metaparse/define_error.hpp>
#include <boost/metaparse/reject.hpp>

#include <type_traits>

using namespace boost::metaparse;

BOOST_METAPARSE_DEFINE_ERROR(name_expected, "Name expected");

struct return_name_expected
{
  typedef return_name_expected type;

  template <class>
  struct apply : name_expected {};
};

using keyword_name = token<keyword<BOOST_METAPARSE_STRING("name")>>;
using name_token = token<repeated1<letter>>;

using name_parser =
  last_of<
    keyword_name,
    transform_error_message<name_token, return_name_expected>
  >;

static_assert(
  !is_error<
    name_parser::apply<BOOST_METAPARSE_STRING("name Bela"), start>
  >::type::value,
  "name_parser should accept \"name <a name>\""
);

static_assert(
  is_error<
    name_parser::apply<BOOST_METAPARSE_STRING("name ?"), start>
  >::type::value,
  "name_parser should reject input when name is a question mark"
);

static_assert(
  std::is_same<
    get_message<
      name_parser::apply<BOOST_METAPARSE_STRING("name ?"), start>
    >::type,
    name_expected
  >::type::value,
  "the error message should be the one specified by change_error_message"
);

Synopsis

template <class P, class F>
struct transform_error;

This is a parser combinator.

Table 23.85. Arguments

Name

Type

P

parser

F

template metafunction class taking one argument


Description

It parses the input with P. When this succeeds, the result of parsing with transform_error will be the result of parsing with P. When it fails, F is evaluated with the error P returned as argument. Parsing with transform_error will fail and the error will be what F returns. Therefore, F is expected to accept and return a reject value.

Header

#include <boost/metaparse/transform_error.hpp>

Expression semantics

For any p parser and f metafunction class accepting one argument

transform_error<p, f>::apply<s, pos>

is equivalent to p::apply<s, pos> when p accepts the input. It is equivalent to f::apply<p::apply<s, pos>::type> otherwise.

Example

#include <boost/metaparse/transform_error.hpp>
#include <boost/metaparse/repeated1.hpp>
#include <boost/metaparse/letter.hpp>
#include <boost/metaparse/keyword.hpp>
#include <boost/metaparse/last_of.hpp>
#include <boost/metaparse/token.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/get_message.hpp>
#include <boost/metaparse/get_position.hpp>
#include <boost/metaparse/define_error.hpp>
#include <boost/metaparse/reject.hpp>

#include <boost/mpl/lambda.hpp>

#include <type_traits>

using namespace boost::metaparse;

BOOST_METAPARSE_DEFINE_ERROR(name_expected, "Name expected");

using keyword_name = token<keyword<BOOST_METAPARSE_STRING("name")>>;
using name_token = token<repeated1<letter>>;

using name_parser =
  last_of<
    keyword_name,
    transform_error<
      name_token,
      boost::mpl::lambda<
        reject<name_expected, get_position<boost::mpl::_1> >
      >::type
    >
  >;

static_assert(
  !is_error<
    name_parser::apply<BOOST_METAPARSE_STRING("name Bela"), start>
  >::type::value,
  "name_parser should accept \"name <a name>\""
);

static_assert(
  is_error<
    name_parser::apply<BOOST_METAPARSE_STRING("name ?"), start>
  >::type::value,
  "name_parser should reject input when name is a question mark"
);

static_assert(
  std::is_same<
    get_message<
      name_parser::apply<BOOST_METAPARSE_STRING("name ?"), start>
    >::type,
    name_expected
  >::type::value,
  "the error message should be the one specified by change_error_message"
);

Synopsis

template <class P, class T>
struct transform;

This is a parser combinator.

Table 23.86. Arguments

Name

Type

P

parser

T

template metafunction class taking one argument


Description

transform parses the input using P and transforms the result P returns with T. The result of parsing is what T returns. When P fails, the failure is returned unchanged.

Header

#include <boost/metaparse/transform.hpp>

Expression semantics

For any p parser, t metafunction class accepting one argument, s compile-time string and pos source position

get_result<transform<p, t>::apply<s, pos>>::type

is equivalent to

t::apply<get_result<p::apply<s, pos>>::type>::type

When p::apply<s, pos> doesn't return an error. The combinator returns the error otherwise.

Example

#include <boost/metaparse/transform.hpp>
#include <boost/metaparse/digit.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/is_error.hpp>
#include <boost/metaparse/get_result.hpp>

#include <boost/metaparse/util/digit_to_int.hpp>

using namespace boost::metaparse;

using digit_value = transform<digit, util::digit_to_int<>>;

static_assert(
  !is_error<
    digit_value::apply<BOOST_METAPARSE_STRING("0"), start>
  >::type::value,
  "digit_val should accept a digit"
);

static_assert(
  is_error<digit_value::apply<BOOST_METAPARSE_STRING("x"), start>>::type::value,
  "digit_val should reject a character"
);

static_assert(
  get_result<
    digit_value::apply<BOOST_METAPARSE_STRING("0"), start>
  >::type::value == 0,
  "the result of parsing should be the int value"
);

Synopsis

namespace error
{
  struct unexpected_character;
}

This is a parsing error message.

Description

Class representing the error that a different character was expected than what was found at a specific location.

Header

#include <boost/metaparse/error/unexpected_character.hpp>

Synopsis

namespace error
{
  struct unexpected_end_of_input;
}

This is a parsing error message.

Description

Class representing the error that the end of input has been reached while it should contain further characters.

Header

#include <boost/metaparse/error/unexpected_end_of_input.hpp>

Synopsis

template <class T, class NotErrorCase>
struct unless_error;

This is a lazy template metafunction.

Table 23.87. Arguments

Name

Type

T

accept or reject value

NotErrorCase

template metaprogramming value


Description

Checks if T is a parsing error or not. When it is, the result is T. When it is not, the result is NotErrorCase.

Header

#include <boost/metaparse/unless_error.hpp>

Expression semantics

For any t and c classes the following are equivalent:

unless_error<t, c>

boost::mpl::if_<is_error<t::type>::type, t, c>

Example

#include <boost/metaparse/unless_error.hpp>
#include <boost/metaparse/accept.hpp>
#include <boost/metaparse/reject.hpp>
#include <boost/metaparse/start.hpp>
#include <boost/metaparse/string.hpp>
#include <boost/metaparse/define_error.hpp>

#include <type_traits>

using namespace boost::metaparse;

BOOST_METAPARSE_DEFINE_ERROR(sample_error, "Sample error message");

using accept1 =
  accept<std::integral_constant<int, 11>, BOOST_METAPARSE_STRING("foo"), start>;

using accept2 =
  accept<std::integral_constant<int, 13>, BOOST_METAPARSE_STRING("bar"), start>;

using reject1 = reject<sample_error, start>;

struct returns_accept1 { using type = accept1; };
struct returns_accept2 { using type = accept2; };

static_assert(
  std::is_same<accept2, unless_error<accept1, accept2>::type>::type::value,
  "it returns the second argument when the first argument is an accept"
);

static_assert(
  std::is_same<reject1, unless_error<reject1, accept2>::type>::type::value,
  "it returns the first argument when that is a reject"
);

static_assert(
  std::is_same<
    accept2,
    unless_error<returns_accept1, returns_accept2>::type
  >::type::value,
  "it supports lazy evaluation"
);

Synopsis

namespace error
{
  template <int Line, int Col, class Msg = boost::mpl::na>
  struct unpaired;
}

This is a parsing error message.

Table 23.88. Arguments

Name

Type

Line

int value

Col

int value

Msg

template metaprogramming value


Description

Template class representing the error that the closing element of an "opening element ... closing element" structure is missing. (eg. a closing paren is missing). Line and Col point to the beginning of the opening element (eg. the opening paren). Msg is the error message the parser trying to parse the closing element failed with.

It supports currying: unpaired<Line, Col> is a template metafunction class taking one argument: the Msg element and returning the corresponding unpaired value.

Header

#include <boost/metaparse/error/unpaired.hpp>

Synopsis

namespace error
{
  struct whitespace_expected;
}

This is a parsing error message.

Description

Class representing the error that a whitespace character was expected at a specific location.

Header

#include <boost/metaparse/error/whitespace_expected.hpp>

PrevUpHomeNext