diff --git a/src/grammar.lalrpop b/src/grammar.lalrpop index 61d16f7..f53396a 100644 --- a/src/grammar.lalrpop +++ b/src/grammar.lalrpop @@ -3,13 +3,14 @@ use std::rc::Rc; grammar<'s>(); +pub(crate) Trees = Tree+; pub(crate) Tree: Tree = { "(" ")" => Tree::Branch(<>), "(" "define" ")" => Tree::Define(<>), - "(" "define" "(" > ")" > ")" => Tree::Define(name, Box::new(Tree::Lambda(Lambda(args, body)))), + "(" "define" "(" > ")" > ")" => Tree::Define(name, Box::new(Tree::Lambda(Lambda(args, body)))), "(" "if" ")" => Tree::If(Box::new([<>])), - "(" "lambda (" > ")" > ")" => Tree::Lambda(Lambda(<>)), + "(" "lambda (" > ")" > ")" => Tree::Lambda(Lambda(<>)), Literal => Tree::Leaf(<>), } diff --git a/src/grammar.rs b/src/grammar.rs index b275c54..22db621 100644 --- a/src/grammar.rs +++ b/src/grammar.rs @@ -1,5 +1,5 @@ // auto-generated: "lalrpop 0.19.6" -// sha3: 779020ca179c7d99169ea2a3dc209511d4dc5bfa2f6290c09a821c6f93ced8c +// sha3: a54ba28b30feb1da2d7a31653f616967fd0bc59c54744f5e93177dbb161775 use crate::{Tree, Literal, Lambda}; use std::rc::Rc; #[allow(unused_extern_crates)] @@ -30,8 +30,8 @@ mod __parse__Tree { Variant2(bool), Variant3(Literal), Variant4(f64), - Variant5(Rc), - Variant6(Rc<[String]>), + Variant5(Rc<[String]>), + Variant6(Rc<[Tree]>), Variant7(String), Variant8(alloc::vec::Vec), Variant9(Tree), @@ -39,87 +39,87 @@ mod __parse__Tree { } const __ACTION: &[i8] = &[ // State 0 - 20, 21, 2, 0, 0, 0, 0, 22, 23, + 21, 22, 2, 0, 0, 0, 0, 23, 24, // State 1 - 20, 21, 2, 0, 4, 5, 6, 22, 23, + 21, 22, 2, 0, 4, 5, 6, 23, 24, // State 2 - 20, 21, 2, 26, 0, 0, 0, 22, 23, + 21, 22, 2, 27, 0, 0, 0, 23, 24, // State 3 - 0, 0, 8, 0, 0, 0, 0, 0, 23, + 0, 0, 8, 0, 0, 0, 0, 0, 24, // State 4 - 20, 21, 2, 0, 0, 0, 0, 22, 23, + 21, 22, 2, 0, 0, 0, 0, 23, 24, // State 5 - 0, 0, 0, -10, 0, 0, 0, 0, 23, + 0, 0, 0, -9, 0, 0, 0, 0, 24, // State 6 - 20, 21, 2, 0, 0, 0, 0, 22, 23, + 21, 22, 2, 0, 0, 0, 0, 23, 24, // State 7 - 0, 0, 0, 0, 0, 0, 0, 0, 23, + 0, 0, 0, 0, 0, 0, 0, 0, 24, // State 8 - 20, 21, 2, 0, 0, 0, 0, 22, 23, + 21, 22, 2, 0, 0, 0, 0, 23, 24, // State 9 - 0, 0, 0, -11, 0, 0, 0, 0, 23, + 0, 0, 0, -10, 0, 0, 0, 0, 24, // State 10 - 0, 0, 0, -10, 0, 0, 0, 0, 23, + 0, 0, 0, -9, 0, 0, 0, 0, 24, // State 11 - 20, 21, 2, 0, 0, 0, 0, 22, 23, + 21, 22, 2, 0, 0, 0, 0, 23, 24, // State 12 - 20, 21, 2, 0, 0, 0, 0, 22, 23, + 21, 22, 2, -11, 0, 0, 0, 23, 24, // State 13 - 20, 21, 2, 0, 0, 0, 0, 22, 23, + 21, 22, 2, -12, 0, 0, 0, 23, 24, // State 14 - -7, -7, -7, -7, 0, 0, 0, -7, -7, + 21, 22, 2, -11, 0, 0, 0, 23, 24, // State 15 - -22, -22, -22, -22, 0, 0, 0, -22, -22, + -7, -7, -7, -7, 0, 0, 0, -7, -7, // State 16 - -6, -6, -6, -6, 0, 0, 0, -6, -6, - // State 17 - -5, -5, -5, -5, 0, 0, 0, -5, -5, - // State 18 - 0, 0, 0, 0, 0, 0, 0, 0, 0, - // State 19 - -3, -3, -3, -3, 0, 0, 0, -3, -3, - // State 20 - -2, -2, -2, -2, 0, 0, 0, -2, -2, - // State 21 - -8, -8, -8, -8, 0, 0, 0, -8, -8, - // State 22 - -12, -12, -12, -12, 0, 0, 0, -12, -12, - // State 23 -23, -23, -23, -23, 0, 0, 0, -23, -23, + // State 17 + -6, -6, -6, -6, 0, 0, 0, -6, -6, + // State 18 + -5, -5, -5, -5, 0, 0, 0, -5, -5, + // State 19 + 0, 0, 0, 0, 0, 0, 0, 0, 0, + // State 20 + -3, -3, -3, -3, 0, 0, 0, -3, -3, + // State 21 + -2, -2, -2, -2, 0, 0, 0, -2, -2, + // State 22 + -8, -8, -8, -8, 0, 0, 0, -8, -8, + // State 23 + -13, -13, -13, -13, 0, 0, 0, -13, -13, // State 24 - -24, -24, -24, -24, 0, 0, 0, -24, -24, + -26, -26, -26, -26, 0, 0, 0, -26, -26, // State 25 - -17, -17, -17, -17, 0, 0, 0, -17, -17, + -27, -27, -27, -27, 0, 0, 0, -27, -27, // State 26 - 0, 0, 0, 13, 0, 0, 0, 0, 0, - // State 27 - 0, 0, 0, -15, 0, 0, 0, 0, -15, - // State 28 - 0, 0, 0, 33, 0, 0, 0, 0, 0, - // State 29 - 0, 0, 0, -1, 0, 0, 0, 0, 0, - // State 30 - 0, 0, 0, -4, 0, 0, 0, 0, 0, - // State 31 - 0, 0, 0, -16, 0, 0, 0, 0, -16, - // State 32 -18, -18, -18, -18, 0, 0, 0, -18, -18, + // State 27 + 0, 0, 0, 13, 0, 0, 0, 0, 0, + // State 28 + 0, 0, 0, -16, 0, 0, 0, 0, -16, + // State 29 + 0, 0, 0, 34, 0, 0, 0, 0, 0, + // State 30 + 0, 0, 0, -1, 0, 0, 0, 0, 0, + // State 31 + 0, 0, 0, -4, 0, 0, 0, 0, 0, + // State 32 + 0, 0, 0, -17, 0, 0, 0, 0, -17, // State 33 - 0, 0, 0, 14, 0, 0, 0, 0, 0, + -19, -19, -19, -19, 0, 0, 0, -19, -19, // State 34 - 0, 0, 0, 38, 0, 0, 0, 0, 0, + 0, 0, 0, 15, 0, 0, 0, 0, 0, // State 35 - 0, 0, 0, 39, 0, 0, 0, 0, 0, + 0, 0, 0, 38, 0, 0, 0, 0, 0, // State 36 - 0, 0, 0, -9, 0, 0, 0, 0, 0, + 0, 0, 0, 39, 0, 0, 0, 0, 0, // State 37 - -20, -20, -20, -20, 0, 0, 0, -20, -20, - // State 38 -21, -21, -21, -21, 0, 0, 0, -21, -21, + // State 38 + -22, -22, -22, -22, 0, 0, 0, -22, -22, // State 39 0, 0, 0, 41, 0, 0, 0, 0, 0, // State 40 - -19, -19, -19, -19, 0, 0, 0, -19, -19, + -20, -20, -20, -20, 0, 0, 0, -20, -20, ]; fn __action(state: i8, integer: usize) -> i8 { __ACTION[(state as usize) * 9 + integer] @@ -154,31 +154,31 @@ mod __parse__Tree { // State 13 0, // State 14 - -7, - // State 15 - -22, - // State 16 - -6, - // State 17 - -5, - // State 18 - -25, - // State 19 - -3, - // State 20 - -2, - // State 21 - -8, - // State 22 - -12, - // State 23 0, + // State 15 + -7, + // State 16 + -23, + // State 17 + -6, + // State 18 + -5, + // State 19 + -29, + // State 20 + -3, + // State 21 + -2, + // State 22 + -8, + // State 23 + -13, // State 24 0, // State 25 - -17, - // State 26 0, + // State 26 + -18, // State 27 0, // State 28 @@ -190,9 +190,9 @@ mod __parse__Tree { // State 31 0, // State 32 - -18, - // State 33 0, + // State 33 + -19, // State 34 0, // State 35 @@ -200,48 +200,50 @@ mod __parse__Tree { // State 36 0, // State 37 - -20, - // State 38 -21, + // State 38 + -22, // State 39 0, // State 40 - -19, + -20, ]; fn __goto(state: i8, nt: usize) -> i8 { match nt { - 0 => 28, - 1 => 14, - 2 => 29, - 3 => 15, - 4 => 16, + 0 => 29, + 1 => 15, + 2 => 30, + 3 => 16, + 4 => 17, 5 => match state { - 13 => 39, - _ => 35, + 10 => 34, + _ => 27, }, 6 => match state { - 10 => 33, - _ => 26, + 14 => 39, + _ => 36, }, 7 => match state { 3 => 6, 7 => 10, - 5 | 10 => 27, - 9 => 31, - _ => 17, + 5 | 10 => 28, + 9 => 32, + _ => 18, }, 9 => 9, 10 => match state { + 4 => 8, 8 => 11, - 0 => 18, - 1 => 23, - 2 => 24, - 6 => 30, - 11 => 34, - 12..=13 => 36, - _ => 8, + 0 => 19, + 2 | 13 => 25, + 6 => 31, + 11 => 35, + _ => 24, + }, + 12 => match state { + 1 => 2, + _ => 13, }, - 11 => 2, _ => 0, } } @@ -520,13 +522,28 @@ mod __parse__Tree { __reduce23(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>) } 24 => { - // __Tree = Tree => ActionFn(0); + __reduce24(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>) + } + 25 => { + __reduce25(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>) + } + 26 => { + __reduce26(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>) + } + 27 => { + __reduce27(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>) + } + 28 => { + // __Tree = Tree => ActionFn(1); let __sym0 = __pop_Variant9(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action0::<>(input, __sym0); + let __nt = super::__action1::<>(input, __sym0); return Some(Ok(__nt)); } + 29 => { + __reduce29(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>) + } _ => panic!("invalid action code {}", __action) }; let __states_len = __states.len(); @@ -562,25 +579,25 @@ mod __parse__Tree { _ => __symbol_type_mismatch() } } - fn __pop_Variant6< + fn __pop_Variant5< 'input, >( __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> ) -> (usize, Rc<[String]>, usize) { match __symbols.pop() { - Some((__l, __Symbol::Variant6(__v), __r)) => (__l, __v, __r), + Some((__l, __Symbol::Variant5(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch() } } - fn __pop_Variant5< + fn __pop_Variant6< 'input, >( __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> - ) -> (usize, Rc, usize) + ) -> (usize, Rc<[Tree]>, usize) { match __symbols.pop() { - Some((__l, __Symbol::Variant5(__v), __r)) => (__l, __v, __r), + Some((__l, __Symbol::Variant6(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch() } } @@ -671,11 +688,11 @@ mod __parse__Tree { _: core::marker::PhantomData<(&'input (), &'s ())>, ) -> (usize, usize) { - // BTree = Box => ActionFn(7); + // BTree = Box => ActionFn(9); let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action7::<>(input, __sym0); + let __nt = super::__action9::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant1(__nt), __end)); (1, 0) } @@ -689,11 +706,11 @@ mod __parse__Tree { _: core::marker::PhantomData<(&'input (), &'s ())>, ) -> (usize, usize) { - // Bool = "#t" => ActionFn(13); + // Bool = "#t" => ActionFn(15); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action13::<>(input, __sym0); + let __nt = super::__action15::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 1) } @@ -707,11 +724,11 @@ mod __parse__Tree { _: core::marker::PhantomData<(&'input (), &'s ())>, ) -> (usize, usize) { - // Bool = "#f" => ActionFn(14); + // Bool = "#f" => ActionFn(16); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action14::<>(input, __sym0); + let __nt = super::__action16::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 1) } @@ -725,11 +742,11 @@ mod __parse__Tree { _: core::marker::PhantomData<(&'input (), &'s ())>, ) -> (usize, usize) { - // Box = Tree => ActionFn(15); + // Box = Tree => ActionFn(17); let __sym0 = __pop_Variant9(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action15::<>(input, __sym0); + let __nt = super::__action17::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant1(__nt), __end)); (1, 2) } @@ -743,11 +760,11 @@ mod __parse__Tree { _: core::marker::PhantomData<(&'input (), &'s ())>, ) -> (usize, usize) { - // Literal = Sym => ActionFn(8); + // Literal = Sym => ActionFn(10); let __sym0 = __pop_Variant7(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action8::<>(input, __sym0); + let __nt = super::__action10::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 3) } @@ -761,11 +778,11 @@ mod __parse__Tree { _: core::marker::PhantomData<(&'input (), &'s ())>, ) -> (usize, usize) { - // Literal = Num => ActionFn(9); + // Literal = Num => ActionFn(11); let __sym0 = __pop_Variant4(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action9::<>(input, __sym0); + let __nt = super::__action11::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 3) } @@ -779,11 +796,11 @@ mod __parse__Tree { _: core::marker::PhantomData<(&'input (), &'s ())>, ) -> (usize, usize) { - // Literal = Bool => ActionFn(10); + // Literal = Bool => ActionFn(12); let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action10::<>(input, __sym0); + let __nt = super::__action12::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 3) } @@ -797,11 +814,11 @@ mod __parse__Tree { _: core::marker::PhantomData<(&'input (), &'s ())>, ) -> (usize, usize) { - // Num = r#"[0-9]+(\\.[0-9]+)?"# => ActionFn(12); + // Num = r#"[0-9]+(\\.[0-9]+)?"# => ActionFn(14); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action12::<>(input, __sym0); + let __nt = super::__action14::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant4(__nt), __end)); (1, 4) } @@ -815,13 +832,12 @@ mod __parse__Tree { _: core::marker::PhantomData<(&'input (), &'s ())>, ) -> (usize, usize) { - // Rc = Tree => ActionFn(16); - let __sym0 = __pop_Variant9(__symbols); - let __start = __sym0.0.clone(); - let __end = __sym0.2.clone(); - let __nt = super::__action16::<>(input, __sym0); + // RcSlice = => ActionFn(28); + let __start = __lookahead_start.cloned().or_else(|| __symbols.last().map(|s| s.2.clone())).unwrap_or_default(); + let __end = __start.clone(); + let __nt = super::__action28::<>(input, &__start, &__end); __symbols.push((__start, __Symbol::Variant5(__nt), __end)); - (1, 5) + (0, 5) } pub(crate) fn __reduce9< 'input, @@ -833,12 +849,13 @@ mod __parse__Tree { _: core::marker::PhantomData<(&'input (), &'s ())>, ) -> (usize, usize) { - // RcSlice = => ActionFn(24); - let __start = __lookahead_start.cloned().or_else(|| __symbols.last().map(|s| s.2.clone())).unwrap_or_default(); - let __end = __start.clone(); - let __nt = super::__action24::<>(input, &__start, &__end); - __symbols.push((__start, __Symbol::Variant6(__nt), __end)); - (0, 6) + // RcSlice = Sym+ => ActionFn(29); + let __sym0 = __pop_Variant8(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym0.2.clone(); + let __nt = super::__action29::<>(input, __sym0); + __symbols.push((__start, __Symbol::Variant5(__nt), __end)); + (1, 5) } pub(crate) fn __reduce10< 'input, @@ -850,13 +867,12 @@ mod __parse__Tree { _: core::marker::PhantomData<(&'input (), &'s ())>, ) -> (usize, usize) { - // RcSlice = Sym+ => ActionFn(25); - let __sym0 = __pop_Variant8(__symbols); - let __start = __sym0.0.clone(); - let __end = __sym0.2.clone(); - let __nt = super::__action25::<>(input, __sym0); + // RcSlice = => ActionFn(30); + let __start = __lookahead_start.cloned().or_else(|| __symbols.last().map(|s| s.2.clone())).unwrap_or_default(); + let __end = __start.clone(); + let __nt = super::__action30::<>(input, &__start, &__end); __symbols.push((__start, __Symbol::Variant6(__nt), __end)); - (1, 6) + (0, 6) } pub(crate) fn __reduce11< 'input, @@ -868,13 +884,13 @@ mod __parse__Tree { _: core::marker::PhantomData<(&'input (), &'s ())>, ) -> (usize, usize) { - // Sym = r#"[A-Za-z!$%&*+\\-./:<=>?@^_~][A-Za-z!$%&*+\\-./:<=>?@^_~0-9]*"# => ActionFn(11); - let __sym0 = __pop_Variant0(__symbols); + // RcSlice = Tree+ => ActionFn(31); + let __sym0 = __pop_Variant10(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action11::<>(input, __sym0); - __symbols.push((__start, __Symbol::Variant7(__nt), __end)); - (1, 7) + let __nt = super::__action31::<>(input, __sym0); + __symbols.push((__start, __Symbol::Variant6(__nt), __end)); + (1, 6) } pub(crate) fn __reduce12< 'input, @@ -886,12 +902,13 @@ mod __parse__Tree { _: core::marker::PhantomData<(&'input (), &'s ())>, ) -> (usize, usize) { - // Sym* = => ActionFn(20); - let __start = __lookahead_start.cloned().or_else(|| __symbols.last().map(|s| s.2.clone())).unwrap_or_default(); - let __end = __start.clone(); - let __nt = super::__action20::<>(input, &__start, &__end); - __symbols.push((__start, __Symbol::Variant8(__nt), __end)); - (0, 8) + // Sym = r#"[A-Za-z!$%&*+\\-./:<=>?@^_~][A-Za-z!$%&*+\\-./:<=>?@^_~0-9]*"# => ActionFn(13); + let __sym0 = __pop_Variant0(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym0.2.clone(); + let __nt = super::__action13::<>(input, __sym0); + __symbols.push((__start, __Symbol::Variant7(__nt), __end)); + (1, 7) } pub(crate) fn __reduce13< 'input, @@ -903,13 +920,12 @@ mod __parse__Tree { _: core::marker::PhantomData<(&'input (), &'s ())>, ) -> (usize, usize) { - // Sym* = Sym+ => ActionFn(21); - let __sym0 = __pop_Variant8(__symbols); - let __start = __sym0.0.clone(); - let __end = __sym0.2.clone(); - let __nt = super::__action21::<>(input, __sym0); + // Sym* = => ActionFn(22); + let __start = __lookahead_start.cloned().or_else(|| __symbols.last().map(|s| s.2.clone())).unwrap_or_default(); + let __end = __start.clone(); + let __nt = super::__action22::<>(input, &__start, &__end); __symbols.push((__start, __Symbol::Variant8(__nt), __end)); - (1, 8) + (0, 8) } pub(crate) fn __reduce14< 'input, @@ -921,13 +937,13 @@ mod __parse__Tree { _: core::marker::PhantomData<(&'input (), &'s ())>, ) -> (usize, usize) { - // Sym+ = Sym => ActionFn(22); - let __sym0 = __pop_Variant7(__symbols); + // Sym* = Sym+ => ActionFn(23); + let __sym0 = __pop_Variant8(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action22::<>(input, __sym0); + let __nt = super::__action23::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant8(__nt), __end)); - (1, 9) + (1, 8) } pub(crate) fn __reduce15< 'input, @@ -939,15 +955,13 @@ mod __parse__Tree { _: core::marker::PhantomData<(&'input (), &'s ())>, ) -> (usize, usize) { - // Sym+ = Sym+, Sym => ActionFn(23); - assert!(__symbols.len() >= 2); - let __sym1 = __pop_Variant7(__symbols); - let __sym0 = __pop_Variant8(__symbols); + // Sym+ = Sym => ActionFn(26); + let __sym0 = __pop_Variant7(__symbols); let __start = __sym0.0.clone(); - let __end = __sym1.2.clone(); - let __nt = super::__action23::<>(input, __sym0, __sym1); + let __end = __sym0.2.clone(); + let __nt = super::__action26::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant8(__nt), __end)); - (2, 9) + (1, 9) } pub(crate) fn __reduce16< 'input, @@ -959,16 +973,15 @@ mod __parse__Tree { _: core::marker::PhantomData<(&'input (), &'s ())>, ) -> (usize, usize) { - // Tree = "(", Tree+, ")" => ActionFn(1); - assert!(__symbols.len() >= 3); - let __sym2 = __pop_Variant0(__symbols); - let __sym1 = __pop_Variant10(__symbols); - let __sym0 = __pop_Variant0(__symbols); + // Sym+ = Sym+, Sym => ActionFn(27); + assert!(__symbols.len() >= 2); + let __sym1 = __pop_Variant7(__symbols); + let __sym0 = __pop_Variant8(__symbols); let __start = __sym0.0.clone(); - let __end = __sym2.2.clone(); - let __nt = super::__action1::<>(input, __sym0, __sym1, __sym2); - __symbols.push((__start, __Symbol::Variant9(__nt), __end)); - (3, 10) + let __end = __sym1.2.clone(); + let __nt = super::__action27::<>(input, __sym0, __sym1); + __symbols.push((__start, __Symbol::Variant8(__nt), __end)); + (2, 9) } pub(crate) fn __reduce17< 'input, @@ -980,18 +993,16 @@ mod __parse__Tree { _: core::marker::PhantomData<(&'input (), &'s ())>, ) -> (usize, usize) { - // Tree = "(", "define", Sym, BTree, ")" => ActionFn(2); - assert!(__symbols.len() >= 5); - let __sym4 = __pop_Variant0(__symbols); - let __sym3 = __pop_Variant1(__symbols); - let __sym2 = __pop_Variant7(__symbols); - let __sym1 = __pop_Variant0(__symbols); + // Tree = "(", Tree+, ")" => ActionFn(3); + assert!(__symbols.len() >= 3); + let __sym2 = __pop_Variant0(__symbols); + let __sym1 = __pop_Variant10(__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); + let __end = __sym2.2.clone(); + let __nt = super::__action3::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant9(__nt), __end)); - (5, 10) + (3, 10) } pub(crate) fn __reduce18< 'input, @@ -1003,21 +1014,18 @@ mod __parse__Tree { _: core::marker::PhantomData<(&'input (), &'s ())>, ) -> (usize, usize) { - // Tree = "(", "define", "(", Sym, RcSlice, ")", Rc, ")" => ActionFn(3); - assert!(__symbols.len() >= 8); - let __sym7 = __pop_Variant0(__symbols); - let __sym6 = __pop_Variant5(__symbols); - let __sym5 = __pop_Variant0(__symbols); - let __sym4 = __pop_Variant6(__symbols); - let __sym3 = __pop_Variant7(__symbols); - let __sym2 = __pop_Variant0(__symbols); + // Tree = "(", "define", Sym, BTree, ")" => ActionFn(4); + assert!(__symbols.len() >= 5); + let __sym4 = __pop_Variant0(__symbols); + let __sym3 = __pop_Variant1(__symbols); + let __sym2 = __pop_Variant7(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); - let __end = __sym7.2.clone(); - let __nt = super::__action3::<>(input, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7); + let __end = __sym4.2.clone(); + let __nt = super::__action4::<>(input, __sym0, __sym1, __sym2, __sym3, __sym4); __symbols.push((__start, __Symbol::Variant9(__nt), __end)); - (8, 10) + (5, 10) } pub(crate) fn __reduce19< 'input, @@ -1029,19 +1037,21 @@ mod __parse__Tree { _: core::marker::PhantomData<(&'input (), &'s ())>, ) -> (usize, usize) { - // Tree = "(", "if", Tree, Tree, Tree, ")" => ActionFn(4); - assert!(__symbols.len() >= 6); + // Tree = "(", "define", "(", Sym, RcSlice, ")", RcSlice, ")" => ActionFn(5); + assert!(__symbols.len() >= 8); + let __sym7 = __pop_Variant0(__symbols); + let __sym6 = __pop_Variant6(__symbols); let __sym5 = __pop_Variant0(__symbols); - let __sym4 = __pop_Variant9(__symbols); - let __sym3 = __pop_Variant9(__symbols); - let __sym2 = __pop_Variant9(__symbols); + let __sym4 = __pop_Variant5(__symbols); + let __sym3 = __pop_Variant7(__symbols); + let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); - let __end = __sym5.2.clone(); - let __nt = super::__action4::<>(input, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5); + let __end = __sym7.2.clone(); + let __nt = super::__action5::<>(input, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7); __symbols.push((__start, __Symbol::Variant9(__nt), __end)); - (6, 10) + (8, 10) } pub(crate) fn __reduce20< 'input, @@ -1053,17 +1063,17 @@ mod __parse__Tree { _: core::marker::PhantomData<(&'input (), &'s ())>, ) -> (usize, usize) { - // Tree = "(", "lambda (", RcSlice, ")", Rc, ")" => ActionFn(5); + // Tree = "(", "if", Tree, Tree, Tree, ")" => ActionFn(6); assert!(__symbols.len() >= 6); let __sym5 = __pop_Variant0(__symbols); - let __sym4 = __pop_Variant5(__symbols); - let __sym3 = __pop_Variant0(__symbols); - let __sym2 = __pop_Variant6(__symbols); + let __sym4 = __pop_Variant9(__symbols); + let __sym3 = __pop_Variant9(__symbols); + let __sym2 = __pop_Variant9(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); let __end = __sym5.2.clone(); - let __nt = super::__action5::<>(input, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5); + let __nt = super::__action6::<>(input, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5); __symbols.push((__start, __Symbol::Variant9(__nt), __end)); (6, 10) } @@ -1077,13 +1087,19 @@ mod __parse__Tree { _: core::marker::PhantomData<(&'input (), &'s ())>, ) -> (usize, usize) { - // Tree = Literal => ActionFn(6); - let __sym0 = __pop_Variant3(__symbols); + // Tree = "(", "lambda (", RcSlice, ")", RcSlice, ")" => ActionFn(7); + assert!(__symbols.len() >= 6); + let __sym5 = __pop_Variant0(__symbols); + let __sym4 = __pop_Variant6(__symbols); + let __sym3 = __pop_Variant0(__symbols); + let __sym2 = __pop_Variant5(__symbols); + let __sym1 = __pop_Variant0(__symbols); + let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0.clone(); - let __end = __sym0.2.clone(); - let __nt = super::__action6::<>(input, __sym0); + let __end = __sym5.2.clone(); + let __nt = super::__action7::<>(input, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5); __symbols.push((__start, __Symbol::Variant9(__nt), __end)); - (1, 10) + (6, 10) } pub(crate) fn __reduce22< 'input, @@ -1095,13 +1111,13 @@ mod __parse__Tree { _: core::marker::PhantomData<(&'input (), &'s ())>, ) -> (usize, usize) { - // Tree+ = Tree => ActionFn(18); - let __sym0 = __pop_Variant9(__symbols); + // Tree = Literal => ActionFn(8); + let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0.clone(); let __end = __sym0.2.clone(); - let __nt = super::__action18::<>(input, __sym0); - __symbols.push((__start, __Symbol::Variant10(__nt), __end)); - (1, 11) + let __nt = super::__action8::<>(input, __sym0); + __symbols.push((__start, __Symbol::Variant9(__nt), __end)); + (1, 10) } pub(crate) fn __reduce23< 'input, @@ -1113,18 +1129,1334 @@ mod __parse__Tree { _: core::marker::PhantomData<(&'input (), &'s ())>, ) -> (usize, usize) { - // Tree+ = Tree+, Tree => ActionFn(19); + // Tree* = => ActionFn(24); + let __start = __lookahead_start.cloned().or_else(|| __symbols.last().map(|s| s.2.clone())).unwrap_or_default(); + let __end = __start.clone(); + let __nt = super::__action24::<>(input, &__start, &__end); + __symbols.push((__start, __Symbol::Variant10(__nt), __end)); + (0, 11) + } + pub(crate) fn __reduce24< + '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(25); + let __sym0 = __pop_Variant10(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym0.2.clone(); + let __nt = super::__action25::<>(input, __sym0); + __symbols.push((__start, __Symbol::Variant10(__nt), __end)); + (1, 11) + } + pub(crate) fn __reduce25< + '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(20); + let __sym0 = __pop_Variant9(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym0.2.clone(); + let __nt = super::__action20::<>(input, __sym0); + __symbols.push((__start, __Symbol::Variant10(__nt), __end)); + (1, 12) + } + pub(crate) fn __reduce26< + '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(21); assert!(__symbols.len() >= 2); let __sym1 = __pop_Variant9(__symbols); let __sym0 = __pop_Variant10(__symbols); let __start = __sym0.0.clone(); let __end = __sym1.2.clone(); - let __nt = super::__action19::<>(input, __sym0, __sym1); + let __nt = super::__action21::<>(input, __sym0, __sym1); __symbols.push((__start, __Symbol::Variant10(__nt), __end)); - (2, 11) + (2, 12) + } + pub(crate) fn __reduce27< + '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) + { + // Trees = Tree+ => ActionFn(2); + let __sym0 = __pop_Variant10(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym0.2.clone(); + let __nt = super::__action2::<>(input, __sym0); + __symbols.push((__start, __Symbol::Variant10(__nt), __end)); + (1, 13) + } + pub(crate) fn __reduce29< + '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) + { + // __Trees = Trees => ActionFn(0); + let __sym0 = __pop_Variant10(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym0.2.clone(); + let __nt = super::__action0::<>(input, __sym0); + __symbols.push((__start, __Symbol::Variant10(__nt), __end)); + (1, 15) } } pub(crate) use self::__parse__Tree::TreeParser; + +#[cfg_attr(rustfmt, rustfmt_skip)] +mod __parse__Trees { + #![allow(non_snake_case, non_camel_case_types, unused_mut, unused_variables, unused_imports, unused_parens)] + + use crate::{Tree, Literal, Lambda}; + use std::rc::Rc; + #[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), + Variant2(bool), + Variant3(Literal), + Variant4(f64), + Variant5(Rc<[String]>), + Variant6(Rc<[Tree]>), + Variant7(String), + Variant8(alloc::vec::Vec), + Variant9(Tree), + Variant10(alloc::vec::Vec), + } + const __ACTION: &[i8] = &[ + // State 0 + 23, 24, 3, 0, 0, 0, 0, 25, 26, + // State 1 + 23, 24, 3, 0, 0, 0, 0, 25, 26, + // State 2 + 23, 24, 3, 0, 5, 6, 7, 25, 26, + // State 3 + 23, 24, 3, 28, 0, 0, 0, 25, 26, + // State 4 + 0, 0, 9, 0, 0, 0, 0, 0, 26, + // State 5 + 23, 24, 3, 0, 0, 0, 0, 25, 26, + // State 6 + 0, 0, 0, -9, 0, 0, 0, 0, 26, + // State 7 + 23, 24, 3, 0, 0, 0, 0, 25, 26, + // State 8 + 0, 0, 0, 0, 0, 0, 0, 0, 26, + // State 9 + 23, 24, 3, 0, 0, 0, 0, 25, 26, + // State 10 + 0, 0, 0, -10, 0, 0, 0, 0, 26, + // State 11 + 0, 0, 0, -9, 0, 0, 0, 0, 26, + // State 12 + 23, 24, 3, 0, 0, 0, 0, 25, 26, + // State 13 + 23, 24, 3, -11, 0, 0, 0, 25, 26, + // State 14 + 23, 24, 3, -12, 0, 0, 0, 25, 26, + // State 15 + 23, 24, 3, -11, 0, 0, 0, 25, 26, + // State 16 + -7, -7, -7, -7, 0, 0, 0, -7, -7, + // State 17 + -23, -23, -23, -23, 0, 0, 0, -23, -23, + // State 18 + -6, -6, -6, -6, 0, 0, 0, -6, -6, + // State 19 + -5, -5, -5, -5, 0, 0, 0, -5, -5, + // State 20 + -26, -26, -26, -26, 0, 0, 0, -26, -26, + // State 21 + 0, 0, 0, 0, 0, 0, 0, 0, 0, + // State 22 + -3, -3, -3, -3, 0, 0, 0, -3, -3, + // State 23 + -2, -2, -2, -2, 0, 0, 0, -2, -2, + // State 24 + -8, -8, -8, -8, 0, 0, 0, -8, -8, + // State 25 + -13, -13, -13, -13, 0, 0, 0, -13, -13, + // State 26 + -27, -27, -27, -27, 0, 0, 0, -27, -27, + // State 27 + -18, -18, -18, -18, 0, 0, 0, -18, -18, + // State 28 + 0, 0, 0, 14, 0, 0, 0, 0, 0, + // State 29 + 0, 0, 0, -16, 0, 0, 0, 0, -16, + // State 30 + 0, 0, 0, 35, 0, 0, 0, 0, 0, + // State 31 + 0, 0, 0, -1, 0, 0, 0, 0, 0, + // State 32 + 0, 0, 0, -4, 0, 0, 0, 0, 0, + // State 33 + 0, 0, 0, -17, 0, 0, 0, 0, -17, + // State 34 + -19, -19, -19, -19, 0, 0, 0, -19, -19, + // State 35 + 0, 0, 0, 16, 0, 0, 0, 0, 0, + // State 36 + 0, 0, 0, 39, 0, 0, 0, 0, 0, + // State 37 + 0, 0, 0, 40, 0, 0, 0, 0, 0, + // State 38 + -21, -21, -21, -21, 0, 0, 0, -21, -21, + // State 39 + -22, -22, -22, -22, 0, 0, 0, -22, -22, + // State 40 + 0, 0, 0, 42, 0, 0, 0, 0, 0, + // State 41 + -20, -20, -20, -20, 0, 0, 0, -20, -20, + ]; + fn __action(state: i8, integer: usize) -> i8 { + __ACTION[(state as usize) * 9 + integer] + } + const __EOF_ACTION: &[i8] = &[ + // State 0 + 0, + // State 1 + -28, + // State 2 + 0, + // State 3 + 0, + // State 4 + 0, + // State 5 + 0, + // State 6 + 0, + // State 7 + 0, + // State 8 + 0, + // State 9 + 0, + // State 10 + 0, + // State 11 + 0, + // State 12 + 0, + // State 13 + 0, + // State 14 + 0, + // State 15 + 0, + // State 16 + -7, + // State 17 + -23, + // State 18 + -6, + // State 19 + -5, + // State 20 + -26, + // State 21 + -30, + // State 22 + -3, + // State 23 + -2, + // State 24 + -8, + // State 25 + -13, + // State 26 + -27, + // State 27 + -18, + // State 28 + 0, + // State 29 + 0, + // State 30 + 0, + // State 31 + 0, + // State 32 + 0, + // State 33 + 0, + // State 34 + -19, + // State 35 + 0, + // State 36 + 0, + // State 37 + 0, + // State 38 + -21, + // State 39 + -22, + // State 40 + 0, + // State 41 + -20, + ]; + fn __goto(state: i8, nt: usize) -> i8 { + match nt { + 0 => 30, + 1 => 16, + 2 => 31, + 3 => 17, + 4 => 18, + 5 => match state { + 11 => 35, + _ => 28, + }, + 6 => match state { + 15 => 40, + _ => 37, + }, + 7 => match state { + 4 => 7, + 8 => 11, + 6 | 11 => 29, + 10 => 33, + _ => 19, + }, + 9 => 10, + 10 => match state { + 5 => 9, + 9 => 12, + 1 | 3 | 14 => 26, + 7 => 32, + 12 => 36, + _ => 20, + }, + 12 => match state { + 0 => 1, + 2 => 3, + _ => 14, + }, + 13 => 21, + _ => 0, + } + } + fn __expected_tokens(__state: i8) -> alloc::vec::Vec { + const __TERMINAL: &[&str] = &[ + r###""#f""###, + r###""#t""###, + r###""(""###, + r###"")""###, + r###""define""###, + r###""if""###, + r###""lambda (""###, + 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 = alloc::vec::Vec; + 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 { + __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, 9 - 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 { + __expected_tokens(state) + } + + #[inline] + fn uses_error_recovery(&self) -> bool { + false + } + + #[inline] + fn error_recovery_symbol( + &self, + recovery: __state_machine::ErrorRecovery, + ) -> 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, + symbols: &mut alloc::vec::Vec<__state_machine::SymbolTriple>, + ) -> Option<__state_machine::ParseResult> { + __reduce( + self.input, + action, + start_location, + states, + symbols, + core::marker::PhantomData::<(&(), &())>, + ) + } + + fn simulate_reduce(&self, action: i8) -> __state_machine::SimulatedReduce { + panic!("error recovery not enabled for this grammar") + } + } + fn __token_to_integer< + 'input, + 's, + >( + __token: &Token<'input>, + _: core::marker::PhantomData<(&'input (), &'s ())>, + ) -> Option + { + match *__token { + Token(2, _) if true => Some(0), + Token(3, _) if true => Some(1), + Token(4, _) if true => Some(2), + Token(5, _) if true => Some(3), + Token(6, _) if true => Some(4), + Token(7, _) if true => Some(5), + Token(8, _) if true => Some(6), + Token(0, _) if true => Some(7), + Token(1, _) if true => Some(8), + _ => 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 | 5 | 6 | 7 | 8 => match __token { + Token(2, __tok0) | Token(3, __tok0) | Token(4, __tok0) | Token(5, __tok0) | Token(6, __tok0) | Token(7, __tok0) | Token(8, __tok0) | Token(0, __tok0) | Token(1, __tok0) if true => __Symbol::Variant0(__tok0), + _ => unreachable!(), + }, + _ => unreachable!(), + } + } + pub(crate) struct TreesParser { + builder: __lalrpop_util::lexer::MatcherBuilder, + _priv: (), + } + + impl TreesParser { + pub(crate) fn new() -> TreesParser { + let __builder = super::__intern_token::new_builder(); + TreesParser { + builder: __builder, + _priv: (), + } + } + + #[allow(dead_code)] + pub(crate) fn parse< + 'input, + 's, + >( + &self, + input: &'input str, + ) -> Result, __lalrpop_util::ParseError, &'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, + __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>, + _: core::marker::PhantomData<(&'input (), &'s ())>, + ) -> Option,__lalrpop_util::ParseError, &'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 => { + __reduce10(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>) + } + 11 => { + __reduce11(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>) + } + 12 => { + __reduce12(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>) + } + 13 => { + __reduce13(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>) + } + 14 => { + __reduce14(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>) + } + 15 => { + __reduce15(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>) + } + 16 => { + __reduce16(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>) + } + 17 => { + __reduce17(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>) + } + 18 => { + __reduce18(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>) + } + 19 => { + __reduce19(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>) + } + 20 => { + __reduce20(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>) + } + 21 => { + __reduce21(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>) + } + 22 => { + __reduce22(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>) + } + 23 => { + __reduce23(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>) + } + 24 => { + __reduce24(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>) + } + 25 => { + __reduce25(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>) + } + 26 => { + __reduce26(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>) + } + 27 => { + __reduce27(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>) + } + 28 => { + __reduce28(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&(), &())>) + } + 29 => { + // __Trees = Trees => ActionFn(0); + let __sym0 = __pop_Variant10(__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, usize) + { + match __symbols.pop() { + Some((__l, __Symbol::Variant1(__v), __r)) => (__l, __v, __r), + _ => __symbol_type_mismatch() + } + } + fn __pop_Variant3< + 'input, + >( + __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> + ) -> (usize, Literal, usize) + { + match __symbols.pop() { + Some((__l, __Symbol::Variant3(__v), __r)) => (__l, __v, __r), + _ => __symbol_type_mismatch() + } + } + fn __pop_Variant5< + 'input, + >( + __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> + ) -> (usize, Rc<[String]>, 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, Rc<[Tree]>, usize) + { + match __symbols.pop() { + Some((__l, __Symbol::Variant6(__v), __r)) => (__l, __v, __r), + _ => __symbol_type_mismatch() + } + } + fn __pop_Variant7< + 'input, + >( + __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> + ) -> (usize, String, usize) + { + match __symbols.pop() { + Some((__l, __Symbol::Variant7(__v), __r)) => (__l, __v, __r), + _ => __symbol_type_mismatch() + } + } + fn __pop_Variant9< + 'input, + >( + __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> + ) -> (usize, Tree, usize) + { + match __symbols.pop() { + Some((__l, __Symbol::Variant9(__v), __r)) => (__l, __v, __r), + _ => __symbol_type_mismatch() + } + } + fn __pop_Variant8< + 'input, + >( + __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> + ) -> (usize, alloc::vec::Vec, usize) + { + match __symbols.pop() { + Some((__l, __Symbol::Variant8(__v), __r)) => (__l, __v, __r), + _ => __symbol_type_mismatch() + } + } + fn __pop_Variant10< + 'input, + >( + __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> + ) -> (usize, alloc::vec::Vec, usize) + { + match __symbols.pop() { + Some((__l, __Symbol::Variant10(__v), __r)) => (__l, __v, __r), + _ => __symbol_type_mismatch() + } + } + fn __pop_Variant2< + 'input, + >( + __symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)> + ) -> (usize, bool, 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, f64, usize) + { + match __symbols.pop() { + Some((__l, __Symbol::Variant4(__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) + { + // BTree = Box => ActionFn(9); + let __sym0 = __pop_Variant1(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym0.2.clone(); + let __nt = super::__action9::<>(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) + { + // Bool = "#t" => ActionFn(15); + let __sym0 = __pop_Variant0(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym0.2.clone(); + let __nt = super::__action15::<>(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) + { + // Bool = "#f" => ActionFn(16); + let __sym0 = __pop_Variant0(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym0.2.clone(); + let __nt = super::__action16::<>(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) + { + // Box = Tree => ActionFn(17); + let __sym0 = __pop_Variant9(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym0.2.clone(); + let __nt = super::__action17::<>(input, __sym0); + __symbols.push((__start, __Symbol::Variant1(__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) + { + // Literal = Sym => ActionFn(10); + let __sym0 = __pop_Variant7(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym0.2.clone(); + let __nt = super::__action10::<>(input, __sym0); + __symbols.push((__start, __Symbol::Variant3(__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) + { + // Literal = Num => ActionFn(11); + let __sym0 = __pop_Variant4(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym0.2.clone(); + let __nt = super::__action11::<>(input, __sym0); + __symbols.push((__start, __Symbol::Variant3(__nt), __end)); + (1, 3) + } + 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) + { + // Literal = Bool => ActionFn(12); + let __sym0 = __pop_Variant2(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym0.2.clone(); + let __nt = super::__action12::<>(input, __sym0); + __symbols.push((__start, __Symbol::Variant3(__nt), __end)); + (1, 3) + } + 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) + { + // Num = r#"[0-9]+(\\.[0-9]+)?"# => ActionFn(14); + let __sym0 = __pop_Variant0(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym0.2.clone(); + let __nt = super::__action14::<>(input, __sym0); + __symbols.push((__start, __Symbol::Variant4(__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) + { + // RcSlice = => ActionFn(28); + let __start = __lookahead_start.cloned().or_else(|| __symbols.last().map(|s| s.2.clone())).unwrap_or_default(); + let __end = __start.clone(); + let __nt = super::__action28::<>(input, &__start, &__end); + __symbols.push((__start, __Symbol::Variant5(__nt), __end)); + (0, 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) + { + // RcSlice = Sym+ => ActionFn(29); + let __sym0 = __pop_Variant8(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym0.2.clone(); + let __nt = super::__action29::<>(input, __sym0); + __symbols.push((__start, __Symbol::Variant5(__nt), __end)); + (1, 5) + } + pub(crate) fn __reduce10< + '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) + { + // RcSlice = => ActionFn(30); + let __start = __lookahead_start.cloned().or_else(|| __symbols.last().map(|s| s.2.clone())).unwrap_or_default(); + let __end = __start.clone(); + let __nt = super::__action30::<>(input, &__start, &__end); + __symbols.push((__start, __Symbol::Variant6(__nt), __end)); + (0, 6) + } + pub(crate) fn __reduce11< + '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) + { + // RcSlice = Tree+ => ActionFn(31); + let __sym0 = __pop_Variant10(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym0.2.clone(); + let __nt = super::__action31::<>(input, __sym0); + __symbols.push((__start, __Symbol::Variant6(__nt), __end)); + (1, 6) + } + pub(crate) fn __reduce12< + '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(13); + let __sym0 = __pop_Variant0(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym0.2.clone(); + let __nt = super::__action13::<>(input, __sym0); + __symbols.push((__start, __Symbol::Variant7(__nt), __end)); + (1, 7) + } + pub(crate) fn __reduce13< + '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* = => ActionFn(22); + let __start = __lookahead_start.cloned().or_else(|| __symbols.last().map(|s| s.2.clone())).unwrap_or_default(); + let __end = __start.clone(); + let __nt = super::__action22::<>(input, &__start, &__end); + __symbols.push((__start, __Symbol::Variant8(__nt), __end)); + (0, 8) + } + pub(crate) fn __reduce14< + '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* = Sym+ => ActionFn(23); + let __sym0 = __pop_Variant8(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym0.2.clone(); + let __nt = super::__action23::<>(input, __sym0); + __symbols.push((__start, __Symbol::Variant8(__nt), __end)); + (1, 8) + } + pub(crate) fn __reduce15< + '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+ = Sym => ActionFn(26); + let __sym0 = __pop_Variant7(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym0.2.clone(); + let __nt = super::__action26::<>(input, __sym0); + __symbols.push((__start, __Symbol::Variant8(__nt), __end)); + (1, 9) + } + pub(crate) fn __reduce16< + '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+ = Sym+, Sym => ActionFn(27); + assert!(__symbols.len() >= 2); + let __sym1 = __pop_Variant7(__symbols); + let __sym0 = __pop_Variant8(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym1.2.clone(); + let __nt = super::__action27::<>(input, __sym0, __sym1); + __symbols.push((__start, __Symbol::Variant8(__nt), __end)); + (2, 9) + } + pub(crate) fn __reduce17< + '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(3); + assert!(__symbols.len() >= 3); + let __sym2 = __pop_Variant0(__symbols); + let __sym1 = __pop_Variant10(__symbols); + let __sym0 = __pop_Variant0(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym2.2.clone(); + let __nt = super::__action3::<>(input, __sym0, __sym1, __sym2); + __symbols.push((__start, __Symbol::Variant9(__nt), __end)); + (3, 10) + } + pub(crate) fn __reduce18< + '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, BTree, ")" => ActionFn(4); + assert!(__symbols.len() >= 5); + let __sym4 = __pop_Variant0(__symbols); + let __sym3 = __pop_Variant1(__symbols); + let __sym2 = __pop_Variant7(__symbols); + let __sym1 = __pop_Variant0(__symbols); + let __sym0 = __pop_Variant0(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym4.2.clone(); + let __nt = super::__action4::<>(input, __sym0, __sym1, __sym2, __sym3, __sym4); + __symbols.push((__start, __Symbol::Variant9(__nt), __end)); + (5, 10) + } + pub(crate) fn __reduce19< + '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, RcSlice, ")", RcSlice, ")" => ActionFn(5); + assert!(__symbols.len() >= 8); + let __sym7 = __pop_Variant0(__symbols); + let __sym6 = __pop_Variant6(__symbols); + let __sym5 = __pop_Variant0(__symbols); + let __sym4 = __pop_Variant5(__symbols); + let __sym3 = __pop_Variant7(__symbols); + let __sym2 = __pop_Variant0(__symbols); + let __sym1 = __pop_Variant0(__symbols); + let __sym0 = __pop_Variant0(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym7.2.clone(); + let __nt = super::__action5::<>(input, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7); + __symbols.push((__start, __Symbol::Variant9(__nt), __end)); + (8, 10) + } + pub(crate) fn __reduce20< + '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 = "(", "if", Tree, Tree, Tree, ")" => ActionFn(6); + assert!(__symbols.len() >= 6); + let __sym5 = __pop_Variant0(__symbols); + let __sym4 = __pop_Variant9(__symbols); + let __sym3 = __pop_Variant9(__symbols); + let __sym2 = __pop_Variant9(__symbols); + let __sym1 = __pop_Variant0(__symbols); + let __sym0 = __pop_Variant0(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym5.2.clone(); + let __nt = super::__action6::<>(input, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5); + __symbols.push((__start, __Symbol::Variant9(__nt), __end)); + (6, 10) + } + pub(crate) fn __reduce21< + '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 = "(", "lambda (", RcSlice, ")", RcSlice, ")" => ActionFn(7); + assert!(__symbols.len() >= 6); + let __sym5 = __pop_Variant0(__symbols); + let __sym4 = __pop_Variant6(__symbols); + let __sym3 = __pop_Variant0(__symbols); + let __sym2 = __pop_Variant5(__symbols); + let __sym1 = __pop_Variant0(__symbols); + let __sym0 = __pop_Variant0(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym5.2.clone(); + let __nt = super::__action7::<>(input, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5); + __symbols.push((__start, __Symbol::Variant9(__nt), __end)); + (6, 10) + } + pub(crate) fn __reduce22< + '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(8); + let __sym0 = __pop_Variant3(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym0.2.clone(); + let __nt = super::__action8::<>(input, __sym0); + __symbols.push((__start, __Symbol::Variant9(__nt), __end)); + (1, 10) + } + pub(crate) fn __reduce23< + '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* = => ActionFn(24); + let __start = __lookahead_start.cloned().or_else(|| __symbols.last().map(|s| s.2.clone())).unwrap_or_default(); + let __end = __start.clone(); + let __nt = super::__action24::<>(input, &__start, &__end); + __symbols.push((__start, __Symbol::Variant10(__nt), __end)); + (0, 11) + } + pub(crate) fn __reduce24< + '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(25); + let __sym0 = __pop_Variant10(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym0.2.clone(); + let __nt = super::__action25::<>(input, __sym0); + __symbols.push((__start, __Symbol::Variant10(__nt), __end)); + (1, 11) + } + pub(crate) fn __reduce25< + '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(20); + let __sym0 = __pop_Variant9(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym0.2.clone(); + let __nt = super::__action20::<>(input, __sym0); + __symbols.push((__start, __Symbol::Variant10(__nt), __end)); + (1, 12) + } + pub(crate) fn __reduce26< + '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(21); + assert!(__symbols.len() >= 2); + let __sym1 = __pop_Variant9(__symbols); + let __sym0 = __pop_Variant10(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym1.2.clone(); + let __nt = super::__action21::<>(input, __sym0, __sym1); + __symbols.push((__start, __Symbol::Variant10(__nt), __end)); + (2, 12) + } + pub(crate) fn __reduce27< + '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) + { + // Trees = Tree+ => ActionFn(2); + let __sym0 = __pop_Variant10(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym0.2.clone(); + let __nt = super::__action2::<>(input, __sym0); + __symbols.push((__start, __Symbol::Variant10(__nt), __end)); + (1, 13) + } + pub(crate) fn __reduce28< + '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); + let __sym0 = __pop_Variant9(__symbols); + let __start = __sym0.0.clone(); + let __end = __sym0.2.clone(); + let __nt = super::__action1::<>(input, __sym0); + __symbols.push((__start, __Symbol::Variant9(__nt), __end)); + (1, 14) + } +} +pub(crate) use self::__parse__Trees::TreesParser; #[cfg_attr(rustfmt, rustfmt_skip)] mod __intern_token { #![allow(unused_imports)] @@ -1158,6 +2490,18 @@ pub(crate) use self::__lalrpop_util::lexer::Token; fn __action0< 'input, 's, +>( + input: &'input str, + (_, __0, _): (usize, alloc::vec::Vec, usize), +) -> alloc::vec::Vec +{ + __0 +} + +#[allow(unused_variables)] +fn __action1< + 'input, + 's, >( input: &'input str, (_, __0, _): (usize, Tree, usize), @@ -1167,7 +2511,19 @@ fn __action0< } #[allow(unused_variables)] -fn __action1< +fn __action2< + 'input, + 's, +>( + input: &'input str, + (_, __0, _): (usize, alloc::vec::Vec, usize), +) -> alloc::vec::Vec +{ + __0 +} + +#[allow(unused_variables)] +fn __action3< 'input, 's, >( @@ -1181,7 +2537,7 @@ fn __action1< } #[allow(unused_variables)] -fn __action2< +fn __action4< 'input, 's, >( @@ -1197,7 +2553,7 @@ fn __action2< } #[allow(unused_variables)] -fn __action3< +fn __action5< 'input, 's, >( @@ -1208,7 +2564,7 @@ fn __action3< (_, name, _): (usize, String, usize), (_, args, _): (usize, Rc<[String]>, usize), (_, _, _): (usize, &'input str, usize), - (_, body, _): (usize, Rc, usize), + (_, body, _): (usize, Rc<[Tree]>, usize), (_, _, _): (usize, &'input str, usize), ) -> Tree { @@ -1216,7 +2572,7 @@ fn __action3< } #[allow(unused_variables)] -fn __action4< +fn __action6< 'input, 's, >( @@ -1233,7 +2589,7 @@ fn __action4< } #[allow(unused_variables)] -fn __action5< +fn __action7< 'input, 's, >( @@ -1242,7 +2598,7 @@ fn __action5< (_, _, _): (usize, &'input str, usize), (_, __0, _): (usize, Rc<[String]>, usize), (_, _, _): (usize, &'input str, usize), - (_, __1, _): (usize, Rc, usize), + (_, __1, _): (usize, Rc<[Tree]>, usize), (_, _, _): (usize, &'input str, usize), ) -> Tree { @@ -1250,7 +2606,7 @@ fn __action5< } #[allow(unused_variables)] -fn __action6< +fn __action8< 'input, 's, >( @@ -1262,7 +2618,7 @@ fn __action6< } #[allow(unused_variables)] -fn __action7< +fn __action9< 'input, 's, >( @@ -1274,7 +2630,7 @@ fn __action7< } #[allow(unused_variables)] -fn __action8< +fn __action10< 'input, 's, >( @@ -1286,7 +2642,7 @@ fn __action8< } #[allow(unused_variables)] -fn __action9< +fn __action11< 'input, 's, >( @@ -1298,7 +2654,7 @@ fn __action9< } #[allow(unused_variables)] -fn __action10< +fn __action12< 'input, 's, >( @@ -1310,7 +2666,7 @@ fn __action10< } #[allow(unused_variables)] -fn __action11< +fn __action13< 'input, 's, >( @@ -1322,7 +2678,7 @@ fn __action11< } #[allow(unused_variables)] -fn __action12< +fn __action14< 'input, 's, >( @@ -1334,7 +2690,7 @@ fn __action12< } #[allow(unused_variables)] -fn __action13< +fn __action15< 'input, 's, >( @@ -1346,7 +2702,7 @@ fn __action13< } #[allow(unused_variables)] -fn __action14< +fn __action16< 'input, 's, >( @@ -1358,7 +2714,7 @@ fn __action14< } #[allow(unused_variables)] -fn __action15< +fn __action17< 'input, 's, >( @@ -1370,19 +2726,19 @@ fn __action15< } #[allow(unused_variables)] -fn __action16< +fn __action18< 'input, 's, >( input: &'input str, - (_, __0, _): (usize, Tree, usize), -) -> Rc + (_, __0, _): (usize, alloc::vec::Vec, usize), +) -> Rc<[Tree]> { - Rc::new(__0) + __0.into() } #[allow(unused_variables)] -fn __action17< +fn __action19< 'input, 's, >( @@ -1394,7 +2750,7 @@ fn __action17< } #[allow(unused_variables)] -fn __action18< +fn __action20< 'input, 's, >( @@ -1406,7 +2762,7 @@ fn __action18< } #[allow(unused_variables)] -fn __action19< +fn __action21< 'input, 's, >( @@ -1419,7 +2775,7 @@ fn __action19< } #[allow(unused_variables)] -fn __action20< +fn __action22< 'input, 's, >( @@ -1432,7 +2788,7 @@ fn __action20< } #[allow(unused_variables)] -fn __action21< +fn __action23< 'input, 's, >( @@ -1444,7 +2800,32 @@ fn __action21< } #[allow(unused_variables)] -fn __action22< +fn __action24< + 'input, + 's, +>( + input: &'input str, + __lookbehind: &usize, + __lookahead: &usize, +) -> alloc::vec::Vec +{ + alloc::vec![] +} + +#[allow(unused_variables)] +fn __action25< + 'input, + 's, +>( + input: &'input str, + (_, v, _): (usize, alloc::vec::Vec, usize), +) -> alloc::vec::Vec +{ + v +} + +#[allow(unused_variables)] +fn __action26< 'input, 's, >( @@ -1456,7 +2837,7 @@ fn __action22< } #[allow(unused_variables)] -fn __action23< +fn __action27< 'input, 's, >( @@ -1469,7 +2850,7 @@ fn __action23< } #[allow(unused_variables)] -fn __action24< +fn __action28< 'input, 's, >( @@ -1480,20 +2861,20 @@ fn __action24< { let __start0 = __lookbehind.clone(); let __end0 = __lookahead.clone(); - let __temp0 = __action20( + let __temp0 = __action22( input, &__start0, &__end0, ); let __temp0 = (__start0, __temp0, __end0); - __action17( + __action19( input, __temp0, ) } #[allow(unused_variables)] -fn __action25< +fn __action29< 'input, 's, >( @@ -1503,12 +2884,58 @@ fn __action25< { let __start0 = __0.0.clone(); let __end0 = __0.2.clone(); - let __temp0 = __action21( + let __temp0 = __action23( input, __0, ); let __temp0 = (__start0, __temp0, __end0); - __action17( + __action19( + input, + __temp0, + ) +} + +#[allow(unused_variables)] +fn __action30< + 'input, + 's, +>( + input: &'input str, + __lookbehind: &usize, + __lookahead: &usize, +) -> Rc<[Tree]> +{ + let __start0 = __lookbehind.clone(); + let __end0 = __lookahead.clone(); + let __temp0 = __action24( + input, + &__start0, + &__end0, + ); + let __temp0 = (__start0, __temp0, __end0); + __action18( + input, + __temp0, + ) +} + +#[allow(unused_variables)] +fn __action31< + 'input, + 's, +>( + input: &'input str, + __0: (usize, alloc::vec::Vec, usize), +) -> Rc<[Tree]> +{ + let __start0 = __0.0.clone(); + let __end0 = __0.2.clone(); + let __temp0 = __action25( + input, + __0, + ); + let __temp0 = (__start0, __temp0, __end0); + __action18( input, __temp0, ) diff --git a/src/main.rs b/src/main.rs index 120441d..116724e 100644 --- a/src/main.rs +++ b/src/main.rs @@ -4,13 +4,14 @@ mod grammar; -use debug2::dbg; +// use debug2::dbg; use rustyline::validate::{ MatchingBracketValidator, ValidationContext, ValidationResult, Validator, }; use rustyline::Editor; use rustyline_derive::{Completer, Helper, Highlighter, Hinter}; use std::collections::HashMap; +use std::io; use std::rc::Rc; #[derive(Debug, debug2::Debug, PartialEq)] @@ -23,7 +24,7 @@ enum Tree { } #[derive(Debug, debug2::Debug, PartialEq, Clone)] -struct Lambda(Rc<[String]>, Rc); +struct Lambda(Rc<[String]>, Rc<[Tree]>); #[derive(Debug, debug2::Debug, PartialEq)] enum Literal { @@ -94,7 +95,7 @@ impl Value { match self { Self::Func(f) => Ok(Callable::Func(*f)), Self::Lambda(l) => Ok(Callable::Lambda(l)), - _ => Err(RTError("Expected a function".to_owned())), + _ => Err(RTError(format!("Expected a function, got {:?}", self))), } } @@ -141,6 +142,25 @@ impl<'a> Env<'a> { } fn main() { + let args = std::env::args().collect::>(); + match &args[..] { + [_] => repl(), + [_, file] => run_file(file).unwrap(), + _ => panic!("To many args `{:?}`", args), + } +} + +fn run_file(file: &str) -> io::Result<()> { + let src = std::fs::read_to_string(file)?; + let tree = grammar::TreesParser::new().parse(&src).unwrap(); + let mut env = default_env(); + for i in tree { + eval(&i, &mut env).unwrap(); + } + Ok(()) +} + +fn repl() { let mut rl = Editor::new(); rl.set_helper(Some(InputValidator { brackets: MatchingBracketValidator::new(), @@ -182,11 +202,17 @@ fn eval(t: &Tree, env: &mut Env) -> Result { Callable::Func(f) => f(&args)?, Callable::Lambda(l) => { if l.0.len() == args.len() { - let mut new_env = env.child(); + let mut env = env.child(); for (x, y) in l.0.iter().zip(args) { - new_env.define(x.clone(), y) + env.define(x.clone(), y) } - eval(&l.1, &mut new_env)? + + let [main @ .., tail] = &l.1[..] else { unreachable!("Body has 1+ element by parser") }; + for i in main { + eval(i, &mut env)?; + } + + eval(tail, &mut env)? } else { return err(format!("Need {} args, got {}", l.0.len(), args.len())); } @@ -214,7 +240,13 @@ fn default_env() -> Env<'static> { ("+", prims::add as Func), ("-", prims::sub as Func), ("/", prims::div as Func), + // TODO: Spec compiance ("=", prims::equals as Func), + ("eq?", prims::equals as Func), + ("eqv?", prims::equals as Func), + ("equal?", prims::equals as Func), + ("display", prims::display as Func), + ("newline", prims::newline as Func), ] { vars.insert(name.to_owned(), Value::Func(fun)); } @@ -226,8 +258,9 @@ fn default_env() -> Env<'static> { } mod prims { - use crate::{RTError, Value}; + use crate::{err, RTError, Value}; + // TODO: DRY +-/* pub(crate) fn add(args: &[Value]) -> Result { args.iter() .map(Value::as_num) @@ -247,8 +280,13 @@ mod prims { .get(0) .ok_or_else(|| RTError("`div` needs at least one argument".to_owned()))? .as_num()?; - let rest = mul(&args[1..])?.as_num().unwrap(); - Ok(Value::Num(init / rest)) + + Ok(Value::Num(if args.len() == 1 { + 1.0 / init + } else { + let rest = mul(&args[1..])?.as_num().unwrap(); + init / rest + })) } pub(crate) fn sub(args: &[Value]) -> Result { @@ -256,13 +294,32 @@ mod prims { .get(0) .ok_or_else(|| RTError("`sub` needs at least one argument".to_owned()))? .as_num()?; - let rest = add(&args[1..])?.as_num().unwrap(); - Ok(Value::Num(init - rest)) + + Ok(Value::Num(if args.len() == 1 { + -init + } else { + let rest = add(&args[1..])?.as_num().unwrap(); + init - rest + })) } pub(crate) fn equals(args: &[Value]) -> Result { Ok(Value::Bool(args.array_windows().all(|[l, r]| l == r))) } + + pub(crate) fn display(args: &[Value]) -> Result { + let [arg] = args else {return err("To many args to `display`".to_owned())}; + print!("{:?}", arg); + Ok(Value::NotAValue) + } + + pub(crate) fn newline(args: &[Value]) -> Result { + if !args.is_empty() { + return err("Newline takes no args".to_owned()); + } + println!(""); + Ok(Value::NotAValue) + } } // #[cfg(test)] diff --git a/test/pass/lambda-calc.scm b/test/pass/lambda-calc.scm new file mode 100644 index 0000000..6eb505f --- /dev/null +++ b/test/pass/lambda-calc.scm @@ -0,0 +1,28 @@ +(define (displayln x) (display x) (newline)) +(define (printbool x) (displayln (bool->int x))) + +(define (true x y) x) +(define (false x y) y) +(define (and x y) (x y x)) +(define (or x y) (x x y)) +(define (not x) (x false true)) + +(define (bool->int x) + (if + (equal? x true) 1 + (if (equal? x false) 0 (- 1)))) + +(printbool true) +(printbool false) +(printbool bool->int) +(printbool (not true)) +(printbool (not false)) +(printbool (and true true)) +(printbool (and true false)) +(printbool (and false true)) +(printbool (and false false)) +(printbool (or true true)) +(printbool (or true false)) +(printbool (or false true)) +(printbool (or false false)) +(printbool (and (or true false) (or false true))) \ No newline at end of file diff --git a/test/pass/math.scm b/test/pass/math.scm index f3250a9..e4f600a 100644 --- a/test/pass/math.scm +++ b/test/pass/math.scm @@ -1 +1,16 @@ -( + 1 2 ( / 2 3 4 5) ) \ No newline at end of file +(define (displayln x) (display x) (newline)) + +(displayln (+)) +(displayln (+ 1)) +(displayln (+ 1 2 3 4)) +(displayln (+)) + +(displayln (- 1)) +(displayln (- 1 2 3 4)) + +(displayln (* 1)) +(displayln (* 1 2)) +(displayln (*)) + +(displayln (/ 10)) +(displayln (/ 10 5 2))