From d6e8be6ce5d2a907acd0be1cb7da9f13c8d713a0 Mon Sep 17 00:00:00 2001 From: unspeaker Date: Mon, 26 May 2025 22:49:55 +0300 Subject: [PATCH] dsl gets the gordian treatment --- dsl/src/dsl_ast.rs | 84 ++++-------- dsl/src/dsl_cst.rs | 288 +---------------------------------------- dsl/src/dsl_display.rs | 39 ++++++ dsl/src/dsl_domain.rs | 22 +++- dsl/src/dsl_iter.rs | 96 ++++++++++++++ dsl/src/dsl_token.rs | 264 +++++++++++++++++++++++++++++++++++++ dsl/src/lib.rs | 3 + input/src/input_dsl.rs | 43 +++--- output/src/ops_dsl.rs | 157 ++++++++++------------ 9 files changed, 540 insertions(+), 456 deletions(-) create mode 100644 dsl/src/dsl_display.rs create mode 100644 dsl/src/dsl_iter.rs create mode 100644 dsl/src/dsl_token.rs diff --git a/dsl/src/dsl_ast.rs b/dsl/src/dsl_ast.rs index 15c4374..010d3f6 100644 --- a/dsl/src/dsl_ast.rs +++ b/dsl/src/dsl_ast.rs @@ -1,70 +1,36 @@ use crate::*; use std::sync::Arc; -use std::fmt::{Debug, Display, Formatter}; +use std::borrow::Cow; -#[derive(Clone, Default, Debug)] -pub enum Ast { - #[default] Nil, - Err(DslError), - Num(usize), - Sym(Arc), - Key(Arc), - Str(Arc), - Exp(Arc>), -} +/// Owns its values, and has no metadata. +pub type AstToken = Token; -/// Emits tokens. -pub trait AstIter: Debug { - fn peek (&self) -> Option; - fn next (&mut self) -> Option; - fn rest (self) -> Option>; -} +#[derive(Debug, Copy, Clone, Default, PartialEq)] +pub struct AstMeta; -/// A [Cst] can be used as an [Ast]. -impl<'source: 'static> AstIter for Cst<'source> { - fn peek (&self) -> Option { - Cst::peek(self).map(|token|token.value.into()) - } - fn next (&mut self) -> Option { - Iterator::next(self).map(|token|token.value.into()) - } - fn rest (self) -> Option> { - self.peek().is_some().then(||Box::new(self) as Box) - } -} - -impl std::fmt::Display for Ast { - fn fmt (&self, out: &mut Formatter) -> Result<(), std::fmt::Error> { - use Ast::*; - write!(out, "{}", match self { - Nil => String::new(), - Err(e) => format!("[error: {e}]"), - Num(n) => format!("{n}"), - Sym(s) => format!("{s}"), - Key(s) => format!("{s}"), - Str(s) => format!("{s}"), - Exp(e) => format!("{e:?}"), - }) - } -} - -impl<'source: 'static> From> for Ast { - fn from (other: CstValue<'source>) -> Self { - use CstValue::*; - match other { - Nil => Self::Nil, - Err(e) => Self::Err(e), - Num(u) => Self::Num(u), - Sym(s) => Self::Sym(s.into()), - Key(s) => Self::Key(s.into()), - Str(s) => Self::Str(s.into()), - Exp(_, s) => Self::Exp(Arc::new(s.into())), +pub type AstValue = Value, AstExp>; +impl<'source> From> for AstValue { + fn from (value: CstValue<'source>) -> Self { + use Value::*; + match value { + Nil => Nil, + Err(e) => Err(e), + Num(u) => Num(u), + Sym(s) => Sym(s.into()), + Key(s) => Key(s.into()), + Str(s) => Str(s.into()), + Exp(x) => Exp(x.into()), } } } -impl<'source: 'static> Into> for Cst<'source> { - fn into (self) -> Box { - Box::new(self) +#[derive(Clone, Default, PartialEq)] +pub struct AstExp(pub Vec); +impl<'source> From> for AstExp { + fn from (exp: CstExp<'source>) -> AstExp { + AstExp(exp.words.map(|token|Token( + AstValue::from(token.value()), + AstMeta, + )).collect()) } } diff --git a/dsl/src/dsl_cst.rs b/dsl/src/dsl_cst.rs index a45e77a..61b9352 100644 --- a/dsl/src/dsl_cst.rs +++ b/dsl/src/dsl_cst.rs @@ -1,291 +1,17 @@ use crate::*; -/// Provides a native [Iterator] API over [CstConstIter], -/// emitting [CstToken] items. -/// -/// [Cst::next] returns just the [CstToken] and mutates `self`, -/// instead of returning an updated version of the struct as [CstConstIter::next] does. -#[derive(Copy, Clone, Debug, Default, PartialEq)] -pub struct Cst<'a>(pub CstConstIter<'a>); +/// Keeps the reference to the source slice. +pub type CstToken<'source> = Token, CstMeta<'source>>; -/// Owns a reference to the source text. -/// [CstConstIter::next] emits subsequent pairs of: -/// * a [CstToken] and -/// * the source text remaining -/// * [ ] TODO: maybe [CstConstIter::next] should wrap the remaining source in `Self` ? -#[derive(Copy, Clone, Debug, Default, PartialEq)] -pub struct CstConstIter<'a>(pub &'a str); - -/// A CST token, with reference to the source slice. -#[derive(Debug, Copy, Clone, Default, PartialEq)] pub struct CstToken<'source> { +#[derive(Debug, Copy, Clone, Default, PartialEq)] pub struct CstMeta<'source> { pub source: &'source str, pub start: usize, pub length: usize, - pub value: CstValue<'source>, } -/// The meaning of a CST token. Strip the source from this to get an [AstValue]. -#[derive(Debug, Copy, Clone, Default, PartialEq)] pub enum CstValue<'source> { - #[default] Nil, - Err(DslError), - Num(usize), - Sym(&'source str), - Key(&'source str), - Str(&'source str), - Exp(usize, Cst<'source>), -} +pub type CstValue<'source> = Value<&'source str, CstExp<'source>>; -impl<'a> Cst<'a> { - pub const fn new (source: &'a str) -> Self { - Self(CstConstIter::new(source)) - } - pub const fn peek (&self) -> Option> { - self.0.peek() - } -} - -impl<'a> Iterator for Cst<'a> { - type Item = CstToken<'a>; - fn next (&mut self) -> Option> { - self.0.next().map(|(item, rest)|{self.0 = rest; item}) - } -} - -impl<'a> From<&'a str> for Cst<'a> { - fn from (source: &'a str) -> Self{ - Self(CstConstIter(source)) - } -} - -impl<'a> From> for Cst<'a> { - fn from (source: CstConstIter<'a>) -> Self{ - Self(source) - } -} - -/// Implement the const iterator pattern. -#[macro_export] macro_rules! const_iter { - ($(<$l:lifetime>)?|$self:ident: $Struct:ty| => $Item:ty => $expr:expr) => { - impl$(<$l>)? Iterator for $Struct { - type Item = $Item; - fn next (&mut $self) -> Option<$Item> { $expr } - } - impl$(<$l>)? ConstIntoIter for $Struct { - type Kind = IsIteratorKind; - type Item = $Item; - type IntoIter = Self; - } - } -} - -const_iter!(<'a>|self: CstConstIter<'a>| => CstToken<'a> => self.next_mut().map(|(result, _)|result)); - -impl<'a> From<&'a str> for CstConstIter<'a> { - fn from (source: &'a str) -> Self{ - Self::new(source) - } -} - -impl<'a> CstConstIter<'a> { - pub const fn new (source: &'a str) -> Self { - Self(source) - } - pub const fn chomp (&self, index: usize) -> Self { - Self(split_at(self.0, index).1) - } - pub const fn next (mut self) -> Option<(CstToken<'a>, Self)> { - Self::next_mut(&mut self) - } - pub const fn peek (&self) -> Option> { - peek_src(self.0) - } - pub const fn next_mut (&mut self) -> Option<(CstToken<'a>, Self)> { - match self.peek() { - Some(token) => Some((token, self.chomp(token.end()))), - None => None - } - } -} - -/// Static iteration helper. -#[macro_export] macro_rules! iterate { - ($expr:expr => $arg: pat => $body:expr) => { - let mut iter = $expr; - while let Some(($arg, next)) = iter.next() { - $body; - iter = next; - } - } -} - -pub const fn peek_src <'a> (source: &'a str) -> Option> { - use CstValue::*; - let mut token: CstToken<'a> = CstToken::new(source, 0, 0, Nil); - iterate!(char_indices(source) => (start, c) => token = match token.value() { - Err(_) => return Some(token), - Nil => match c { - ' '|'\n'|'\r'|'\t' => - token.grow(), - '(' => - CstToken::new(source, start, 1, Exp(1, Cst::new(str_range(source, start, start + 1)))), - '"' => - CstToken::new(source, start, 1, Str(str_range(source, start, start + 1))), - ':'|'@' => - CstToken::new(source, start, 1, Sym(str_range(source, start, start + 1))), - '/'|'a'..='z' => - CstToken::new(source, start, 1, Key(str_range(source, start, start + 1))), - '0'..='9' => - CstToken::new(source, start, 1, match to_digit(c) { - Ok(c) => CstValue::Num(c), - Result::Err(e) => CstValue::Err(e) - }), - _ => token.error(Unexpected(c)) - }, - Str(_) => match c { - '"' => return Some(token), - _ => token.grow_str(), - }, - Num(n) => match c { - '0'..='9' => token.grow_num(n, c), - ' '|'\n'|'\r'|'\t'|')' => return Some(token), - _ => token.error(Unexpected(c)) - }, - Sym(_) => match c { - 'a'..='z'|'A'..='Z'|'0'..='9'|'-' => token.grow_sym(), - ' '|'\n'|'\r'|'\t'|')' => return Some(token), - _ => token.error(Unexpected(c)) - }, - Key(_) => match c { - 'a'..='z'|'0'..='9'|'-'|'/' => token.grow_key(), - ' '|'\n'|'\r'|'\t'|')' => return Some(token), - _ => token.error(Unexpected(c)) - }, - Exp(depth, _) => match depth { - 0 => return Some(token.grow_exp()), - _ => match c { - ')' => token.grow_out(), - '(' => token.grow_in(), - _ => token.grow_exp(), - } - }, - }); - match token.value() { - Nil => None, - _ => Some(token), - } -} - -pub const fn to_number (digits: &str) -> DslResult { - let mut value = 0; - iterate!(char_indices(digits) => (_, c) => match to_digit(c) { - Ok(digit) => value = 10 * value + digit, - Result::Err(e) => return Result::Err(e) - }); - Ok(value) -} - -pub const fn to_digit (c: char) -> DslResult { - Ok(match c { - '0' => 0, '1' => 1, '2' => 2, '3' => 3, '4' => 4, - '5' => 5, '6' => 6, '7' => 7, '8' => 8, '9' => 9, - _ => return Result::Err(Unexpected(c)) - }) -} - -impl<'source> CstToken<'source> { - pub const fn new ( - source: &'source str, start: usize, length: usize, value: CstValue<'source> - ) -> Self { - Self { source, start, length, value } - } - pub const fn end (&self) -> usize { - self.start.saturating_add(self.length) - } - pub const fn slice (&'source self) -> &'source str { - self.slice_source(self.source) - } - pub const fn slice_source <'range> (&'source self, source: &'range str) -> &'range str { - str_range(source, self.start, self.end()) - } - pub const fn slice_source_exp <'range> (&'source self, source: &'range str) -> &'range str { - str_range(source, self.start.saturating_add(1), self.end()) - } - pub const fn with_value (self, value: CstValue<'source>) -> Self { - Self { value, ..self } - } - pub const fn value (&self) -> CstValue { - self.value - } - pub const fn error (self, error: DslError) -> Self { - Self { value: CstValue::Err(error), ..self } - } - pub const fn grow (self) -> Self { - Self { length: self.length.saturating_add(1), ..self } - } - pub const fn grow_num (self, m: usize, c: char) -> Self { - use CstValue::*; - match to_digit(c) { - Ok(n) => Self { value: Num(10*m+n), ..self.grow() }, - Result::Err(e) => Self { value: Err(e), ..self.grow() }, - } - } - pub const fn grow_key (self) -> Self { - use CstValue::*; - let token = self.grow(); - token.with_value(Key(token.slice_source(self.source))) - } - pub const fn grow_sym (self) -> Self { - use CstValue::*; - let token = self.grow(); - token.with_value(Sym(token.slice_source(self.source))) - } - pub const fn grow_str (self) -> Self { - use CstValue::*; - let token = self.grow(); - token.with_value(Str(token.slice_source(self.source))) - } - pub const fn grow_exp (self) -> Self { - use CstValue::*; - let token = self.grow(); - if let Exp(depth, _) = token.value { - token.with_value(Exp(depth, Cst::new(token.slice_source_exp(self.source)))) - } else { - unreachable!() - } - } - pub const fn grow_in (self) -> Self { - let token = self.grow_exp(); - if let CstValue::Exp(depth, source) = token.value { - token.with_value(CstValue::Exp(depth.saturating_add(1), source)) - } else { - unreachable!() - } - } - pub const fn grow_out (self) -> Self { - let token = self.grow_exp(); - if let CstValue::Exp(depth, source) = token.value { - if depth > 0 { - token.with_value(CstValue::Exp(depth - 1, source)) - } else { - return self.error(Unexpected(')')) - } - } else { - unreachable!() - } - } -} - -impl<'source> std::fmt::Display for CstValue<'source> { - fn fmt (&self, out: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> { - use CstValue::*; - write!(out, "{}", match self { - Nil => String::new(), - Err(e) => format!("[error: {e}]"), - Num(n) => format!("{n}"), - Sym(s) => format!("{s}"), - Key(s) => format!("{s}"), - Str(s) => format!("{s}"), - Exp(_, e) => format!("{e:?}"), - }) - } +#[derive(Debug, Copy, Clone, Default, PartialEq)] pub struct CstExp<'source> { + pub depth: usize, + pub words: SourceIter<'source> } diff --git a/dsl/src/dsl_display.rs b/dsl/src/dsl_display.rs new file mode 100644 index 0000000..a986664 --- /dev/null +++ b/dsl/src/dsl_display.rs @@ -0,0 +1,39 @@ +use crate::*; + +use std::fmt::{Debug, Display, Formatter, Error as FormatError}; + +impl Display for AstValue { + fn fmt (&self, out: &mut Formatter) -> Result<(), FormatError> { + use Value::*; + write!(out, "{}", match self { + Nil => String::new(), + Err(e) => format!("[error: {e}]"), + Num(n) => format!("{n}"), + Sym(s) => format!("{s}"), + Key(s) => format!("{s}"), + Str(s) => format!("{s}"), + Exp(e) => format!("{e:?}"), + }) + } +} + +impl Debug for AstExp { + fn fmt (&self, out: &mut Formatter) -> Result<(), FormatError> { + todo!() + } +} + +impl<'source> Display for CstValue<'source> { + fn fmt (&self, out: &mut Formatter) -> Result<(), FormatError> { + use Value::*; + write!(out, "{}", match self { + Nil => String::new(), + Err(e) => format!("[error: {e}]"), + Num(n) => format!("{n}"), + Sym(s) => format!("{s}"), + Key(s) => format!("{s}"), + Str(s) => format!("{s}"), + Exp(e) => format!("{e:?}"), + }) + } +} diff --git a/dsl/src/dsl_domain.rs b/dsl/src/dsl_domain.rs index 88af556..8289ff8 100644 --- a/dsl/src/dsl_domain.rs +++ b/dsl/src/dsl_domain.rs @@ -13,13 +13,25 @@ pub trait Eval { } } +//impl, I, O> Eval for &S { + //fn try_eval (&self, input: I) -> Perhaps { + //(*self).try_eval(input) + //} +//} + +//impl, I: Ast, O: Dsl> Eval for S { + //fn try_eval (&self, input: I) -> Perhaps { + //Dsl::try_provide(self, input) + //} +//} + /// May construct [Self] from token stream. pub trait Dsl: Sized { - fn try_provide (state: State, source: Ast) -> Perhaps; + fn try_provide (state: &State, source: impl DslValue) -> Perhaps; fn provide >, F: Fn()->E> ( - state: State, source: Ast, error: F + state: &State, source: impl DslValue, error: F ) -> Usually { - let next = source.clone(); + let next = format!("{source:?}"); if let Some(value) = Self::try_provide(state, source)? { Ok(value) } else { @@ -28,10 +40,6 @@ pub trait Dsl: Sized { } } -impl, S> Eval for S { - fn try_eval (&self, input: Ast) -> Perhaps { todo!() } -} - //pub trait Give<'state, 'source, Type> { ///// Implement this to be able to [Give] [Type] from the [Cst]. ///// Advance the stream if returning `Ok>`. diff --git a/dsl/src/dsl_iter.rs b/dsl/src/dsl_iter.rs new file mode 100644 index 0000000..9b5cc24 --- /dev/null +++ b/dsl/src/dsl_iter.rs @@ -0,0 +1,96 @@ +use crate::*; + +pub trait DslIter { + type Token: DslToken; + fn peek (&self) -> Option<::Value>; + fn next (&mut self) -> Option<::Value>; + fn rest (&self) -> Option<&[::Value]>; +} + +/// Provides a native [Iterator] API over [SourceConstIter], +/// emitting [CstToken] items. +/// +/// [Cst::next] returns just the [CstToken] and mutates `self`, +/// instead of returning an updated version of the struct as [SourceConstIter::next] does. +#[derive(Copy, Clone, Debug, Default, PartialEq)] +pub struct SourceIter<'a>(pub SourceConstIter<'a>); + +impl<'a> SourceIter<'a> { + pub const fn new (source: &'a str) -> Self { + Self(SourceConstIter::new(source)) + } + pub const fn peek (&self) -> Option> { + self.0.peek() + } +} + +impl<'a> Iterator for SourceIter<'a> { + type Item = CstToken<'a>; + fn next (&mut self) -> Option> { + self.0.next().map(|(item, rest)|{self.0 = rest; item}) + } +} + +impl<'a> From<&'a str> for SourceIter<'a> { + fn from (source: &'a str) -> Self{ + Self(SourceConstIter(source)) + } +} + +/// Implement the const iterator pattern. +#[macro_export] macro_rules! const_iter { + ($(<$l:lifetime>)?|$self:ident: $Struct:ty| => $Item:ty => $expr:expr) => { + impl$(<$l>)? Iterator for $Struct { + type Item = $Item; + fn next (&mut $self) -> Option<$Item> { $expr } + } + impl$(<$l>)? ConstIntoIter for $Struct { + type Kind = IsIteratorKind; + type Item = $Item; + type IntoIter = Self; + } + } +} + +/// Owns a reference to the source text. +/// [SourceConstIter::next] emits subsequent pairs of: +/// * a [CstToken] and +/// * the source text remaining +/// * [ ] TODO: maybe [SourceConstIter::next] should wrap the remaining source in `Self` ? +#[derive(Copy, Clone, Debug, Default, PartialEq)] +pub struct SourceConstIter<'a>(pub &'a str); + +impl<'a> From> for SourceIter<'a> { + fn from (source: SourceConstIter<'a>) -> Self{ + Self(source) + } +} + +impl<'a> From<&'a str> for SourceConstIter<'a> { + fn from (source: &'a str) -> Self{ + Self::new(source) + } +} + +impl<'a> SourceConstIter<'a> { + pub const fn new (source: &'a str) -> Self { + Self(source) + } + pub const fn chomp (&self, index: usize) -> Self { + Self(split_at(self.0, index).1) + } + pub const fn next (mut self) -> Option<(CstToken<'a>, Self)> { + Self::next_mut(&mut self) + } + pub const fn peek (&self) -> Option> { + peek_src(self.0) + } + pub const fn next_mut (&mut self) -> Option<(CstToken<'a>, Self)> { + match self.peek() { + Some(token) => Some((token, self.chomp(token.end()))), + None => None + } + } +} + +const_iter!(<'a>|self: SourceConstIter<'a>| => CstToken<'a> => self.next_mut().map(|(result, _)|result)); diff --git a/dsl/src/dsl_token.rs b/dsl/src/dsl_token.rs new file mode 100644 index 0000000..6a132a9 --- /dev/null +++ b/dsl/src/dsl_token.rs @@ -0,0 +1,264 @@ +use crate::*; + +#[derive(PartialEq, Clone, Default, Debug)] +pub enum Value< + S: PartialEq + Clone + Default + Debug, + X: PartialEq + Clone + Default + Debug, +> { + #[default] Nil, Err(DslError), Num(usize), Sym(S), Key(S), Str(S), Exp(X), +} + +pub trait DslValue: PartialEq + Clone + Default + Debug { + type Err: PartialEq + Clone + Debug; + type Num: PartialEq + Copy + Clone + Default + Debug; + type Str: PartialEq + Clone + Default + Debug; + type Exp: PartialEq + Clone + Default + Debug; + fn nil (&self) -> bool; + fn err (&self) -> Option<&Self::Err>; + fn num (&self) -> Option; + fn sym (&self) -> Option<&Self::Str>; + fn key (&self) -> Option<&Self::Str>; + fn str (&self) -> Option<&Self::Str>; + fn exp (&self) -> Option<&Self::Exp>; + fn exp_head (&self) -> Option<&Self> { None } // TODO + fn exp_tail (&self) -> Option<&[Self]> { None } // TODO +} + +impl< + Str: PartialEq + Clone + Default + Debug, + Exp: PartialEq + Clone + Default + Debug, +> DslValue for Value { + type Err = DslError; + type Num = usize; + type Str = Str; + type Exp = Exp; + fn nil (&self) -> bool { + matches!(self, Self::Nil) + } + fn err (&self) -> Option<&DslError> { + if let Self::Err(e) = self { Some(e) } else { None } + } + fn num (&self) -> Option { + if let Self::Num(n) = self { Some(*n) } else { None } + } + fn sym (&self) -> Option<&Str> { + if let Self::Sym(s) = self { Some(s) } else { None } + } + fn key (&self) -> Option<&Str> { + if let Self::Key(k) = self { Some(k) } else { None } + } + fn str (&self) -> Option<&Str> { + if let Self::Str(s) = self { Some(s) } else { None } + } + fn exp (&self) -> Option<&Exp> { + if let Self::Exp(x) = self { Some(x) } else { None } + } +} + + +#[derive(PartialEq, Clone, Default, Debug)] +pub struct Token< + V: PartialEq + Clone + Default + Debug, + M: PartialEq + Clone + Default + Debug, +>(pub V, pub M); + +pub trait DslToken: PartialEq + Clone + Default + Debug { + type Value: DslValue; + type Meta: Clone + Default + Debug; + fn value (&self) -> &Self::Value; + fn meta (&self) -> &Self::Meta; +} + +impl DslToken for Token { + type Value = V; + type Meta = M; + fn value (&self) -> &Self::Value { + &self.0 + } + fn meta (&self) -> &Self::Meta { + &self.1 + } +} + +impl<'source> CstToken<'source> { + pub const fn new ( + source: &'source str, start: usize, length: usize, value: CstValue<'source> + ) -> Self { + Self(value, CstMeta { source, start, length }) + } + pub const fn end (&self) -> usize { + self.1.start.saturating_add(self.1.length) + } + pub const fn slice (&'source self) -> &'source str { + self.slice_source(self.1.source) + } + pub const fn slice_source <'range> (&'source self, source: &'range str) -> &'range str { + str_range(source, self.1.start, self.end()) + } + pub const fn slice_source_exp <'range> (&'source self, source: &'range str) -> &'range str { + str_range(source, self.1.start.saturating_add(1), self.end()) + } + pub const fn with_value (self, value: CstValue<'source>) -> Self { + Self(value, self.1) + } + pub const fn value (&self) -> CstValue<'source> { + self.0 + } + pub const fn error (self, error: DslError) -> Self { + Self(Value::Err(error), self.1) + } + pub const fn grow (self) -> Self { + Self(self.0, CstMeta { length: self.1.length.saturating_add(1), ..self.1 }) + } + pub const fn grow_num (self, m: usize, c: char) -> Self { + use Value::*; + match to_digit(c) { + Result::Ok(n) => Self(Num(10*m+n), self.grow().1), + Result::Err(e) => Self(Err(e), self.grow().1), + } + } + pub const fn grow_key (self) -> Self { + use Value::*; + let token = self.grow(); + token.with_value(Key(token.slice_source(self.1.source))) + } + pub const fn grow_sym (self) -> Self { + use Value::*; + let token = self.grow(); + token.with_value(Sym(token.slice_source(self.1.source))) + } + pub const fn grow_str (self) -> Self { + use Value::*; + let token = self.grow(); + token.with_value(Str(token.slice_source(self.1.source))) + } + pub const fn grow_exp (self) -> Self { + use Value::*; + let token = self.grow(); + if let Exp(depth, _) = token.value() { + token.with_value(Exp(depth, Cst::new(token.slice_source_exp(self.source)))) + } else { + unreachable!() + } + } + pub const fn grow_in (self) -> Self { + let token = self.grow_exp(); + if let Value::Exp(depth, source) = token.value { + token.with_value(Value::Exp(depth.saturating_add(1), source)) + } else { + unreachable!() + } + } + pub const fn grow_out (self) -> Self { + let token = self.grow_exp(); + if let Value::Exp(depth, source) = token.value { + if depth > 0 { + token.with_value(Value::Exp(depth - 1, source)) + } else { + return self.error(Unexpected(')')) + } + } else { + unreachable!() + } + } +} + +pub const fn to_number (digits: &str) -> DslResult { + let mut value = 0; + iterate!(char_indices(digits) => (_, c) => match to_digit(c) { + Ok(digit) => value = 10 * value + digit, + Result::Err(e) => return Result::Err(e) + }); + Ok(value) +} + +pub const fn to_digit (c: char) -> DslResult { + Ok(match c { + '0' => 0, '1' => 1, '2' => 2, '3' => 3, '4' => 4, + '5' => 5, '6' => 6, '7' => 7, '8' => 8, '9' => 9, + _ => return Result::Err(Unexpected(c)) + }) +} + +/// Static iteration helper. +#[macro_export] macro_rules! iterate { + ($expr:expr => $arg: pat => $body:expr) => { + let mut iter = $expr; + while let Some(($arg, next)) = iter.next() { + $body; + iter = next; + } + } +} + +pub const fn peek_src <'a> (source: &'a str) -> Option> { + use Value::*; + let mut token: CstToken<'a> = CstToken::new(source, 0, 0, Nil); + iterate!(char_indices(source) => (start, c) => token = match token.value() { + Err(_) => return Some(token), + Nil => match c { + ' '|'\n'|'\r'|'\t' => + token.grow(), + '(' => + CstToken::new(source, start, 1, Exp(1, Cst::new(str_range(source, start, start + 1)))), + '"' => + CstToken::new(source, start, 1, Str(str_range(source, start, start + 1))), + ':'|'@' => + CstToken::new(source, start, 1, Sym(str_range(source, start, start + 1))), + '/'|'a'..='z' => + CstToken::new(source, start, 1, Key(str_range(source, start, start + 1))), + '0'..='9' => + CstToken::new(source, start, 1, match to_digit(c) { + Ok(c) => Value::Num(c), + Result::Err(e) => Value::Err(e) + }), + _ => token.error(Unexpected(c)) + }, + Str(_) => match c { + '"' => return Some(token), + _ => token.grow_str(), + }, + Num(n) => match c { + '0'..='9' => token.grow_num(n, c), + ' '|'\n'|'\r'|'\t'|')' => return Some(token), + _ => token.error(Unexpected(c)) + }, + Sym(_) => match c { + 'a'..='z'|'A'..='Z'|'0'..='9'|'-' => token.grow_sym(), + ' '|'\n'|'\r'|'\t'|')' => return Some(token), + _ => token.error(Unexpected(c)) + }, + Key(_) => match c { + 'a'..='z'|'0'..='9'|'-'|'/' => token.grow_key(), + ' '|'\n'|'\r'|'\t'|')' => return Some(token), + _ => token.error(Unexpected(c)) + }, + Exp(depth, _) => match depth { + 0 => return Some(token.grow_exp()), + _ => match c { + ')' => token.grow_out(), + '(' => token.grow_in(), + _ => token.grow_exp(), + } + }, + }); + match token.value() { + Nil => None, + _ => Some(token), + } +} + +//impl, X1, X2: From> From> for Value { + //fn from (other: Value) -> Self { + //use Value::*; + //match other { + //Nil => Nil, + //Err(e) => Err(e), + //Num(u) => Num(u), + //Sym(s) => Sym(s.into()), + //Key(s) => Key(s.into()), + //Str(s) => Str(s.into()), + //Exp(x) => Exp(x.into()), + //} + //} +//} diff --git a/dsl/src/lib.rs b/dsl/src/lib.rs index 0cd66c8..8fc06e4 100644 --- a/dsl/src/lib.rs +++ b/dsl/src/lib.rs @@ -46,8 +46,11 @@ pub(crate) use self::DslError::*; mod dsl_ast; pub use self::dsl_ast::*; mod dsl_cst; pub use self::dsl_cst::*; +mod dsl_display; pub use self::dsl_display::*; mod dsl_domain; pub use self::dsl_domain::*; mod dsl_error; pub use self::dsl_error::*; +mod dsl_iter; pub use self::dsl_iter::*; +mod dsl_token; pub use self::dsl_token::*; #[cfg(test)] mod test_token_iter { use crate::*; diff --git a/input/src/input_dsl.rs b/input/src/input_dsl.rs index c6d26e1..7bd3605 100644 --- a/input/src/input_dsl.rs +++ b/input/src/input_dsl.rs @@ -1,40 +1,47 @@ use crate::*; use std::marker::PhantomData; use std::fmt::Debug; -/// List of input layers with optional conditional filters. -#[derive(Default, Debug)] pub struct InputLayers(Vec>); -#[derive(Default, Debug)] pub struct InputLayer{ - __: PhantomData, - condition: Option, - binding: Ast, -} -impl InputLayers { - pub fn new (layer: Ast) -> Self { + +#[derive(Default, Debug)] pub struct InputLayers(Vec); + +#[derive(Default, Debug)] pub struct InputLayer(Option>, Cst<'static>); + +impl InputLayers { + pub fn new (layer: Cst<'static>) -> Self { Self(vec![]).layer(layer) } - pub fn layer (mut self, layer: Ast) -> Self { + pub fn layer (mut self, layer: Cst<'static>) -> Self { self.add_layer(layer); self } - pub fn layer_if (mut self, condition: Ast, layer: Ast) -> Self { + pub fn layer_if (mut self, condition: Cst<'static>, layer: Cst<'static>) -> Self { self.add_layer_if(Some(condition), layer); self } - pub fn add_layer (&mut self, layer: Ast) -> &mut Self { + pub fn add_layer (&mut self, layer: Cst<'static>) -> &mut Self { self.add_layer_if(None, layer.into()); self } - pub fn add_layer_if (&mut self, condition: Option, binding: Ast) -> &mut Self { + pub fn add_layer_if (&mut self, condition: Option>, binding: Cst<'static>) -> &mut Self { self.0.push(InputLayer { condition, binding, __: Default::default() }); self } + pub fn handle , I, O: Command> ( + &self, state: &mut S, input: I + ) -> Perhaps { + InputHandle(state, self.0.as_slice()).try_eval(input) + } } -impl + Eval, C: Command, I: Debug + Eval> Eval<(S, I), C> for InputLayers { - fn try_eval (&self, (state, input): (S, I)) -> Perhaps { - for InputLayer { condition, binding, .. } in self.0.iter() { + +pub struct InputHandle<'a, S>(&'a mut S, &'a [InputLayer]); + +impl<'a, S: Eval<&'a dyn Ast, bool>, I, O: Command> Eval for InputHandle<'a, S> { + fn try_eval (&self, input: I) -> Perhaps { + let Self(state, layers) = self; + for InputLayer(condition, binding) in layers.iter() { let mut matches = true; if let Some(condition) = condition { - matches = state.eval(condition.clone(), ||"input: no condition")?; + matches = state.eval(*condition, ||"input: no condition")?; } if matches { - if let Ast::Exp(e) = binding { + if let AstValue::Exp(e) = binding.peek() { if let Some(ast) = e.peek() { if input.eval(ast.clone(), ||"InputLayers: input.eval(binding) failed")? && let Some(command) = state.try_eval(ast)? { diff --git a/output/src/ops_dsl.rs b/output/src/ops_dsl.rs index e86a634..2dd72fb 100644 --- a/output/src/ops_dsl.rs +++ b/output/src/ops_dsl.rs @@ -1,12 +1,13 @@ use crate::*; impl Dsl for When where S: Eval + Eval { - fn try_provide (state: S, source: Ast) -> Perhaps { - if let Ast::Exp(source) = source { - if let Some(Ast::Key(id)) = source.next() && *id == *"when" { + fn try_provide (state: S, source: impl Ast) -> Perhaps { + if let Ast::Exp(exp) = source { + let mut iter = source.clone(); + if let Some(Ast::Key(id)) = iter.next() && *id == *"when" { return Ok(Some(Self( - state.eval(source.next().unwrap(), ||"when: expected condition")?, - state.eval(source.next().unwrap(), ||"when: expected content")?, + state.eval(iter.next().unwrap(), ||"when: expected condition")?, + state.eval(iter.next().unwrap(), ||"when: expected content")?, ))) } } @@ -15,13 +16,14 @@ impl Dsl for When where S: Eval + Eval { } impl Dsl for Either where S: Eval + Eval + Eval { - fn try_provide (state: S, mut source: Ast) -> Perhaps { - if let Ast::Exp(mut source) = source { - if let Some(Ast::Key(id)) = source.next() && *id == *"either" { + fn try_provide (state: S, source: impl Ast) -> Perhaps { + if let Ast::Exp(source) = source { + let mut iter = source.clone(); + if let Some(Ast::Key(id)) = iter.next() && *id == *"either" { return Ok(Some(Self( - state.eval(source.next().unwrap(), ||"either: expected condition")?, - state.eval(source.next().unwrap(), ||"either: expected content 1")?, - state.eval(source.next().unwrap(), ||"either: expected content 2")?, + state.eval(iter.next().unwrap(), ||"either: expected condition")?, + state.eval(iter.next().unwrap(), ||"either: expected content 1")?, + state.eval(iter.next().unwrap(), ||"either: expected content 2")?, ))) } } @@ -29,41 +31,35 @@ impl Dsl for Either where S: Eval + Eval + } } -impl Dsl for Bsp -where S: Eval, A> + Eval, B> { - fn try_provide (state: S, source: Ast) -> Perhaps { +impl Dsl for Bsp where S: Eval, A> + Eval, B> { + fn try_provide (state: S, source: impl Ast) -> Perhaps { Ok(Some(if let Ast::Exp(source) = source { - match source.next() { - Some(Value::Key("bsp/n")) => { - let a: A = state.eval(source.next(), ||"bsp/n: expected content 1")?; - let b: B = state.eval(source.next(), ||"bsp/n: expected content 2")?; - Self::n(a, b) - }, - Some(Value::Key("bsp/s")) => { - let a: A = state.eval(source.next(), ||"bsp/s: expected content 1")?; - let b: B = state.eval(source.next(), ||"bsp/s: expected content 2")?; - Self::s(a, b) - }, - Some(Value::Key("bsp/e")) => { - let a: A = state.eval(source.next(), ||"bsp/e: expected content 1")?; - let b: B = state.eval(source.next(), ||"bsp/e: expected content 2")?; - Self::e(a, b) - }, - Some(Value::Key("bsp/w")) => { - let a: A = state.eval(source.next(), ||"bsp/w: expected content 1")?; - let b: B = state.eval(source.next(), ||"bsp/w: expected content 2")?; - Self::w(a, b) - }, - Some(Value::Key("bsp/a")) => { - let a: A = state.eval(source.next(), ||"bsp/a: expected content 1")?; - let b: B = state.eval(source.next(), ||"bsp/a: expected content 2")?; - Self::a(a, b) - }, - Some(Value::Key("bsp/b")) => { - let a: A = state.eval(source.next(), ||"bsp/b: expected content 1")?; - let b: B = state.eval(source.next(), ||"bsp/b: expected content 2")?; - Self::b(a, b) - }, + let mut iter = source.clone(); + match iter.next() { + Some(Value::Key("bsp/n")) => Self::n( + state.eval(iter.next(), ||"bsp/n: expected content 1")?, + state.eval(iter.next(), ||"bsp/n: expected content 2")?, + ), + Some(Value::Key("bsp/s")) => Self::s( + state.eval(iter.next(), ||"bsp/s: expected content 1")?, + state.eval(iter.next(), ||"bsp/s: expected content 2")?, + ), + Some(Value::Key("bsp/e")) => Self::e( + state.eval(iter.next(), ||"bsp/e: expected content 1")?, + state.eval(iter.next(), ||"bsp/e: expected content 2")?, + ), + Some(Value::Key("bsp/w")) => Self::w( + state.eval(iter.next(), ||"bsp/w: expected content 1")?, + state.eval(iter.next(), ||"bsp/w: expected content 2")?, + ), + Some(Value::Key("bsp/a")) => Self::a( + state.eval(iter.next(), ||"bsp/a: expected content 1")?, + state.eval(iter.next(), ||"bsp/a: expected content 2")?, + ), + Some(Value::Key("bsp/b")) => Self::b( + state.eval(iter.next(), ||"bsp/b: expected content 1")?, + state.eval(iter.next(), ||"bsp/b: expected content 2")?, + ), _ => return Ok(None), } } else { @@ -73,53 +69,32 @@ where S: Eval, A> + Eval, B> { } impl Dsl for Align where S: Eval, A> { - fn try_provide (state: S, source: Ast) -> Perhaps { + fn try_provide (state: S, source: impl Ast) -> Perhaps { Ok(Some(if let Ast::Exp(source) = source { - match source.next() { - Some(Value::Key("align/c")) => { - let content: A = state.eval(source.next(), ||"align/c: expected content")?; - Self::c(content) - }, - Some(Value::Key("align/x")) => { - let content: A = state.eval(source.next(), ||"align/x: expected content")?; - Self::x(content) - }, - Some(Value::Key("align/y")) => { - let content: A = state.eval(source.next(), ||"align/y: expected content")?; - Self::y(content) - }, - Some(Value::Key("align/n")) => { - let content: A = state.eval(source.next(), ||"align/n: expected content")?; - Self::n(content) - }, - Some(Value::Key("align/s")) => { - let content: A = state.eval(source.next(), ||"align/s: expected content")?; - Self::s(content) - }, - Some(Value::Key("align/e")) => { - let content: A = state.eval(source.next(), ||"align/e: expected content")?; - Self::e(content) - }, - Some(Value::Key("align/w")) => { - let content: A = state.eval(source.next(), ||"align/w: expected content")?; - Self::w(content) - }, - Some(Value::Key("align/nw")) => { - let content: A = state.eval(source.next(), ||"align/nw: expected content")?; - Self::nw(content) - }, - Some(Value::Key("align/ne")) => { - let content: A = state.eval(source.next(), ||"align/ne: expected content")?; - Self::ne(content) - }, - Some(Value::Key("align/sw")) => { - let content: A = state.eval(source.next(), ||"align/sw: expected content")?; - Self::sw(content) - }, - Some(Value::Key("align/se")) => { - let content: A = state.eval(source.next(), ||"align/se: expected content")?; - Self::se(content) - }, + let mut iter = source.clone(); + match iter.next() { + Some(Value::Key("align/c")) => + Self::c(state.eval(iter.next(), ||"align/c: expected content")?), + Some(Value::Key("align/x")) => + Self::x(state.eval(iter.next(), ||"align/x: expected content")?), + Some(Value::Key("align/y")) => + Self::y(state.eval(iter.next(), ||"align/y: expected content")?), + Some(Value::Key("align/n")) => + Self::n(state.eval(iter.next(), ||"align/n: expected content")?), + Some(Value::Key("align/s")) => + Self::s(state.eval(iter.next(), ||"align/s: expected content")?), + Some(Value::Key("align/e")) => + Self::e(state.eval(iter.next(), ||"align/e: expected content")?), + Some(Value::Key("align/w")) => + Self::w(state.eval(iter.next(), ||"align/w: expected content")?), + Some(Value::Key("align/nw")) => + Self::nw(state.eval(iter.next(), ||"align/nw: expected content")?), + Some(Value::Key("align/ne")) => + Self::ne(state.eval(iter.next(), ||"align/ne: expected content")?), + Some(Value::Key("align/sw")) => + Self::sw(state.eval(iter.next(), ||"align/sw: expected content")?), + Some(Value::Key("align/se")) => + Self::se(state.eval(iter.next(), ||"align/se: expected content")?), _ => return Ok(None), } } else {