From 4fc0db577737ad1ce2601aa99d45248dba9a2d5f Mon Sep 17 00:00:00 2001 From: unspeaker Date: Sat, 16 Aug 2025 12:38:24 +0300 Subject: [PATCH 1/3] dsl eval and ns again --- dsl/src/dsl.rs | 80 ++++++++++++++++++- dsl/src/dsl_ns.rs | 74 ------------------ dsl/src/dsl_type.rs | 183 ++++++++++++++++++++++++++++++++++++++++++-- 3 files changed, 256 insertions(+), 81 deletions(-) delete mode 100644 dsl/src/dsl_ns.rs diff --git a/dsl/src/dsl.rs b/dsl/src/dsl.rs index a4012f9..6348d49 100644 --- a/dsl/src/dsl.rs +++ b/dsl/src/dsl.rs @@ -16,13 +16,91 @@ pub(crate) use ::{ }; pub(crate) use self::DslError::*; mod dsl_conv; pub use self::dsl_conv::*; -mod dsl_ns; pub use self::dsl_ns::*; mod dsl_type; #[cfg(test)] mod dsl_test; /// DSL-specific result type. pub type DslResult = Result; /// DSL-specific optional result type. pub type DslPerhaps = Result, DslError>; +/// Namespace mapping. +pub struct DslNsMap<'t, T: 't>(pub &'t [(&'t str, T)]); +impl<'t, T: 't> DslNsMap<'t, T> { + /// Populate a namespace. + pub const fn new (data: &'t [(&'t str, T)]) -> Self { + Self(data) // TODO build search index + } +} +pub trait DslNs<'t, T: 't>: 't { + /// Known symbols. + const SYMS: DslNsMap<'t, fn (&'t Self)->Perhaps> = DslNsMap::new(&[]); + /// Known expressions. + const EXPS: DslNsMap<'t, fn (&'t Self, &str)->Perhaps> = DslNsMap::new(&[]); + /// Resolve a symbol if known. + fn from_sym (&'t self, dsl: D) -> Perhaps { + if let Some(dsl) = dsl.sym()? { + for (sym, get) in Self::SYMS.0 { if dsl == *sym { return get(self) } } + } + return Ok(None) + } + /// Resolve an expression if known. + fn from_exp (&'t self, dsl: D) -> Perhaps { + if let Some(exp) = dsl.exp()? { + for (key, value) in Self::EXPS.0.iter() { + if exp.head() == Ok(Some(key)) { return value(self, exp.tail()?.unwrap_or("")) } + } + } + return Ok(None) + } + /// Resolve an expression or symbol. + fn from (&'t self, dsl: D) -> Perhaps { + if let Ok(Some(src)) = dsl.src() { + if let Ok(Some(src)) = src.sym() { + self.from_sym(src) + } else { + self.from_exp(src) + } + } else { + Ok(None) + } + } +} +/// Define a namespace: +#[macro_export] macro_rules! dsl_ns ( + (|$state:ident : $State: ty| $($Type:ty $(=> { $($pat:tt => $body:expr),* $(,)? })?;)+) => { + $(dsl_ns!(|$state: $State| -> $Type { $( $($pat => $body),* )? });)+ + }; + (|$state:ident : $State: ty| -> $Type:ty { $($pat:tt => $body:expr),* $(,)? }) => { + impl<'t> DslNs<'t, $Type> for $State { + const SYMS: DslNsMap<'t, fn (&'t $State)->Perhaps<$Type>> = + DslNsMap::new(&[$(dsl_ns!{@sym ($state: $State) -> $Type { $pat => $body }}),*]); + const EXPS: DslNsMap<'t, fn (&'t $State, &str)->Perhaps<$Type>> = + DslNsMap::new(&[$(dsl_ns!{@exp ($state: $State) -> $Type { $pat => $body }}),*]); + } + }; + (@sym ($state:ident: $State:ty) -> $Type:ty { $sym:literal => $body:expr }) => { + ($sym, |$state|Ok(Some($body))) + }; + (@exp ($state:ident: $State:ty) -> $Type:ty { + ($head:literal $(,$arg:ident:$ty:ty)* $(,)*) => $body:expr + }) => { ($head, |$state, tail: &str|{ + $( + let head = tail.head()?.unwrap_or_default(); + let $arg: $ty = if let Some(arg) = $state.from(&head)? { + arg + } else { + return Err(format!("missing argument: {}", stringify!($arg)).into()) + }; + let tail = tail.tail()?.unwrap_or_default(); + )* + Ok(Some($body)) + }) }; + (@sym ($state:ident: $State:ty) -> $Type:ty { $pat:tt => $body:expr }) => { + ("", |_|Ok(None)) + }; + (@exp ($state:ident: $State:ty) -> $Type:ty { $pat:tt => $body:expr }) => { + ("", |_, _|Ok(None)) + }; +); // Some things that can be DSL source: impl Dsl for String { fn src (&self) -> DslPerhaps<&str> { Ok(Some(self.as_ref())) } } impl Dsl for Arc { fn src (&self) -> DslPerhaps<&str> { Ok(Some(self.as_ref())) } } diff --git a/dsl/src/dsl_ns.rs b/dsl/src/dsl_ns.rs deleted file mode 100644 index bb59abf..0000000 --- a/dsl/src/dsl_ns.rs +++ /dev/null @@ -1,74 +0,0 @@ -use crate::*; - -/// Namespace where keys are symbols. -pub trait DslSymNs<'t, T: 't>: 't { - /// Known symbold. - const SYMS: DslNs<'t, fn (&'t Self)->Perhaps> = DslNs(&[]); - /// Resolve a symbol if known. - fn from_sym (&'t self, dsl: D) -> Perhaps { - if let Some(dsl) = dsl.sym()? { - for (sym, get) in Self::SYMS.0 { if dsl == *sym { return get(self) } } - } - return Ok(None) - } -} - -/// Define a symbol namespace. -#[macro_export] macro_rules! dsl_sym_ns ( - (|$state:ident:$State:ty| -> $Type:ty {$($lit:literal => $exp:expr),* $(,)?})=>{ - impl<'t> DslSymNs<'t, $Type> for $State { - const SYMS: DslNs<'t, fn (&'t $State)->Perhaps<$Type>> = DslNs(&[ - $(($lit, |$state: &$State|Ok(Some($exp)))),* - ]); - } - }); - -/// Namespace where the keys are heads of expressions. -pub trait DslExpNs<'t, T: 't>: 't { - /// Known expressions. - const EXPS: DslNs<'t, fn (&'t Self, &str)->Perhaps> = DslNs(&[]); - /// Resolve an expression if known. - fn from_exp (&'t self, dsl: D) -> Perhaps { - if let Some(exp) = dsl.exp()? { - //panic!("exp\n{:?}\n{:?}\n{:?}\n{:?}", - //exp.src(), exp.head(), exp.head().src(), Self::EXPS.0); - for (key, value) in Self::EXPS.0.iter() { - println!("{key} {:?}", exp.head()); - if exp.head() == Ok(Some(key)) { return value(self, exp.tail()?.unwrap_or("")) } - } - } - return Ok(None) - } -} - -/// Define an expression namespace. -#[macro_export] macro_rules! dsl_exp_ns ( - (|$state:ident:$State:ty|->$Type:ty { $( ( - $key:literal $(/ $sub:ident : $Sub:ty)? $(, $arg:ident:$ty:ty)* $(, ..$tail:ident)? - ) => $body:expr),* $(,)? }) => { - impl<'t> DslExpNs<'t, $Type> for $State { - const EXPS: DslNs<'t, fn (&'t $State, &str)->Perhaps<$Type>> = DslNs(&[ $( - ($key, |$state: &$State, mut tail: &str|{ - $(let $arg: $ty = if let Some(val) = dsl_next(&mut tail)? { - val - } else { - return Err(format!("missing arg: {}", stringify!($arg)).into()) - };)* - $(let $tail = tail;)? - Ok(Some($body)) - }) - ),* ]); - } - }); - -pub fn dsl_next (dsl: &mut impl Dsl) -> DslPerhaps { - todo!() -} - -/// Namespace. -/// -/// Currently linearly searched. -/// Maybe it's better to use a trie. -/// I don't think there's a `const` trie in Rust? -/// Oughtta be. -pub struct DslNs<'t, T: 't>(pub &'t [(&'t str, T)]); diff --git a/dsl/src/dsl_type.rs b/dsl/src/dsl_type.rs index 02312c0..985c37b 100644 --- a/dsl/src/dsl_type.rs +++ b/dsl/src/dsl_type.rs @@ -9,12 +9,6 @@ use crate::*; })=>{ pub trait $T: Dsl { $($trait)* } impl $T for D {} - dsl_peek_seek!($peek, $peek_only, $seek, $seek_start, $seek_length); - pub const fn $seek_start ($source1: &str) -> DslPerhaps $body1 - pub const fn $seek_length ($source2: &str) -> DslPerhaps $body2 -}); - -#[macro_export] macro_rules! dsl_peek_seek(($peek:ident, $peek_only:ident, $seek:ident, $seek_start:ident, $seek_length:ident)=>{ /// Find a slice corrensponding to a syntax token. pub const fn $peek (source: &str) -> DslPerhaps<&str> { match $seek(source) { @@ -48,4 +42,181 @@ use crate::*; }, } } + pub const fn $seek_start ($source1: &str) -> DslPerhaps $body1 + pub const fn $seek_length ($source2: &str) -> DslPerhaps $body2 }); + +pub const fn is_exp_start (c: char) -> bool { c == '(' } +pub const fn is_exp_end (c: char) -> bool { c == ')' } +dsl_type!(DslExp { + fn exp (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(exp_peek_inner_only))} + fn head (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(peek))} + fn tail (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(peek_tail))} + /// my other car is a cdr :< + fn each (&self, mut cb: impl FnMut(&str)->Usually<()>) -> Usually<()> { + Ok(if let Some(head) = self.head()? { + cb(head)?; + if let Some(tail) = self.tail()? { + tail.each(cb)?; + } + }) + } +} { + pub const fn exp_peek [generated]; + pub const fn exp_peek_only [generated]; + pub const fn exp_seek [generated]; + pub const fn exp_seek_start (src) { + for_each!((i, c) in char_indices(src) => + if is_exp_start(c) { return Ok(Some(i)) } else + if !is_space(c) { return Err(Unexpected(c, Some(i), Some("expected expression start"))) }); + Ok(None) + } + pub const fn exp_seek_length (src) { + let mut depth = 0; + for_each!((i, c) in char_indices(src) => + if is_exp_start(c) { depth += 1; } else + if is_exp_end(c) { + if depth == 0 { + return Err(Unexpected(c, Some(i), Some("expected expression end"))) + } else if depth == 1 { + return Ok(Some(i + 1)) + } else { + depth -= 1; + } + }); + Err(Incomplete) + } +}); + +pub const fn exp_peek_inner (src: &str) -> DslPerhaps<&str> { + match exp_peek(src) { + Ok(Some(peeked)) => { + let len = peeked.len(); + let start = if len > 0 { 1 } else { 0 }; + Ok(Some(str_range(src, start, start + len.saturating_sub(2)))) + }, + e => e + } +} + +pub const fn exp_peek_inner_only (src: &str) -> DslPerhaps<&str> { + match exp_seek(src) { + Err(e) => Err(e), + Ok(None) => Ok(None), + Ok(Some((start, length))) => { + if let Err(e) = no_trailing_non_space(src, start + length, Some("exp_peek_inner_only")) { return Err(e) } + let peeked = str_range(src, start, start + length); + let len = peeked.len(); + let start = if len > 0 { 1 } else { 0 }; + Ok(Some(str_range(peeked, start, start + len.saturating_sub(2)))) + }, + } +} + +pub const fn is_sym_start (c: char) -> bool { matches!(c, ':'|'@') } +pub const fn is_sym_char (c: char) -> bool { is_sym_start(c) || matches!(c, 'a'..='z'|'A'..='Z'|'0'..='9'|'-'|'/') } +pub const fn is_sym_end (c: char) -> bool { is_space(c) || matches!(c, ')') } +dsl_type!(DslSym { + fn sym (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(sym_peek_only))} +} { + pub const fn sym_peek [generated]; + pub const fn sym_peek_only [generated]; + pub const fn sym_seek [generated]; + pub const fn sym_seek_start (src) { + for_each!((i, c) in char_indices(src) => if + is_sym_start(c) { return Ok(Some(i)) } else + if !is_space(c) { return Err(Unexpected(c, Some(i), Some("sym_seek_start"))) }); + Ok(None) + } + pub const fn sym_seek_length (src) { + for_each!((i, c) in char_indices(src) => + if is_sym_end(c) { return Ok(Some(i)) } else + if !is_sym_char(c) { return Err(Unexpected(c, Some(i), Some("sym_seek_length"))) }); + Ok(Some(src.len())) + } +}); + +pub const fn is_text_start (c: char) -> bool { matches!(c, '"') } +pub const fn is_text_end (c: char) -> bool { matches!(c, '"') } +dsl_type!(DslText { + fn text (&self) -> DslPerhaps<&str> { ok_flat(self.src()?.map(text_peek_only)) } +} { + pub const fn text_peek [generated]; + pub const fn text_peek_only [generated]; + pub const fn text_seek [generated]; + pub const fn text_seek_start (src) { + for_each!((i, c) in char_indices(src) => + if is_text_start(c) { return Ok(Some(i)) } else + if !is_space(c) { return Err(Unexpected(c, Some(i), None)) }); + Ok(None) + } + pub const fn text_seek_length (src) { + for_each!((i, c) in char_indices(src) => + if is_text_end(c) { return Ok(Some(i)) }); + Ok(None) + } +}); + +pub const fn is_key_start (c: char) -> bool { matches!(c, '/'|('a'..='z')) } +pub const fn is_key_char (c: char) -> bool { is_key_start(c) || matches!(c, '0'..='9'|'-') } +pub const fn is_key_end (c: char) -> bool { !is_key_char(c) } +dsl_type!(DslKey { + fn key (&self) -> DslPerhaps<&str> { ok_flat(self.src()?.map(key_peek_only)) } +} { + pub const fn key_peek [generated]; + pub const fn key_peek_only [generated]; + pub const fn key_seek [generated]; + pub const fn key_seek_start (src) { + for_each!((i, c) in char_indices(src) => + if is_key_start(c) { return Ok(Some(i)) } else + if !is_space(c) { return Err(Unexpected(c, Some(i), None)) }); + Ok(None) + } + pub const fn key_seek_length (src) { + for_each!((i, c) in char_indices(src) => + if is_key_end(c) { return Ok(Some(i)) } else + if !is_key_char(c) { return Err(Unexpected(c, Some(i), None)) }); + Ok(Some(src.len())) + } +}); + +dsl_type!(DslNum { + fn num (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(num_peek_only))} +} { + pub const fn num_peek [generated]; + pub const fn num_peek_only [generated]; + pub const fn num_seek [generated]; + pub const fn num_seek_start (src) { + for_each!((i, c) in char_indices(src) => + if is_digit(c) { return Ok(Some(i)); } else + if !is_space(c) { return Err(Unexpected(c, Some(i), None)) }); + Ok(None) + } + pub const fn num_seek_length (src) { + for_each!((i, c) in char_indices(src) => + if is_num_end(c) { return Ok(Some(i)) } else + if !is_digit(c) { return Err(Unexpected(c, Some(i), None)) }); + Ok(None) + } +}); +pub const fn is_digit (c: char) -> bool { matches!(c, '0'..='9') } +pub const fn is_num_end (c: char) -> bool { matches!(c, ' '|'\n'|'\r'|'\t'|')') } +pub const fn to_number (digits: &str) -> Result { + let mut iter = char_indices(digits); + let mut value = 0; + while let Some(((_, c), next)) = iter.next() { + match to_digit(c) { + Ok(digit) => value = 10 * value + digit, + Err(e) => return Err(e), + } + iter = next; + } + Ok(value) +} +pub const fn to_digit (c: char) -> Result { + Ok(match c { + '0' => 0, '1' => 1, '2' => 2, '3' => 3, '4' => 4, + '5' => 5, '6' => 6, '7' => 7, '8' => 8, '9' => 9, + _ => return Err(Unexpected(c, None, Some("parse digit"))) + }) +} From cf253c28f9fbb476988d9fefc18c804447921b88 Mon Sep 17 00:00:00 2001 From: unspeaker Date: Sat, 16 Aug 2025 16:28:24 +0300 Subject: [PATCH 2/3] dsl: modularize --- Cargo.toml | 1 + dsl/src/dsl.rs | 334 ++--------------------------------------- dsl/src/dsl_ns.rs | 118 +++++++++++++++ dsl/src/dsl_src.rs | 21 +++ dsl/src/dsl_type.rs | 53 ++++++- input/src/input_dsl.rs | 94 +++--------- 6 files changed, 224 insertions(+), 397 deletions(-) create mode 100644 dsl/src/dsl_ns.rs create mode 100644 dsl/src/dsl_src.rs diff --git a/Cargo.toml b/Cargo.toml index a204087..e491b53 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -22,6 +22,7 @@ version = "0.13.0" edition = "2024" [workspace.dependencies] +anyhow = { version = "1.0" } atomic_float = { version = "1" } better-panic = { version = "0.3.0" } const_panic = { version = "0.2.12", features = [ "derive" ] } diff --git a/dsl/src/dsl.rs b/dsl/src/dsl.rs index 6348d49..71e9a9f 100644 --- a/dsl/src/dsl.rs +++ b/dsl/src/dsl.rs @@ -16,331 +16,27 @@ pub(crate) use ::{ }; pub(crate) use self::DslError::*; mod dsl_conv; pub use self::dsl_conv::*; -mod dsl_type; +mod dsl_ns; pub use self::dsl_ns::*; +mod dsl_src; pub use self::dsl_src::*; +mod dsl_type; pub use self::dsl_type::*; #[cfg(test)] mod dsl_test; /// DSL-specific result type. pub type DslResult = Result; /// DSL-specific optional result type. pub type DslPerhaps = Result, DslError>; -/// Namespace mapping. -pub struct DslNsMap<'t, T: 't>(pub &'t [(&'t str, T)]); -impl<'t, T: 't> DslNsMap<'t, T> { - /// Populate a namespace. - pub const fn new (data: &'t [(&'t str, T)]) -> Self { - Self(data) // TODO build search index - } -} -pub trait DslNs<'t, T: 't>: 't { - /// Known symbols. - const SYMS: DslNsMap<'t, fn (&'t Self)->Perhaps> = DslNsMap::new(&[]); - /// Known expressions. - const EXPS: DslNsMap<'t, fn (&'t Self, &str)->Perhaps> = DslNsMap::new(&[]); - /// Resolve a symbol if known. - fn from_sym (&'t self, dsl: D) -> Perhaps { - if let Some(dsl) = dsl.sym()? { - for (sym, get) in Self::SYMS.0 { if dsl == *sym { return get(self) } } - } - return Ok(None) - } - /// Resolve an expression if known. - fn from_exp (&'t self, dsl: D) -> Perhaps { - if let Some(exp) = dsl.exp()? { - for (key, value) in Self::EXPS.0.iter() { - if exp.head() == Ok(Some(key)) { return value(self, exp.tail()?.unwrap_or("")) } - } - } - return Ok(None) - } - /// Resolve an expression or symbol. - fn from (&'t self, dsl: D) -> Perhaps { - if let Ok(Some(src)) = dsl.src() { - if let Ok(Some(src)) = src.sym() { - self.from_sym(src) - } else { - self.from_exp(src) - } - } else { - Ok(None) - } - } -} -/// Define a namespace: -#[macro_export] macro_rules! dsl_ns ( - (|$state:ident : $State: ty| $($Type:ty $(=> { $($pat:tt => $body:expr),* $(,)? })?;)+) => { - $(dsl_ns!(|$state: $State| -> $Type { $( $($pat => $body),* )? });)+ - }; - (|$state:ident : $State: ty| -> $Type:ty { $($pat:tt => $body:expr),* $(,)? }) => { - impl<'t> DslNs<'t, $Type> for $State { - const SYMS: DslNsMap<'t, fn (&'t $State)->Perhaps<$Type>> = - DslNsMap::new(&[$(dsl_ns!{@sym ($state: $State) -> $Type { $pat => $body }}),*]); - const EXPS: DslNsMap<'t, fn (&'t $State, &str)->Perhaps<$Type>> = - DslNsMap::new(&[$(dsl_ns!{@exp ($state: $State) -> $Type { $pat => $body }}),*]); - } - }; - (@sym ($state:ident: $State:ty) -> $Type:ty { $sym:literal => $body:expr }) => { - ($sym, |$state|Ok(Some($body))) - }; - (@exp ($state:ident: $State:ty) -> $Type:ty { - ($head:literal $(,$arg:ident:$ty:ty)* $(,)*) => $body:expr - }) => { ($head, |$state, tail: &str|{ - $( - let head = tail.head()?.unwrap_or_default(); - let $arg: $ty = if let Some(arg) = $state.from(&head)? { - arg - } else { - return Err(format!("missing argument: {}", stringify!($arg)).into()) - }; - let tail = tail.tail()?.unwrap_or_default(); - )* - Ok(Some($body)) - }) }; - (@sym ($state:ident: $State:ty) -> $Type:ty { $pat:tt => $body:expr }) => { - ("", |_|Ok(None)) - }; - (@exp ($state:ident: $State:ty) -> $Type:ty { $pat:tt => $body:expr }) => { - ("", |_, _|Ok(None)) - }; -); -// Some things that can be DSL source: -impl Dsl for String { fn src (&self) -> DslPerhaps<&str> { Ok(Some(self.as_ref())) } } -impl Dsl for Arc { fn src (&self) -> DslPerhaps<&str> { Ok(Some(self.as_ref())) } } -impl<'s> Dsl for &'s str { fn src (&self) -> DslPerhaps<&str> { Ok(Some(self.as_ref())) } } - -// Designates a string as parsable DSL. -flex_trait!(Dsl: Debug + Send + Sync + Sized { fn src (&self) -> DslPerhaps<&str> { unreachable!("Dsl::src default impl") } }); -impl Dsl for Option { - fn src (&self) -> DslPerhaps<&str> {Ok(if let Some(dsl) = self { dsl.src()? } else { None })} -} -impl Dsl for Result { - fn src (&self) -> DslPerhaps<&str> {match self {Ok(dsl) => Ok(dsl.src()?), Err(e) => Err(*e)}} -} - /// DSL-specific error codes. #[derive(Error, Debug, Copy, Clone, PartialEq, PanicFmt)] pub enum DslError { - #[error("parse failed: not implemented")] Unimplemented, - #[error("parse failed: empty")] Empty, - #[error("parse failed: incomplete")] Incomplete, - #[error("parse failed: unexpected character '{0}'")] Unexpected(char, Option, Option<&'static str>), - #[error("parse failed: error #{0}")] Code(u8), - #[error("end reached")] End -} - -fn ok_flat (x: Option>) -> DslPerhaps { Ok(x.transpose()?.flatten()) } -pub const fn is_space (c: char) -> bool { - matches!(c, ' '|'\n'|'\r'|'\t') -} -pub const fn no_trailing_non_space (src: &str, offset: usize, context: Option<&'static str>) -> DslResult<()> { - Ok(for_each!((i, c) in char_indices(str_range(src, offset, src.len())) => if !is_space(c) { - return Err(Unexpected(c, Some(offset + i), if let Some(context) = context { - Some(context) - } else { - Some("trailing non-space") - })) - })) -} - -pub const fn peek (src: &str) -> DslPerhaps<&str> { - Ok(Some(if let Ok(Some(exp)) = exp_peek(src) { exp } else - if let Ok(Some(sym)) = sym_peek(src) { sym } else - if let Ok(Some(key)) = key_peek(src) { key } else - if let Ok(Some(num)) = num_peek(src) { num } else - if let Ok(Some(text)) = text_peek(src) { text } else - if let Err(e) = no_trailing_non_space(src, 0, Some("peek")) { return Err(e) } - else { return Ok(None) })) -} -pub const fn seek (src: &str) -> DslPerhaps<(usize, usize)> { - Ok(Some(if let Ok(Some(exp)) = exp_seek(src) { exp } else - if let Ok(Some(sym)) = sym_seek(src) { sym } else - if let Ok(Some(key)) = key_seek(src) { key } else - if let Ok(Some(num)) = num_seek(src) { num } else - if let Ok(Some(text)) = text_seek(src) { text } else - if let Err(e) = no_trailing_non_space(src, 0, Some("seek")) { return Err(e) } - else { return Ok(None) })) -} -pub const fn peek_tail (src: &str) -> DslPerhaps<&str> { - match seek(src) { - Err(e) => Err(e), - Ok(None) => Ok(None), - Ok(Some((start, length))) => { - let tail = str_range(src, start + length, src.len()); - for_each!((_i, c) in char_indices(tail) => if !is_space(c) { return Ok(Some(tail)) }); - Ok(None) - }, - } -} - -pub const fn is_exp_start (c: char) -> bool { c == '(' } -pub const fn is_exp_end (c: char) -> bool { c == ')' } -dsl_type!(DslExp { - fn exp (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(exp_peek_inner_only))} - fn head (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(peek))} - fn tail (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(peek_tail))} - /// my other car is a cdr :< - fn each (&self, mut cb: impl FnMut(&str)->Usually<()>) -> Usually<()> { - Ok(if let Some(head) = self.head()? { - cb(head)?; - if let Some(tail) = self.tail()? { - tail.each(cb)?; - } - }) - } -} { - pub const fn exp_peek [generated]; - pub const fn exp_peek_only [generated]; - pub const fn exp_seek [generated]; - pub const fn exp_seek_start (src) { - for_each!((i, c) in char_indices(src) => - if is_exp_start(c) { return Ok(Some(i)) } else - if !is_space(c) { return Err(Unexpected(c, Some(i), Some("expected expression start"))) }); - Ok(None) - } - pub const fn exp_seek_length (src) { - let mut depth = 0; - for_each!((i, c) in char_indices(src) => - if is_exp_start(c) { depth += 1; } else - if is_exp_end(c) { - if depth == 0 { - return Err(Unexpected(c, Some(i), Some("expected expression end"))) - } else if depth == 1 { - return Ok(Some(i + 1)) - } else { - depth -= 1; - } - }); - Err(Incomplete) - } -}); - -pub const fn exp_peek_inner (src: &str) -> DslPerhaps<&str> { - match exp_peek(src) { - Ok(Some(peeked)) => { - let len = peeked.len(); - let start = if len > 0 { 1 } else { 0 }; - Ok(Some(str_range(src, start, start + len.saturating_sub(2)))) - }, - e => e - } -} - -pub const fn exp_peek_inner_only (src: &str) -> DslPerhaps<&str> { - match exp_seek(src) { - Err(e) => Err(e), - Ok(None) => Ok(None), - Ok(Some((start, length))) => { - if let Err(e) = no_trailing_non_space(src, start + length, Some("exp_peek_inner_only")) { return Err(e) } - let peeked = str_range(src, start, start + length); - let len = peeked.len(); - let start = if len > 0 { 1 } else { 0 }; - Ok(Some(str_range(peeked, start, start + len.saturating_sub(2)))) - }, - } -} - -pub const fn is_sym_start (c: char) -> bool { matches!(c, ':'|'@') } -pub const fn is_sym_char (c: char) -> bool { is_sym_start(c) || matches!(c, 'a'..='z'|'A'..='Z'|'0'..='9'|'-'|'/') } -pub const fn is_sym_end (c: char) -> bool { is_space(c) || matches!(c, ')') } -dsl_type!(DslSym { - fn sym (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(sym_peek_only))} -} { - pub const fn sym_peek [generated]; - pub const fn sym_peek_only [generated]; - pub const fn sym_seek [generated]; - pub const fn sym_seek_start (src) { - for_each!((i, c) in char_indices(src) => if - is_sym_start(c) { return Ok(Some(i)) } else - if !is_space(c) { return Err(Unexpected(c, Some(i), Some("sym_seek_start"))) }); - Ok(None) - } - pub const fn sym_seek_length (src) { - for_each!((i, c) in char_indices(src) => - if is_sym_end(c) { return Ok(Some(i)) } else - if !is_sym_char(c) { return Err(Unexpected(c, Some(i), Some("sym_seek_length"))) }); - Ok(Some(src.len())) - } -}); - -pub const fn is_text_start (c: char) -> bool { matches!(c, '"') } -pub const fn is_text_end (c: char) -> bool { matches!(c, '"') } -dsl_type!(DslText { - fn text (&self) -> DslPerhaps<&str> { ok_flat(self.src()?.map(text_peek_only)) } -} { - pub const fn text_peek [generated]; - pub const fn text_peek_only [generated]; - pub const fn text_seek [generated]; - pub const fn text_seek_start (src) { - for_each!((i, c) in char_indices(src) => - if is_text_start(c) { return Ok(Some(i)) } else - if !is_space(c) { return Err(Unexpected(c, Some(i), None)) }); - Ok(None) - } - pub const fn text_seek_length (src) { - for_each!((i, c) in char_indices(src) => - if is_text_end(c) { return Ok(Some(i)) }); - Ok(None) - } -}); - -pub const fn is_key_start (c: char) -> bool { matches!(c, '/'|('a'..='z')) } -pub const fn is_key_char (c: char) -> bool { is_key_start(c) || matches!(c, '0'..='9'|'-') } -pub const fn is_key_end (c: char) -> bool { !is_key_char(c) } -dsl_type!(DslKey { - fn key (&self) -> DslPerhaps<&str> { ok_flat(self.src()?.map(key_peek_only)) } -} { - pub const fn key_peek [generated]; - pub const fn key_peek_only [generated]; - pub const fn key_seek [generated]; - pub const fn key_seek_start (src) { - for_each!((i, c) in char_indices(src) => - if is_key_start(c) { return Ok(Some(i)) } else - if !is_space(c) { return Err(Unexpected(c, Some(i), None)) }); - Ok(None) - } - pub const fn key_seek_length (src) { - for_each!((i, c) in char_indices(src) => - if is_key_end(c) { return Ok(Some(i)) } else - if !is_key_char(c) { return Err(Unexpected(c, Some(i), None)) }); - Ok(Some(src.len())) - } -}); - -dsl_type!(DslNum { - fn num (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(num_peek_only))} -} { - pub const fn num_peek [generated]; - pub const fn num_peek_only [generated]; - pub const fn num_seek [generated]; - pub const fn num_seek_start (src) { - for_each!((i, c) in char_indices(src) => - if is_digit(c) { return Ok(Some(i)); } else - if !is_space(c) { return Err(Unexpected(c, Some(i), None)) }); - Ok(None) - } - pub const fn num_seek_length (src) { - for_each!((i, c) in char_indices(src) => - if is_num_end(c) { return Ok(Some(i)) } else - if !is_digit(c) { return Err(Unexpected(c, Some(i), None)) }); - Ok(None) - } -}); -pub const fn is_digit (c: char) -> bool { matches!(c, '0'..='9') } -pub const fn is_num_end (c: char) -> bool { matches!(c, ' '|'\n'|'\r'|'\t'|')') } -pub const fn to_number (digits: &str) -> Result { - let mut iter = char_indices(digits); - let mut value = 0; - while let Some(((_, c), next)) = iter.next() { - match to_digit(c) { - Ok(digit) => value = 10 * value + digit, - Err(e) => return Err(e), - } - iter = next; - } - Ok(value) -} -pub const fn to_digit (c: char) -> Result { - Ok(match c { - '0' => 0, '1' => 1, '2' => 2, '3' => 3, '4' => 4, - '5' => 5, '6' => 6, '7' => 7, '8' => 8, '9' => 9, - _ => return Err(Unexpected(c, None, Some("parse digit"))) - }) + #[error("parse failed: not implemented")] + Unimplemented, + #[error("parse failed: empty")] + Empty, + #[error("parse failed: incomplete")] + Incomplete, + #[error("parse failed: unexpected character '{0}'")] + Unexpected(char, Option, Option<&'static str>), + #[error("parse failed: error #{0}")] + Code(u8), + #[error("end reached")] + End } diff --git a/dsl/src/dsl_ns.rs b/dsl/src/dsl_ns.rs new file mode 100644 index 0000000..f179905 --- /dev/null +++ b/dsl/src/dsl_ns.rs @@ -0,0 +1,118 @@ +use crate::*; +/// Define a namespace: +#[macro_export] macro_rules! dsl_ns ( + // Special form for numeric types + (num |$state:ident : $State: ty| $($($num:lifetime)? $Type:ty $(=> { $( + $pat:tt => $body:expr + ),* $(,)? })?;)+) => { + $(dsl_ns!(num |$state: $State| -> $($num)? $Type { $( $($pat => $body),* )? });)+ + }; + // Special form for numeric types + (num |$state:ident : $State: ty| -> $Type:ty { $( $pat:tt => $body:expr ),* $(,)? }) => { + impl<'t> DslNs<'t, $Type> for $State { + const SYMS: DslNsMap<'t, fn (&'t $State)->Perhaps<$Type>> = + DslNsMap::new(&[$(dsl_ns!{@sym ($state: $State) -> $Type { $pat => $body }}),*]); + const EXPS: DslNsMap<'t, fn (&'t $State, &str)->Perhaps<$Type>> = + DslNsMap::new(&[$(dsl_ns!{@exp ($state: $State) -> $Type { $pat => $body }}),*]); + fn from (&'t self, dsl: D) -> Perhaps<$Type> { + if let Ok(Some(src)) = dsl.src() { + if let Ok(Some(num)) = src.num() { + Ok(Some(to_number(num)? as $Type)) + } else if let Ok(Some(src)) = src.sym() { + self.from_sym(src) + } else { + self.from_exp(src) + } + } else { + Ok(None) + } + } + } + }; + // A namespace may resolve one or more types. + (|$state:ident : $State: ty| $($Type:ty $(=> { $( $pat:tt => $body:expr ),* $(,)? })? ;)+) => { + $(dsl_ns!(|$state: $State| -> $Type { $( $($pat => $body),* )? });)+ + }; + // Regular form for single type + (|$state:ident : $State: ty| -> $Type:ty { $( $pat:tt => $body:expr ),* $(,)? }) => { + impl<'t> DslNs<'t, $Type> for $State { + const SYMS: DslNsMap<'t, fn (&'t $State)->Perhaps<$Type>> = + DslNsMap::new(&[$(dsl_ns!{@sym ($state: $State) -> $Type { $pat => $body }}),*]); + const EXPS: DslNsMap<'t, fn (&'t $State, &str)->Perhaps<$Type>> = + DslNsMap::new(&[$(dsl_ns!{@exp ($state: $State) -> $Type { $pat => $body }}),*]); + } + }; + // Symbols only. + (@sym ($state:ident: $State:ty) -> $Type:ty { + $sym:literal => $body:expr + }) => { + ($sym, |$state|Ok(Some($body))) + }; + // Expression handlers only. + (@exp ($state:ident: $State:ty) -> $Type:ty { + ($head:literal $(,$arg:ident:$ty:ty)* $(,)*) => $body:expr + }) => { ($head, |$state, tail: &str|{ + $( + let head = tail.head()?.unwrap_or_default(); + let $arg: $ty = if let Some(arg) = $state.from(&head)? { + arg + } else { + return Err(format!("missing argument: {}", stringify!($arg)).into()) + }; + let tail = tail.tail()?.unwrap_or_default(); + )* + Ok(Some($body)) + }) }; + // Nothing else in symbols. + (@sym ($state:ident: $State:ty) -> $Type:ty { $pat:tt => $body:expr }) => { + ("", |_|Ok(None)) // FIXME don't emit at all + }; + // Nothing else in expression handlers. + (@exp ($state:ident: $State:ty) -> $Type:ty { $pat:tt => $body:expr }) => { + ("", |_, _|Ok(None)) // FIXME don't emit at all + }; + +); + +pub trait DslNs<'t, T: 't>: 't { + /// Known symbols. + const SYMS: DslNsMap<'t, fn (&'t Self)->Perhaps> = DslNsMap::new(&[]); + /// Known expressions. + const EXPS: DslNsMap<'t, fn (&'t Self, &str)->Perhaps> = DslNsMap::new(&[]); + /// Resolve a symbol if known. + fn from_sym (&'t self, dsl: D) -> Perhaps { + if let Some(dsl) = dsl.sym()? { + for (sym, get) in Self::SYMS.0 { if dsl == *sym { return get(self) } } + } + return Ok(None) + } + /// Resolve an expression if known. + fn from_exp (&'t self, dsl: D) -> Perhaps { + if let Some(exp) = dsl.exp()? { + for (key, value) in Self::EXPS.0.iter() { + if exp.head() == Ok(Some(key)) { return value(self, exp.tail()?.unwrap_or("")) } + } + } + return Ok(None) + } + /// Resolve an expression or symbol. + fn from (&'t self, dsl: D) -> Perhaps { + if let Ok(Some(src)) = dsl.src() { + if let Ok(Some(src)) = src.sym() { + self.from_sym(src) + } else { + self.from_exp(src) + } + } else { + Ok(None) + } + } +} +/// Namespace mapping. +pub struct DslNsMap<'t, T: 't>(pub &'t [(&'t str, T)]); +impl<'t, T: 't> DslNsMap<'t, T> { + /// Populate a namespace. + pub const fn new (data: &'t [(&'t str, T)]) -> Self { + Self(data) // TODO build search index + } +} diff --git a/dsl/src/dsl_src.rs b/dsl/src/dsl_src.rs new file mode 100644 index 0000000..89b5fc9 --- /dev/null +++ b/dsl/src/dsl_src.rs @@ -0,0 +1,21 @@ +use crate::*; +// Designates a string as parsable DSL. +flex_trait!(Dsl: Debug + Send + Sync + Sized { + fn src (&self) -> DslPerhaps<&str> { unreachable!("Dsl::src default impl") } +}); +// Some things that can be DSL source: +impl Dsl for String { + fn src (&self) -> DslPerhaps<&str> { Ok(Some(self.as_ref())) } +} +impl Dsl for Arc { + fn src (&self) -> DslPerhaps<&str> { Ok(Some(self.as_ref())) } +} +impl<'s> Dsl for &'s str { + fn src (&self) -> DslPerhaps<&str> { Ok(Some(self.as_ref())) } +} +impl Dsl for Option { + fn src (&self) -> DslPerhaps<&str> {Ok(if let Some(dsl) = self { dsl.src()? } else { None })} +} +impl Dsl for Result { + fn src (&self) -> DslPerhaps<&str> {match self {Ok(dsl) => Ok(dsl.src()?), Err(e) => Err(*e)}} +} diff --git a/dsl/src/dsl_type.rs b/dsl/src/dsl_type.rs index 985c37b..94ff0ec 100644 --- a/dsl/src/dsl_type.rs +++ b/dsl/src/dsl_type.rs @@ -1,5 +1,50 @@ use crate::*; +fn ok_flat (x: Option>) -> DslPerhaps { + Ok(x.transpose()?.flatten()) +} +pub const fn is_space (c: char) -> bool { + matches!(c, ' '|'\n'|'\r'|'\t') +} +pub const fn no_trailing_non_space ( + src: &str, offset: usize, context: Option<&'static str> +) -> DslResult<()> { + Ok(for_each!((i, c) in char_indices(str_range(src, offset, src.len())) => if !is_space(c) { + return Err(Unexpected(c, Some(offset + i), if let Some(context) = context { + Some(context) + } else { + Some("trailing non-space") + })) + })) +} +pub const fn peek (src: &str) -> DslPerhaps<&str> { + Ok(Some(if let Ok(Some(exp)) = exp_peek(src) { exp } else + if let Ok(Some(sym)) = sym_peek(src) { sym } else + if let Ok(Some(num)) = num_peek(src) { num } else + if let Ok(Some(text)) = text_peek(src) { text } else + if let Err(e) = no_trailing_non_space(src, 0, Some("peek")) { return Err(e) } + else { return Ok(None) })) +} +pub const fn seek (src: &str) -> DslPerhaps<(usize, usize)> { + Ok(Some(if let Ok(Some(exp)) = exp_seek(src) { exp } else + if let Ok(Some(sym)) = sym_seek(src) { sym } else + if let Ok(Some(num)) = num_seek(src) { num } else + if let Ok(Some(text)) = text_seek(src) { text } else + if let Err(e) = no_trailing_non_space(src, 0, Some("seek")) { return Err(e) } + else { return Ok(None) })) +} +pub const fn peek_tail (src: &str) -> DslPerhaps<&str> { + match seek(src) { + Err(e) => Err(e), + Ok(None) => Ok(None), + Ok(Some((start, length))) => { + let tail = str_range(src, start + length, src.len()); + for_each!((_i, c) in char_indices(tail) => if !is_space(c) { return Ok(Some(tail)) }); + Ok(None) + }, + } +} + #[macro_export] macro_rules! dsl_type (($T:ident { $($trait:tt)* } { pub const fn $peek:ident $($_1:tt)?; pub const fn $peek_only:ident $($_2:tt)?; @@ -113,9 +158,9 @@ pub const fn exp_peek_inner_only (src: &str) -> DslPerhaps<&str> { } } -pub const fn is_sym_start (c: char) -> bool { matches!(c, ':'|'@') } -pub const fn is_sym_char (c: char) -> bool { is_sym_start(c) || matches!(c, 'a'..='z'|'A'..='Z'|'0'..='9'|'-'|'/') } -pub const fn is_sym_end (c: char) -> bool { is_space(c) || matches!(c, ')') } +pub const fn is_sym_start (c: char) -> bool { is_sym_char(c) } +pub const fn is_sym_char (c: char) -> bool { matches!(c, 'a'..='z'|'A'..='Z'|'0'..='9'|'-'|'/'|'@'|':') } +pub const fn is_sym_end (c: char) -> bool { is_space(c) || is_exp_end(c) } dsl_type!(DslSym { fn sym (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(sym_peek_only))} } { @@ -201,7 +246,7 @@ dsl_type!(DslNum { }); pub const fn is_digit (c: char) -> bool { matches!(c, '0'..='9') } pub const fn is_num_end (c: char) -> bool { matches!(c, ' '|'\n'|'\r'|'\t'|')') } -pub const fn to_number (digits: &str) -> Result { +pub const fn to_number (digits: &str) -> Result { let mut iter = char_indices(digits); let mut value = 0; while let Some(((_, c), next)) = iter.next() { diff --git a/input/src/input_dsl.rs b/input/src/input_dsl.rs index 24f6f1a..dd717c9 100644 --- a/input/src/input_dsl.rs +++ b/input/src/input_dsl.rs @@ -1,9 +1,5 @@ use crate::*; use std::{sync::Arc, collections::BTreeMap, path::{Path, PathBuf}, fs::{exists, read_to_string}}; -/// Map of each event (e.g. key combination) to -/// all command expressions bound to it by -/// all loaded input layers. -type EventMapImpl = BTreeMap>>; /// A collection of input bindings. /// /// Each contained layer defines a mapping from input event to command invocation @@ -14,15 +10,33 @@ type EventMapImpl = BTreeMap>>; /// When the first non-conditional or true conditional binding is executed, /// that .event()binding's value is returned. #[derive(Debug)] -pub struct EventMap(pub EventMapImpl); +pub struct EventMap( + /// Map of each event (e.g. key combination) to + /// all command expressions bound to it by + /// all loaded input layers. + pub BTreeMap>> +); /// An input binding. #[derive(Debug, Clone)] pub struct Binding { - pub command: C, + pub commands: Arc<[C]>, pub condition: Option, pub description: Option>, pub source: Option>, } +impl Binding { + pub fn from_dsl (dsl: impl Dsl) -> Usually { + let command: Option = None; + let condition: Option = None; + let description: Option> = None; + let source: Option> = None; + if let Some(command) = command { + Ok(Self { commands: [command].into(), condition, description, source }) + } else { + Err(format!("no command in {dsl:?}").into()) + } + } +} /// Input bindings are only returned if this evaluates to true #[derive(Clone)] pub struct Condition(Arcbool + Send + Sync>>); @@ -59,72 +73,4 @@ impl EventMap { .map(|bb|bb.iter().filter(|b|b.condition.as_ref().map(|c|(c.0)()).unwrap_or(true)).next()) .flatten() } - /// Create event map from path to text file. - pub fn load_from_path <'s> ( - &'s mut self, path: impl AsRef - ) -> Usually<&'s mut Self> where Self: DslInto + DslInto { - if exists(path.as_ref())? { - let source = read_to_string(&path)?; - let path: Arc = Arc::new(path.as_ref().into()); - self.load_from_source(&source, &Some(&path)) - } else { - return Err(format!("(e5) not found: {:?}", path.as_ref()).into()) - } - } - /// Create event map from DSL tokenizer. - pub fn load_from_source ( - &mut self, dsl: impl Dsl, path: &Option<&Arc> - ) -> Usually<&mut Self> where Self: DslInto + DslInto { - dsl.each(|dsl|self.load_from_source_one(&dsl, path).map(move|_|()))?; - Ok(self) - } - /// Load one event binding into the event map. - pub fn load_from_source_one <'s> ( - &'s mut self, dsl: impl Dsl, path: &Option<&Arc> - ) -> Usually<&'s mut Self> where Self: DslInto + DslInto { - if let Some(exp) = dsl.head()?.exp()? - && let Some(sym) = exp.head()?.sym()? - && let Some(tail) = exp.tail()? - { - let event = self.dsl_into_or_else(&sym, ||panic!())?; - let command = self.dsl_into_or_else(&tail, ||panic!())?; - Ok(self.add(event, Binding { - command, condition: None, description: None, source: path.cloned() - })) - } else { - Err(format!("unexpected: {:?}", dsl.head()?).into()) - } - } - //})Ok(if let Some(sym) = dsl.head()?.exp()?.head()?.sym()? { - //if let Some(tail) = dsl.head()?.exp()?.tail()? { - //let event: E = sym.into(); - //let binding: Binding = Binding { command: tail.into(), condition: None, description: None, source: None }; - //if let Some(bindings) = map.0.get_mut(&event) { - //bindings.push(binding); - //} else { - //map.0.insert(event, vec![binding]); - //} - //} else { - //panic!("empty binding: {}", dsl.head()?.exp()?.unwrap_or_default()) - //} - //} else if let Some(ref text) = dsl.text()? { - //map.0.extend(Self::from_path(PathBuf::from(text))?.0); - //} else { - //return Err(format!("unexpected: {dsl:?}").into()) - //})); - //Ok(map) - //} -} -impl Binding { - pub fn from_dsl (dsl: impl Dsl) -> Usually { - let command: Option = None; - let condition: Option = None; - let description: Option> = None; - let source: Option> = None; - if let Some(command) = command { - Ok(Self { command, condition, description, source }) - } else { - Err(format!("no command in {dsl:?}").into()) - } - } } From ca4138e36588089d5568a80d05afdfb923eadf3c Mon Sep 17 00:00:00 2001 From: unspeaker Date: Sat, 16 Aug 2025 16:57:53 +0300 Subject: [PATCH 3/3] dsl: exp -> expr, sym -> word --- dsl/README.md | 2 +- dsl/src/dsl.rs | 267 +++++++++++++++++++++++++++++++- dsl/src/dsl_ns.rs | 73 +++++---- dsl/src/dsl_type.rs | 267 -------------------------------- input/src/input_dsl.rs | 2 +- output/src/ops.rs | 8 +- proc/src/proc_expose.rs | 6 +- tui/src/tui_engine/tui_event.rs | 12 +- 8 files changed, 321 insertions(+), 316 deletions(-) delete mode 100644 dsl/src/dsl_type.rs diff --git a/dsl/README.md b/dsl/README.md index 6220947..ce24bc1 100644 --- a/dsl/README.md +++ b/dsl/README.md @@ -95,7 +95,7 @@ or configuration statements, and look like this: ## implementation notes -### `DslExp` trait behavior +### `DslExpr` trait behavior this is the trait which differentiates "a thing" from "a thing that is many things". diff --git a/dsl/src/dsl.rs b/dsl/src/dsl.rs index 71e9a9f..e7463ae 100644 --- a/dsl/src/dsl.rs +++ b/dsl/src/dsl.rs @@ -18,7 +18,6 @@ pub(crate) use self::DslError::*; mod dsl_conv; pub use self::dsl_conv::*; mod dsl_ns; pub use self::dsl_ns::*; mod dsl_src; pub use self::dsl_src::*; -mod dsl_type; pub use self::dsl_type::*; #[cfg(test)] mod dsl_test; /// DSL-specific result type. pub type DslResult = Result; @@ -40,3 +39,269 @@ pub enum DslError { #[error("end reached")] End } +fn ok_flat (x: Option>) -> DslPerhaps { + Ok(x.transpose()?.flatten()) +} +pub const fn is_space (c: char) -> bool { + matches!(c, ' '|'\n'|'\r'|'\t') +} +pub const fn no_trailing_non_space ( + src: &str, offset: usize, context: Option<&'static str> +) -> DslResult<()> { + Ok(for_each!((i, c) in char_indices(str_range(src, offset, src.len())) => if !is_space(c) { + return Err(Unexpected(c, Some(offset + i), if let Some(context) = context { + Some(context) + } else { + Some("trailing non-space") + })) + })) +} +pub const fn peek (src: &str) -> DslPerhaps<&str> { + Ok(Some(if let Ok(Some(expr)) = expr_peek(src) { expr } else + if let Ok(Some(word)) = word_peek(src) { word } else + if let Ok(Some(num)) = num_peek(src) { num } else + if let Ok(Some(text)) = text_peek(src) { text } else + if let Err(e) = no_trailing_non_space(src, 0, Some("peek")) { return Err(e) } + else { return Ok(None) })) +} +pub const fn seek (src: &str) -> DslPerhaps<(usize, usize)> { + Ok(Some(if let Ok(Some(expr)) = expr_seek(src) { expr } else + if let Ok(Some(word)) = word_seek(src) { word } else + if let Ok(Some(num)) = num_seek(src) { num } else + if let Ok(Some(text)) = text_seek(src) { text } else + if let Err(e) = no_trailing_non_space(src, 0, Some("seek")) { return Err(e) } + else { return Ok(None) })) +} +pub const fn peek_tail (src: &str) -> DslPerhaps<&str> { + match seek(src) { + Err(e) => Err(e), + Ok(None) => Ok(None), + Ok(Some((start, length))) => { + let tail = str_range(src, start + length, src.len()); + for_each!((_i, c) in char_indices(tail) => if !is_space(c) { return Ok(Some(tail)) }); + Ok(None) + }, + } +} + +#[macro_export] macro_rules! dsl_type (($T:ident { $($trait:tt)* } { + pub const fn $peek:ident $($_1:tt)?; + pub const fn $peek_only:ident $($_2:tt)?; + pub const fn $seek:ident $($_3:tt)?; + pub const fn $seek_start:ident ($source1:ident) $body1:block + pub const fn $seek_length:ident ($source2:ident) $body2:block +})=>{ + pub trait $T: Dsl { $($trait)* } + impl $T for D {} + /// Find a slice corrensponding to a syntax token. + pub const fn $peek (source: &str) -> DslPerhaps<&str> { + match $seek(source) { + Err(e) => Err(e), + Ok(None) => Ok(None), + Ok(Some((start, length))) => Ok(Some(str_range(source, start, start + length))), + } + } + /// Find a slice corrensponding to a syntax token + /// but return an error if it isn't the only thing + /// in the source. + pub const fn $peek_only (source: &str) -> DslPerhaps<&str> { + match $seek(source) { + Err(e) => Err(e), + Ok(None) => Ok(None), + Ok(Some((start, length))) => { + if let Err(e) = no_trailing_non_space(source, start + length, Some("peek_only")) { return Err(e) } + Ok(Some(str_range(source, start, start + length))) + } + } + } + /// Find a start and length corresponding to a syntax token. + pub const fn $seek (source: &str) -> DslPerhaps<(usize, usize)> { + match $seek_start(source) { + Err(e) => Err(e), + Ok(None) => Ok(None), + Ok(Some(start)) => match $seek_length(str_from(source, start)) { + Ok(Some(length)) => Ok(Some((start, length))), + Ok(None) => Ok(None), + Err(e) => Err(e), + }, + } + } + pub const fn $seek_start ($source1: &str) -> DslPerhaps $body1 + pub const fn $seek_length ($source2: &str) -> DslPerhaps $body2 +}); + +pub const fn is_expr_start (c: char) -> bool { c == '(' } +pub const fn is_expr_end (c: char) -> bool { c == ')' } +dsl_type!(DslExpr { + fn expr (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(expr_peek_inner_only))} + fn head (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(peek))} + fn tail (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(peek_tail))} + /// my other car is a cdr :< + fn each (&self, mut cb: impl FnMut(&str)->Usually<()>) -> Usually<()> { + Ok(if let Some(head) = self.head()? { + cb(head)?; + if let Some(tail) = self.tail()? { + tail.each(cb)?; + } + }) + } +} { + pub const fn expr_peek [generated]; + pub const fn expr_peek_only [generated]; + pub const fn expr_seek [generated]; + pub const fn expr_seek_start (src) { + for_each!((i, c) in char_indices(src) => + if is_expr_start(c) { return Ok(Some(i)) } else + if !is_space(c) { return Err(Unexpected(c, Some(i), Some("expected expression start"))) }); + Ok(None) + } + pub const fn expr_seek_length (src) { + let mut depth = 0; + for_each!((i, c) in char_indices(src) => + if is_expr_start(c) { depth += 1; } else + if is_expr_end(c) { + if depth == 0 { + return Err(Unexpected(c, Some(i), Some("expected expression end"))) + } else if depth == 1 { + return Ok(Some(i + 1)) + } else { + depth -= 1; + } + }); + Err(Incomplete) + } +}); + +pub const fn expr_peek_inner (src: &str) -> DslPerhaps<&str> { + match expr_peek(src) { + Ok(Some(peeked)) => { + let len = peeked.len(); + let start = if len > 0 { 1 } else { 0 }; + Ok(Some(str_range(src, start, start + len.saturating_sub(2)))) + }, + e => e + } +} + +pub const fn expr_peek_inner_only (src: &str) -> DslPerhaps<&str> { + match expr_seek(src) { + Err(e) => Err(e), + Ok(None) => Ok(None), + Ok(Some((start, length))) => { + if let Err(e) = no_trailing_non_space(src, start + length, Some("expr_peek_inner_only")) { return Err(e) } + let peeked = str_range(src, start, start + length); + let len = peeked.len(); + let start = if len > 0 { 1 } else { 0 }; + Ok(Some(str_range(peeked, start, start + len.saturating_sub(2)))) + }, + } +} + +pub const fn is_word_char (c: char) -> bool { + matches!(c, 'a'..='z'|'A'..='Z'|'0'..='9'|'-'|'/'|'@'|':') +} +pub const fn is_word_end (c: char) -> bool { + is_space(c) || is_expr_end(c) +} +dsl_type!(DslWord { + fn word (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(word_peek_only))} +} { + pub const fn word_peek [generated]; + pub const fn word_peek_only [generated]; + pub const fn word_seek [generated]; + pub const fn word_seek_start (src) { + for_each!((i, c) in char_indices(src) => if + is_word_char(c) { return Ok(Some(i)) } else + if !is_space(c) { return Err(Unexpected(c, Some(i), Some("word_seek_start"))) }); + Ok(None) + } + pub const fn word_seek_length (src) { + for_each!((i, c) in char_indices(src) => if !is_word_char(c) { return Ok(Some(i)) }); + Ok(Some(src.len())) + } +}); + +pub const fn is_text_start (c: char) -> bool { matches!(c, '"') } +pub const fn is_text_end (c: char) -> bool { matches!(c, '"') } +dsl_type!(DslText { + fn text (&self) -> DslPerhaps<&str> { ok_flat(self.src()?.map(text_peek_only)) } +} { + pub const fn text_peek [generated]; + pub const fn text_peek_only [generated]; + pub const fn text_seek [generated]; + pub const fn text_seek_start (src) { + for_each!((i, c) in char_indices(src) => + if is_text_start(c) { return Ok(Some(i)) } else + if !is_space(c) { return Err(Unexpected(c, Some(i), None)) }); + Ok(None) + } + pub const fn text_seek_length (src) { + for_each!((i, c) in char_indices(src) => + if is_text_end(c) { return Ok(Some(i)) }); + Ok(None) + } +}); + +pub const fn is_key_start (c: char) -> bool { matches!(c, '/'|('a'..='z')) } +pub const fn is_key_char (c: char) -> bool { is_key_start(c) || matches!(c, '0'..='9'|'-') } +pub const fn is_key_end (c: char) -> bool { !is_key_char(c) } +dsl_type!(DslKey { + fn key (&self) -> DslPerhaps<&str> { ok_flat(self.src()?.map(key_peek_only)) } +} { + pub const fn key_peek [generated]; + pub const fn key_peek_only [generated]; + pub const fn key_seek [generated]; + pub const fn key_seek_start (src) { + for_each!((i, c) in char_indices(src) => + if is_key_start(c) { return Ok(Some(i)) } else + if !is_space(c) { return Err(Unexpected(c, Some(i), None)) }); + Ok(None) + } + pub const fn key_seek_length (src) { + for_each!((i, c) in char_indices(src) => + if is_key_end(c) { return Ok(Some(i)) } else + if !is_key_char(c) { return Err(Unexpected(c, Some(i), None)) }); + Ok(Some(src.len())) + } +}); + +dsl_type!(DslNum { + fn num (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(num_peek_only))} +} { + pub const fn num_peek [generated]; + pub const fn num_peek_only [generated]; + pub const fn num_seek [generated]; + pub const fn num_seek_start (src) { + for_each!((i, c) in char_indices(src) => + if is_digit(c) { return Ok(Some(i)); } else + if !is_space(c) { return Err(Unexpected(c, Some(i), None)) }); + Ok(None) + } + pub const fn num_seek_length (src) { + for_each!((i, c) in char_indices(src) => + if is_num_end(c) { return Ok(Some(i)) } else + if !is_digit(c) { return Err(Unexpected(c, Some(i), None)) }); + Ok(None) + } +}); +pub const fn is_digit (c: char) -> bool { matches!(c, '0'..='9') } +pub const fn is_num_end (c: char) -> bool { matches!(c, ' '|'\n'|'\r'|'\t'|')') } +pub const fn to_number (digits: &str) -> Result { + let mut iter = char_indices(digits); + let mut value = 0; + while let Some(((_, c), next)) = iter.next() { + match to_digit(c) { + Ok(digit) => value = 10 * value + digit, + Err(e) => return Err(e), + } + iter = next; + } + Ok(value) +} +pub const fn to_digit (c: char) -> Result { + Ok(match c { + '0' => 0, '1' => 1, '2' => 2, '3' => 3, '4' => 4, + '5' => 5, '6' => 6, '7' => 7, '8' => 8, '9' => 9, + _ => return Err(Unexpected(c, None, Some("parse digit"))) + }) +} diff --git a/dsl/src/dsl_ns.rs b/dsl/src/dsl_ns.rs index f179905..7f91c46 100644 --- a/dsl/src/dsl_ns.rs +++ b/dsl/src/dsl_ns.rs @@ -11,15 +11,15 @@ use crate::*; (num |$state:ident : $State: ty| -> $Type:ty { $( $pat:tt => $body:expr ),* $(,)? }) => { impl<'t> DslNs<'t, $Type> for $State { const SYMS: DslNsMap<'t, fn (&'t $State)->Perhaps<$Type>> = - DslNsMap::new(&[$(dsl_ns!{@sym ($state: $State) -> $Type { $pat => $body }}),*]); + DslNsMap::new(&[$(dsl_ns!{@word ($state: $State) -> $Type { $pat => $body }}),*]); const EXPS: DslNsMap<'t, fn (&'t $State, &str)->Perhaps<$Type>> = DslNsMap::new(&[$(dsl_ns!{@exp ($state: $State) -> $Type { $pat => $body }}),*]); fn from (&'t self, dsl: D) -> Perhaps<$Type> { if let Ok(Some(src)) = dsl.src() { if let Ok(Some(num)) = src.num() { Ok(Some(to_number(num)? as $Type)) - } else if let Ok(Some(src)) = src.sym() { - self.from_sym(src) + } else if let Ok(Some(src)) = src.word() { + self.from_word(src) } else { self.from_exp(src) } @@ -37,16 +37,16 @@ use crate::*; (|$state:ident : $State: ty| -> $Type:ty { $( $pat:tt => $body:expr ),* $(,)? }) => { impl<'t> DslNs<'t, $Type> for $State { const SYMS: DslNsMap<'t, fn (&'t $State)->Perhaps<$Type>> = - DslNsMap::new(&[$(dsl_ns!{@sym ($state: $State) -> $Type { $pat => $body }}),*]); + DslNsMap::new(&[$(dsl_ns!{@word ($state: $State) -> $Type { $pat => $body }}),*]); const EXPS: DslNsMap<'t, fn (&'t $State, &str)->Perhaps<$Type>> = DslNsMap::new(&[$(dsl_ns!{@exp ($state: $State) -> $Type { $pat => $body }}),*]); } }; // Symbols only. - (@sym ($state:ident: $State:ty) -> $Type:ty { - $sym:literal => $body:expr + (@word ($state:ident: $State:ty) -> $Type:ty { + $word:literal => $body:expr }) => { - ($sym, |$state|Ok(Some($body))) + ($word, |$state|Ok(Some($body))) }; // Expression handlers only. (@exp ($state:ident: $State:ty) -> $Type:ty { @@ -57,14 +57,17 @@ use crate::*; let $arg: $ty = if let Some(arg) = $state.from(&head)? { arg } else { - return Err(format!("missing argument: {}", stringify!($arg)).into()) + return Err(format!("{}: missing argument: {}", + stringify!($head), + stringify!($arg) + ).into()) }; let tail = tail.tail()?.unwrap_or_default(); )* Ok(Some($body)) }) }; // Nothing else in symbols. - (@sym ($state:ident: $State:ty) -> $Type:ty { $pat:tt => $body:expr }) => { + (@word ($state:ident: $State:ty) -> $Type:ty { $pat:tt => $body:expr }) => { ("", |_|Ok(None)) // FIXME don't emit at all }; // Nothing else in expression handlers. @@ -75,31 +78,11 @@ use crate::*; ); pub trait DslNs<'t, T: 't>: 't { - /// Known symbols. - const SYMS: DslNsMap<'t, fn (&'t Self)->Perhaps> = DslNsMap::new(&[]); - /// Known expressions. - const EXPS: DslNsMap<'t, fn (&'t Self, &str)->Perhaps> = DslNsMap::new(&[]); - /// Resolve a symbol if known. - fn from_sym (&'t self, dsl: D) -> Perhaps { - if let Some(dsl) = dsl.sym()? { - for (sym, get) in Self::SYMS.0 { if dsl == *sym { return get(self) } } - } - return Ok(None) - } - /// Resolve an expression if known. - fn from_exp (&'t self, dsl: D) -> Perhaps { - if let Some(exp) = dsl.exp()? { - for (key, value) in Self::EXPS.0.iter() { - if exp.head() == Ok(Some(key)) { return value(self, exp.tail()?.unwrap_or("")) } - } - } - return Ok(None) - } /// Resolve an expression or symbol. fn from (&'t self, dsl: D) -> Perhaps { if let Ok(Some(src)) = dsl.src() { - if let Ok(Some(src)) = src.sym() { - self.from_sym(src) + if let Ok(Some(src)) = src.word() { + self.from_word(src) } else { self.from_exp(src) } @@ -107,10 +90,34 @@ pub trait DslNs<'t, T: 't>: 't { Ok(None) } } + /// Resolve a symbol if known. + fn from_word (&'t self, dsl: D) -> Perhaps { + if let Some(dsl) = dsl.word()? { + for (word, get) in Self::SYMS.0 { if dsl == *word { return get(self) } } + } + return Ok(None) + } + /// Resolve an expression if known. + fn from_exp (&'t self, dsl: D) -> Perhaps { + if let Some(head) = dsl.expr().head()? { + for (key, value) in Self::EXPS.0.iter() { + if head == *key { + return value(self, dsl.expr().tail()?.unwrap_or("")) + } + } + } + panic!("{dsl:?}"); + return Ok(None) + } + /// Known symbols. + const SYMS: DslNsMap<'t, fn (&'t Self)->Perhaps> = DslNsMap::new(&[]); + /// Known expressions. + const EXPS: DslNsMap<'t, fn (&'t Self, &str)->Perhaps> = DslNsMap::new(&[]); } /// Namespace mapping. -pub struct DslNsMap<'t, T: 't>(pub &'t [(&'t str, T)]); -impl<'t, T: 't> DslNsMap<'t, T> { +#[derive(Debug)] +pub struct DslNsMap<'t, T: Debug + 't>(pub &'t [(&'t str, T)]); +impl<'t, T: Debug + 't> DslNsMap<'t, T> { /// Populate a namespace. pub const fn new (data: &'t [(&'t str, T)]) -> Self { Self(data) // TODO build search index diff --git a/dsl/src/dsl_type.rs b/dsl/src/dsl_type.rs deleted file mode 100644 index 94ff0ec..0000000 --- a/dsl/src/dsl_type.rs +++ /dev/null @@ -1,267 +0,0 @@ -use crate::*; - -fn ok_flat (x: Option>) -> DslPerhaps { - Ok(x.transpose()?.flatten()) -} -pub const fn is_space (c: char) -> bool { - matches!(c, ' '|'\n'|'\r'|'\t') -} -pub const fn no_trailing_non_space ( - src: &str, offset: usize, context: Option<&'static str> -) -> DslResult<()> { - Ok(for_each!((i, c) in char_indices(str_range(src, offset, src.len())) => if !is_space(c) { - return Err(Unexpected(c, Some(offset + i), if let Some(context) = context { - Some(context) - } else { - Some("trailing non-space") - })) - })) -} -pub const fn peek (src: &str) -> DslPerhaps<&str> { - Ok(Some(if let Ok(Some(exp)) = exp_peek(src) { exp } else - if let Ok(Some(sym)) = sym_peek(src) { sym } else - if let Ok(Some(num)) = num_peek(src) { num } else - if let Ok(Some(text)) = text_peek(src) { text } else - if let Err(e) = no_trailing_non_space(src, 0, Some("peek")) { return Err(e) } - else { return Ok(None) })) -} -pub const fn seek (src: &str) -> DslPerhaps<(usize, usize)> { - Ok(Some(if let Ok(Some(exp)) = exp_seek(src) { exp } else - if let Ok(Some(sym)) = sym_seek(src) { sym } else - if let Ok(Some(num)) = num_seek(src) { num } else - if let Ok(Some(text)) = text_seek(src) { text } else - if let Err(e) = no_trailing_non_space(src, 0, Some("seek")) { return Err(e) } - else { return Ok(None) })) -} -pub const fn peek_tail (src: &str) -> DslPerhaps<&str> { - match seek(src) { - Err(e) => Err(e), - Ok(None) => Ok(None), - Ok(Some((start, length))) => { - let tail = str_range(src, start + length, src.len()); - for_each!((_i, c) in char_indices(tail) => if !is_space(c) { return Ok(Some(tail)) }); - Ok(None) - }, - } -} - -#[macro_export] macro_rules! dsl_type (($T:ident { $($trait:tt)* } { - pub const fn $peek:ident $($_1:tt)?; - pub const fn $peek_only:ident $($_2:tt)?; - pub const fn $seek:ident $($_3:tt)?; - pub const fn $seek_start:ident ($source1:ident) $body1:block - pub const fn $seek_length:ident ($source2:ident) $body2:block -})=>{ - pub trait $T: Dsl { $($trait)* } - impl $T for D {} - /// Find a slice corrensponding to a syntax token. - pub const fn $peek (source: &str) -> DslPerhaps<&str> { - match $seek(source) { - Err(e) => Err(e), - Ok(None) => Ok(None), - Ok(Some((start, length))) => Ok(Some(str_range(source, start, start + length))), - } - } - /// Find a slice corrensponding to a syntax token - /// but return an error if it isn't the only thing - /// in the source. - pub const fn $peek_only (source: &str) -> DslPerhaps<&str> { - match $seek(source) { - Err(e) => Err(e), - Ok(None) => Ok(None), - Ok(Some((start, length))) => { - if let Err(e) = no_trailing_non_space(source, start + length, Some("peek_only")) { return Err(e) } - Ok(Some(str_range(source, start, start + length))) - } - } - } - /// Find a start and length corresponding to a syntax token. - pub const fn $seek (source: &str) -> DslPerhaps<(usize, usize)> { - match $seek_start(source) { - Err(e) => Err(e), - Ok(None) => Ok(None), - Ok(Some(start)) => match $seek_length(str_from(source, start)) { - Ok(Some(length)) => Ok(Some((start, length))), - Ok(None) => Ok(None), - Err(e) => Err(e), - }, - } - } - pub const fn $seek_start ($source1: &str) -> DslPerhaps $body1 - pub const fn $seek_length ($source2: &str) -> DslPerhaps $body2 -}); - -pub const fn is_exp_start (c: char) -> bool { c == '(' } -pub const fn is_exp_end (c: char) -> bool { c == ')' } -dsl_type!(DslExp { - fn exp (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(exp_peek_inner_only))} - fn head (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(peek))} - fn tail (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(peek_tail))} - /// my other car is a cdr :< - fn each (&self, mut cb: impl FnMut(&str)->Usually<()>) -> Usually<()> { - Ok(if let Some(head) = self.head()? { - cb(head)?; - if let Some(tail) = self.tail()? { - tail.each(cb)?; - } - }) - } -} { - pub const fn exp_peek [generated]; - pub const fn exp_peek_only [generated]; - pub const fn exp_seek [generated]; - pub const fn exp_seek_start (src) { - for_each!((i, c) in char_indices(src) => - if is_exp_start(c) { return Ok(Some(i)) } else - if !is_space(c) { return Err(Unexpected(c, Some(i), Some("expected expression start"))) }); - Ok(None) - } - pub const fn exp_seek_length (src) { - let mut depth = 0; - for_each!((i, c) in char_indices(src) => - if is_exp_start(c) { depth += 1; } else - if is_exp_end(c) { - if depth == 0 { - return Err(Unexpected(c, Some(i), Some("expected expression end"))) - } else if depth == 1 { - return Ok(Some(i + 1)) - } else { - depth -= 1; - } - }); - Err(Incomplete) - } -}); - -pub const fn exp_peek_inner (src: &str) -> DslPerhaps<&str> { - match exp_peek(src) { - Ok(Some(peeked)) => { - let len = peeked.len(); - let start = if len > 0 { 1 } else { 0 }; - Ok(Some(str_range(src, start, start + len.saturating_sub(2)))) - }, - e => e - } -} - -pub const fn exp_peek_inner_only (src: &str) -> DslPerhaps<&str> { - match exp_seek(src) { - Err(e) => Err(e), - Ok(None) => Ok(None), - Ok(Some((start, length))) => { - if let Err(e) = no_trailing_non_space(src, start + length, Some("exp_peek_inner_only")) { return Err(e) } - let peeked = str_range(src, start, start + length); - let len = peeked.len(); - let start = if len > 0 { 1 } else { 0 }; - Ok(Some(str_range(peeked, start, start + len.saturating_sub(2)))) - }, - } -} - -pub const fn is_sym_start (c: char) -> bool { is_sym_char(c) } -pub const fn is_sym_char (c: char) -> bool { matches!(c, 'a'..='z'|'A'..='Z'|'0'..='9'|'-'|'/'|'@'|':') } -pub const fn is_sym_end (c: char) -> bool { is_space(c) || is_exp_end(c) } -dsl_type!(DslSym { - fn sym (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(sym_peek_only))} -} { - pub const fn sym_peek [generated]; - pub const fn sym_peek_only [generated]; - pub const fn sym_seek [generated]; - pub const fn sym_seek_start (src) { - for_each!((i, c) in char_indices(src) => if - is_sym_start(c) { return Ok(Some(i)) } else - if !is_space(c) { return Err(Unexpected(c, Some(i), Some("sym_seek_start"))) }); - Ok(None) - } - pub const fn sym_seek_length (src) { - for_each!((i, c) in char_indices(src) => - if is_sym_end(c) { return Ok(Some(i)) } else - if !is_sym_char(c) { return Err(Unexpected(c, Some(i), Some("sym_seek_length"))) }); - Ok(Some(src.len())) - } -}); - -pub const fn is_text_start (c: char) -> bool { matches!(c, '"') } -pub const fn is_text_end (c: char) -> bool { matches!(c, '"') } -dsl_type!(DslText { - fn text (&self) -> DslPerhaps<&str> { ok_flat(self.src()?.map(text_peek_only)) } -} { - pub const fn text_peek [generated]; - pub const fn text_peek_only [generated]; - pub const fn text_seek [generated]; - pub const fn text_seek_start (src) { - for_each!((i, c) in char_indices(src) => - if is_text_start(c) { return Ok(Some(i)) } else - if !is_space(c) { return Err(Unexpected(c, Some(i), None)) }); - Ok(None) - } - pub const fn text_seek_length (src) { - for_each!((i, c) in char_indices(src) => - if is_text_end(c) { return Ok(Some(i)) }); - Ok(None) - } -}); - -pub const fn is_key_start (c: char) -> bool { matches!(c, '/'|('a'..='z')) } -pub const fn is_key_char (c: char) -> bool { is_key_start(c) || matches!(c, '0'..='9'|'-') } -pub const fn is_key_end (c: char) -> bool { !is_key_char(c) } -dsl_type!(DslKey { - fn key (&self) -> DslPerhaps<&str> { ok_flat(self.src()?.map(key_peek_only)) } -} { - pub const fn key_peek [generated]; - pub const fn key_peek_only [generated]; - pub const fn key_seek [generated]; - pub const fn key_seek_start (src) { - for_each!((i, c) in char_indices(src) => - if is_key_start(c) { return Ok(Some(i)) } else - if !is_space(c) { return Err(Unexpected(c, Some(i), None)) }); - Ok(None) - } - pub const fn key_seek_length (src) { - for_each!((i, c) in char_indices(src) => - if is_key_end(c) { return Ok(Some(i)) } else - if !is_key_char(c) { return Err(Unexpected(c, Some(i), None)) }); - Ok(Some(src.len())) - } -}); - -dsl_type!(DslNum { - fn num (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(num_peek_only))} -} { - pub const fn num_peek [generated]; - pub const fn num_peek_only [generated]; - pub const fn num_seek [generated]; - pub const fn num_seek_start (src) { - for_each!((i, c) in char_indices(src) => - if is_digit(c) { return Ok(Some(i)); } else - if !is_space(c) { return Err(Unexpected(c, Some(i), None)) }); - Ok(None) - } - pub const fn num_seek_length (src) { - for_each!((i, c) in char_indices(src) => - if is_num_end(c) { return Ok(Some(i)) } else - if !is_digit(c) { return Err(Unexpected(c, Some(i), None)) }); - Ok(None) - } -}); -pub const fn is_digit (c: char) -> bool { matches!(c, '0'..='9') } -pub const fn is_num_end (c: char) -> bool { matches!(c, ' '|'\n'|'\r'|'\t'|')') } -pub const fn to_number (digits: &str) -> Result { - let mut iter = char_indices(digits); - let mut value = 0; - while let Some(((_, c), next)) = iter.next() { - match to_digit(c) { - Ok(digit) => value = 10 * value + digit, - Err(e) => return Err(e), - } - iter = next; - } - Ok(value) -} -pub const fn to_digit (c: char) -> Result { - Ok(match c { - '0' => 0, '1' => 1, '2' => 2, '3' => 3, '4' => 4, - '5' => 5, '6' => 6, '7' => 7, '8' => 8, '9' => 9, - _ => return Err(Unexpected(c, None, Some("parse digit"))) - }) -} diff --git a/input/src/input_dsl.rs b/input/src/input_dsl.rs index dd717c9..77c6c94 100644 --- a/input/src/input_dsl.rs +++ b/input/src/input_dsl.rs @@ -1,5 +1,5 @@ use crate::*; -use std::{sync::Arc, collections::BTreeMap, path::{Path, PathBuf}, fs::{exists, read_to_string}}; +use std::{sync::Arc, collections::BTreeMap, path::PathBuf}; /// A collection of input bindings. /// /// Each contained layer defines a mapping from input event to command invocation diff --git a/output/src/ops.rs b/output/src/ops.rs index f16d971..cfa7f37 100644 --- a/output/src/ops.rs +++ b/output/src/ops.rs @@ -511,7 +511,7 @@ transform_xy_unit!("padding/x" "padding/y" "padding/xy"|self: Padding, area|{ ///// The syntagm `(when :condition :content)` corresponds to a [When] layout element. //impl FromDsl for When where bool: FromDsl, A: FromDsl { - //fn try_provide (state: &S, source: &DslVal) -> Perhaps { + //fn try_provide (state: &S, source: &DslVal) -> Perhaps { //source.exp_match("when", |_, tail|Ok(Some(Self( //FromDsl::::provide(state, //tail.nth(0, ||"no condition".into())?, ||"no condition".into())?, @@ -522,7 +522,7 @@ transform_xy_unit!("padding/x" "padding/y" "padding/xy"|self: Padding, area|{ //} ///// The syntagm `(either :condition :content1 :content2)` corresponds to an [Either] layout element. //impl FromDsl for Either where S: Eval + Eval + Eval { - //fn try_provide (state: &S, source: &DslVal) -> Perhaps { + //fn try_provide (state: &S, source: &DslVal) -> Perhaps { //source.exp_match("either", |_, tail|Ok(Some(Self( //state.eval(tail.nth(0, ||"no condition")?, ||"no condition")?, //state.eval(tail.nth(1, ||"no content 1")?, ||"no content 1")?, @@ -533,7 +533,7 @@ transform_xy_unit!("padding/x" "padding/y" "padding/xy"|self: Padding, area|{ ///// The syntagm `(align/* :content)` corresponds to an [Align] layout element, ///// where `*` specifies the direction of the alignment. //impl FromDsl for Align where S: Eval, A> { - //fn try_provide (state: &S, source: &DslVal) -> Perhaps { + //fn try_provide (state: &S, source: &DslVal) -> Perhaps { //source.exp_match("align/", |head, tail|Ok(Some(match head { //"c" => Self::c(state.eval(tail.nth(0, ||"no content")?, ||"no content")), //"x" => Self::x(state.eval(tail.nth(0, ||"no content")?, ||"no content")), @@ -553,7 +553,7 @@ transform_xy_unit!("padding/x" "padding/y" "padding/xy"|self: Padding, area|{ ///// The syntagm `(bsp/* :content1 :content2)` corresponds to a [Bsp] layout element, ///// where `*` specifies the direction of the split. //impl FromDsl for Bsp where S: Eval, A> + Eval, B> { - //fn try_provide (state: &S, source: &DslVal) -> Perhaps { + //fn try_provide (state: &S, source: &DslVal) -> Perhaps { //source.exp_match("bsp/", |head, tail|Ok(Some(match head { //"n" => Self::n(tail.nth(0, ||"no content 1"), tail.nth(1, ||"no content 2")), //"s" => Self::s(tail.nth(0, ||"no content 1"), tail.nth(1, ||"no content 2")), diff --git a/proc/src/proc_expose.rs b/proc/src/proc_expose.rs index 23bf062..fa2707c 100644 --- a/proc/src/proc_expose.rs +++ b/proc/src/proc_expose.rs @@ -90,7 +90,7 @@ impl ExposeImpl { match dsl.key()? { Some("true") => Ok(Some(true)), Some("false") => Ok(Some(false)), - _ => match dsl.sym()? { #(#variants)* _ => Ok(None) } + _ => match dsl.word()? { #(#variants)* _ => Ok(None) } } } } @@ -102,7 +102,7 @@ impl ExposeImpl { fn from_dsl (state: &#state, dsl: &impl Dsl) -> Perhaps { match dsl.num()? { Some(n) => Ok(Some(n.parse::<#t>()?)), - _ => match dsl.sym()? { #(#variants)* _ => Ok(None) } + _ => match dsl.word()? { #(#variants)* _ => Ok(None) } } } } @@ -112,7 +112,7 @@ impl ExposeImpl { /// Generated by [tengri_proc::expose]. impl ::tengri::dsl::FromDsl<#state> for #t { fn from_dsl (state: &#state, dsl: &impl Dsl) -> Perhaps { - match dsl.sym()? { #(#variants)* _ => Ok(None) } + match dsl.word()? { #(#variants)* _ => Ok(None) } } } } diff --git a/tui/src/tui_engine/tui_event.rs b/tui/src/tui_engine/tui_event.rs index f0ab399..8824c8c 100644 --- a/tui/src/tui_engine/tui_event.rs +++ b/tui/src/tui_engine/tui_event.rs @@ -18,14 +18,14 @@ pub struct TuiKey(Option, KeyModifiers); impl TuiKey { const SPLIT: char = '/'; pub fn from_dsl (dsl: impl Dsl) -> Usually { - if let Some(symbol) = dsl.sym()? { - let symbol = symbol.trim(); - Ok(if symbol == ":char" { + if let Some(word) = dsl.word()? { + let word = word.trim(); + Ok(if word == ":char" { Self(None, KeyModifiers::NONE) - } else if symbol.chars().nth(0) == Some('@') { + } else if word.chars().nth(0) == Some('@') { let mut key = None; let mut modifiers = KeyModifiers::NONE; - let mut tokens = symbol[1..].split(Self::SPLIT).peekable(); + let mut tokens = word[1..].split(Self::SPLIT).peekable(); while let Some(token) = tokens.next() { if tokens.peek().is_some() { match token { @@ -47,7 +47,7 @@ impl TuiKey { } Self(key, modifiers) } else { - return Err(format!("TuiKey: unexpected: {symbol}").into()) + return Err(format!("TuiKey: unexpected: {word}").into()) }) } else { return Err(format!("TuiKey: unspecified").into())