pogmommy/eww
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

asdf

Browse source
This commit is contained in:
elkowar 2021-07-01 19:57:10 +02:00
parent 159ded782e
commit e21983f92d
No known key found for this signature in database
GPG key ID: E321AD71B1D1F27F
4 changed files with 121 additions and 794 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

703
src/calc.rs
View file

@ -1,703 +0,0 @@
// auto-generated: "lalrpop 0.19.5"
// sha3: 7f1eed9c7f5eae965f19f037e3f83cc3f8b8ac855ed1b7d5e579d3c668c23b2
use std::str::FromStr;
use crate::Expr;
#[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__Expr {
#![allow(non_snake_case, non_camel_case_types, unused_mut, unused_variables, unused_imports, unused_parens)]
use std::str::FromStr;
use crate::Expr;
#[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(Expr),
Variant2(alloc::vec::Vec<Expr>),
Variant3(i32),
}
const __ACTION: &[i8] = &[
// State 0
2, 0, 7, 8,
// State 1
2, 0, 7, 8,
// State 2
2, 11, 7, 8,
// State 3
0, 0, 0, 0,
// State 4
-5, -5, -5, -5,
// State 5
-6, -6, -6, -6,
// State 6
-7, -7, -7, -7,
// State 7
-8, -8, -8, -8,
// State 8
-2, -2, -2, -2,
// State 9
-3, -3, -3, -3,
// State 10
-4, -4, -4, -4,
];
fn __action(state: i8, integer: usize) -> i8 {
__ACTION[(state as usize) * 4 + integer]
}
const __EOF_ACTION: &[i8] = &[
// State 0
0,
// State 1
0,
// State 2
0,
// State 3
-9,
// State 4
-5,
// State 5
-6,
// State 6
-7,
// State 7
-8,
// State 8
0,
// State 9
0,
// State 10
-4,
];
fn __goto(state: i8, nt: usize) -> i8 {
match nt {
1 => 2,
2 => match state {
1 => 8,
2 => 9,
_ => 3,
},
3 => 4,
4 => 5,
_ => 0,
}
}
fn __expected_tokens(__state: i8) -> alloc::vec::Vec<alloc::string::String> {
const __TERMINAL: &[&str] = &[
r###""(""###,
r###"")""###,
r###"r#":[^\\s]+"#"###,
r###"r#"[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>
where
{
input: &'input str,
__phantom: core::marker::PhantomData<(&'input ())>,
}
impl<'input> __state_machine::ParserDefinition for __StateMachine<'input>
where
{
type Location = usize;
type Error = &'static str;
type Token = Token<'input>;
type TokenIndex = usize;
type Symbol = __Symbol<'input>;
type Success = Expr;
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, 4 - 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,
>(
__token: &Token<'input>,
_: core::marker::PhantomData<(&'input ())>,
) -> Option<usize>
{
match *__token {
Token(2, _) if true => Some(0),
Token(3, _) if true => Some(1),
Token(0, _) if true => Some(2),
Token(1, _) if true => Some(3),
_ => None,
}
}
fn __token_to_symbol<
'input,
>(
__token_index: usize,
__token: Token<'input>,
_: core::marker::PhantomData<(&'input ())>,
) -> __Symbol<'input>
{
match __token_index {
0 | 1 | 2 | 3 => match __token {
Token(2, __tok0) | Token(3, __tok0) | Token(0, __tok0) | Token(1, __tok0) if true => __Symbol::Variant0(__tok0),
_ => unreachable!(),
},
_ => unreachable!(),
}
}
pub struct ExprParser {
builder: __lalrpop_util::lexer::MatcherBuilder,
_priv: (),
}
impl ExprParser {
pub fn new() -> ExprParser {
let __builder = super::__intern_token::new_builder();
ExprParser {
builder: __builder,
_priv: (),
}
}
#[allow(dead_code)]
pub fn parse<
'input,
>(
&self,
input: &'input str,
) -> Result<Expr, __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,
>(
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 ())>,
) -> Option<Result<Expr,__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 => {
// __Expr = Expr => ActionFn(0);
let __sym0 = __pop_Variant1(__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, Expr, 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, alloc::vec::Vec<Expr>, usize)
{
match __symbols.pop() {
Some((__l, __Symbol::Variant2(__v), __r)) => (__l, __v, __r),
_ => __symbol_type_mismatch()
}
}
fn __pop_Variant3<
'input,
>(
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>
) -> (usize, i32, 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,
>(
input: &'input str,
__lookahead_start: Option<&usize>,
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
_: core::marker::PhantomData<(&'input ())>,
) -> (usize, usize)
{
// (<Expr>) = Expr => ActionFn(8);
let __sym0 = __pop_Variant1(__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,
>(
input: &'input str,
__lookahead_start: Option<&usize>,
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
_: core::marker::PhantomData<(&'input ())>,
) -> (usize, usize)
{
// (<Expr>)+ = Expr => 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::Variant2(__nt), __end));
(1, 1)
}
pub(crate) fn __reduce2<
'input,
>(
input: &'input str,
__lookahead_start: Option<&usize>,
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
_: core::marker::PhantomData<(&'input ())>,
) -> (usize, usize)
{
// (<Expr>)+ = (<Expr>)+, Expr => ActionFn(10);
assert!(__symbols.len() >= 2);
let __sym1 = __pop_Variant1(__symbols);
let __sym0 = __pop_Variant2(__symbols);
let __start = __sym0.0.clone();
let __end = __sym1.2.clone();
let __nt = super::__action10::<>(input, __sym0, __sym1);
__symbols.push((__start, __Symbol::Variant2(__nt), __end));
(2, 1)
}
pub(crate) fn __reduce3<
'input,
>(
input: &'input str,
__lookahead_start: Option<&usize>,
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
_: core::marker::PhantomData<(&'input ())>,
) -> (usize, usize)
{
// Expr = "(", (<Expr>)+, ")" => ActionFn(1);
assert!(__symbols.len() >= 3);
let __sym2 = __pop_Variant0(__symbols);
let __sym1 = __pop_Variant2(__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::Variant1(__nt), __end));
(3, 2)
}
pub(crate) fn __reduce4<
'input,
>(
input: &'input str,
__lookahead_start: Option<&usize>,
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
_: core::marker::PhantomData<(&'input ())>,
) -> (usize, usize)
{
// Expr = Keyword => ActionFn(2);
let __sym0 = __pop_Variant1(__symbols);
let __start = __sym0.0.clone();
let __end = __sym0.2.clone();
let __nt = super::__action2::<>(input, __sym0);
__symbols.push((__start, __Symbol::Variant1(__nt), __end));
(1, 2)
}
pub(crate) fn __reduce5<
'input,
>(
input: &'input str,
__lookahead_start: Option<&usize>,
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
_: core::marker::PhantomData<(&'input ())>,
) -> (usize, usize)
{
// Expr = Num => ActionFn(3);
let __sym0 = __pop_Variant3(__symbols);
let __start = __sym0.0.clone();
let __end = __sym0.2.clone();
let __nt = super::__action3::<>(input, __sym0);
__symbols.push((__start, __Symbol::Variant1(__nt), __end));
(1, 2)
}
pub(crate) fn __reduce6<
'input,
>(
input: &'input str,
__lookahead_start: Option<&usize>,
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
_: core::marker::PhantomData<(&'input ())>,
) -> (usize, usize)
{
// Keyword = r#":[^\\s]+"# => ActionFn(4);
let __sym0 = __pop_Variant0(__symbols);
let __start = __sym0.0.clone();
let __end = __sym0.2.clone();
let __nt = super::__action4::<>(input, __sym0);
__symbols.push((__start, __Symbol::Variant1(__nt), __end));
(1, 3)
}
pub(crate) fn __reduce7<
'input,
>(
input: &'input str,
__lookahead_start: Option<&usize>,
__symbols: &mut alloc::vec::Vec<(usize,__Symbol<'input>,usize)>,
_: core::marker::PhantomData<(&'input ())>,
) -> (usize, usize)
{
// Num = r#"[0-9]+"# => ActionFn(5);
let __sym0 = __pop_Variant0(__symbols);
let __start = __sym0.0.clone();
let __end = __sym0.2.clone();
let __nt = super::__action5::<>(input, __sym0);
__symbols.push((__start, __Symbol::Variant3(__nt), __end));
(1, 4)
}
}
pub use self::__parse__Expr::ExprParser;
#[cfg_attr(rustfmt, rustfmt_skip)]
mod __intern_token {
#![allow(unused_imports)]
use std::str::FromStr;
use crate::Expr;
#[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)] = &[
("^(:[\u{0}-\u{8}\u{e}-\u{1f}!-\u{84}\u{86}-\u{9f}¡-ᙿᚁ-\u{1fff}\u{200b}-‧\u{202a}-\u{202e}‰-⁞\u{2060}-\u{2fff}、-\u{10ffff}]+)", false),
("^([0-9]+)", false),
("^(\\()", false),
("^(\\))", 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,
>(
input: &'input str,
(_, __0, _): (usize, Expr, usize),
) -> Expr
{
__0
}
#[allow(unused_variables)]
fn __action1<
'input,
>(
input: &'input str,
(_, _, _): (usize, &'input str, usize),
(_, elems, _): (usize, alloc::vec::Vec<Expr>, usize),
(_, _, _): (usize, &'input str, usize),
) -> Expr
{
Expr::List(elems)
}
#[allow(unused_variables)]
fn __action2<
'input,
>(
input: &'input str,
(_, x, _): (usize, Expr, usize),
) -> Expr
{
x
}
#[allow(unused_variables)]
fn __action3<
'input,
>(
input: &'input str,
(_, x, _): (usize, i32, usize),
) -> Expr
{
Expr::Number(x)
}
#[allow(unused_variables)]
fn __action4<
'input,
>(
input: &'input str,
(_, __0, _): (usize, &'input str, usize),
) -> Expr
{
Expr::Keyword(__0.to_string())
}
#[allow(unused_variables)]
fn __action5<
'input,
>(
input: &'input str,
(_, __0, _): (usize, &'input str, usize),
) -> i32
{
i32::from_str(__0).unwrap()
}
#[allow(unused_variables)]
fn __action6<
'input,
>(
input: &'input str,
(_, __0, _): (usize, Expr, usize),
) -> alloc::vec::Vec<Expr>
{
alloc::vec![__0]
}
#[allow(unused_variables)]
fn __action7<
'input,
>(
input: &'input str,
(_, v, _): (usize, alloc::vec::Vec<Expr>, usize),
(_, e, _): (usize, Expr, usize),
) -> alloc::vec::Vec<Expr>
{
{ let mut v = v; v.push(e); v }
}
#[allow(unused_variables)]
fn __action8<
'input,
>(
input: &'input str,
(_, __0, _): (usize, Expr, usize),
) -> Expr
{
__0
}
#[allow(unused_variables)]
fn __action9<
'input,
>(
input: &'input str,
__0: (usize, Expr, usize),
) -> alloc::vec::Vec<Expr>
{
let __start0 = __0.0.clone();
let __end0 = __0.2.clone();
let __temp0 = __action8(
input,
__0,
);
let __temp0 = (__start0, __temp0, __end0);
__action6(
input,
__temp0,
)
}
#[allow(unused_variables)]
fn __action10<
'input,
>(
input: &'input str,
__0: (usize, alloc::vec::Vec<Expr>, usize),
__1: (usize, Expr, usize),
) -> alloc::vec::Vec<Expr>
{
let __start0 = __1.0.clone();
let __end0 = __1.2.clone();
let __temp0 = __action8(
input,
__1,
);
let __temp0 = (__start0, __temp0, __end0);
__action7(
input,
__0,
__temp0,
)
}
pub trait __ToTriple<'input, > {
fn to_triple(value: Self) -> Result<(usize,Token<'input>,usize), __lalrpop_util::ParseError<usize, Token<'input>, &'static str>>;
}
impl<'input, > __ToTriple<'input, > 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, > __ToTriple<'input, > 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 }),
}
}
}

158
src/config.rs
View file

@ -2,16 +2,28 @@ use std::{collections::HashMap, iter::FromIterator};
use super::*;
use anyhow::*;
use itertools::Itertools;
use std::collections::LinkedList;
type VarName = String;
type AttrValue = String;
type AttrName = String;
#[derive(Debug, PartialEq, Eq)]
pub enum AstError {
UnexpectedNode,
InvalidDefinition,
WrongExprType,
WrongExprType(Sp<Expr>),
MissingNode,
}
trait OptionAstErrorExt<T> {
fn or_missing(self) -> Result<T, AstError>;
}
impl<T> OptionAstErrorExt<T> for Option<T> {
fn or_missing(self) -> Result<T, AstError> {
self.ok_or(AstError::MissingNode)
}
}
impl From<WrongExprType> for AstError {
@ -27,6 +39,12 @@ pub trait FromExpr: Sized {
}
}
impl FromExpr for Expr {
fn from_expr(e: Expr) -> Result<Self, AstError> {
Ok(e)
}
}
pub enum DefType {
Widget,
}
@ -54,15 +72,13 @@ pub struct Definitional<T> {
impl<T: FromExpr> FromExpr for Definitional<T> {
fn from_expr(e: Expr) -> Result<Self, AstError> {
if let Expr::List(list) = e {
let mut iter = SExpIterator::new(list);
let mut iter = itertools::put_back(list.into_iter());
let def_type = DefType::from_sp(iter.next().unwrap().as_single().unwrap())?;
let name = iter.next().unwrap().as_single().unwrap().1.str()?;
let attrs = iter.next().unwrap().as_key_value().unwrap();
let def_type = DefType::from_sp(iter.next().or_missing()?)?;
let name = iter.next().or_missing()?.1.str()?;
let attrs = parse_key_values(&mut iter);
let children = iter
.map(|elem| T::from_sp(elem.as_single()?))
.collect::<Result<Vec<_>, AstError>>()?;
let children = iter.map(T::from_sp).collect::<Result<Vec<_>, AstError>>()?;
Ok(Definitional {
def_type,
name,
@ -74,72 +90,88 @@ impl<T: FromExpr> FromExpr for Definitional<T> {
}
}
}
pub struct WidgetDefinition {
#[derive(Debug, Eq, PartialEq)]
pub struct Element<T> {
name: String,
argnames: Vec<VarName>,
attrs: HashMap<AttrName, Sp<Expr>>,
children: Vec<T>,
}
struct SExpIterator {
elements: LinkedList<Sp<Expr>>,
}
impl FromExpr for Element<Sp<Expr>> {
fn from_expr(e: Expr) -> Result<Self, AstError> {
if let Expr::List(list) = e {
let mut iter = itertools::put_back(list.into_iter());
impl SExpIterator {
fn new(elements: Vec<Sp<Expr>>) -> Self {
SExpIterator {
elements: LinkedList::from_iter(elements.into_iter()),
let name = iter.next().or_missing()?.1.str()?;
let attrs = parse_key_values(&mut iter);
Ok(Element {
name,
attrs,
children: iter.collect_vec(),
})
} else {
Err(AstError::UnexpectedNode)
}
}
}
enum ExpressionElement {
Single(Sp<Expr>),
KeyValue(HashMap<String, Sp<Expr>>),
}
impl ExpressionElement {
fn as_single(self) -> Option<Sp<Expr>> {
match self {
ExpressionElement::Single(x) => Some(x),
ExpressionElement::KeyValue(_) => None,
}
}
fn as_key_value(self) -> Option<HashMap<String, Sp<Expr>>> {
match self {
ExpressionElement::Single(_) => None,
ExpressionElement::KeyValue(x) => Some(x),
}
}
}
impl Iterator for SExpIterator {
type Item = ExpressionElement;
fn next(&mut self) -> Option<Self::Item> {
let mut data = HashMap::new();
loop {
let first_is_kw = self.elements.front().map_or(false, |x| x.1.is_keyword());
if first_is_kw {
let (l, kw, r) = match self.elements.pop_front() {
Some(Sp(l, Expr::Keyword(kw), r)) => (l, kw, r),
_ => unreachable!(),
};
if let Some(value) = self.elements.pop_front() {
fn parse_key_values<I: Iterator<Item = Sp<Expr>>>(
iter: &mut itertools::PutBack<I>,
) -> HashMap<String, Sp<Expr>> {
let mut data = HashMap::new();
loop {
match iter.next() {
Some(Sp(l, Expr::Keyword(kw), r)) => match iter.next() {
Some(value) => {
data.insert(kw, value);
} else {
return if data.is_empty() {
Some(ExpressionElement::Single(Sp(l, Expr::Keyword(kw), r)))
} else {
Some(ExpressionElement::KeyValue(data))
};
}
} else {
return if data.is_empty() {
Some(ExpressionElement::Single(self.elements.pop_front()?))
} else {
Some(ExpressionElement::KeyValue(data))
};
None => {
iter.put_back(Sp(l, Expr::Keyword(kw), r));
return data;
}
},
Some(expr) => {
iter.put_back(expr);
return data;
}
None => return data,
}
}
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn test() {
let parser = parser::ExprParser::new();
assert_eq!(
Element::<Sp<Expr>>::from_expr(
parser
.parse("(box foo :bar 12 :baz \"hi\" foo (bar))")
.unwrap()
)
.unwrap(),
Element {
name: "box".to_string(),
children: vec![
Sp(1, Expr::Symbol("foo".to_string()), 2),
Sp(
2,
Expr::List(vec![Sp(2, Expr::Symbol("bar".to_string()), 3)]),
3
)
],
attrs: {
let mut data = HashMap::new();
data.insert("foo".to_string(), Sp(2, Expr::Number(12), 3));
data.insert("bar".to_string(), Sp(2, Expr::Str("hi".to_string()), 3));
data
},
}
);
}
}

54
src/main.rs
View file

@ -11,7 +11,7 @@ use lalrpop_util::lalrpop_mod;
//mod lexer;
lalrpop_mod!(pub calc);
lalrpop_mod!(pub parser);
#[derive(Debug, Eq, PartialEq, Clone, Copy)]
pub struct Sp<T>(pub usize, pub T, pub usize);
@ -22,10 +22,10 @@ impl<T: std::fmt::Display> std::fmt::Display for Sp<T> {
}
}
#[derive(Debug, Clone, Copy)]
pub struct WrongExprType;
#[derive(Debug, Clone)]
pub struct WrongExprType(Sp<Expr>);
#[derive(Debug)]
#[derive(Debug, PartialEq, Eq, Clone)]
pub enum Expr {
List(Vec<Sp<Expr>>),
Table(Vec<(Sp<Expr>, Sp<Expr>)>),
@ -41,7 +41,7 @@ impl Expr {
use Expr::*;
match self {
Str(x) => Ok(x),
_ => Err(WrongExprType),
x => Err(WrongExprType(x)),
}
}
fn is_keyword(&self) -> bool {
@ -77,7 +77,7 @@ fn main() {}
macro_rules! test_p {
($e:expr) => {
let e = $e;
let p = calc::ExprParser::new();
let p = parser::ExprParser::new();
match p.parse(e) {
Ok(res) => println!("{}\n=> {}\n", e, res),
Err(e) => eprintln!("{}", e),
@ -86,31 +86,29 @@ macro_rules! test_p {
}
#[test]
fn calc() {
test_p!("1");
test_p!("(12)");
test_p!("(1 2)");
test_p!("(1 :foo 1)");
test_p!("(:foo 1)");
test_p!("(:foo->: 1)");
test_p!("(foo 1)");
test_p!("(lol😄 1)");
fn test() {
//test_p!("1");
//test_p!("(12)");
//test_p!("(1 2)");
//test_p!("(1 :foo 1)");
//test_p!("(:foo 1)");
//test_p!("(:foo->: 1)");
//test_p!("(foo 1)");
//test_p!("(lol😄 1)");
test_p!(r#"(test "hi")"#);
test_p!(r#"(test "h\"i")"#);
test_p!(r#"(test " hi ")"#);
//test_p!(r#"(test "hi")"#);
//test_p!(r#"(test "h\"i")"#);
//test_p!(r#"(test " hi ")"#);
test_p!("(+ (1 2 (* 2 5)))");
//test_p!("(+ (1 2 (* 2 5)))");
test_p!(r#"{:key value 12 "hi" (test) (1 2 3)}"#);
//test_p!(r#"{:key value 12 "hi" (test) (1 2 3)}"#);
test_p!(r#"; test"#);
test_p!(
r#"(f arg ; test
arg2)"#
);
//test_p!(r#"; test"#);
//test_p!(
//r#"(f arg ; test
//arg2)"#
//);
println!("\n\n\n\n\n\n");
panic!()
//println!("\n\n\n\n\n\n");
}

0
src/calc.lalrpop → src/parser.lalrpop
View file