898 lines
24 KiB
Plaintext
898 lines
24 KiB
Plaintext
[/==============================================================================
|
|
Copyright (C) 2001-2011 Joel de Guzman
|
|
Copyright (C) 2001-2011 Hartmut Kaiser
|
|
|
|
Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
===============================================================================/]
|
|
[section:operator Parser Operators]
|
|
|
|
Operators are used as a means for object composition and embedding.
|
|
Simple parsers may be composed to form composites through operator
|
|
overloading, crafted to approximate the syntax of __peg__ (PEG). An
|
|
expression such as:
|
|
|
|
a | b
|
|
|
|
yields a new parser type which is a composite of its operands, `a` and
|
|
`b`.
|
|
|
|
This module includes different parsers which get instantiated if one of
|
|
the overloaded operators is used with more primitive parser constructs.
|
|
It includes Alternative (`|`), And-predicate (unary `&`), Difference
|
|
(`-`), Expect (`>`), Kleene star (unary `*`), Lists (`%`), Not-predicate (`!`),
|
|
Optional (unary `-`), Permutation (`^`), Plus (unary
|
|
`+`), Sequence (`>>`), and Sequential-Or (`||`).
|
|
|
|
[heading Module Header]
|
|
|
|
// forwards to <boost/spirit/home/qi/operator.hpp>
|
|
#include <boost/spirit/include/qi_operator.hpp>
|
|
|
|
Also, see __include_structure__.
|
|
|
|
[/------------------------------------------------------------------------------]
|
|
[section:alternative Alternative Parser (`a | b`)]
|
|
|
|
[heading Description]
|
|
|
|
The alternative operator, `a | b`, matches one of two or more operands
|
|
(`a`, `b`, ... etc.):
|
|
|
|
a | b | ...
|
|
|
|
Alternative operands are tried one by one on a first-match-wins basis
|
|
starting from the leftmost operand. After a successfully matched
|
|
alternative is found, the parser concludes its search, essentially
|
|
short-circuiting the search for other potentially viable candidates.
|
|
This short-circuiting implicitly gives the highest priority to the
|
|
leftmost alternative.
|
|
|
|
Short-circuiting is done in the same manner as C or C++'s logical
|
|
expressions; e.g. `if (x < 3 || y < 2)` where, if `x < 3`, the `y < 2`
|
|
test is not done at all. In addition to providing an implicit priority
|
|
rule for alternatives which is necessary, given its non-deterministic
|
|
nature, short-circuiting improves the execution time. If the order of
|
|
your alternatives is logically irrelevant, strive to put the (expected)
|
|
most common choice first for maximum efficiency.
|
|
|
|
[heading Header]
|
|
|
|
// forwards to <boost/spirit/home/qi/operator/alternative.hpp>
|
|
#include <boost/spirit/include/qi_alternative.hpp>
|
|
|
|
Also, see __include_structure__.
|
|
|
|
[heading Model of]
|
|
|
|
[:__nary_parser_concept__]
|
|
|
|
[variablelist Notation
|
|
[[`a`, `b`] [A __parser_concept__]]
|
|
]
|
|
|
|
[heading Expression Semantics]
|
|
|
|
Semantics of an expression is defined only where it differs from, or is not
|
|
defined in __nary_parser_concept__.
|
|
|
|
[table
|
|
[[Expression] [Semantics]]
|
|
[[`a | b`] [Match `a` or `b`.]]
|
|
]
|
|
|
|
[heading Attributes]
|
|
|
|
See __qi_comp_attr_notation__.
|
|
|
|
[table
|
|
[[Expression] [Attribute]]
|
|
[[`a | b`]
|
|
[``a: A, b: B --> (a | b): variant<A, B>
|
|
a: A, b: Unused --> (a | b): optional<A>
|
|
a: A, b: B, c: Unused --> (a | b | c): optional<variant<A, B> >
|
|
a: Unused, b: B --> (a | b): optional<B>
|
|
a: Unused, b: Unused --> (a | b): Unused
|
|
a: A, b: A --> (a | b): A``]]
|
|
]
|
|
|
|
[note Alternative parsers do not roll back changes made to the outer attribute
|
|
because of a failed alternative. If you need to enforce that only the
|
|
succeeded alternative changes the outer attribute please utilize the
|
|
directive __qi_hold__`[]`.]
|
|
|
|
[heading Complexity]
|
|
|
|
[:The overall complexity of the alternative parser is defined by the sum
|
|
of the complexities of its elements. The complexity of the alternative
|
|
parser itself is O(N), where N is the number of alternatives.]
|
|
|
|
[heading Example]
|
|
|
|
[note The test harness for the example(s) below is presented in the
|
|
__qi_basics_examples__ section.]
|
|
|
|
Some using declarations:
|
|
|
|
[reference_using_declarations_alternative]
|
|
|
|
[reference_alternative]
|
|
|
|
[endsect] [/ Alternative]
|
|
|
|
[/------------------------------------------------------------------------------]
|
|
[section:and_predicate And-Predicate Parser (`&a`)]
|
|
|
|
[heading Description]
|
|
|
|
Syntactic predicates assert a certain conditional syntax to be satisfied
|
|
before evaluating another production. Similar to semantic predicates,
|
|
__qi_eps__, syntactic predicates do not consume any input. The /and-predicate/,
|
|
`&a`, is a positive syntactic predicate that returns a zero
|
|
length match only if its predicate matches.
|
|
|
|
[heading Header]
|
|
|
|
// forwards to <boost/spirit/home/qi/operator/and_predicate.hpp>
|
|
#include <boost/spirit/include/qi_and_predicate.hpp>
|
|
|
|
Also, see __include_structure__.
|
|
|
|
[heading Model of]
|
|
|
|
[:__unary_parser_concept__]
|
|
|
|
[variablelist Notation
|
|
[[`a`] [A __parser_concept__]]
|
|
]
|
|
|
|
[heading Expression Semantics]
|
|
|
|
Semantics of an expression is defined only where it differs from, or is
|
|
not defined in __unary_parser_concept__.
|
|
|
|
[table
|
|
[[Expression] [Semantics]]
|
|
[[`&a`] [If the predicate `a` matches, return a zero
|
|
length match. Otherwise, fail.]]
|
|
]
|
|
|
|
[heading Attributes]
|
|
|
|
See __qi_comp_attr_notation__.
|
|
|
|
[table
|
|
[[Expression] [Attribute]]
|
|
[[`&a`] [__unused_type__]]
|
|
]
|
|
|
|
[heading Complexity]
|
|
|
|
[:The complexity is defined by the complexity of the predicate, `a`]
|
|
|
|
[heading Example]
|
|
|
|
[note The test harness for the example(s) below is presented in the
|
|
__qi_basics_examples__ section.]
|
|
|
|
[reference_and_predicate]
|
|
|
|
[endsect] [/ And Predicate]
|
|
|
|
[/------------------------------------------------------------------------------]
|
|
[section:difference Difference Parser (`a - b`)]
|
|
|
|
[heading Description]
|
|
|
|
The difference operator, `a - b`, is a binary operator that matches the
|
|
first (LHS) operand but not the second (RHS). [footnote Unlike classic
|
|
Spirit, with Spirit2, the expression will always fail if the RHS is a
|
|
successful match regardless if the RHS matches less characters. For
|
|
example, the rule `lit("policeman") - "police"` will always fail to
|
|
match. Spirit2 does not count the matching chars while parsing and there
|
|
is no reliable and fast way to check if the LHS matches more than the
|
|
RHS.]
|
|
|
|
[heading Header]
|
|
|
|
// forwards to <boost/spirit/home/qi/operator/difference.hpp>
|
|
#include <boost/spirit/include/qi_difference.hpp>
|
|
|
|
Also, see __include_structure__.
|
|
|
|
[heading Model of]
|
|
|
|
[:__binary_parser_concept__]
|
|
|
|
[variablelist Notation
|
|
[[`a`, `b`] [A __parser_concept__]]
|
|
]
|
|
|
|
[heading Expression Semantics]
|
|
|
|
Semantics of an expression is defined only where it differs from, or is
|
|
not defined in __binary_parser_concept__.
|
|
|
|
[table
|
|
[[Expression] [Semantics]]
|
|
[[`a - b`] [Parse `a` but not `b`.]]
|
|
]
|
|
|
|
[heading Attributes]
|
|
|
|
See __qi_comp_attr_notation__.
|
|
|
|
[table
|
|
[[Expression] [Attribute]]
|
|
[[`a - b`]
|
|
[``a: A, b: B --> (a - b): A
|
|
a: Unused, b: B --> (a - b): Unused``]]
|
|
]
|
|
|
|
[heading Complexity]
|
|
|
|
[:The complexity of the difference parser is defined by the sum of the
|
|
complexities of both operands.]
|
|
|
|
[heading Example]
|
|
|
|
[note The test harness for the example(s) below is presented in the
|
|
__qi_basics_examples__ section.]
|
|
|
|
[reference_difference]
|
|
|
|
[endsect] [/ Difference]
|
|
|
|
[/------------------------------------------------------------------------------]
|
|
[section:expect Expectation Operator (`a > b`)]
|
|
|
|
[heading Description]
|
|
|
|
There are occasions in which it is expected that the input must match a
|
|
particular parser or the input is invalid. Such cases generally arise
|
|
after matching a portion of a grammar, such that the context is fully
|
|
known. In such a situation, failure to match should result in an
|
|
exception. For example, when parsing an e-mail address, after matching a
|
|
name and "@" there must be a domain name or the address is invalid.
|
|
|
|
The expectation operator (>) requires that the following parser match
|
|
the input or an exception is emitted. Using on_error(), that exception
|
|
can be handled by calling a handler with the context at which the
|
|
parsing failed can be reported.
|
|
|
|
By contrast, the follows operator (>>) does not require that the
|
|
following parser match the input, which allows for backtracking or
|
|
simply returning false from the parse() function with no exceptions.
|
|
|
|
Like the __qi_sequence__, the expectation operator, `a > b`, parses two or
|
|
more operands (`a`, `b`, ... etc.), in sequence:
|
|
|
|
a > b > ...
|
|
|
|
However, while the plain __qi_sequence__ simply returns a no-match
|
|
(returns `false`) when one of the elements fail, the expectation: `>`
|
|
operator throws an __qi_expectation_failure__`<Iter>` when the second or
|
|
succeeding operands (all operands except the first) fail to match.
|
|
|
|
[heading Header]
|
|
|
|
// forwards to <boost/spirit/home/qi/operator/expect.hpp>
|
|
#include <boost/spirit/include/qi_expect.hpp>
|
|
|
|
Also, see __include_structure__.
|
|
|
|
[heading Model of]
|
|
|
|
[:__nary_parser_concept__]
|
|
|
|
[variablelist Notation
|
|
[[`a`, `b`] [A __parser_concept__]]
|
|
[[`Iter`] [A __fwditer__ type]]
|
|
]
|
|
|
|
[heading Expectation Failure]
|
|
|
|
When any operand, except the first, fail to match an
|
|
`expectation_failure<Iter>` is thrown:
|
|
|
|
template <typename Iter>
|
|
struct expectation_failure : std::runtime_error
|
|
{
|
|
Iter first; // [first, last) iterator pointing
|
|
Iter last; // to the error position in the input.
|
|
__info__ what_; // Information about the nature of the error.
|
|
};
|
|
|
|
[heading Expression Semantics]
|
|
|
|
Semantics of an expression is defined only where it differs from, or is not
|
|
defined in __nary_parser_concept__.
|
|
|
|
[table
|
|
[[Expression] [Semantics]]
|
|
[[`a > b`] [Match `a` followed by `b`. If `a` fails, no-match.
|
|
If `b` fails, throw an `expectation_failure<Iter>`]]
|
|
]
|
|
|
|
[note If you need an exception to be thrown if `a` fails, use the __qi_expectd__ directive instead of the expectation operator.]
|
|
|
|
[heading Attributes]
|
|
|
|
See __qi_comp_attr_notation__.
|
|
|
|
[table
|
|
[[Expression] [Attribute]]
|
|
[[`a > b`]
|
|
[``a: A, b: B --> (a > b): tuple<A, B>
|
|
a: A, b: Unused --> (a > b): A
|
|
a: Unused, b: B --> (a > b): B
|
|
a: Unused, b: Unused --> (a > b): Unused
|
|
|
|
a: A, b: A --> (a > b): vector<A>
|
|
a: vector<A>, b: A --> (a > b): vector<A>
|
|
a: A, b: vector<A> --> (a > b): vector<A>
|
|
a: vector<A>, b: vector<A> --> (a > b): vector<A>``]]
|
|
]
|
|
|
|
[heading Complexity]
|
|
|
|
[:The overall complexity of the expectation parser is defined by the sum
|
|
of the complexities of its elements. The complexity of the expectation
|
|
operator itself is O(N), where N is the number of elements in the
|
|
sequence.]
|
|
|
|
[heading Example]
|
|
|
|
[note The test harness for the example(s) below is presented in the
|
|
__qi_basics_examples__ section.]
|
|
|
|
Some using declarations:
|
|
|
|
[reference_using_declarations_expect]
|
|
|
|
[reference_expect]
|
|
|
|
[endsect] [/ Expectation]
|
|
|
|
[/------------------------------------------------------------------------------]
|
|
[section:kleene Kleene Parser (`*a`)]
|
|
|
|
[heading Description]
|
|
|
|
The kleene operator, `*a`, is a unary operator that matches its operand
|
|
zero or more times.
|
|
|
|
[heading Header]
|
|
|
|
// forwards to <boost/spirit/home/qi/operator/kleene.hpp>
|
|
#include <boost/spirit/include/qi_kleene.hpp>
|
|
|
|
Also, see __include_structure__.
|
|
|
|
[heading Model of]
|
|
|
|
[:__unary_parser_concept__]
|
|
|
|
[variablelist Notation
|
|
[[`a`] [A __parser_concept__]]
|
|
]
|
|
|
|
[heading Expression Semantics]
|
|
|
|
Semantics of an expression is defined only where it differs from, or is not
|
|
defined in __unary_parser_concept__.
|
|
|
|
[table
|
|
[[Expression] [Semantics]]
|
|
[[`*a`] [Match `a` zero or more times.]]
|
|
]
|
|
|
|
[heading Attributes]
|
|
|
|
See __qi_comp_attr_notation__.
|
|
|
|
[table
|
|
[[Expression] [Attribute]]
|
|
[[`*a`]
|
|
[``a: A --> *a: vector<A>
|
|
a: Unused --> *a: Unused``]]
|
|
]
|
|
|
|
[heading Complexity]
|
|
|
|
[:The overall complexity of the Kleene star is defined by the complexity
|
|
of its subject, `a`, multiplied by the number of repetitions. The
|
|
complexity of the Kleene star itself is O(N), where N is the number
|
|
successful repetitions.]
|
|
|
|
[heading Example]
|
|
|
|
[note The test harness for the example(s) below is presented in the
|
|
__qi_basics_examples__ section.]
|
|
|
|
[reference_kleene]
|
|
|
|
[endsect] [/ Kleene]
|
|
|
|
[/------------------------------------------------------------------------------]
|
|
[section:list List Parser (`a % b`)]
|
|
|
|
[heading Description]
|
|
|
|
The list operator, `a % b`, is a binary operator that matches a list of
|
|
one or more repetitions of `a` separated by occurrences of `b`. This is
|
|
equivalent to `a >> *(b >> a)`.
|
|
|
|
[heading Header]
|
|
|
|
// forwards to <boost/spirit/home/qi/operator/list.hpp>
|
|
#include <boost/spirit/include/qi_list.hpp>
|
|
|
|
Also, see __include_structure__.
|
|
|
|
[heading Model of]
|
|
|
|
[:__binary_parser_concept__]
|
|
|
|
[variablelist Notation
|
|
[[`a`, `b`] [A __parser_concept__]]
|
|
]
|
|
|
|
[heading Expression Semantics]
|
|
|
|
Semantics of an expression is defined only where it differs from, or is
|
|
not defined in __binary_parser_concept__.
|
|
|
|
[table
|
|
[[Expression] [Semantics]]
|
|
[[`a % b`] [Match a list of one or more repetitions of `a`
|
|
separated by occurrences of `b`. This is
|
|
equivalent to `a >> *(omit[b] >> a)`.]]
|
|
]
|
|
|
|
[note The list operator `a % b` omits the attribute of parser `b`. If you need
|
|
`b` to contribute to the result attribute choose `a >> *(b >> a)` over
|
|
the list operator `a % b`.]
|
|
|
|
|
|
[heading Attributes]
|
|
|
|
See __qi_comp_attr_notation__.
|
|
|
|
[table
|
|
[[Expression] [Attribute]]
|
|
[[`a % b`]
|
|
[``a: A, b: B --> (a % b): vector<A>
|
|
a: Unused, b: B --> (a % b): Unused``]]
|
|
]
|
|
|
|
[heading Complexity]
|
|
|
|
[:The overall complexity of the List is defined by the complexity of its
|
|
subject, `a`, multiplied by the number of repetitions. The complexity of
|
|
the List itself is O(N), where N is the number successful repetitions.]
|
|
|
|
[heading Example]
|
|
|
|
[note The test harness for the example(s) below is presented in the
|
|
__qi_basics_examples__ section.]
|
|
|
|
[reference_list]
|
|
|
|
[endsect] [/ List]
|
|
|
|
[/------------------------------------------------------------------------------]
|
|
[section:not_predicate Not-Predicate Parser (`!a`)]
|
|
|
|
[heading Description]
|
|
|
|
Syntactic predicates assert a certain conditional syntax to be satisfied
|
|
before evaluating another production. Similar to semantic predicates,
|
|
__qi_eps__, syntactic predicates do not consume any input. The /not-predicate/,
|
|
`!a`, is a negative syntactic predicate that returns a zero
|
|
length match only if its predicate fails to match.
|
|
|
|
[heading Header]
|
|
|
|
// forwards to <boost/spirit/home/qi/operator/not_predicate.hpp>
|
|
#include <boost/spirit/include/qi_not_predicate.hpp>
|
|
|
|
Also, see __include_structure__.
|
|
|
|
[heading Model of]
|
|
|
|
[:__unary_parser_concept__]
|
|
|
|
[variablelist Notation
|
|
[[`a`] [A __parser_concept__]]
|
|
]
|
|
|
|
[heading Expression Semantics]
|
|
|
|
Semantics of an expression is defined only where it differs from, or is
|
|
not defined in __unary_parser_concept__.
|
|
|
|
[table
|
|
[[Expression] [Semantics]]
|
|
[[`!a`] [If the predicate `a` matches, fail. Otherwise,
|
|
return a zero length match.]]
|
|
]
|
|
|
|
[heading Attributes]
|
|
|
|
See __qi_comp_attr_notation__.
|
|
|
|
[table
|
|
[[Expression] [Attribute]]
|
|
[[`!a`] [__unused_type__]]
|
|
]
|
|
|
|
[heading Complexity]
|
|
|
|
[:The complexity is defined by the complexity of the predicate, `a`]
|
|
|
|
[heading Example]
|
|
|
|
[note The test harness for the example(s) below is presented in the
|
|
__qi_basics_examples__ section.]
|
|
|
|
[reference_not_predicate]
|
|
|
|
[endsect] [/ Not Predicate]
|
|
|
|
[/------------------------------------------------------------------------------]
|
|
[section:optional Optional Parser (`-a`)]
|
|
|
|
[heading Description]
|
|
|
|
The optional operator, `-a`, is a unary operator that matches its
|
|
operand zero or one time.
|
|
|
|
[heading Header]
|
|
|
|
// forwards to <boost/spirit/home/qi/operator/optional.hpp>
|
|
#include <boost/spirit/include/qi_optional.hpp>
|
|
|
|
Also, see __include_structure__.
|
|
|
|
[heading Model of]
|
|
|
|
[:__unary_parser_concept__]
|
|
|
|
[variablelist Notation
|
|
[[`a`] [A __parser_concept__]]
|
|
]
|
|
|
|
[heading Expression Semantics]
|
|
|
|
Semantics of an expression is defined only where it differs from, or is not
|
|
defined in __unary_parser_concept__.
|
|
|
|
[table
|
|
[[Expression] [Semantics]]
|
|
[[`-a`] [Match `a` zero or one time.]]
|
|
]
|
|
|
|
[heading Attributes]
|
|
|
|
See __qi_comp_attr_notation__.
|
|
|
|
[table
|
|
[[Expression] [Attribute]]
|
|
[[`-a`]
|
|
[``a: A --> -a: optional<A>
|
|
a: Unused --> -a: Unused``]]
|
|
]
|
|
|
|
[heading Complexity]
|
|
|
|
[:The complexity is defined by the complexity of the operand, `a`]
|
|
|
|
[heading Example]
|
|
|
|
[note The test harness for the example(s) below is presented in the
|
|
__qi_basics_examples__ section.]
|
|
|
|
[reference_optional]
|
|
|
|
[endsect] [/ Optional]
|
|
|
|
[/------------------------------------------------------------------------------]
|
|
[section:permutation Permutation Parser (`a ^ b`)]
|
|
|
|
[heading Description]
|
|
|
|
The permutation operator, `a ^ b`, matches one or more operands (`a`, `b`,
|
|
... etc.) in any order:
|
|
|
|
a ^ b ^ ...
|
|
|
|
The operands are the elements in the permutation set. Each element in
|
|
the permutation set may occur at most once, but not all elements of the
|
|
given set need to be present. Note that by this definition, the
|
|
permutation operator is not limited to strict permutations.
|
|
|
|
For example:
|
|
|
|
char_('a') ^ 'b' ^ 'c'
|
|
|
|
matches:
|
|
|
|
"a", "ab", "abc", "cba", "bca" ... etc.
|
|
|
|
[heading Header]
|
|
|
|
// forwards to <boost/spirit/home/qi/operator/permutation.hpp>
|
|
#include <boost/spirit/include/qi_permutation.hpp>
|
|
|
|
Also, see __include_structure__.
|
|
|
|
[heading Model of]
|
|
|
|
[:__nary_parser_concept__]
|
|
|
|
[variablelist Notation
|
|
[[`a`, `b`] [A __parser_concept__]]
|
|
]
|
|
|
|
[heading Expression Semantics]
|
|
|
|
Semantics of an expression is defined only where it differs from, or is not
|
|
defined in __nary_parser_concept__.
|
|
|
|
[table
|
|
[[Expression] [Semantics]]
|
|
[[`a ^ b`] [Match `a` or `b` in any order. Each operand
|
|
may match zero or one time as long as at least
|
|
one operand matches.]]
|
|
]
|
|
|
|
[heading Attributes]
|
|
|
|
See __qi_comp_attr_notation__.
|
|
|
|
[table
|
|
[[Expression] [Attribute]]
|
|
[[`a ^ b`]
|
|
[``a: A, b: B --> (a ^ b): tuple<optional<A>, optional<B> >
|
|
a: A, b: Unused --> (a ^ b): optional<A>
|
|
a: Unused, b: B --> (a ^ b): optional<B>
|
|
a: Unused, b: Unused --> (a ^ b): Unused``]]
|
|
]
|
|
|
|
[heading Complexity]
|
|
|
|
[:The overall complexity of the permutation parser is defined by the sum
|
|
of the complexities of its elements, s, multiplied by log s. The
|
|
complexity of the permutation parser itself is O(N log N), where N is
|
|
the number of elements.]
|
|
|
|
[heading Example]
|
|
|
|
[note The test harness for the example(s) below is presented in the
|
|
__qi_basics_examples__ section.]
|
|
|
|
Some using declarations:
|
|
|
|
[reference_using_declarations_permutation]
|
|
|
|
[reference_permutation]
|
|
|
|
[endsect] [/ Permutation]
|
|
|
|
[/------------------------------------------------------------------------------]
|
|
[section:plus Plus Parser (`+a`)]
|
|
|
|
[heading Description]
|
|
|
|
The plus operator, `+a`, is a unary operator that matches its operand one
|
|
or more times.
|
|
|
|
[heading Header]
|
|
|
|
// forwards to <boost/spirit/home/qi/operator/plus.hpp>
|
|
#include <boost/spirit/include/qi_plus.hpp>
|
|
|
|
Also, see __include_structure__.
|
|
|
|
[heading Model of]
|
|
|
|
[:__unary_parser_concept__]
|
|
|
|
[variablelist Notation
|
|
[[`a`] [A __parser_concept__]]
|
|
]
|
|
|
|
[heading Expression Semantics]
|
|
|
|
Semantics of an expression is defined only where it differs from, or is not
|
|
defined in __unary_parser_concept__.
|
|
|
|
[table
|
|
[[Expression] [Semantics]]
|
|
[[`+a`] [Match `a` one or more times.]]
|
|
]
|
|
|
|
[heading Attributes]
|
|
|
|
See __qi_comp_attr_notation__.
|
|
|
|
[table
|
|
[[Expression] [Attribute]]
|
|
[[`+a`]
|
|
[``a: A --> +a: vector<A>
|
|
a: Unused --> +a: Unused``]]
|
|
]
|
|
|
|
[heading Complexity]
|
|
|
|
[:The overall complexity of the Plus is defined by the complexity of its
|
|
subject, `a`, multiplied by the number of repetitions. The complexity of
|
|
the Plus itself is O(N), where N is the number successful repetitions.]
|
|
|
|
[heading Example]
|
|
|
|
[note The test harness for the example(s) below is presented in the
|
|
__qi_basics_examples__ section.]
|
|
|
|
[reference_plus]
|
|
|
|
[endsect] [/ Plus]
|
|
|
|
[/------------------------------------------------------------------------------]
|
|
[section:sequence Sequence Parser (`a >> b`)]
|
|
|
|
[heading Description]
|
|
|
|
The sequence operator, `a >> b`, parses two or more operands (`a`,
|
|
`b`, ... etc.), in sequence:
|
|
|
|
a >> b >> ...
|
|
|
|
[heading Header]
|
|
|
|
// forwards to <boost/spirit/home/qi/operator/sequence.hpp>
|
|
#include <boost/spirit/include/qi_sequence.hpp>
|
|
|
|
Also, see __include_structure__.
|
|
|
|
[heading Model of]
|
|
|
|
[:__nary_parser_concept__]
|
|
|
|
[variablelist Notation
|
|
[[`a`, `b`] [A __parser_concept__]]
|
|
]
|
|
|
|
[heading Expression Semantics]
|
|
|
|
Semantics of an expression is defined only where it differs from, or is not
|
|
defined in __nary_parser_concept__.
|
|
|
|
[table
|
|
[[Expression] [Semantics]]
|
|
[[`a >> b`] [Match `a` followed by `b`.]]
|
|
]
|
|
|
|
[heading Attributes]
|
|
|
|
See __qi_comp_attr_notation__.
|
|
|
|
[table
|
|
[[Expression] [Attribute]]
|
|
[[`a >> b`]
|
|
[``a: A, b: B --> (a >> b): tuple<A, B>
|
|
a: A, b: Unused --> (a >> b): A
|
|
a: Unused, b: B --> (a >> b): B
|
|
a: Unused, b: Unused --> (a >> b): Unused
|
|
|
|
a: A, b: A --> (a >> b): vector<A>
|
|
a: vector<A>, b: A --> (a >> b): vector<A>
|
|
a: A, b: vector<A> --> (a >> b): vector<A>
|
|
a: vector<A>, b: vector<A> --> (a >> b): vector<A>``]]
|
|
]
|
|
|
|
[heading Complexity]
|
|
|
|
[:The overall complexity of the sequence parser is defined by the sum of
|
|
the complexities of its elements. The complexity of the sequence itself
|
|
is O(N), where N is the number of elements in the sequence.]
|
|
|
|
[heading Example]
|
|
|
|
Some using declarations:
|
|
|
|
[reference_using_declarations_sequence]
|
|
|
|
[note The test harness for the example(s) below is presented in the
|
|
__qi_basics_examples__ section.]
|
|
|
|
[reference_sequence]
|
|
|
|
[endsect] [/ Sequence]
|
|
|
|
[/------------------------------------------------------------------------------]
|
|
[section:sequential_or Sequential Or Parser (`a || b`)]
|
|
|
|
[heading Description]
|
|
|
|
The sequential-or operator, `a || b`, matches `a` or `b` or `a` followed
|
|
by `b`. That is, if both `a` and `b` match, it must be in sequence; this
|
|
is equivalent to `a >> -b | b`:
|
|
|
|
a || b || ...
|
|
|
|
[heading Header]
|
|
|
|
// forwards to <boost/spirit/home/qi/operator/sequential_or.hpp>
|
|
#include <boost/spirit/include/qi_sequential_or.hpp>
|
|
|
|
Also, see __include_structure__.
|
|
|
|
[heading Model of]
|
|
|
|
[:__nary_parser_concept__]
|
|
|
|
[variablelist Notation
|
|
[[`a`, `b`] [A __parser_concept__]]
|
|
]
|
|
|
|
[heading Expression Semantics]
|
|
|
|
Semantics of an expression is defined only where it differs from, or is not
|
|
defined in __nary_parser_concept__.
|
|
|
|
[table
|
|
[[Expression] [Semantics]]
|
|
[[`a || b`] [Match `a` or `b` in sequence. equivalent to `a >> -b | b`]]
|
|
]
|
|
|
|
[heading Attributes]
|
|
|
|
See __qi_comp_attr_notation__.
|
|
|
|
[table
|
|
[[Expression] [Attribute]]
|
|
[[`a || b`]
|
|
[``a: A, b: B --> (a || b): tuple<optional<A>, optional<B> >
|
|
a: A, b: Unused --> (a || b): optional<A>
|
|
a: Unused, b: B --> (a || b): optional<B>
|
|
a: Unused, b: Unused --> (a || b): Unused
|
|
|
|
a: A, b: A --> (a || b): vector<optional<A> >``]]
|
|
]
|
|
|
|
[note The sequential-or parser behaves attribute-wise very similar to the
|
|
plain sequence parser (`a >> b`) in the sense that it exposes the
|
|
attributes of its elements separately. For instance, if you attach a
|
|
semantic action to the whole sequential-or:
|
|
``
|
|
(int_ || int_)[print_pair(_1, _2)]
|
|
``
|
|
the function object `print_pair` would be invoked with the
|
|
attribute of the first `int_` (`boost::optional<int>`) as its first
|
|
parameter and the attribute of the second `int_` (`boost::optional<int>`
|
|
as well) as its second parameter.]
|
|
|
|
[heading Complexity]
|
|
|
|
[:The overall complexity of the sequential-or parser is defined by the
|
|
sum of the complexities of its elements. The complexity of the
|
|
sequential-or itself is O(N), where N is the number of elements in the
|
|
sequence.]
|
|
|
|
[heading Example]
|
|
|
|
[note The test harness for the example(s) below is presented in the
|
|
__qi_basics_examples__ section.]
|
|
|
|
Some using declarations:
|
|
|
|
[reference_using_declarations_sequential_or]
|
|
|
|
[reference_sequential_or]
|
|
|
|
[endsect] [/ Sequential Or]
|
|
|
|
[endsect]
|