Compiling oak v0.3.1 (file:///home/ptalbot/repositories/oak)
Compiling oak_runtime v0.3.1 (file:///home/ptalbot/repositories/oak)
note: pub mod ntcc {
#![allow(dead_code)]
#![allow(unused_parens, unused_variables, unused_mut, unused_imports)]
extern crate oak_runtime;
use oak_runtime::parse_state::MergeSuccess;
#[inline]
fn parse_sequence_in_rule_dotdot_12<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_dotdot_12(stream)
}
#[inline]
pub fn parse_tell<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_tell(stream)
}
#[inline]
pub fn recognize_par_kw<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_par_kw_37(stream)
}
#[inline]
fn recognize_star_in_rule_integer_75<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
{
let mut state =
oak_runtime::ParseState::stateless(stream.clone());
let mut next =
recognize_class_char_in_rule_integer_74(state.stream());
while state.soft_merge(next) {
next =
recognize_class_char_in_rule_integer_74(state.stream());
}
{
if state.stream_eq(&stream) {
state.to_error()
} else { state }
}
}
}
#[inline]
pub fn parse_min_bound<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_min_bound(stream)
}
#[inline]
pub fn recognize_oror<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_sequence_in_rule_oror_61(stream)
}
#[inline]
pub fn parse_expression2<S>(mut stream: S)
-> oak_runtime::ParseState<S, Vec<()>> where S: oak_runtime::CharStream {
parse_choice_in_rule_expression2_28(stream)
}
#[inline]
pub fn recognize_var_decl<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_var_decl_71(stream)
}
#[inline]
fn recognize_sequence_in_rule_sum_body_51<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_or(stream).and_then(|success| { let stream = success.stream;
recognize_when(stream) })
}
#[inline]
pub fn parse_right_arrow<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_right_arrow(stream)
}
#[inline]
fn recognize_sequence_in_rule_oror_61<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_oror_60(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
fn recognize_sequence_in_rule_when_88<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_when_kw(stream).and_then(|success| {
let stream = success.stream;
recognize_entails(stream).and_then(|success|
{
let stream =
success.stream;
recognize_right_arrow(stream).and_then(|success|
{
let stream =
success.stream;
recognize_expression(stream)
})
})
})
}
#[inline]
pub fn parse_end_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_end_kw(stream)
}
#[inline]
fn recognize_sequence_in_rule_gt_64<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_gt_63(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
pub fn recognize_async_kw<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_async_kw_39(stream)
}
#[inline]
fn parse_sequence_in_rule_entailed_by_20<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_entailed_by_20(stream)
}
#[inline]
fn recognize_sequence_in_rule_par_kw_37<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_par_kw_36(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
fn parse_sequence_in_rule_dom_kw_41<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_dom_kw_41(stream)
}
#[inline]
fn recognize_sequence_in_rule_le_85<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_le_84(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
fn recognize_sequence_in_rule_range_23<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_range_bound(stream).and_then(|success| {
let stream = success.stream;
recognize_dotdot(stream).and_then(|success|
{
let stream =
success.stream;
recognize_range_bound(stream)
})
})
}
#[inline]
fn recognize_str_literal_in_rule_entail_55<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "|=")
}
#[inline]
fn recognize_sequence_in_rule_let_in_50<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_let_kw(stream).and_then(|success| {
let stream = success.stream;
recognize_var_decl(stream).and_then(|success|
{
let stream =
success.stream;
recognize_in_kw(stream).and_then(|success|
{
let stream =
success.stream;
recognize_expression(stream)
})
})
})
}
#[inline]
fn recognize_str_literal_in_rule_max_kw_21<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "max")
}
#[inline]
pub fn parse_next<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_next(stream)
}
#[inline]
pub fn recognize_when<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_sequence_in_rule_when_88(stream)
}
#[inline]
pub fn recognize_range<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_sequence_in_rule_range_23(stream)
}
#[inline]
pub fn parse_var_ident<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_var_ident(stream)
}
#[inline]
fn recognize_sequence_in_rule_next_81<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_next_kw(stream).and_then(|success| {
let stream = success.stream;
recognize_expression(stream) })
}
#[inline]
fn recognize_sequence_in_rule_in_kw_53<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_in_kw_52(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
fn parse_sequence_in_rule_par_27<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_par_27(stream)
}
#[inline]
pub fn recognize_end_kw<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_end_kw_59(stream)
}
#[inline]
fn parse_sequence_in_rule_par_body_54<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_par_body_54(stream)
}
#[inline]
fn recognize_sequence_in_rule_dotdot_12<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_dotdot_11(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
pub fn parse_async<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_async(stream)
}
#[inline]
pub fn recognize_eq_bind<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_eq_bind_94(stream)
}
#[inline]
pub fn parse_max_bound<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_max_bound(stream)
}
#[inline]
pub fn recognize_entailed_by<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_entailed_by_20(stream)
}
#[inline]
pub fn recognize_max_kw<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_max_kw_22(stream)
}
#[inline]
pub fn recognize_expression<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_expression2(stream)
}
#[inline]
fn recognize_str_literal_in_rule_lt_34<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "<")
}
#[inline]
fn parse_choice_in_rule_constraint_operand_4<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_choice_in_rule_constraint_operand_4(stream)
}
#[inline]
fn recognize_optional_in_rule_sum_65<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::optional_recognizer(recognize_or(stream.clone()), stream)
}
#[inline]
fn recognize_sequence_in_rule_when_kw_1<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_when_kw_0(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
fn recognize_choice_in_rule_constraint_operand_4<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_integer(stream.clone()).or_else_merge(||
recognize_var_ident(stream))
}
#[inline]
fn recognize_sequence_in_rule_sum_68<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_pick_kw(stream).and_then(|success| {
let stream = success.stream;
recognize_optional_in_rule_sum_65(stream).and_then(|success|
{
let stream =
success.stream;
recognize_when(stream).and_then(|success|
{
let stream =
success.stream;
recognize_star_in_rule_sum_66(stream).and_then(|success|
{
let stream =
success.stream;
recognize_optional_in_rule_sum_67(stream)
})
})
})
})
}
#[inline]
pub fn recognize_constraint<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_constraint_70(stream)
}
#[inline]
pub fn recognize_unless_kw<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_unless_kw_78(stream)
}
#[inline]
pub fn parse_entail<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_entail(stream)
}
#[inline]
fn recognize_sequence_in_rule_eq_16<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_eq_15(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
fn parse_sequence_in_rule_min_bound_46<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_min_bound_46(stream)
}
#[inline]
fn recognize_str_literal_in_rule_or_72<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "|")
}
#[inline]
pub fn recognize_par_body<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_par_body_54(stream)
}
#[inline]
fn recognize_sequence_in_rule_neq_49<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_neq_48(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
fn recognize_sequence_in_rule_tell_5<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_store_kw(stream).and_then(|success| {
let stream = success.stream;
recognize_left_arrow(stream).and_then(|success|
{
let stream =
success.stream;
recognize_constraint(stream)
})
})
}
#[inline]
fn recognize_star_in_rule_par_25<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
{
let mut state =
oak_runtime::ParseState::stateless(stream.clone());
let mut next = recognize_par_body(state.stream());
while state.soft_merge(next) {
next = recognize_par_body(state.stream());
}
state
}
}
#[inline]
fn recognize_sequence_in_rule_ge_96<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_ge_95(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
fn parse_sequence_in_rule_entails_69<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_entails_69(stream)
}
#[inline]
fn recognize_class_char_in_rule_spacing_89<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
{
let past = stream.clone();
match stream.next() {
Some(current) if
(current >= ' ' && current <= ' ') ||
(current >= '\n' && current <= '\n') ||
(current >= '\t' && current <= '\t') => {
oak_runtime::ParseState::stateless(stream)
}
_ => { oak_runtime::ParseState::error(past, "[\" \n\t\"]") }
}
}
}
#[inline]
fn parse_sequence_in_rule_right_arrow_92<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_right_arrow_92(stream)
}
#[inline]
fn recognize_not_predicate_in_rule_var_ident_7<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::not_predicate(recognize_class_char_in_rule_var_ident_6(stream.clone()),
stream)
}
#[inline]
pub fn parse_domain<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_domain(stream)
}
#[inline]
pub fn parse_skip_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_skip_kw(stream)
}
#[inline]
pub fn parse_range<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_range(stream)
}
#[inline]
fn parse_sequence_in_rule_left_arrow_14<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_left_arrow_14(stream)
}
#[inline]
fn recognize_str_literal_in_rule_let_kw_82<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "let")
}
#[inline]
fn parse_sequence_in_rule_eq_bind_94<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_eq_bind_94(stream)
}
#[inline]
fn recognize_str_literal_in_rule_when_kw_0<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "when")
}
#[inline]
fn parse_sequence_in_rule_par_kw_37<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_par_kw_37(stream)
}
#[inline]
fn recognize_str_literal_in_rule_skip_kw_32<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "skip")
}
#[inline]
pub fn parse_in_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_in_kw(stream)
}
#[inline]
pub fn parse_constraint_operand<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_constraint_operand(stream)
}
#[inline]
fn parse_sequence_in_rule_unless_47<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_unless_47(stream)
}
#[inline]
fn recognize_str_literal_in_rule_neq_48<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "<>")
}
#[inline]
fn parse_sequence_in_rule_gt_64<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_gt_64(stream)
}
#[inline]
fn parse_sequence_in_rule_entail_56<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_entail_56(stream)
}
#[inline]
pub fn parse_left_arrow<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_left_arrow(stream)
}
#[inline]
pub fn parse_spacing<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_spacing(stream)
}
#[inline]
pub fn recognize_le<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_sequence_in_rule_le_85(stream)
}
#[inline]
pub fn parse_ntcc<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_ntcc(stream)
}
#[inline]
pub fn parse_neq<S>(mut stream: S) -> oak_runtime::ParseState<S, ()> where
S: oak_runtime::CharStream {
recognize_neq(stream)
}
#[inline]
pub fn parse_comparison<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_comparison(stream)
}
#[inline]
pub fn parse_unless<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_unless(stream)
}
#[inline]
fn parse_sequence_in_rule_sum_body_51<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_sum_body_51(stream)
}
#[inline]
fn parse_choice_in_rule_var_range_17<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_choice_in_rule_var_range_17(stream)
}
#[inline]
fn parse_sequence_in_rule_domain_31<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_domain_31(stream)
}
#[inline]
pub fn parse_store_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_store_kw(stream)
}
#[inline]
pub fn recognize_ge<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_sequence_in_rule_ge_96(stream)
}
#[inline]
fn recognize_choice_in_rule_comparison_18<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_le(stream.clone()).or_else_merge(||
recognize_neq(stream.clone()).or_else_merge(||
recognize_lt(stream.clone()).or_else_merge(||
recognize_ge(stream.clone()).or_else_merge(||
recognize_gt(stream.clone()).or_else_merge(||
recognize_eq(stream))))))
}
#[inline]
pub fn parse_sum<S>(mut stream: S) -> oak_runtime::ParseState<S, Vec<()>>
where S: oak_runtime::CharStream {
parse_sequence_in_rule_sum_68(stream)
}
#[inline]
fn recognize_sequence_in_rule_par_27<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_par_kw(stream).and_then(|success| {
let stream = success.stream;
recognize_optional_in_rule_par_24(stream).and_then(|success|
{
let stream =
success.stream;
recognize_expression(stream).and_then(|success|
{
let stream =
success.stream;
recognize_star_in_rule_par_25(stream).and_then(|success|
{
let stream =
success.stream;
recognize_optional_in_rule_par_26(stream)
})
})
})
})
}
#[inline]
pub fn parse_rep<S>(mut stream: S) -> oak_runtime::ParseState<S, ()> where
S: oak_runtime::CharStream {
recognize_rep(stream)
}
#[inline]
pub fn recognize_var_range<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_choice_in_rule_var_range_17(stream)
}
#[inline]
fn parse_choice_in_rule_comparison_18<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_choice_in_rule_comparison_18(stream)
}
#[inline]
pub fn parse_eq<S>(mut stream: S) -> oak_runtime::ParseState<S, ()> where
S: oak_runtime::CharStream {
recognize_eq(stream)
}
#[inline]
pub fn recognize_unless<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_unless_47(stream)
}
#[inline]
pub fn parse_var_decl<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_var_decl(stream)
}
#[inline]
pub fn recognize_or<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_sequence_in_rule_or_73(stream)
}
#[inline]
fn recognize_sequence_in_rule_domain_31<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_dom_kw(stream).and_then(|success| {
let stream = success.stream;
recognize_var_ident(stream) })
}
#[inline]
fn recognize_sequence_in_rule_store_kw_45<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_store_kw_44(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
fn parse_sequence_in_rule_async_kw_39<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_async_kw_39(stream)
}
#[inline]
fn recognize_str_literal_in_rule_ge_95<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, ">=")
}
#[inline]
fn parse_sequence_in_rule_when_kw_1<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_when_kw_1(stream)
}
#[inline]
pub fn parse_var_range<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_var_range(stream)
}
#[inline]
pub fn recognize_constraint_operand<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_choice_in_rule_constraint_operand_4(stream)
}
#[inline]
fn recognize_sequence_in_rule_unless_47<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_unless_kw(stream).and_then(|success| {
let stream = success.stream;
recognize_entailed_by(stream).and_then(|success|
{
let stream =
success.stream;
recognize_next(stream)
})
})
}
#[inline]
fn parse_optional_in_rule_sum_67<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_optional_in_rule_sum_67(stream)
}
#[inline]
fn recognize_choice_in_rule_var_range_17<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_range(stream.clone()).or_else_merge(||
recognize_domain(stream))
}
#[inline]
pub fn parse_integer<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_integer(stream)
}
#[inline]
fn recognize_optional_in_rule_par_24<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::optional_recognizer(recognize_oror(stream.clone()),
stream)
}
#[inline]
pub fn recognize_gt<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_sequence_in_rule_gt_64(stream)
}
#[inline]
pub fn parse_dom_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_dom_kw(stream)
}
#[inline]
fn recognize_str_literal_in_rule_dotdot_11<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "..")
}
#[inline]
pub fn parse_oror<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_oror(stream)
}
#[inline]
pub fn parse_async_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_async_kw(stream)
}
#[inline]
fn parse_sequence_in_rule_var_ident_10<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_var_ident_10(stream)
}
#[inline]
fn recognize_str_literal_in_rule_le_84<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "<=")
}
#[inline]
fn recognize_str_literal_in_rule_left_arrow_13<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "<-")
}
#[inline]
fn recognize_class_char_in_rule_var_ident_6<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
{
let past = stream.clone();
match stream.next() {
Some(current) if (current >= '0' && current <= '9') => {
oak_runtime::ParseState::stateless(stream)
}
_ => { oak_runtime::ParseState::error(past, "[\"0-9\"]") }
}
}
}
#[inline]
fn recognize_sequence_in_rule_end_kw_59<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_end_kw_58(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
fn recognize_str_literal_in_rule_min_kw_42<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "min")
}
#[inline]
fn recognize_choice_in_rule_expression2_28<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sum(stream.clone()).or_else_merge(||
recognize_par(stream.clone()).or_else_merge(||
recognize_tell(stream.clone()).or_else_merge(||
recognize_next(stream.clone()).or_else_merge(||
recognize_async(stream.clone()).or_else_merge(||
recognize_rep(stream.clone()).or_else_merge(||
recognize_unless(stream.clone()).or_else_merge(||
recognize_let_in(stream.clone()).or_else_merge(||
recognize_skip_kw(stream)))))))))
}
#[inline]
fn recognize_sequence_in_rule_skip_kw_33<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_skip_kw_32(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
pub fn recognize_dom_kw<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_dom_kw_41(stream)
}
#[inline]
fn recognize_sequence_in_rule_constraint_70<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_constraint_operand(stream).and_then(|success| {
let stream =
success.stream;
recognize_comparison(stream).and_then(|success|
{
let stream =
success.stream;
recognize_constraint_operand(stream)
})
})
}
#[inline]
pub fn parse_min_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_min_kw(stream)
}
#[inline]
fn recognize_sequence_in_rule_par_body_54<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_oror(stream).and_then(|success| {
let stream = success.stream;
recognize_expression(stream) })
}
#[inline]
fn recognize_sequence_in_rule_async_kw_39<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_async_kw_38(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
fn parse_sequence_in_rule_integer_76<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_integer_76(stream)
}
#[inline]
fn recognize_star_in_rule_sum_66<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
{
let mut state =
oak_runtime::ParseState::stateless(stream.clone());
let mut next = recognize_sum_body(state.stream());
while state.soft_merge(next) {
next = recognize_sum_body(state.stream());
}
state
}
}
#[inline]
pub fn recognize_var_ident<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_var_ident_10(stream)
}
#[inline]
fn parse_sequence_in_rule_async_19<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_async_19(stream)
}
#[inline]
fn parse_sequence_in_rule_lt_35<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_lt_35(stream)
}
#[inline]
pub fn parse_range_bound<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_range_bound(stream)
}
#[inline]
pub fn recognize_comparison<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_choice_in_rule_comparison_18(stream)
}
#[inline]
pub fn parse_gt<S>(mut stream: S) -> oak_runtime::ParseState<S, ()> where
S: oak_runtime::CharStream {
recognize_gt(stream)
}
#[inline]
fn recognize_sequence_in_rule_ntcc_2<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_spacing(stream).and_then(|success| {
let stream = success.stream;
recognize_expression(stream) })
}
#[inline]
fn recognize_class_char_in_rule_var_ident_8<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
{
let past = stream.clone();
match stream.next() {
Some(current) if
(current >= 'a' && current <= 'z') ||
(current >= 'A' && current <= 'Z') ||
(current >= '0' && current <= '9') ||
(current >= '_' && current <= '_') => {
oak_runtime::ParseState::stateless(stream)
}
_ => {
oak_runtime::ParseState::error(past, "[\"a-zA-Z0-9_\"]")
}
}
}
}
#[inline]
fn parse_sequence_in_rule_pick_kw_80<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_pick_kw_80(stream)
}
#[inline]
fn parse_sequence_in_rule_in_kw_53<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_in_kw_53(stream)
}
#[inline]
fn recognize_str_literal_in_rule_store_kw_44<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "store")
}
#[inline]
fn recognize_sequence_in_rule_right_arrow_92<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_right_arrow_91(stream).and_then(|success|
{
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
fn parse_sequence_in_rule_min_kw_43<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_min_kw_43(stream)
}
#[inline]
fn recognize_str_literal_in_rule_rep_kw_29<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "rep")
}
#[inline]
fn parse_sequence_in_rule_unless_kw_78<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_unless_kw_78(stream)
}
#[inline]
fn recognize_choice_in_rule_range_bound_57<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_integer(stream.clone()).or_else_merge(||
recognize_min_bound(stream.clone()).or_else_merge(||
recognize_max_bound(stream)))
}
#[inline]
fn recognize_sequence_in_rule_next_kw_87<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_next_kw_86(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
pub fn recognize_next_kw<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_next_kw_87(stream)
}
#[inline]
fn recognize_star_in_rule_spacing_90<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
{
let mut state =
oak_runtime::ParseState::stateless(stream.clone());
let mut next =
recognize_class_char_in_rule_spacing_89(state.stream());
while state.soft_merge(next) {
next =
recognize_class_char_in_rule_spacing_89(state.stream());
}
state
}
}
#[inline]
pub fn recognize_sum<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_sequence_in_rule_sum_68(stream)
}
#[inline]
fn recognize_str_literal_in_rule_end_kw_58<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "end")
}
#[inline]
fn recognize_sequence_in_rule_or_73<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_or_72(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
fn recognize_sequence_in_rule_dom_kw_41<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_dom_kw_40(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
pub fn parse_lt<S>(mut stream: S) -> oak_runtime::ParseState<S, ()> where
S: oak_runtime::CharStream {
recognize_lt(stream)
}
#[inline]
fn recognize_sequence_in_rule_max_kw_22<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_max_kw_21(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
fn parse_sequence_in_rule_ge_96<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_ge_96(stream)
}
#[inline]
fn recognize_sequence_in_rule_left_arrow_14<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_left_arrow_13(stream).and_then(|success|
{
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
fn parse_sequence_in_rule_tell_5<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_tell_5(stream)
}
#[inline]
pub fn recognize_async<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_sequence_in_rule_async_19(stream)
}
#[inline]
pub fn parse_dotdot<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_dotdot(stream)
}
#[inline]
pub fn recognize_left_arrow<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_left_arrow_14(stream)
}
#[inline]
fn recognize_str_literal_in_rule_next_kw_86<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "next")
}
#[inline]
fn recognize_sequence_in_rule_eq_bind_94<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_eq_bind_93(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
pub fn parse_entails<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_entails(stream)
}
#[inline]
pub fn parse_sum_body<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_sum_body(stream)
}
#[inline]
pub fn recognize_integer<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_integer_76(stream)
}
#[inline]
pub fn parse_constraint<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_constraint(stream)
}
#[inline]
fn parse_sequence_in_rule_var_decl_71<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_var_decl_71(stream)
}
#[inline]
pub fn recognize_domain<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_domain_31(stream)
}
#[inline]
fn parse_sequence_in_rule_neq_49<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_neq_49(stream)
}
#[inline]
pub fn parse_le<S>(mut stream: S) -> oak_runtime::ParseState<S, ()> where
S: oak_runtime::CharStream {
recognize_le(stream)
}
#[inline]
pub fn parse_next_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_next_kw(stream)
}
#[inline]
fn parse_sequence_in_rule_next_81<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_next_81(stream)
}
#[inline]
pub fn recognize_sum_body<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_sum_body_51(stream)
}
#[inline]
fn parse_star_in_rule_spacing_90<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_star_in_rule_spacing_90(stream)
}
#[inline]
fn recognize_str_literal_in_rule_gt_63<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, ">")
}
#[inline]
fn recognize_sequence_in_rule_entail_56<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_entail_55(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
fn recognize_sequence_in_rule_min_bound_46<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_min_kw(stream).and_then(|success| {
let stream = success.stream;
recognize_var_ident(stream) })
}
#[inline]
pub fn parse_par<S>(mut stream: S) -> oak_runtime::ParseState<S, ()> where
S: oak_runtime::CharStream {
recognize_par(stream)
}
#[inline]
fn parse_sequence_in_rule_rep_kw_30<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_rep_kw_30(stream)
}
#[inline]
fn recognize_sequence_in_rule_async_19<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_async_kw(stream).and_then(|success| {
let stream = success.stream;
recognize_expression(stream) })
}
#[inline]
pub fn parse_or<S>(mut stream: S) -> oak_runtime::ParseState<S, ()> where
S: oak_runtime::CharStream {
recognize_or(stream)
}
#[inline]
pub fn recognize_min_bound<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_min_bound_46(stream)
}
#[inline]
pub fn recognize_neq<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_sequence_in_rule_neq_49(stream)
}
#[inline]
fn recognize_sequence_in_rule_max_bound_62<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_max_kw(stream).and_then(|success| {
let stream = success.stream;
recognize_var_ident(stream) })
}
#[inline]
pub fn parse_expression<S>(mut stream: S)
-> oak_runtime::ParseState<S, Vec<()>> where S: oak_runtime::CharStream {
parse_expression2(stream)
}
#[inline]
fn parse_sequence_in_rule_let_kw_83<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_let_kw_83(stream)
}
#[inline]
fn recognize_sequence_in_rule_entailed_by_20<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_constraint(stream).and_then(|success| {
let stream = success.stream;
recognize_entail(stream).and_then(|success|
{
let stream =
success.stream;
recognize_store_kw(stream)
})
})
}
#[inline]
fn parse_sequence_in_rule_skip_kw_33<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_skip_kw_33(stream)
}
#[inline]
fn parse_sequence_in_rule_oror_61<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_oror_61(stream)
}
#[inline]
pub fn recognize_when_kw<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_when_kw_1(stream)
}
#[inline]
pub fn parse_unless_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_unless_kw(stream)
}
#[inline]
pub fn recognize_let_in<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_let_in_50(stream)
}
#[inline]
pub fn recognize_entail<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_entail_56(stream)
}
#[inline]
fn parse_sequence_in_rule_end_kw_59<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_end_kw_59(stream)
}
#[inline]
pub fn recognize_tell<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_sequence_in_rule_tell_5(stream)
}
#[inline]
fn recognize_sequence_in_rule_var_decl_71<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_var_ident(stream).and_then(|success| {
let stream = success.stream;
recognize_eq_bind(stream).and_then(|success|
{
let stream =
success.stream;
recognize_var_range(stream)
})
})
}
#[inline]
fn parse_sequence_in_rule_next_kw_87<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_next_kw_87(stream)
}
#[inline]
pub fn recognize_right_arrow<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_right_arrow_92(stream)
}
#[inline]
fn recognize_star_in_rule_var_ident_9<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
{
let mut state =
oak_runtime::ParseState::stateless(stream.clone());
let mut next =
recognize_class_char_in_rule_var_ident_8(state.stream());
while state.soft_merge(next) {
next =
recognize_class_char_in_rule_var_ident_8(state.stream());
}
{
if state.stream_eq(&stream) {
state.to_error()
} else { state }
}
}
}
#[inline]
pub fn recognize_entails<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_entails_69(stream)
}
#[inline]
fn recognize_sequence_in_rule_unless_kw_78<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_unless_kw_77(stream).and_then(|success|
{
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
pub fn recognize_range_bound<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_choice_in_rule_range_bound_57(stream)
}
#[inline]
fn parse_sequence_in_rule_rep_3<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_rep_3(stream)
}
#[inline]
pub fn recognize_lt<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_sequence_in_rule_lt_35(stream)
}
#[inline]
pub fn parse_rep_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_rep_kw(stream)
}
#[inline]
fn recognize_sequence_in_rule_let_kw_83<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_let_kw_82(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
fn parse_choice_in_rule_range_bound_57<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_choice_in_rule_range_bound_57(stream)
}
#[inline]
pub fn parse_let_in<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_let_in(stream)
}
#[inline]
fn parse_sequence_in_rule_max_kw_22<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_max_kw_22(stream)
}
#[inline]
pub fn recognize_rep<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_sequence_in_rule_rep_3(stream)
}
#[inline]
fn recognize_class_char_in_rule_integer_74<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
{
let past = stream.clone();
match stream.next() {
Some(current) if (current >= '0' && current <= '9') => {
oak_runtime::ParseState::stateless(stream)
}
_ => { oak_runtime::ParseState::error(past, "[\"0-9\"]") }
}
}
}
#[inline]
fn recognize_str_literal_in_rule_right_arrow_91<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "->")
}
#[inline]
fn recognize_str_literal_in_rule_eq_15<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "==")
}
#[inline]
pub fn parse_entailed_by<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_entailed_by(stream)
}
#[inline]
pub fn recognize_min_kw<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_min_kw_43(stream)
}
#[inline]
pub fn recognize_dotdot<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_dotdot_12(stream)
}
#[inline]
pub fn parse_par_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_par_kw(stream)
}
#[inline]
fn recognize_str_literal_in_rule_unless_kw_77<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "unless")
}
#[inline]
fn recognize_sequence_in_rule_lt_35<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_lt_34(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
fn parse_sequence_in_rule_max_bound_62<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_max_bound_62(stream)
}
#[inline]
fn parse_sequence_in_rule_or_73<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_or_73(stream)
}
#[inline]
pub fn recognize_let_kw<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_let_kw_83(stream)
}
#[inline]
pub fn recognize_eq<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_sequence_in_rule_eq_16(stream)
}
#[inline]
fn recognize_str_literal_in_rule_eq_bind_93<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "=")
}
#[inline]
pub fn parse_ge<S>(mut stream: S) -> oak_runtime::ParseState<S, ()> where
S: oak_runtime::CharStream {
recognize_ge(stream)
}
#[inline]
pub fn recognize_spacing<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_star_in_rule_spacing_90(stream)
}
#[inline]
pub fn parse_pick_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_pick_kw(stream)
}
#[inline]
fn recognize_str_literal_in_rule_dom_kw_40<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "dom")
}
#[inline]
pub fn parse_par_body<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_par_body(stream)
}
#[inline]
fn parse_choice_in_rule_expression2_28<S>(mut stream: S)
-> oak_runtime::ParseState<S, Vec<()>> where S: oak_runtime::CharStream {
parse_sum(stream.clone()).or_else_merge(||
parse_par(stream.clone()).or_else_merge(||
parse_tell(stream.clone()).or_else_merge(||
parse_next(stream.clone()).or_else_merge(||
parse_async(stream.clone()).or_else_merge(||
parse_rep(stream.clone()).or_else_merge(||
parse_unless(stream.clone()).or_else_merge(||
parse_let_in(stream.clone()).or_else_merge(||
parse_skip_kw(stream)))))))))
}
#[inline]
fn parse_sequence_in_rule_eq_16<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_eq_16(stream)
}
#[inline]
pub fn recognize_ntcc<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_sequence_in_rule_ntcc_2(stream)
}
#[inline]
pub fn recognize_in_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_sequence_in_rule_in_kw_53(stream)
}
#[inline]
fn recognize_sequence_in_rule_min_kw_43<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_min_kw_42(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
pub fn parse_let_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_let_kw(stream)
}
#[inline]
pub fn recognize_skip_kw<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_skip_kw_33(stream)
}
#[inline]
fn parse_sequence_in_rule_le_85<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_le_85(stream)
}
#[inline]
pub fn parse_when<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_when(stream)
}
#[inline]
fn recognize_str_literal_in_rule_async_kw_38<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "async")
}
#[inline]
fn parse_sequence_in_rule_range_23<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_range_23(stream)
}
#[inline]
fn recognize_optional_in_rule_sum_67<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::optional_recognizer(recognize_end_kw(stream.clone()),
stream)
}
#[inline]
fn parse_sequence_in_rule_store_kw_45<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_store_kw_45(stream)
}
#[inline]
fn recognize_sequence_in_rule_rep_3<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_rep_kw(stream).and_then(|success| {
let stream = success.stream;
recognize_expression(stream) })
}
#[inline]
fn recognize_str_literal_in_rule_pick_kw_79<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "pick")
}
#[inline]
fn parse_star_in_rule_sum_66<S>(mut stream: S)
-> oak_runtime::ParseState<S, Vec<()>> where S: oak_runtime::CharStream {
{
let mut state =
oak_runtime::ParseState::success(stream.clone(), vec!());
let mut next = parse_sum_body(state.stream());
while state.soft_merge(next) {
next = parse_sum_body(state.stream());
}
state
}
}
#[inline]
fn recognize_sequence_in_rule_pick_kw_80<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_pick_kw_79(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
pub fn recognize_max_bound<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_max_bound_62(stream)
}
#[inline]
fn recognize_str_literal_in_rule_in_kw_52<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "in")
}
#[inline]
fn parse_sequence_in_rule_ntcc_2<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_ntcc_2(stream)
}
#[inline]
fn parse_optional_in_rule_sum_65<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_optional_in_rule_sum_65(stream)
}
#[inline]
fn recognize_optional_in_rule_par_26<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::optional_recognizer(recognize_end_kw(stream.clone()),
stream)
}
#[inline]
pub fn recognize_rep_kw<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_rep_kw_30(stream)
}
#[inline]
fn recognize_str_literal_in_rule_oror_60<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "||")
}
#[inline]
pub fn recognize_expression2<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_choice_in_rule_expression2_28(stream)
}
#[inline]
pub fn parse_max_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_max_kw(stream)
}
#[inline]
fn parse_sequence_in_rule_constraint_70<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_constraint_70(stream)
}
#[inline]
fn parse_sequence_in_rule_let_in_50<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_let_in_50(stream)
}
#[inline]
fn parse_sequence_in_rule_when_88<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_when_88(stream)
}
#[inline]
fn recognize_sequence_in_rule_entails_69<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_store_kw(stream).and_then(|success| {
let stream = success.stream;
recognize_entail(stream).and_then(|success|
{
let stream =
success.stream;
recognize_constraint(stream)
})
})
}
#[inline]
pub fn parse_eq_bind<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_eq_bind(stream)
}
#[inline]
pub fn recognize_pick_kw<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_pick_kw_80(stream)
}
#[inline]
fn recognize_sequence_in_rule_var_ident_10<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_not_predicate_in_rule_var_ident_7(stream).and_then(|success|
{
let stream =
success.stream;
recognize_star_in_rule_var_ident_9(stream).and_then(|success|
{
let stream =
success.stream;
recognize_spacing(stream)
})
})
}
#[inline]
fn parse_sequence_in_rule_sum_68<S>(mut stream: S)
-> oak_runtime::ParseState<S, Vec<()>> where S: oak_runtime::CharStream {
parse_pick_kw(stream).and_then(move |state4| {
let stream = state4.stream.clone();
parse_optional_in_rule_sum_65(stream).and_then(move
|state3|
{
let stream =
state3.stream.clone();
parse_when(stream).and_then(move
|state2|
{
let stream =
state2.stream.clone();
parse_star_in_rule_sum_66(stream).and_then(move
|state1|
{
let stream =
state1.stream.clone();
parse_optional_in_rule_sum_67(stream).and_then(move
|state0|
{
let stream =
state0.stream.clone();
oak_runtime::ParseState::success(stream,
state1.data)
})
})
})
})
})
}
#[inline]
pub fn parse_when_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_when_kw(stream)
}
#[inline]
fn recognize_sequence_in_rule_integer_76<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_star_in_rule_integer_75(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
fn recognize_sequence_in_rule_rep_kw_30<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_rep_kw_29(stream).and_then(|success| {
let stream =
success.stream;
recognize_spacing(stream)
})
}
#[inline]
pub fn recognize_store_kw<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_store_kw_45(stream)
}
#[inline]
fn recognize_str_literal_in_rule_par_kw_36<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "par")
}
#[inline]
pub fn recognize_par<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_sequence_in_rule_par_27(stream)
}
#[inline]
pub fn recognize_next<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_sequence_in_rule_next_81(stream)
}
}
tests/testoak.rs:1:1: 137:2 error: mismatched types:
expected `oak_runtime::parse_state::ParseState<S, collections::vec::Vec<()>>`,
found `oak_runtime::parse_state::ParseState<S, ()>`
(expected struct `collections::vec::Vec`,
found ()) [E0308]
(internal compiler error: unprintable span)
tests/testoak.rs:15:1: 320:1 note: in expansion of grammar!
tests/grammars/ntcc.rs:18:1: 137:2 note: expansion site
tests/testoak.rs:1:1: 137:2 help: run `rustc --explain E0308` to see a detailed explanation
error: aborting due to previous error
Could not compile `oak`.
To learn more, run the command again with --verbose.