#[derive(Debug, Clone)]
pub struct SavedGame {
pub sections: Vec<Section>,
}
#[allow(non_camel_case_types)]
#[derive(Debug, Clone)]
pub enum Section {
Jump(Jump),
PusherSelection(PusherSelection),
Steps(Steps),
}
pub type Steps = StepsContents;
pub type StepsContents = String;
pub type PusherSelection = PusherSelectionContents;
pub type PusherSelectionContents = String;
pub type Jump = JumpContents;
pub type JumpContents = String;
pub type Move = char;
pub type Push = char;
pub type CurrentPos = char;
impl peginator_generated::PegParserAdvanced<()> for SavedGame {
fn parse_advanced<TT: peginator_generated::ParseTracer>(
s: &str, settings: &peginator_generated::ParseSettings, user_context: (),
) -> Result<Self, peginator_generated::ParseError> {
Ok(peginator_generated::parse_SavedGame(
peginator_generated::ParseState::new(s, settings),
&mut peginator_generated::ParseGlobal::<TT, peginator_generated::ParseCache, ()>::new(
Default::default(),
user_context,
),
)?
.result)
}
}
#[allow(
non_snake_case,
unused_variables,
unused_imports,
unused_mut,
dead_code
)]
mod peginator_generated {
use peginator::*;
pub use peginator::{
IndentedTracer, ParseError, ParseGlobal, ParseSettings, ParseState, ParseTracer, PegParser,
PegParserAdvanced, PegPosition,
};
use super::*;
#[derive(Default)]
pub struct ParseCache<'a> {
_please_dont_complain: std::marker::PhantomData<&'a ()>,
}
mod SavedGame_impl {
use super::*;
mod part_0 {
use super::*;
mod closure {
use super::*;
}
#[inline(always)]
pub fn parse<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, Parsed> {
let mut iterations: usize = 0;
let mut state = state;
let mut sections: Vec<Section> = Vec::new();
loop {
match parse_Whitespace(state.clone(), &mut *global)
.and_then(|ParseOk { state, .. }| parse_Section(state, &mut *global))
.map_inner(|result| vec![result])
{
Ok(ParseOk {
result: __result,
state: new_state,
..
}) => {
sections.extend(__result);
state = new_state;
}
Err(err) => {
state = state.record_error(err);
break;
}
}
iterations += 1;
}
if iterations == 0 {
return Err(state.report_farthest_error());
}
Ok(ParseOk {
result: sections,
state,
})
}
pub type Parsed = Vec<Section>;
}
#[inline(always)]
pub fn parse<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, Parsed> {
let ParseOk {
result: mut sections,
state,
} = part_0::parse(state, global)?;
let ParseOk { state, .. } = parse_Whitespace(state, &mut *global)
.and_then(|ParseOk { state, .. }| parse_end_of_input(state))?;
Ok(ParseOk {
result: sections,
state,
})
}
pub type Parsed = Vec<Section>;
}
#[inline]
pub(super) fn parse_SavedGame<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, SavedGame> {
global.tracer.print_trace_start(&state, "SavedGame");
let result = (|| {
let result =
SavedGame_impl::parse(state, global)?.map(|r| super::SavedGame { sections: r });
Ok(result)
})();
global.tracer.print_trace_result(&result);
result
}
mod Section_impl {
use super::*;
#[inline(always)]
pub fn parse<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, Parsed> {
ChoiceHelper::new(state)
.choice(|state| {
parse_Whitespace(state, &mut *global)
.and_then(|ParseOk { state, .. }| parse_Jump(state, &mut *global))
.map_inner(Parsed__override::Jump)
})
.choice(|state| {
parse_Whitespace(state, &mut *global)
.and_then(|ParseOk { state, .. }| {
parse_PusherSelection(state, &mut *global)
})
.map_inner(Parsed__override::PusherSelection)
})
.choice(|state| {
parse_Whitespace(state, &mut *global)
.and_then(|ParseOk { state, .. }| parse_Steps(state, &mut *global))
.map_inner(Parsed__override::Steps)
})
.end()
}
pub type Parsed = Parsed__override;
use super::Section as Parsed__override;
}
#[inline]
pub(super) fn parse_Section<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, Section> {
global.tracer.print_trace_start(&state, "Section");
let result = (|| {
let result = Section_impl::parse(state, global)?;
Ok(result)
})();
global.tracer.print_trace_result(&result);
result
}
mod Steps_impl {
use super::*;
#[inline(always)]
pub fn parse<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, Parsed> {
parse_Whitespace(state, &mut *global)
.and_then(|ParseOk { state, .. }| parse_StepsContents(state, &mut *global))
}
pub type Parsed = StepsContents;
use super::Steps as Parsed__override;
}
#[inline]
pub(super) fn parse_Steps<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, Steps> {
global.tracer.print_trace_start(&state, "Steps");
let result = (|| {
let result = Steps_impl::parse(state, global)?;
Ok(result)
})();
global.tracer.print_trace_result(&result);
result
}
mod StepsContents_impl {
use super::*;
mod closure {
use super::*;
}
#[inline(always)]
pub fn parse<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, Parsed> {
let mut iterations: usize = 0;
let mut state = state;
loop {
match ChoiceHelper::new(state.clone())
.choice(|state| {
parse_Whitespace(state, &mut *global)
.and_then(|ParseOk { state, .. }| parse_Move(state, &mut *global))
.discard_result()
})
.choice(|state| {
parse_Whitespace(state, &mut *global)
.and_then(|ParseOk { state, .. }| parse_Push(state, &mut *global))
.discard_result()
})
.choice(|state| {
parse_Whitespace(state, &mut *global)
.and_then(|ParseOk { state, .. }| parse_CurrentPos(state, &mut *global))
.discard_result()
})
.end()
{
Ok(ParseOk {
result: __result,
state: new_state,
..
}) => {
state = new_state;
}
Err(err) => {
state = state.record_error(err);
break;
}
}
iterations += 1;
}
if iterations == 0 {
return Err(state.report_farthest_error());
}
Ok(ParseOk { result: (), state })
}
pub type Parsed = ();
}
#[inline]
pub(super) fn parse_StepsContents<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, StepsContents> {
global.tracer.print_trace_start(&state, "StepsContents");
let result = (|| {
let result =
StepsContents_impl::parse(state.clone(), global)?.map_with_state(|_, new_state| {
let string = state.slice_until(new_state).to_string();
string
});
Ok(result)
})();
global.tracer.print_trace_result(&result);
result
}
mod PusherSelection_impl {
use super::*;
#[inline(always)]
pub fn parse<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, Parsed> {
let ParseOk { state, .. } = parse_Whitespace(state, &mut *global)
.and_then(|ParseOk { state, .. }| parse_character_literal(state, '{'))
.discard_result()?;
let ParseOk {
result: _override,
state,
} = parse_Whitespace(state, &mut *global).and_then(|ParseOk { state, .. }| {
parse_PusherSelectionContents(state, &mut *global)
})?;
let ParseOk { state, .. } = parse_Whitespace(state, &mut *global)
.and_then(|ParseOk { state, .. }| parse_character_literal(state, '}'))
.discard_result()?;
Ok(ParseOk {
result: _override,
state,
})
}
pub type Parsed = PusherSelectionContents;
use super::PusherSelection as Parsed__override;
}
#[inline]
pub(super) fn parse_PusherSelection<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, PusherSelection> {
global.tracer.print_trace_start(&state, "PusherSelection");
let result = (|| {
let result = PusherSelection_impl::parse(state, global)?;
Ok(result)
})();
global.tracer.print_trace_result(&result);
result
}
mod PusherSelectionContents_impl {
use super::*;
mod closure {
use super::*;
}
#[inline(always)]
pub fn parse<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, Parsed> {
let mut state = state;
loop {
match ChoiceHelper::new(state.clone())
.choice(|state| {
parse_Whitespace(state, &mut *global)
.and_then(|ParseOk { state, .. }| parse_Move(state, &mut *global))
.discard_result()
})
.choice(|state| {
parse_Whitespace(state, &mut *global)
.and_then(|ParseOk { state, .. }| parse_CurrentPos(state, &mut *global))
.discard_result()
})
.end()
{
Ok(ParseOk {
result: __result,
state: new_state,
..
}) => {
state = new_state;
}
Err(err) => {
state = state.record_error(err);
break;
}
}
}
Ok(ParseOk { result: (), state })
}
pub type Parsed = ();
}
#[inline]
pub(super) fn parse_PusherSelectionContents<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, PusherSelectionContents> {
global
.tracer
.print_trace_start(&state, "PusherSelectionContents");
let result = (|| {
let result = PusherSelectionContents_impl::parse(state.clone(), global)?
.map_with_state(|_, new_state| {
let string = state.slice_until(new_state).to_string();
string
});
Ok(result)
})();
global.tracer.print_trace_result(&result);
result
}
mod Jump_impl {
use super::*;
#[inline(always)]
pub fn parse<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, Parsed> {
let ParseOk { state, .. } = parse_Whitespace(state, &mut *global)
.and_then(|ParseOk { state, .. }| parse_character_literal(state, '['))
.discard_result()?;
let ParseOk {
result: _override,
state,
} = parse_Whitespace(state, &mut *global)
.and_then(|ParseOk { state, .. }| parse_JumpContents(state, &mut *global))?;
let ParseOk { state, .. } = parse_Whitespace(state, &mut *global)
.and_then(|ParseOk { state, .. }| parse_character_literal(state, ']'))
.discard_result()?;
Ok(ParseOk {
result: _override,
state,
})
}
pub type Parsed = JumpContents;
use super::Jump as Parsed__override;
}
#[inline]
pub(super) fn parse_Jump<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, Jump> {
global.tracer.print_trace_start(&state, "Jump");
let result = (|| {
let result = Jump_impl::parse(state, global)?;
Ok(result)
})();
global.tracer.print_trace_result(&result);
result
}
mod JumpContents_impl {
use super::*;
mod closure {
use super::*;
}
#[inline(always)]
pub fn parse<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, Parsed> {
let mut state = state;
loop {
match ChoiceHelper::new(state.clone())
.choice(|state| {
parse_Whitespace(state, &mut *global)
.and_then(|ParseOk { state, .. }| parse_Move(state, &mut *global))
.discard_result()
})
.choice(|state| {
parse_Whitespace(state, &mut *global)
.and_then(|ParseOk { state, .. }| parse_CurrentPos(state, &mut *global))
.discard_result()
})
.end()
{
Ok(ParseOk {
result: __result,
state: new_state,
..
}) => {
state = new_state;
}
Err(err) => {
state = state.record_error(err);
break;
}
}
}
Ok(ParseOk { result: (), state })
}
pub type Parsed = ();
}
#[inline]
pub(super) fn parse_JumpContents<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, JumpContents> {
global.tracer.print_trace_start(&state, "JumpContents");
let result = (|| {
let result =
JumpContents_impl::parse(state.clone(), global)?.map_with_state(|_, new_state| {
let string = state.slice_until(new_state).to_string();
string
});
Ok(result)
})();
global.tracer.print_trace_result(&result);
result
}
#[inline]
pub(super) fn parse_Move<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, Move> {
if let Ok(result) = parse_character_literal(state.clone(), 'l') {
return Ok(result);
}
if let Ok(result) = parse_character_literal(state.clone(), 'u') {
return Ok(result);
}
if let Ok(result) = parse_character_literal(state.clone(), 'r') {
return Ok(result);
}
if let Ok(result) = parse_character_literal(state.clone(), 'd') {
return Ok(result);
}
if let Ok(result) = parse_character_literal(state.clone(), 'n') {
return Ok(result);
}
if let Ok(result) = parse_character_literal(state.clone(), 'e') {
return Ok(result);
}
if let Ok(result) = parse_character_literal(state.clone(), 's') {
return Ok(result);
}
if let Ok(result) = parse_character_literal(state.clone(), 'w') {
return Ok(result);
}
Err(state.report_error(ParseErrorSpecifics::ExpectedCharacterClass { name: "Move" }))
}
#[inline]
pub(super) fn parse_Push<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, Push> {
if let Ok(result) = parse_character_literal(state.clone(), 'L') {
return Ok(result);
}
if let Ok(result) = parse_character_literal(state.clone(), 'U') {
return Ok(result);
}
if let Ok(result) = parse_character_literal(state.clone(), 'R') {
return Ok(result);
}
if let Ok(result) = parse_character_literal(state.clone(), 'D') {
return Ok(result);
}
if let Ok(result) = parse_character_literal(state.clone(), 'N') {
return Ok(result);
}
if let Ok(result) = parse_character_literal(state.clone(), 'E') {
return Ok(result);
}
if let Ok(result) = parse_character_literal(state.clone(), 'S') {
return Ok(result);
}
if let Ok(result) = parse_character_literal(state.clone(), 'W') {
return Ok(result);
}
Err(state.report_error(ParseErrorSpecifics::ExpectedCharacterClass { name: "Push" }))
}
#[inline]
pub(super) fn parse_CurrentPos<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, CurrentPos> {
if let Ok(result) = parse_character_literal(state.clone(), '*') {
return Ok(result);
}
Err(state.report_error(ParseErrorSpecifics::ExpectedCharacterClass { name: "CurrentPos" }))
}
}