822 lines
23 KiB
Rust
822 lines
23 KiB
Rust
// auto-generated: "lalrpop 0.19.6"
|
|
// sha3: 5c17121d6330bf8eebfa9cdfd4782fcc522dc2e0de3d264435b7dabb6e5fde
|
|
use crate::{Tree, Literal};
|
|
#[allow(unused_extern_crates)]
|
|
extern crate lalrpop_util as __lalrpop_util;
|
|
#[allow(unused_imports)]
|
|
use self::__lalrpop_util::state_machine as __state_machine;
|
|
extern crate core;
|
|
extern crate alloc;
|
|
|
|
#[cfg_attr(rustfmt, rustfmt_skip)]
|
|
mod __parse__Tree {
|
|
#![allow(non_snake_case, non_camel_case_types, unused_mut, unused_variables, unused_imports, unused_parens)]
|
|
|
|
use crate::{Tree, Literal};
|
|
#[allow(unused_extern_crates)]
|
|
extern crate lalrpop_util as __lalrpop_util;
|
|
#[allow(unused_imports)]
|
|
use self::__lalrpop_util::state_machine as __state_machine;
|
|
extern crate core;
|
|
extern crate alloc;
|
|
use self::__lalrpop_util::lexer::Token;
|
|
#[allow(dead_code)]
|
|
pub(crate) enum __Symbol<'input>
|
|
{
|
|
Variant0(&'input str),
|
|
Variant1(Box<Tree>),
|
|
Variant2(Literal),
|
|
Variant3(f64),
|
|
Variant4(String),
|
|
Variant5(Tree),
|
|
Variant6(alloc::vec::Vec<Tree>),
|
|
}
|
|
const __ACTION: &[i8] = &[
|
|
// State 0
|
|
2, 0, 0, 10, 11,
|
|
// State 1
|
|
2, 0, 4, 10, 11,
|
|
// State 2
|
|
2, 14, 0, 10, 11,
|
|
// State 3
|
|
0, 0, 0, 0, 11,
|
|
// State 4
|
|
2, 0, 0, 10, 11,
|
|
// State 5
|
|
-8, -8, 0, -8, -8,
|
|
// State 6
|
|
-3, -3, 0, -3, -3,
|
|
// State 7
|
|
-2, -2, 0, -2, -2,
|
|
// State 8
|
|
0, 0, 0, 0, 0,
|
|
// State 9
|
|
-4, -4, 0, -4, -4,
|
|
// State 10
|
|
-5, -5, 0, -5, -5,
|
|
// State 11
|
|
-9, -9, 0, -9, -9,
|
|
// State 12
|
|
-10, -10, 0, -10, -10,
|
|
// State 13
|
|
-6, -6, 0, -6, -6,
|
|
// State 14
|
|
0, 17, 0, 0, 0,
|
|
// State 15
|
|
0, -1, 0, 0, 0,
|
|
// State 16
|
|
-7, -7, 0, -7, -7,
|
|
];
|
|
fn __action(state: i8, integer: usize) -> i8 {
|
|
__ACTION[(state as usize) * 5 + integer]
|
|
}
|
|
const __EOF_ACTION: &[i8] = &[
|
|
// State 0
|
|
0,
|
|
// State 1
|
|
0,
|
|
// State 2
|
|
0,
|
|
// State 3
|
|
0,
|
|
// State 4
|
|
0,
|
|
// State 5
|
|
-8,
|
|
// State 6
|
|
-3,
|
|
// State 7
|
|
-2,
|
|
// State 8
|
|
-11,
|
|
// State 9
|
|
-4,
|
|
// State 10
|
|
-5,
|
|
// State 11
|
|
0,
|
|
// State 12
|
|
0,
|
|
// State 13
|
|
-6,
|
|
// State 14
|
|
0,
|
|
// State 15
|
|
0,
|
|
// State 16
|
|
-7,
|
|
];
|
|
fn __goto(state: i8, nt: usize) -> i8 {
|
|
match nt {
|
|
0 => 14,
|
|
1 => 5,
|
|
2 => 6,
|
|
3 => match state {
|
|
3 => 4,
|
|
_ => 7,
|
|
},
|
|
4 => match state {
|
|
1 => 11,
|
|
2 => 12,
|
|
4 => 15,
|
|
_ => 8,
|
|
},
|
|
5 => 2,
|
|
_ => 0,
|
|
}
|
|
}
|
|
fn __expected_tokens(__state: i8) -> alloc::vec::Vec<alloc::string::String> {
|
|
const __TERMINAL: &[&str] = &[
|
|
r###""(""###,
|
|
r###"")""###,
|
|
r###""define""###,
|
|
r###"r#"[0-9]+(\\.[0-9]+)?"#"###,
|
|
r###"r#"[A-Za-z!$%&*+\\-./:<=>?@^_~][A-Za-z!$%&*+\\-./:<=>?@^_~0-9]*"#"###,
|
|
];
|
|
__TERMINAL.iter().enumerate().filter_map(|(index, terminal)| {
|
|
let next_state = __action(__state, index);
|
|
if next_state == 0 {
|
|
None
|
|
} else {
|
|
Some(alloc::string::ToString::to_string(terminal))
|
|
}
|
|
}).collect()
|
|
}
|
|
pub(crate) struct __StateMachine<'input, 's>
|
|
where
|
|
{
|
|
input: &'input str,
|
|
__phantom: core::marker::PhantomData<(&'input (), &'s ())>,
|
|
}
|
|
impl<'input, 's> __state_machine::ParserDefinition for __StateMachine<'input, 's>
|
|
where
|
|
{
|
|
type Location = usize;
|
|
type Error = &'static str;
|
|
type Token = Token<'input>;
|
|
type TokenIndex = usize;
|
|
type Symbol = __Symbol<'input>;
|
|
type Success = Tree;
|
|
type StateIndex = i8;
|
|
type Action = i8;
|
|
type ReduceIndex = i8;
|
|
type NonterminalIndex = usize;
|
|
|
|
#[inline]
|
|
fn start_location(&self) -> Self::Location {
|
|
Default::default()
|
|
}
|
|
|
|
#[inline]
|
|
fn start_state(&self) -> Self::StateIndex {
|
|
0
|
|
}
|
|
|
|
#[inline]
|
|
fn token_to_index(&self, token: &Self::Token) -> Option<usize> {
|
|
__token_to_integer(token, core::marker::PhantomData::<(&(), &())>)
|
|
}
|
|
|
|
#[inline]
|
|
fn action(&self, state: i8, integer: usize) -> i8 {
|
|
__action(state, integer)
|
|
}
|
|
|
|
#[inline]
|
|
fn error_action(&self, state: i8) -> i8 {
|
|
__action(state, 5 - 1)
|
|
}
|
|
|
|
#[inline]
|
|
fn eof_action(&self, state: i8) -> i8 {
|
|
__EOF_ACTION[state as usize]
|
|
}
|
|
|
|
#[inline]
|
|
fn goto(&self, state: i8, nt: usize) -> i8 {
|
|
__goto(state, nt)
|
|
}
|
|
|
|
fn token_to_symbol(&self, token_index: usize, token: Self::Token) -> Self::Symbol {
|
|
__token_to_symbol(token_index, token, core::marker::PhantomData::<(&(), &())>)
|
|
}
|
|
|
|
fn expected_tokens(&self, state: i8) -> alloc::vec::Vec<alloc::string::String> {
|
|
__expected_tokens(state)
|
|
}
|
|
|
|
#[inline]
|
|
fn uses_error_recovery(&self) -> bool {
|
|
false
|
|
}
|
|
|
|
#[inline]
|
|
fn error_recovery_symbol(
|
|
&self,
|
|
recovery: __state_machine::ErrorRecovery<Self>,
|
|
) -> Self::Symbol {
|
|
panic!("error recovery not enabled for this grammar")
|
|
}
|
|
|
|
fn reduce(
|
|
&mut self,
|
|
action: i8,
|
|
start_location: Option<&Self::Location>,
|
|
states: &mut alloc::vec::Vec<i8>,
|
|
symbols: &mut alloc::vec::Vec<__state_machine::SymbolTriple<Self>>,
|
|
) -> Option<__state_machine::ParseResult<Self>> {
|
|
__reduce(
|
|
self.input,
|
|
action,
|
|
start_location,
|
|
states,
|
|
symbols,
|
|
core::marker::PhantomData::<(&(), &())>,
|
|
)
|
|
}
|
|
|
|
fn simulate_reduce(&self, action: i8) -> __state_machine::SimulatedReduce<Self> {
|
|
panic!("error recovery not enabled for this grammar")
|
|
}
|
|
}
|
|
fn __token_to_integer<
|
|
'input,
|
|
's,
|
|
>(
|
|
__token: &Token<'input>,
|
|
_: core::marker::PhantomData<(&'input (), &'s ())>,
|
|
) -> Option<usize>
|
|
{
|
|
match *__token {
|
|
Token(2, _) if true => Some(0),
|
|
Token(3, _) if true => Some(1),
|
|
Token(4, _) if true => Some(2),
|
|
Token(0, _) if true => Some(3),
|
|
Token(1, _) if true => Some(4),
|
|
_ => None,
|
|
}
|
|
}
|
|
fn __token_to_symbol<
|
|
'input,
|
|
's,
|
|
>(
|
|
__token_index: usize,
|
|
__token: Token<'input>,
|
|
_: core::marker::PhantomData<(&'input (), &'s ())>,
|
|
) -> __Symbol<'input>
|
|
{
|
|
match __token_index {
|
|
0 | 1 | 2 | 3 | 4 => match __token {
|
|
Token(2, __tok0) | Token(3, __tok0) | Token(4, __tok0) | Token(0, __tok0) | Token(1, __tok0) if true => __Symbol::Variant0(__tok0),
|
|
_ => unreachable!(),
|
|
},
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
pub(crate) struct TreeParser {
|
|
builder: __lalrpop_util::lexer::MatcherBuilder,
|
|
_priv: (),
|
|
}
|
|
|
|
impl TreeParser {
|
|
pub(crate) fn new() -> TreeParser {
|
|
let __builder = super::__intern_token::new_builder();
|
|
TreeParser {
|
|
builder: __builder,
|
|
_priv: (),
|
|
}
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
pub(crate) fn parse<
|
|
'input,
|
|
's,
|
|
>(
|
|
&self,
|
|
input: &'input str,
|
|
) -> Result<Tree, __lalrpop_util::ParseError<usize, Token<'input>, &'static str>>
|
|
{
|
|
let mut __tokens = self.builder.matcher(input);
|
|
__state_machine::Parser::drive(
|
|
__StateMachine {
|
|
input,
|
|
__phantom: core::marker::PhantomData::<(&(), &())>,
|
|
},
|
|
__tokens,
|
|
)
|
|
}
|
|
}
|
|
pub(crate) fn __reduce<
|
|
'input,
|
|
's,
|
|
>(
|
|
input: &'input str,
|
|
__action: i8,
|
|
__lookahead_start: Option<&usize>,
|
|
__states: &mut alloc::vec::Vec<i8>,
|
|
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
|
|
_: core::marker::PhantomData<(&'input (), &'s ())>,
|
|
) -> Option<Result<Tree,__lalrpop_util::ParseError<usize, Token<'input>, &'static str>>>
|
|
{
|
|
let (__pop_states, __nonterminal) = match __action {
|
|
0 => {
|
|
__reduce0(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>)
|
|
}
|
|
1 => {
|
|
__reduce1(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>)
|
|
}
|
|
2 => {
|
|
__reduce2(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>)
|
|
}
|
|
3 => {
|
|
__reduce3(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>)
|
|
}
|
|
4 => {
|
|
__reduce4(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>)
|
|
}
|
|
5 => {
|
|
__reduce5(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>)
|
|
}
|
|
6 => {
|
|
__reduce6(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>)
|
|
}
|
|
7 => {
|
|
__reduce7(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>)
|
|
}
|
|
8 => {
|
|
__reduce8(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>)
|
|
}
|
|
9 => {
|
|
__reduce9(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>)
|
|
}
|
|
10 => {
|
|
// __Tree = Tree => ActionFn(0);
|
|
let __sym0 = __pop_Variant5(__symbols);
|
|
let __start = __sym0.0.clone();
|
|
let __end = __sym0.2.clone();
|
|
let __nt = super::__action0::<>(input, __sym0);
|
|
return Some(Ok(__nt));
|
|
}
|
|
_ => panic!("invalid action code {}", __action)
|
|
};
|
|
let __states_len = __states.len();
|
|
__states.truncate(__states_len - __pop_states);
|
|
let __state = *__states.last().unwrap();
|
|
let __next_state = __goto(__state, __nonterminal);
|
|
__states.push(__next_state);
|
|
None
|
|
}
|
|
#[inline(never)]
|
|
fn __symbol_type_mismatch() -> ! {
|
|
panic!("symbol type mismatch")
|
|
}
|
|
fn __pop_Variant1<
|
|
'input,
|
|
>(
|
|
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>
|
|
) -> (usize, Box<Tree>, usize)
|
|
{
|
|
match __symbols.pop() {
|
|
Some((__l, __Symbol::Variant1(__v), __r)) => (__l, __v, __r),
|
|
_ => __symbol_type_mismatch()
|
|
}
|
|
}
|
|
fn __pop_Variant2<
|
|
'input,
|
|
>(
|
|
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>
|
|
) -> (usize, Literal, usize)
|
|
{
|
|
match __symbols.pop() {
|
|
Some((__l, __Symbol::Variant2(__v), __r)) => (__l, __v, __r),
|
|
_ => __symbol_type_mismatch()
|
|
}
|
|
}
|
|
fn __pop_Variant4<
|
|
'input,
|
|
>(
|
|
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>
|
|
) -> (usize, String, usize)
|
|
{
|
|
match __symbols.pop() {
|
|
Some((__l, __Symbol::Variant4(__v), __r)) => (__l, __v, __r),
|
|
_ => __symbol_type_mismatch()
|
|
}
|
|
}
|
|
fn __pop_Variant5<
|
|
'input,
|
|
>(
|
|
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>
|
|
) -> (usize, Tree, usize)
|
|
{
|
|
match __symbols.pop() {
|
|
Some((__l, __Symbol::Variant5(__v), __r)) => (__l, __v, __r),
|
|
_ => __symbol_type_mismatch()
|
|
}
|
|
}
|
|
fn __pop_Variant6<
|
|
'input,
|
|
>(
|
|
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>
|
|
) -> (usize, alloc::vec::Vec<Tree>, usize)
|
|
{
|
|
match __symbols.pop() {
|
|
Some((__l, __Symbol::Variant6(__v), __r)) => (__l, __v, __r),
|
|
_ => __symbol_type_mismatch()
|
|
}
|
|
}
|
|
fn __pop_Variant3<
|
|
'input,
|
|
>(
|
|
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>
|
|
) -> (usize, f64, usize)
|
|
{
|
|
match __symbols.pop() {
|
|
Some((__l, __Symbol::Variant3(__v), __r)) => (__l, __v, __r),
|
|
_ => __symbol_type_mismatch()
|
|
}
|
|
}
|
|
fn __pop_Variant0<
|
|
'input,
|
|
>(
|
|
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>
|
|
) -> (usize, &'input str, usize)
|
|
{
|
|
match __symbols.pop() {
|
|
Some((__l, __Symbol::Variant0(__v), __r)) => (__l, __v, __r),
|
|
_ => __symbol_type_mismatch()
|
|
}
|
|
}
|
|
pub(crate) fn __reduce0<
|
|
'input,
|
|
's,
|
|
>(
|
|
input: &'input str,
|
|
__lookahead_start: Option<&usize>,
|
|
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
|
|
_: core::marker::PhantomData<(&'input (), &'s ())>,
|
|
) -> (usize, usize)
|
|
{
|
|
// Box<Tree> = Tree => ActionFn(8);
|
|
let __sym0 = __pop_Variant5(__symbols);
|
|
let __start = __sym0.0.clone();
|
|
let __end = __sym0.2.clone();
|
|
let __nt = super::__action8::<>(input, __sym0);
|
|
__symbols.push((__start, __Symbol::Variant1(__nt), __end));
|
|
(1, 0)
|
|
}
|
|
pub(crate) fn __reduce1<
|
|
'input,
|
|
's,
|
|
>(
|
|
input: &'input str,
|
|
__lookahead_start: Option<&usize>,
|
|
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
|
|
_: core::marker::PhantomData<(&'input (), &'s ())>,
|
|
) -> (usize, usize)
|
|
{
|
|
// Literal = Sym => ActionFn(4);
|
|
let __sym0 = __pop_Variant4(__symbols);
|
|
let __start = __sym0.0.clone();
|
|
let __end = __sym0.2.clone();
|
|
let __nt = super::__action4::<>(input, __sym0);
|
|
__symbols.push((__start, __Symbol::Variant2(__nt), __end));
|
|
(1, 1)
|
|
}
|
|
pub(crate) fn __reduce2<
|
|
'input,
|
|
's,
|
|
>(
|
|
input: &'input str,
|
|
__lookahead_start: Option<&usize>,
|
|
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
|
|
_: core::marker::PhantomData<(&'input (), &'s ())>,
|
|
) -> (usize, usize)
|
|
{
|
|
// Literal = Num => ActionFn(5);
|
|
let __sym0 = __pop_Variant3(__symbols);
|
|
let __start = __sym0.0.clone();
|
|
let __end = __sym0.2.clone();
|
|
let __nt = super::__action5::<>(input, __sym0);
|
|
__symbols.push((__start, __Symbol::Variant2(__nt), __end));
|
|
(1, 1)
|
|
}
|
|
pub(crate) fn __reduce3<
|
|
'input,
|
|
's,
|
|
>(
|
|
input: &'input str,
|
|
__lookahead_start: Option<&usize>,
|
|
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
|
|
_: core::marker::PhantomData<(&'input (), &'s ())>,
|
|
) -> (usize, usize)
|
|
{
|
|
// Num = r#"[0-9]+(\\.[0-9]+)?"# => ActionFn(7);
|
|
let __sym0 = __pop_Variant0(__symbols);
|
|
let __start = __sym0.0.clone();
|
|
let __end = __sym0.2.clone();
|
|
let __nt = super::__action7::<>(input, __sym0);
|
|
__symbols.push((__start, __Symbol::Variant3(__nt), __end));
|
|
(1, 2)
|
|
}
|
|
pub(crate) fn __reduce4<
|
|
'input,
|
|
's,
|
|
>(
|
|
input: &'input str,
|
|
__lookahead_start: Option<&usize>,
|
|
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
|
|
_: core::marker::PhantomData<(&'input (), &'s ())>,
|
|
) -> (usize, usize)
|
|
{
|
|
// Sym = r#"[A-Za-z!$%&*+\\-./:<=>?@^_~][A-Za-z!$%&*+\\-./:<=>?@^_~0-9]*"# => ActionFn(6);
|
|
let __sym0 = __pop_Variant0(__symbols);
|
|
let __start = __sym0.0.clone();
|
|
let __end = __sym0.2.clone();
|
|
let __nt = super::__action6::<>(input, __sym0);
|
|
__symbols.push((__start, __Symbol::Variant4(__nt), __end));
|
|
(1, 3)
|
|
}
|
|
pub(crate) fn __reduce5<
|
|
'input,
|
|
's,
|
|
>(
|
|
input: &'input str,
|
|
__lookahead_start: Option<&usize>,
|
|
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
|
|
_: core::marker::PhantomData<(&'input (), &'s ())>,
|
|
) -> (usize, usize)
|
|
{
|
|
// Tree = "(", Tree+, ")" => ActionFn(1);
|
|
assert!(__symbols.len() >= 3);
|
|
let __sym2 = __pop_Variant0(__symbols);
|
|
let __sym1 = __pop_Variant6(__symbols);
|
|
let __sym0 = __pop_Variant0(__symbols);
|
|
let __start = __sym0.0.clone();
|
|
let __end = __sym2.2.clone();
|
|
let __nt = super::__action1::<>(input, __sym0, __sym1, __sym2);
|
|
__symbols.push((__start, __Symbol::Variant5(__nt), __end));
|
|
(3, 4)
|
|
}
|
|
pub(crate) fn __reduce6<
|
|
'input,
|
|
's,
|
|
>(
|
|
input: &'input str,
|
|
__lookahead_start: Option<&usize>,
|
|
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
|
|
_: core::marker::PhantomData<(&'input (), &'s ())>,
|
|
) -> (usize, usize)
|
|
{
|
|
// Tree = "(", "define", Sym, Box<Tree>, ")" => ActionFn(2);
|
|
assert!(__symbols.len() >= 5);
|
|
let __sym4 = __pop_Variant0(__symbols);
|
|
let __sym3 = __pop_Variant1(__symbols);
|
|
let __sym2 = __pop_Variant4(__symbols);
|
|
let __sym1 = __pop_Variant0(__symbols);
|
|
let __sym0 = __pop_Variant0(__symbols);
|
|
let __start = __sym0.0.clone();
|
|
let __end = __sym4.2.clone();
|
|
let __nt = super::__action2::<>(input, __sym0, __sym1, __sym2, __sym3, __sym4);
|
|
__symbols.push((__start, __Symbol::Variant5(__nt), __end));
|
|
(5, 4)
|
|
}
|
|
pub(crate) fn __reduce7<
|
|
'input,
|
|
's,
|
|
>(
|
|
input: &'input str,
|
|
__lookahead_start: Option<&usize>,
|
|
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
|
|
_: core::marker::PhantomData<(&'input (), &'s ())>,
|
|
) -> (usize, usize)
|
|
{
|
|
// Tree = Literal => ActionFn(3);
|
|
let __sym0 = __pop_Variant2(__symbols);
|
|
let __start = __sym0.0.clone();
|
|
let __end = __sym0.2.clone();
|
|
let __nt = super::__action3::<>(input, __sym0);
|
|
__symbols.push((__start, __Symbol::Variant5(__nt), __end));
|
|
(1, 4)
|
|
}
|
|
pub(crate) fn __reduce8<
|
|
'input,
|
|
's,
|
|
>(
|
|
input: &'input str,
|
|
__lookahead_start: Option<&usize>,
|
|
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
|
|
_: core::marker::PhantomData<(&'input (), &'s ())>,
|
|
) -> (usize, usize)
|
|
{
|
|
// Tree+ = Tree => ActionFn(9);
|
|
let __sym0 = __pop_Variant5(__symbols);
|
|
let __start = __sym0.0.clone();
|
|
let __end = __sym0.2.clone();
|
|
let __nt = super::__action9::<>(input, __sym0);
|
|
__symbols.push((__start, __Symbol::Variant6(__nt), __end));
|
|
(1, 5)
|
|
}
|
|
pub(crate) fn __reduce9<
|
|
'input,
|
|
's,
|
|
>(
|
|
input: &'input str,
|
|
__lookahead_start: Option<&usize>,
|
|
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
|
|
_: core::marker::PhantomData<(&'input (), &'s ())>,
|
|
) -> (usize, usize)
|
|
{
|
|
// Tree+ = Tree+, Tree => ActionFn(10);
|
|
assert!(__symbols.len() >= 2);
|
|
let __sym1 = __pop_Variant5(__symbols);
|
|
let __sym0 = __pop_Variant6(__symbols);
|
|
let __start = __sym0.0.clone();
|
|
let __end = __sym1.2.clone();
|
|
let __nt = super::__action10::<>(input, __sym0, __sym1);
|
|
__symbols.push((__start, __Symbol::Variant6(__nt), __end));
|
|
(2, 5)
|
|
}
|
|
}
|
|
pub(crate) use self::__parse__Tree::TreeParser;
|
|
#[cfg_attr(rustfmt, rustfmt_skip)]
|
|
mod __intern_token {
|
|
#![allow(unused_imports)]
|
|
use crate::{Tree, Literal};
|
|
#[allow(unused_extern_crates)]
|
|
extern crate lalrpop_util as __lalrpop_util;
|
|
#[allow(unused_imports)]
|
|
use self::__lalrpop_util::state_machine as __state_machine;
|
|
extern crate core;
|
|
extern crate alloc;
|
|
pub fn new_builder() -> __lalrpop_util::lexer::MatcherBuilder {
|
|
let __strs: &[(&str, bool)] = &[
|
|
("^([0-9]+(\\.[0-9]+)?)", false),
|
|
("^([!\\$-\\&\\*-\\+\\--/:<-Z\\^-_a-z\\~][!\\$-\\&\\*-\\+\\--:<-Z\\^-_a-z\\~]*)", false),
|
|
("^(\\()", false),
|
|
("^(\\))", false),
|
|
("^(define)", false),
|
|
(r"^(\s*)", true),
|
|
];
|
|
__lalrpop_util::lexer::MatcherBuilder::new(__strs.iter().copied()).unwrap()
|
|
}
|
|
}
|
|
pub(crate) use self::__lalrpop_util::lexer::Token;
|
|
|
|
#[allow(unused_variables)]
|
|
fn __action0<
|
|
'input,
|
|
's,
|
|
>(
|
|
input: &'input str,
|
|
(_, __0, _): (usize, Tree, usize),
|
|
) -> Tree
|
|
{
|
|
__0
|
|
}
|
|
|
|
#[allow(unused_variables)]
|
|
fn __action1<
|
|
'input,
|
|
's,
|
|
>(
|
|
input: &'input str,
|
|
(_, _, _): (usize, &'input str, usize),
|
|
(_, __0, _): (usize, alloc::vec::Vec<Tree>, usize),
|
|
(_, _, _): (usize, &'input str, usize),
|
|
) -> Tree
|
|
{
|
|
Tree::Branch(__0)
|
|
}
|
|
|
|
#[allow(unused_variables)]
|
|
fn __action2<
|
|
'input,
|
|
's,
|
|
>(
|
|
input: &'input str,
|
|
(_, _, _): (usize, &'input str, usize),
|
|
(_, _, _): (usize, &'input str, usize),
|
|
(_, __0, _): (usize, String, usize),
|
|
(_, __1, _): (usize, Box<Tree>, usize),
|
|
(_, _, _): (usize, &'input str, usize),
|
|
) -> Tree
|
|
{
|
|
Tree::Define(__0, __1)
|
|
}
|
|
|
|
#[allow(unused_variables)]
|
|
fn __action3<
|
|
'input,
|
|
's,
|
|
>(
|
|
input: &'input str,
|
|
(_, __0, _): (usize, Literal, usize),
|
|
) -> Tree
|
|
{
|
|
Tree::Leaf(__0)
|
|
}
|
|
|
|
#[allow(unused_variables)]
|
|
fn __action4<
|
|
'input,
|
|
's,
|
|
>(
|
|
input: &'input str,
|
|
(_, __0, _): (usize, String, usize),
|
|
) -> Literal
|
|
{
|
|
Literal::Sym(__0)
|
|
}
|
|
|
|
#[allow(unused_variables)]
|
|
fn __action5<
|
|
'input,
|
|
's,
|
|
>(
|
|
input: &'input str,
|
|
(_, __0, _): (usize, f64, usize),
|
|
) -> Literal
|
|
{
|
|
Literal::Num(__0)
|
|
}
|
|
|
|
#[allow(unused_variables)]
|
|
fn __action6<
|
|
'input,
|
|
's,
|
|
>(
|
|
input: &'input str,
|
|
(_, __0, _): (usize, &'input str, usize),
|
|
) -> String
|
|
{
|
|
__0.to_owned()
|
|
}
|
|
|
|
#[allow(unused_variables)]
|
|
fn __action7<
|
|
'input,
|
|
's,
|
|
>(
|
|
input: &'input str,
|
|
(_, __0, _): (usize, &'input str, usize),
|
|
) -> f64
|
|
{
|
|
__0.parse().unwrap()
|
|
}
|
|
|
|
#[allow(unused_variables)]
|
|
fn __action8<
|
|
'input,
|
|
's,
|
|
>(
|
|
input: &'input str,
|
|
(_, __0, _): (usize, Tree, usize),
|
|
) -> Box<Tree>
|
|
{
|
|
Box::new(__0)
|
|
}
|
|
|
|
#[allow(unused_variables)]
|
|
fn __action9<
|
|
'input,
|
|
's,
|
|
>(
|
|
input: &'input str,
|
|
(_, __0, _): (usize, Tree, usize),
|
|
) -> alloc::vec::Vec<Tree>
|
|
{
|
|
alloc::vec![__0]
|
|
}
|
|
|
|
#[allow(unused_variables)]
|
|
fn __action10<
|
|
'input,
|
|
's,
|
|
>(
|
|
input: &'input str,
|
|
(_, v, _): (usize, alloc::vec::Vec<Tree>, usize),
|
|
(_, e, _): (usize, Tree, usize),
|
|
) -> alloc::vec::Vec<Tree>
|
|
{
|
|
{ let mut v = v; v.push(e); v }
|
|
}
|
|
|
|
pub trait __ToTriple<'input, 's, > {
|
|
fn to_triple(value: Self) -> Result<(usize,Token<'input>,usize), __lalrpop_util::ParseError<usize, Token<'input>, &'static str>>;
|
|
}
|
|
|
|
impl<'input, 's, > __ToTriple<'input, 's, > for (usize, Token<'input>, usize) {
|
|
fn to_triple(value: Self) -> Result<(usize,Token<'input>,usize), __lalrpop_util::ParseError<usize, Token<'input>, &'static str>> {
|
|
Ok(value)
|
|
}
|
|
}
|
|
impl<'input, 's, > __ToTriple<'input, 's, > for Result<(usize, Token<'input>, usize), &'static str> {
|
|
fn to_triple(value: Self) -> Result<(usize,Token<'input>,usize), __lalrpop_util::ParseError<usize, Token<'input>, &'static str>> {
|
|
match value {
|
|
Ok(v) => Ok(v),
|
|
Err(error) => Err(__lalrpop_util::ParseError::User { error }),
|
|
}
|
|
}
|
|
}
|