note: pub mod calculator {
#![allow(dead_code)]
#![allow(unused_parens, unused_variables, unused_mut)]
extern crate oak_runtime;
pub type Digit = u32;
fn add(x: Digit, rest: Vec<Digit>) -> Digit {
rest.iter().fold(x, |x, y| x + y)
}
fn to_digit(raw_text: Vec<char>) -> Digit {
use std::str::FromStr;
let text: String = raw_text.into_iter().collect();
u32::from_str(&*text).unwrap()
}
fn mult(x: Digit, rest: Vec<Digit>) -> Digit {
rest.iter().fold(x, |x, y| x * y)
}
#[inline]
fn parse_choice_in_rule_value_6<S>(mut stream: S)
-> oak_runtime::ParseState<S, Digit> where S: oak_runtime::CharStream {
parse_semantic_action_in_rule_value_2(stream.clone()).or_else_join(||
parse_sequence_in_rule_value_5(stream))
}
#[inline]
fn recognize_str_literal_in_rule_sum_7<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_value_5<S>(mut stream: S)
-> oak_runtime::ParseState<S, Digit> where S: oak_runtime::CharStream {
parse_str_literal_in_rule_value_3(stream).and_then(|state2| {
let stream =
state2.stream.clone();
parse_expression(stream).and_then(|state1|
{
let stream =
state1.stream.clone();
parse_str_literal_in_rule_value_4(stream).and_then(|state0|
{
let stream =
state0.stream.clone();
oak_runtime::ParseState::success(stream,
state1.data)
})
})
})
}
#[inline]
fn recognize_star_in_rule_value_1<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
{
let mut state =
oak_runtime::ParseState::stateless(stream.clone());
while state.has_successor() {
let next =
recognize_class_char_in_rule_value_0(state.stream());
state = state.join(next.error);
if let Some(success) = next.success {
state.merge_success(success);
} else { break ; }
}
{
if state.stream_eq(&stream) {
state.to_error()
} else { state }
}
}
}
#[inline]
fn parse_star_in_rule_value_1<S>(mut stream: S)
-> oak_runtime::ParseState<S, Vec<char>> where
S: oak_runtime::CharStream {
{
let mut state =
oak_runtime::ParseState::success(stream.clone(), vec!());
while state.has_successor() {
let next = parse_class_char_in_rule_value_0(state.stream());
state = state.join(next.error);
if let Some(success) = next.success {
state.merge_success(success);
} else { break ; }
}
{
if state.stream_eq(&stream) {
state.to_error()
} else { state }
}
}
}
#[inline]
fn recognize_class_char_in_rule_value_0<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
{
match stream.next() {
Some(current) if (current >= '0' && current <= '9') => {
oak_runtime::ParseState::stateless(stream)
}
_ => { oak_runtime::ParseState::error(stream, "[\"0-9\"]") }
}
}
}
#[inline]
fn parse_star_in_rule_sum_9<S>(mut stream: S)
-> oak_runtime::ParseState<S, Vec<Digit>> where
S: oak_runtime::CharStream {
{
let mut state =
oak_runtime::ParseState::success(stream.clone(), vec!());
while state.has_successor() {
let next = parse_sequence_in_rule_sum_8(state.stream());
state = state.join(next.error);
if let Some(success) = next.success {
state.merge_success(success);
} else { break ; }
}
state
}
}
#[inline]
fn recognize_str_literal_in_rule_value_3<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "(")
}
#[inline]
pub fn recognize_value<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_choice_in_rule_value_6(stream)
}
#[inline]
fn parse_semantic_action_in_rule_product_16<S>(mut stream: S)
-> oak_runtime::ParseState<S, Digit> where S: oak_runtime::CharStream {
parse_sequence_in_rule_product_15(stream).map_data(|data|
mult(data.0,
data.1))
}
#[inline]
pub fn parse_product<S>(mut stream: S)
-> oak_runtime::ParseState<S, Digit> where S: oak_runtime::CharStream {
parse_semantic_action_in_rule_product_16(stream)
}
#[inline]
fn recognize_semantic_action_in_rule_product_16<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_product_15(stream)
}
#[inline]
fn parse_sequence_in_rule_sum_8<S>(mut stream: S)
-> oak_runtime::ParseState<S, Digit> where S: oak_runtime::CharStream {
parse_str_literal_in_rule_sum_7(stream).and_then(|state1| {
let stream =
state1.stream.clone();
parse_product(stream).and_then(|state0|
{
let stream =
state0.stream.clone();
oak_runtime::ParseState::success(stream,
state0.data)
})
})
}
#[inline]
fn parse_semantic_action_in_rule_value_2<S>(mut stream: S)
-> oak_runtime::ParseState<S, Digit> where S: oak_runtime::CharStream {
parse_star_in_rule_value_1(stream).map_data(|data| to_digit(data))
}
#[inline]
fn recognize_semantic_action_in_rule_sum_11<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sequence_in_rule_sum_10(stream)
}
#[inline]
fn parse_class_char_in_rule_value_0<S>(mut stream: S)
-> oak_runtime::ParseState<S, char> where S: oak_runtime::CharStream {
{
match stream.next() {
Some(current) if (current >= '0' && current <= '9') => {
oak_runtime::ParseState::success(stream, current)
}
_ => { oak_runtime::ParseState::error(stream, "[\"0-9\"]") }
}
}
}
#[inline]
pub fn recognize_expression<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_sum(stream)
}
#[inline]
fn recognize_sequence_in_rule_sum_8<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_sum_7(stream).and_then(|success| {
let stream =
success.stream;
recognize_product(stream)
})
}
#[inline]
pub fn recognize_product<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_semantic_action_in_rule_product_16(stream)
}
#[inline]
pub fn parse_expression<S>(mut stream: S)
-> oak_runtime::ParseState<S, Digit> where S: oak_runtime::CharStream {
parse_sum(stream)
}
#[inline]
fn parse_sequence_in_rule_sum_10<S>(mut stream: S)
-> oak_runtime::ParseState<S, (Digit, Vec<Digit>)> where
S: oak_runtime::CharStream {
parse_product(stream).and_then(|state1| {
let stream = state1.stream.clone();
parse_star_in_rule_sum_9(stream).and_then(|state0|
{
let stream =
state0.stream.clone();
oak_runtime::ParseState::success(stream,
(state1.data,
state0.data))
})
})
}
#[inline]
pub fn recognize_sum<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
where S: oak_runtime::CharStream {
recognize_semantic_action_in_rule_sum_11(stream)
}
#[inline]
fn recognize_semantic_action_in_rule_value_2<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_star_in_rule_value_1(stream)
}
#[inline]
pub fn parse_value<S>(mut stream: S) -> oak_runtime::ParseState<S, Digit>
where S: oak_runtime::CharStream {
parse_choice_in_rule_value_6(stream)
}
#[inline]
fn recognize_sequence_in_rule_product_13<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_product_12(stream).and_then(|success| {
let stream =
success.stream;
recognize_value(stream)
})
}
#[inline]
fn parse_str_literal_in_rule_product_12<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_product_12(stream)
}
#[inline]
fn parse_str_literal_in_rule_sum_7<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_sum_7(stream)
}
#[inline]
fn parse_star_in_rule_product_14<S>(mut stream: S)
-> oak_runtime::ParseState<S, Vec<Digit>> where
S: oak_runtime::CharStream {
{
let mut state =
oak_runtime::ParseState::success(stream.clone(), vec!());
while state.has_successor() {
let next = parse_sequence_in_rule_product_13(state.stream());
state = state.join(next.error);
if let Some(success) = next.success {
state.merge_success(success);
} else { break ; }
}
state
}
}
#[inline]
fn recognize_sequence_in_rule_product_15<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_value(stream).and_then(|success| {
let stream = success.stream;
recognize_star_in_rule_product_14(stream)
})
}
#[inline]
fn parse_str_literal_in_rule_value_4<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_value_4(stream)
}
#[inline]
fn recognize_sequence_in_rule_value_5<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_value_3(stream).and_then(|success| {
let stream =
success.stream;
recognize_expression(stream).and_then(|success|
{
let stream =
success.stream;
recognize_str_literal_in_rule_value_4(stream)
})
})
}
#[inline]
fn recognize_star_in_rule_product_14<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
{
let mut state =
oak_runtime::ParseState::stateless(stream.clone());
while state.has_successor() {
let next =
recognize_sequence_in_rule_product_13(state.stream());
state = state.join(next.error);
if let Some(success) = next.success {
state.merge_success(success);
} else { break ; }
}
state
}
}
#[inline]
fn parse_semantic_action_in_rule_sum_11<S>(mut stream: S)
-> oak_runtime::ParseState<S, Digit> where S: oak_runtime::CharStream {
parse_sequence_in_rule_sum_10(stream).map_data(|data|
add(data.0,
data.1))
}
#[inline]
fn recognize_choice_in_rule_value_6<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_semantic_action_in_rule_value_2(stream.clone()).or_else_join(||
recognize_sequence_in_rule_value_5(stream))
}
#[inline]
fn recognize_str_literal_in_rule_product_12<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, "*")
}
#[inline]
pub fn parse_sum<S>(mut stream: S) -> oak_runtime::ParseState<S, Digit>
where S: oak_runtime::CharStream {
parse_semantic_action_in_rule_sum_11(stream)
}
#[inline]
fn parse_sequence_in_rule_product_13<S>(mut stream: S)
-> oak_runtime::ParseState<S, Digit> where S: oak_runtime::CharStream {
parse_str_literal_in_rule_product_12(stream).and_then(|state1| {
let stream =
state1.stream.clone();
parse_value(stream).and_then(|state0|
{
let stream =
state0.stream.clone();
oak_runtime::ParseState::success(stream,
state0.data)
})
})
}
#[inline]
fn recognize_sequence_in_rule_sum_10<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_product(stream).and_then(|success| {
let stream = success.stream;
recognize_star_in_rule_sum_9(stream)
})
}
#[inline]
fn recognize_star_in_rule_sum_9<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
{
let mut state =
oak_runtime::ParseState::stateless(stream.clone());
while state.has_successor() {
let next = recognize_sequence_in_rule_sum_8(state.stream());
state = state.join(next.error);
if let Some(success) = next.success {
state.merge_success(success);
} else { break ; }
}
state
}
}
#[inline]
fn parse_sequence_in_rule_product_15<S>(mut stream: S)
-> oak_runtime::ParseState<S, (Digit, Vec<Digit>)> where
S: oak_runtime::CharStream {
parse_value(stream).and_then(|state1| {
let stream = state1.stream.clone();
parse_star_in_rule_product_14(stream).and_then(|state0|
{
let stream =
state0.stream.clone();
oak_runtime::ParseState::success(stream,
(state1.data,
state0.data))
})
})
}
#[inline]
fn parse_str_literal_in_rule_value_3<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
recognize_str_literal_in_rule_value_3(stream)
}
#[inline]
fn recognize_str_literal_in_rule_value_4<S>(mut stream: S)
-> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
oak_runtime::recognize_match_literal(stream, ")")
}
}
tests/testoak.rs:192:3: 192:24 warning: struct field is never used: `info`, #[warn(dead_code)] on by default
tests/testoak.rs:192 info: &'a GrammarInfo,
^~~~~~~~~~~~~~~~~~~~~