#[derive(Debug, Clone)]
pub struct Rle {
pub sections: Vec<Section>,
}
#[allow(non_camel_case_types)]
#[derive(Debug, Clone)]
pub enum Section {
Chars(Chars),
Group(Group),
RleChunk(RleChunk),
}
#[allow(non_camel_case_types)]
#[derive(Debug, Clone)]
pub enum CharsOrGroup {
Chars(Chars),
Group(Group),
}
#[derive(Debug, Clone)]
pub struct RleChunk {
pub count: RleCount,
pub data: CharsOrGroup,
}
pub type Group = Vec<Section>;
pub type Chars = String;
pub type RleCount = String;
pub type ReservedChars = char;
pub type Digit = char;
impl peginator_generated::PegParserAdvanced<()> for Rle {
fn parse_advanced<TT: peginator_generated::ParseTracer>(
s: &str, settings: &peginator_generated::ParseSettings, user_context: (),
) -> Result<Self, peginator_generated::ParseError> {
Ok(peginator_generated::parse_Rle(
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 Rle_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_Section(state.clone(), &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_end_of_input(state)?;
Ok(ParseOk {
result: sections,
state,
})
}
pub type Parsed = Vec<Section>;
}
#[inline]
pub(super) fn parse_Rle<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, Rle> {
global.tracer.print_trace_start(&state, "Rle");
let result = (|| {
let result = Rle_impl::parse(state, global)?.map(|r| super::Rle { 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_Chars(state, &mut *global).map_inner(Parsed__override::Chars))
.choice(|state| {
parse_RleChunk(state, &mut *global).map_inner(Parsed__override::RleChunk)
})
.choice(|state| parse_Group(state, &mut *global).map_inner(Parsed__override::Group))
.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 CharsOrGroup_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_Chars(state, &mut *global).map_inner(Parsed__override::Chars))
.choice(|state| parse_Group(state, &mut *global).map_inner(Parsed__override::Group))
.end()
}
pub type Parsed = Parsed__override;
use super::CharsOrGroup as Parsed__override;
}
#[inline]
pub(super) fn parse_CharsOrGroup<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, CharsOrGroup> {
global.tracer.print_trace_start(&state, "CharsOrGroup");
let result = (|| {
let result = CharsOrGroup_impl::parse(state, global)?;
Ok(result)
})();
global.tracer.print_trace_result(&result);
result
}
mod RleChunk_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 {
result: count,
state,
} = parse_RleCount(state, &mut *global)?;
let ParseOk {
result: data,
state,
} = parse_CharsOrGroup(state, &mut *global)?;
Ok(ParseOk {
result: Parsed { count, data },
state,
})
}
pub struct Parsed {
pub count: RleCount,
pub data: CharsOrGroup,
}
}
#[inline]
pub(super) fn parse_RleChunk<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, RleChunk> {
global.tracer.print_trace_start(&state, "RleChunk");
let result = (|| {
let result = RleChunk_impl::parse(state, global)?.map(|r| {
super::RleChunk {
count: r.count,
data: r.data,
}
});
Ok(result)
})();
global.tracer.print_trace_result(&result);
result
}
mod Group_impl {
use super::*;
mod part_1 {
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 _override: Vec<Section> = Vec::new();
loop {
match parse_Section(state.clone(), &mut *global)
.map_inner(|result| vec![result])
{
Ok(ParseOk {
result: __result,
state: new_state,
..
}) => {
_override.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: _override,
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 { state, .. } = parse_character_literal(state, '(').discard_result()?;
let ParseOk {
result: mut _override,
state,
} = part_1::parse(state, global)?;
let ParseOk { state, .. } = parse_character_literal(state, ')').discard_result()?;
Ok(ParseOk {
result: _override,
state,
})
}
pub type Parsed = Vec<Section>;
use super::Group as Parsed__override;
}
#[inline]
pub(super) fn parse_Group<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, Group> {
global.tracer.print_trace_start(&state, "Group");
let result = (|| {
let result = Group_impl::parse(state, global)?;
Ok(result)
})();
global.tracer.print_trace_result(&result);
result
}
mod Chars_impl {
use super::*;
mod closure {
use super::*;
mod part_0 {
use super::*;
mod negative_lookahead {
use super::*;
#[inline(always)]
pub fn parse<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, Parsed> {
parse_ReservedChars(state, &mut *global).discard_result()
}
pub type Parsed = ();
}
#[inline(always)]
pub fn parse<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, Parsed> {
match negative_lookahead::parse(state.clone(), global) {
Ok(_) => {
Err(state.report_error(ParseErrorSpecifics::NegativeLookaheadFailed))
}
Err(_) => Ok(ParseOk { result: (), state }),
}
}
pub type Parsed = ();
}
#[inline(always)]
pub fn parse<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, Parsed> {
let ParseOk { state, .. } = part_0::parse(state, global)?;
let ParseOk {
result: mut body,
state,
} = parse_char(state, &mut *global).map_inner(|result| vec![result])?;
Ok(ParseOk {
result: body,
state,
})
}
pub type Parsed = Vec<char>;
}
#[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 body: Vec<char> = Vec::new();
loop {
match closure::parse(state.clone(), global) {
Ok(ParseOk {
result: __result,
state: new_state,
..
}) => {
body.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: body,
state,
})
}
pub type Parsed = Vec<char>;
}
#[inline]
pub(super) fn parse_Chars<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, Chars> {
global.tracer.print_trace_start(&state, "Chars");
let result = (|| {
let result =
Chars_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 RleCount_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 parse_Digit(state.clone(), &mut *global).discard_result() {
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_RleCount<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, RleCount> {
global.tracer.print_trace_start(&state, "RleCount");
let result = (|| {
let result =
RleCount_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_ReservedChars<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, ReservedChars> {
if let Ok(result) = parse_character_literal(state.clone(), '(') {
return Ok(result);
}
if let Ok(result) = parse_character_literal(state.clone(), ')') {
return Ok(result);
}
if let Ok(result) = parse_Digit(state.clone(), global) {
return Ok(result);
}
Err(state.report_error(ParseErrorSpecifics::ExpectedCharacterClass {
name: "ReservedChars",
}))
}
#[inline]
pub(super) fn parse_Digit<'a, TT: ParseTracer>(
state: ParseState<'a>, global: &mut ParseGlobal<TT, ParseCache<'a>, ()>,
) -> ParseResult<'a, Digit> {
if let Ok(result) = parse_character_range(state.clone(), '0', '9') {
return Ok(result);
}
Err(state.report_error(ParseErrorSpecifics::ExpectedCharacterClass { name: "Digit" }))
}
}