#[derive(Debug, Clone)]
pub struct VonParser {
pub value: ValueNode,
}
#[allow(non_camel_case_types)]
#[derive(Debug, Clone)]
pub enum ValueNode {
NumberNode(NumberNode),
SpecialNode(SpecialNode),
StringNode(StringNode),
TableNode(TableNode),
}
#[derive(Debug, Clone)]
pub struct TableNode {
pub hint: Option<IdentifierNode>,
pub items: Vec<TableItem>,
}
#[allow(non_camel_case_types)]
#[derive(Debug, Clone)]
pub enum TableItem {
KeyValueNode(KeyValueNode),
Split(Split),
ValueNode(ValueNode),
}
#[derive(Debug, Clone)]
pub struct KeyValueNode {
pub key: KeyNode,
pub value: ValueNode,
}
#[allow(non_camel_case_types)]
#[derive(Debug, Clone)]
pub enum KeyNode {
IdentifierNode(IdentifierNode),
StringNode(StringNode),
}
#[derive(Debug, Clone)]
pub struct StringNode {
pub hint: Option<IdentifierNode>,
pub position: std::ops::Range<usize>,
}
#[derive(Debug, Clone)]
pub struct NumberNode {
pub num: Num,
pub hint: Option<IdentifierNode>,
pub position: std::ops::Range<usize>,
}
#[derive(Debug, Clone)]
pub struct Num {
pub string: String,
pub position: std::ops::Range<usize>,
}
#[derive(Debug, Clone)]
pub struct NamespaceNode {
pub path: Vec<IdentifierNode>,
pub position: std::ops::Range<usize>,
}
#[derive(Debug, Clone)]
pub struct IdentifierNode {
pub string: String,
pub position: std::ops::Range<usize>,
}
#[derive(Debug, Clone)]
pub struct SpecialNode {
pub string: String,
pub position: std::ops::Range<usize>,
}
pub type XID_START = char;
pub type XID_CONTINUE = char;
pub type Dot = char;
pub type Split = char;
impl peginator_generated::PegParser for VonParser {
fn parse_advanced<T: peginator_generated::ParseTracer>(
s: &str,
settings: &peginator_generated::ParseSettings,
) -> Result<Self, peginator_generated::ParseError> {
Ok(peginator_generated::parse_VonParser(
peginator_generated::ParseState::new(s, settings),
T::new(),
&mut Default::default(),
)?
.result)
}
}
#[allow(non_snake_case, unused_variables, unused_imports, unused_mut, dead_code)]
mod peginator_generated {
use super::*;
use peginator::runtime::*;
pub use peginator::runtime::{IndentedTracer, ParseError, ParseSettings, ParseState, ParseTracer, PegParser, PegPosition};
#[derive(Default)]
pub struct ParseCache<'a> {
_please_dont_complain: std::marker::PhantomData<&'a ()>,
}
mod VonParser_impl {
use super::*;
#[inline(always)]
pub fn parse<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, Parsed> {
let ParseOk { result: value, state } = parse_Whitespace(state, tracer, cache)
.and_then(|ParseOk { state, .. }| parse_ValueNode(state, tracer, cache))?;
let ParseOk { state, .. } =
parse_Whitespace(state, tracer, cache).and_then(|ParseOk { state, .. }| parse_end_of_input(state))?;
Ok(ParseOk { result: value, state })
}
pub type Parsed = ValueNode;
#[inline(always)]
pub fn rule_parser<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, super::VonParser> {
let result = parse(state, tracer, cache)?.map(|r| super::VonParser { value: r });
Ok(result)
}
}
#[inline]
pub(super) fn parse_VonParser<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, VonParser> {
tracer.run_traced("VonParser", state, |state, tracer| VonParser_impl::rule_parser(state, tracer, cache))
}
mod ValueNode_impl {
use super::*;
#[inline(always)]
pub fn parse<'a>(
mut state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, Parsed> {
ChoiceHelper::new(state)
.choice(|state| {
parse_Whitespace(state, tracer, cache)
.and_then(|ParseOk { state, .. }| parse_TableNode(state, tracer, cache))
.map_inner(Parsed__override::TableNode)
})
.choice(|state| {
parse_Whitespace(state, tracer, cache)
.and_then(|ParseOk { state, .. }| parse_SpecialNode(state, tracer, cache))
.map_inner(Parsed__override::SpecialNode)
})
.choice(|state| {
parse_Whitespace(state, tracer, cache)
.and_then(|ParseOk { state, .. }| parse_NumberNode(state, tracer, cache))
.map_inner(Parsed__override::NumberNode)
})
.choice(|state| {
parse_Whitespace(state, tracer, cache)
.and_then(|ParseOk { state, .. }| parse_StringNode(state, tracer, cache))
.map_inner(Parsed__override::StringNode)
})
.end()
}
pub type Parsed = Parsed__override;
use super::ValueNode as Parsed__override;
#[inline(always)]
pub fn rule_parser<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, super::ValueNode> {
let result = parse(state, tracer, cache)?;
Ok(result)
}
}
#[inline]
pub(super) fn parse_ValueNode<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, ValueNode> {
tracer.run_traced("ValueNode", state, |state, tracer| ValueNode_impl::rule_parser(state, tracer, cache))
}
mod TableNode_impl {
use super::*;
mod part_2 {
use super::*;
mod closure {
use super::*;
}
#[inline(always)]
pub fn parse<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, Parsed> {
let mut iterations: usize = 0;
let mut state = state;
let mut items: Vec<TableItem> = Vec::new();
loop {
match parse_Whitespace(state.clone(), tracer, cache)
.and_then(|ParseOk { state, .. }| parse_TableItem(state, tracer, cache))
.map_inner(|result| vec![result])
{
Ok(ParseOk { result: __result, state: new_state, .. }) => {
items.extend(__result);
state = new_state;
}
Err(err) => {
state = state.record_error(err);
break;
}
}
iterations += 1;
}
Ok(ParseOk { result: items, state })
}
pub type Parsed = Vec<TableItem>;
}
#[inline(always)]
pub fn parse<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, Parsed> {
let ParseOk { result: hint, state } = parse_Whitespace(state.clone(), tracer, cache)
.and_then(|ParseOk { state, .. }| parse_IdentifierNode(state, tracer, cache))
.map_inner(Some)
.or_else(|err| Ok(ParseOk { result: Default::default(), state: state.record_error(err) }))?;
let ParseOk { state, .. } = parse_Whitespace(state, tracer, cache)
.and_then(|ParseOk { state, .. }| parse_character_literal(state, '('))
.discard_result()?;
let ParseOk { result: mut items, state } = part_2::parse(state, tracer, cache)?;
let ParseOk { state, .. } = parse_Whitespace(state, tracer, cache)
.and_then(|ParseOk { state, .. }| parse_character_literal(state, ')'))
.discard_result()?;
Ok(ParseOk { result: Parsed { hint, items }, state })
}
pub struct Parsed {
pub hint: Option<IdentifierNode>,
pub items: Vec<TableItem>,
}
#[inline(always)]
pub fn rule_parser<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, super::TableNode> {
let result = parse(state, tracer, cache)?.map(|r| super::TableNode { hint: r.hint, items: r.items });
Ok(result)
}
}
#[inline]
pub(super) fn parse_TableNode<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, TableNode> {
tracer.run_traced("TableNode", state, |state, tracer| TableNode_impl::rule_parser(state, tracer, cache))
}
mod TableItem_impl {
use super::*;
#[inline(always)]
pub fn parse<'a>(
mut state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, Parsed> {
ChoiceHelper::new(state)
.choice(|state| {
parse_Whitespace(state, tracer, cache)
.and_then(|ParseOk { state, .. }| parse_KeyValueNode(state, tracer, cache))
.map_inner(Parsed__override::KeyValueNode)
})
.choice(|state| {
parse_Whitespace(state, tracer, cache)
.and_then(|ParseOk { state, .. }| parse_ValueNode(state, tracer, cache))
.map_inner(Parsed__override::ValueNode)
})
.choice(|state| {
parse_Whitespace(state, tracer, cache)
.and_then(|ParseOk { state, .. }| parse_Split(state, tracer, cache))
.map_inner(Parsed__override::Split)
})
.end()
}
pub type Parsed = Parsed__override;
use super::TableItem as Parsed__override;
#[inline(always)]
pub fn rule_parser<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, super::TableItem> {
let result = parse(state, tracer, cache)?;
Ok(result)
}
}
#[inline]
pub(super) fn parse_TableItem<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, TableItem> {
tracer.run_traced("TableItem", state, |state, tracer| TableItem_impl::rule_parser(state, tracer, cache))
}
mod KeyValueNode_impl {
use super::*;
#[inline(always)]
pub fn parse<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, Parsed> {
let ParseOk { result: key, state } =
parse_Whitespace(state, tracer, cache).and_then(|ParseOk { state, .. }| parse_KeyNode(state, tracer, cache))?;
let ParseOk { state, .. } = parse_Whitespace(state, tracer, cache)
.and_then(|ParseOk { state, .. }| parse_character_literal(state, ':'))
.discard_result()?;
let ParseOk { result: value, state } = parse_Whitespace(state, tracer, cache)
.and_then(|ParseOk { state, .. }| parse_ValueNode(state, tracer, cache))?;
Ok(ParseOk { result: Parsed { key, value }, state })
}
pub struct Parsed {
pub key: KeyNode,
pub value: ValueNode,
}
#[inline(always)]
pub fn rule_parser<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, super::KeyValueNode> {
let result = parse(state, tracer, cache)?.map(|r| super::KeyValueNode { key: r.key, value: r.value });
Ok(result)
}
}
#[inline]
pub(super) fn parse_KeyValueNode<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, KeyValueNode> {
tracer.run_traced("KeyValueNode", state, |state, tracer| KeyValueNode_impl::rule_parser(state, tracer, cache))
}
mod KeyNode_impl {
use super::*;
#[inline(always)]
pub fn parse<'a>(
mut state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, Parsed> {
ChoiceHelper::new(state)
.choice(|state| {
parse_Whitespace(state, tracer, cache)
.and_then(|ParseOk { state, .. }| parse_IdentifierNode(state, tracer, cache))
.map_inner(Parsed__override::IdentifierNode)
})
.choice(|state| {
parse_Whitespace(state, tracer, cache)
.and_then(|ParseOk { state, .. }| parse_StringNode(state, tracer, cache))
.map_inner(Parsed__override::StringNode)
})
.end()
}
pub type Parsed = Parsed__override;
use super::KeyNode as Parsed__override;
#[inline(always)]
pub fn rule_parser<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, super::KeyNode> {
let result = parse(state, tracer, cache)?;
Ok(result)
}
}
#[inline]
pub(super) fn parse_KeyNode<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, KeyNode> {
tracer.run_traced("KeyNode", state, |state, tracer| KeyNode_impl::rule_parser(state, tracer, cache))
}
impl PegPosition for KeyNode {
fn position(&self) -> &std::ops::Range<usize> {
match self {
Self::IdentifierNode(x) => x.position(),
Self::StringNode(x) => x.position(),
}
}
}
mod StringNode_impl {
use super::*;
#[inline(always)]
pub fn parse<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, Parsed> {
let ParseOk { result: hint, state } = parse_Whitespace(state.clone(), tracer, cache)
.and_then(|ParseOk { state, .. }| parse_IdentifierNode(state, tracer, cache))
.map_inner(Some)
.or_else(|err| Ok(ParseOk { result: Default::default(), state: state.record_error(err) }))?;
let ParseOk { state, .. } = parse_Whitespace(state, tracer, cache)
.and_then(|ParseOk { state, .. }| parse_character_literal(state, '"'))
.discard_result()?;
let ParseOk { state, .. } = parse_Whitespace(state, tracer, cache)
.and_then(|ParseOk { state, .. }| parse_character_literal(state, '"'))
.discard_result()?;
Ok(ParseOk { result: hint, state })
}
pub type Parsed = Option<IdentifierNode>;
#[inline(always)]
pub fn rule_parser<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, super::StringNode> {
let result = parse(state.clone(), tracer, cache)?
.map_with_state(|r, new_state| super::StringNode { hint: r, position: state.range_until(new_state) });
Ok(result)
}
}
#[inline]
pub(super) fn parse_StringNode<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, StringNode> {
tracer.run_traced("StringNode", state, |state, tracer| StringNode_impl::rule_parser(state, tracer, cache))
}
impl PegPosition for StringNode {
fn position(&self) -> &std::ops::Range<usize> {
&self.position
}
}
mod NumberNode_impl {
use super::*;
#[inline(always)]
pub fn parse<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, Parsed> {
let ParseOk { result: num, state } = parse_Num(state, tracer, cache)?;
let ParseOk { result: hint, state } = parse_IdentifierNode(state.clone(), tracer, cache)
.map_inner(Some)
.or_else(|err| Ok(ParseOk { result: Default::default(), state: state.record_error(err) }))?;
Ok(ParseOk { result: Parsed { num, hint }, state })
}
pub struct Parsed {
pub num: Num,
pub hint: Option<IdentifierNode>,
}
#[inline(always)]
pub fn rule_parser<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, super::NumberNode> {
let result = parse(state.clone(), tracer, cache)?.map_with_state(|r, new_state| super::NumberNode {
num: r.num,
hint: r.hint,
position: state.range_until(new_state),
});
Ok(result)
}
}
#[inline]
pub(super) fn parse_NumberNode<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, NumberNode> {
tracer.run_traced("NumberNode", state, |state, tracer| NumberNode_impl::rule_parser(state, tracer, cache))
}
impl PegPosition for NumberNode {
fn position(&self) -> &std::ops::Range<usize> {
&self.position
}
}
mod Num_impl {
use super::*;
mod part_0 {
use super::*;
mod closure {
use super::*;
}
#[inline(always)]
pub fn parse<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, Parsed> {
let mut iterations: usize = 0;
let mut state = state;
loop {
match parse_character_range(state.clone(), '0', '9').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 = ();
}
mod part_1 {
use super::*;
mod optional {
use super::*;
mod part_1 {
use super::*;
mod closure {
use super::*;
}
#[inline(always)]
pub fn parse<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, Parsed> {
let mut iterations: usize = 0;
let mut state = state;
loop {
match parse_character_range(state.clone(), '0', '9').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(always)]
pub fn parse<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, Parsed> {
let ParseOk { state, .. } = parse_Dot(state, tracer, cache).discard_result()?;
let ParseOk { state, .. } = part_1::parse(state, tracer, cache)?;
Ok(ParseOk { result: (), state })
}
pub type Parsed = ();
}
#[inline(always)]
pub fn parse<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, Parsed> {
optional::parse(state.clone(), tracer, cache)
.or_else(|err| Ok(ParseOk { result: (), state: state.record_error(err) }))
}
pub type Parsed = ();
}
#[inline(always)]
pub fn parse<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, Parsed> {
let ParseOk { state, .. } = part_0::parse(state, tracer, cache)?;
let ParseOk { state, .. } = part_1::parse(state, tracer, cache)?;
Ok(ParseOk { result: (), state })
}
pub type Parsed = ();
#[inline(always)]
pub fn rule_parser<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, Num> {
let result = parse(state.clone(), tracer, cache)?.map_with_state(|_, new_state| {
let string = state.slice_until(new_state).to_string();
Num { string, position: state.range_until(new_state) }
});
Ok(result)
}
}
#[inline]
pub(super) fn parse_Num<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, Num> {
tracer.run_traced("Num", state, |state, tracer| Num_impl::rule_parser(state, tracer, cache))
}
impl PegPosition for Num {
fn position(&self) -> &std::ops::Range<usize> {
&self.position
}
}
mod NamespaceNode_impl {
use super::*;
mod part_1 {
use super::*;
mod closure {
use super::*;
#[inline(always)]
pub fn parse<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, Parsed> {
let ParseOk { state, .. } = parse_Whitespace(state, tracer, cache)
.and_then(|ParseOk { state, .. }| parse_Dot(state, tracer, cache))
.discard_result()?;
let ParseOk { result: mut path, state } = parse_Whitespace(state, tracer, cache)
.and_then(|ParseOk { state, .. }| parse_IdentifierNode(state, tracer, cache))
.map_inner(|result| vec![result])?;
Ok(ParseOk { result: path, state })
}
pub type Parsed = Vec<IdentifierNode>;
}
#[inline(always)]
pub fn parse<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, Parsed> {
let mut iterations: usize = 0;
let mut state = state;
let mut path: Vec<IdentifierNode> = Vec::new();
loop {
match closure::parse(state.clone(), tracer, cache) {
Ok(ParseOk { result: __result, state: new_state, .. }) => {
path.extend(__result);
state = new_state;
}
Err(err) => {
state = state.record_error(err);
break;
}
}
iterations += 1;
}
Ok(ParseOk { result: path, state })
}
pub type Parsed = Vec<IdentifierNode>;
}
#[inline(always)]
pub fn parse<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, Parsed> {
let ParseOk { result: mut path, state } = parse_Whitespace(state, tracer, cache)
.and_then(|ParseOk { state, .. }| parse_IdentifierNode(state, tracer, cache))
.map_inner(|result| vec![result])?;
let ParseOk { result: extend_path_with, state } = part_1::parse(state, tracer, cache)?;
path.extend(extend_path_with);
Ok(ParseOk { result: path, state })
}
pub type Parsed = Vec<IdentifierNode>;
#[inline(always)]
pub fn rule_parser<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, super::NamespaceNode> {
let result = parse(state.clone(), tracer, cache)?
.map_with_state(|r, new_state| super::NamespaceNode { path: r, position: state.range_until(new_state) });
Ok(result)
}
}
#[inline]
pub(super) fn parse_NamespaceNode<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, NamespaceNode> {
tracer.run_traced("NamespaceNode", state, |state, tracer| NamespaceNode_impl::rule_parser(state, tracer, cache))
}
impl PegPosition for NamespaceNode {
fn position(&self) -> &std::ops::Range<usize> {
&self.position
}
}
mod IdentifierNode_impl {
use super::*;
mod part_1 {
use super::*;
mod closure {
use super::*;
}
#[inline(always)]
pub fn parse<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, Parsed> {
let mut iterations: usize = 0;
let mut state = state;
loop {
match parse_XID_CONTINUE(state.clone(), tracer, cache).discard_result() {
Ok(ParseOk { result: __result, state: new_state, .. }) => {
state = new_state;
}
Err(err) => {
state = state.record_error(err);
break;
}
}
iterations += 1;
}
Ok(ParseOk { result: (), state })
}
pub type Parsed = ();
}
#[inline(always)]
pub fn parse<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, Parsed> {
let ParseOk { state, .. } = ChoiceHelper::new(state)
.choice(|state| parse_XID_START(state, tracer, cache).discard_result())
.choice(|state| parse_character_literal(state, '_').discard_result())
.end()?;
let ParseOk { state, .. } = part_1::parse(state, tracer, cache)?;
Ok(ParseOk { result: (), state })
}
pub type Parsed = ();
#[inline(always)]
pub fn rule_parser<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, IdentifierNode> {
let result = parse(state.clone(), tracer, cache)?.map_with_state(|_, new_state| {
let string = state.slice_until(new_state).to_string();
IdentifierNode { string, position: state.range_until(new_state) }
});
Ok(result)
}
}
#[inline]
pub(super) fn parse_IdentifierNode<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, IdentifierNode> {
tracer.run_traced("IdentifierNode", state, |state, tracer| IdentifierNode_impl::rule_parser(state, tracer, cache))
}
impl PegPosition for IdentifierNode {
fn position(&self) -> &std::ops::Range<usize> {
&self.position
}
}
mod SpecialNode_impl {
use super::*;
#[inline(always)]
pub fn parse<'a>(
mut state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, Parsed> {
ChoiceHelper::new(state)
.choice(|state| {
parse_Whitespace(state, tracer, cache)
.and_then(|ParseOk { state, .. }| parse_string_literal(state, "null"))
.discard_result()
})
.choice(|state| {
parse_Whitespace(state, tracer, cache)
.and_then(|ParseOk { state, .. }| parse_string_literal(state, "default"))
.discard_result()
})
.choice(|state| {
parse_Whitespace(state, tracer, cache)
.and_then(|ParseOk { state, .. }| parse_string_literal(state, "true"))
.discard_result()
})
.choice(|state| {
parse_Whitespace(state, tracer, cache)
.and_then(|ParseOk { state, .. }| parse_string_literal(state, "false"))
.discard_result()
})
.end()
}
pub type Parsed = ();
#[inline(always)]
pub fn rule_parser<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, SpecialNode> {
let result = parse(state.clone(), tracer, cache)?.map_with_state(|_, new_state| {
let string = state.slice_until(new_state).to_string();
SpecialNode { string, position: state.range_until(new_state) }
});
Ok(result)
}
}
#[inline]
pub(super) fn parse_SpecialNode<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, SpecialNode> {
tracer.run_traced("SpecialNode", state, |state, tracer| SpecialNode_impl::rule_parser(state, tracer, cache))
}
impl PegPosition for SpecialNode {
fn position(&self) -> &std::ops::Range<usize> {
&self.position
}
}
#[inline]
pub(super) fn parse_XID_START<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, XID_START> {
if let Some(c) = state.s().chars().next() {
if !unicode_ident::is_xid_start(c) {
return Err(state.report_error(ParseErrorSpecifics::ExpectedCharacterClass { name: "XID_START" }));
}
}
else {
return Err(state.report_error(ParseErrorSpecifics::ExpectedCharacterClass { name: "XID_START" }));
}
if let Ok(result) = parse_char(state.clone(), tracer, cache) {
return Ok(result);
}
Err(state.report_error(ParseErrorSpecifics::ExpectedCharacterClass { name: "XID_START" }))
}
#[inline]
pub(super) fn parse_XID_CONTINUE<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, XID_CONTINUE> {
if let Some(c) = state.s().chars().next() {
if !unicode_ident::is_xid_continue(c) {
return Err(state.report_error(ParseErrorSpecifics::ExpectedCharacterClass { name: "XID_CONTINUE" }));
}
}
else {
return Err(state.report_error(ParseErrorSpecifics::ExpectedCharacterClass { name: "XID_CONTINUE" }));
}
if let Ok(result) = parse_char(state.clone(), tracer, cache) {
return Ok(result);
}
Err(state.report_error(ParseErrorSpecifics::ExpectedCharacterClass { name: "XID_CONTINUE" }))
}
#[inline]
pub(super) fn parse_Dot<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, Dot> {
if let Ok(result) = parse_character_literal(state.clone(), '.') {
return Ok(result);
}
if let Ok(result) = parse_character_literal(state.clone(), '。') {
return Ok(result);
}
Err(state.report_error(ParseErrorSpecifics::ExpectedCharacterClass { name: "Dot" }))
}
#[inline]
pub(super) fn parse_Split<'a>(
state: ParseState<'a>,
tracer: impl ParseTracer,
cache: &mut ParseCache<'a>,
) -> ParseResult<'a, Split> {
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_character_literal(state.clone(), '，') {
return Ok(result);
}
Err(state.report_error(ParseErrorSpecifics::ExpectedCharacterClass { name: "Split" }))
}
}