From f626860924e19f7bad273914ad3e3d639d87704f Mon Sep 17 00:00:00 2001 From: unspeaker Date: Fri, 15 Aug 2025 21:03:49 +0300 Subject: [PATCH 1/2] wip: dsl refactor --- dsl/src/dsl.rs | 348 +++++++++++++++++++---------------------- dsl/src/dsl_conv.rs | 46 ------ dsl/src/dsl_ns.rs | 70 +++++++++ dsl/src/dsl_type.rs | 51 ++++++ input/src/input_dsl.rs | 6 - 5 files changed, 285 insertions(+), 236 deletions(-) create mode 100644 dsl/src/dsl_ns.rs create mode 100644 dsl/src/dsl_type.rs diff --git a/dsl/src/dsl.rs b/dsl/src/dsl.rs index cb2ee5c..a4012f9 100644 --- a/dsl/src/dsl.rs +++ b/dsl/src/dsl.rs @@ -6,12 +6,18 @@ extern crate const_panic; use const_panic::PanicFmt; use std::fmt::Debug; -pub(crate) use std::{error::Error, sync::Arc}; -pub(crate) use konst::{iter::for_each, string::{str_from, str_range, char_indices}}; -pub(crate) use thiserror::Error; -pub(crate) use ::tengri_core::*; +pub(crate) use ::{ + std::sync::Arc, + std::error::Error, + konst::iter::for_each, + konst::string::{str_from, str_range, char_indices}, + thiserror::Error, + tengri_core::* +}; 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; @@ -21,42 +27,41 @@ pub type DslPerhaps = Result, DslError>; 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") } -}); +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)}} } -impl DslText for D {} pub trait DslText: Dsl { - fn text (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(text_peek_only))} + +/// 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 } -impl DslSym for D {} pub trait DslSym: Dsl { - fn sym (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(sym_peek_only))} + +fn ok_flat (x: Option>) -> DslPerhaps { Ok(x.transpose()?.flatten()) } +pub const fn is_space (c: char) -> bool { + matches!(c, ' '|'\n'|'\r'|'\t') } -impl DslKey for D {} pub trait DslKey: Dsl { - fn key (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(key_peek_only))} -} -impl DslNum for D {} pub trait DslNum: Dsl { - fn num (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(num_peek_only))} -} -impl DslExp for D {} pub trait DslExp: Dsl { - 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 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 @@ -86,185 +91,160 @@ pub const fn peek_tail (src: &str) -> DslPerhaps<&str> { }, } } -/// 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 (source: &str, offset: usize, context: Option<&'static str>) -> DslResult<()> { - Ok(for_each!((i, c) in char_indices(str_range(source, offset, source.len())) => if !is_space(c) { - return Err(Unexpected(c, Some(offset + i), if let Some(context) = context { - Some(context) - } else { - Some("trailing non-space") - })) - })) -} -macro_rules! def_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) { - 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))) + +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)?; } - } + }) } - /// 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 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) } }); -def_peek_seek!(exp_peek, exp_peek_only, exp_seek, exp_seek_start, exp_seek_length); -pub const fn exp_peek_inner (source: &str) -> DslPerhaps<&str> { - match exp_peek(source) { + +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(source, start, start + len.saturating_sub(2)))) + Ok(Some(str_range(src, start, start + len.saturating_sub(2)))) }, e => e } } -pub const fn exp_peek_inner_only (source: &str) -> DslPerhaps<&str> { - match exp_seek(source) { + +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(source, start + length, Some("exp_peek_inner_only")) { return Err(e) } - let peeked = str_range(source, start, 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_exp_start (c: char) -> bool { c == '(' } -pub const fn is_exp_end (c: char) -> bool { c == ')' } -pub const fn exp_seek_start (source: &str) -> DslPerhaps { - for_each!((i, c) in char_indices(source) => 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 (source: &str) -> DslPerhaps { - let mut depth = 0; - for_each!((i, c) in char_indices(source) => 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) -} -def_peek_seek!(sym_peek, sym_peek_only, sym_seek, sym_seek_start, sym_seek_length); + 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 sym_seek_start (source: &str) -> DslPerhaps { - for_each!((i, c) in char_indices(source) => 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 (source: &str) -> DslPerhaps { - for_each!((i, c) in char_indices(source) => 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(source.len())) -} -def_peek_seek!(key_peek, key_peek_only, key_seek, key_seek_start, key_seek_length); -pub const fn is_key_start (c: char) -> bool { matches!(c, '/'|('a'..='z')) } -pub const fn is_key_char (c: char) -> bool { matches!(c, 'a'..='z'|'0'..='9'|'-'|'/') } -pub const fn is_key_end (c: char) -> bool { is_space(c) || matches!(c, ')') } -pub const fn key_seek_start (source: &str) -> DslPerhaps { - for_each!((i, c) in char_indices(source) => 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 (source: &str) -> DslPerhaps { - for_each!((i, c) in char_indices(source) => if is_key_end(c) { - return Ok(Some(i)) - } else if !is_key_char(c) { - return Err(Unexpected(c, Some(i), None)) - }); - Ok(Some(source.len())) -} -def_peek_seek!(text_peek, text_peek_only, text_seek, text_seek_start, text_seek_length); +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, '"') } -pub const fn text_seek_start (source: &str) -> DslPerhaps { - for_each!((i, c) in char_indices(source) => 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 (source: &str) -> DslPerhaps { - for_each!((i, c) in char_indices(source) => if is_text_end(c) { return Ok(Some(i)) }); - Ok(None) -} -def_peek_seek!(num_peek, num_peek_only, num_seek, num_seek_start, num_seek_length); -pub const fn num_seek_start (source: &str) -> DslPerhaps { - for_each!((i, c) in char_indices(source) => 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 (source: &str) -> DslPerhaps { - for_each!((i, c) in char_indices(source) => if is_num_end(c) { - return Ok(Some(i)) - } else if !is_digit(c) { - return Err(Unexpected(c, Some(i), None)) - }); - Ok(None) -} +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 { diff --git a/dsl/src/dsl_conv.rs b/dsl/src/dsl_conv.rs index 3d125a4..7bbb91c 100644 --- a/dsl/src/dsl_conv.rs +++ b/dsl/src/dsl_conv.rs @@ -1,51 +1,5 @@ use crate::*; -/// Namespace. Currently linearly searched. -pub struct DslNs<'t, T: 't>(pub &'t [(&'t str, T)]); - -/// Namespace where keys are symbols. -pub trait DslSymNs<'t, T: 't>: 't { - const SYMS: DslNs<'t, fn (&'t Self)->T>; - 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 Ok(Some(get(self))) - } - } - } - return Ok(None) - } -} - -#[macro_export] macro_rules! dsl_sym ( - (|$state:ident:$State:ty| -> $type:ty {$($lit:literal => $exp:expr),* $(,)?})=>{ - impl<'t> DslSymNs<'t, $type> for $State { - const SYMS: DslNs<'t, fn (&'t $State)->$type> = - DslNs(&[$(($lit, |$state: &$State|$exp)),*]); } }); - -pub trait DslExpNs<'t, T: 't>: 't { - const EXPS: DslNs<'t, fn (&'t Self, &str)->T>; - 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 Ok(Some(value(self, exp.tail()?.unwrap_or("")))) - } - } - } - return Ok(None) - } -} - -#[macro_export] macro_rules! dsl_exp ( - (|$state:ident:$State:ty$(, $tail:ident)?|->$type:ty { $( - ($key:literal $(/ $sub:ident: $Sub:ty)? $(, $arg:ident $(?)? :$argtype:ty)*) => $body:expr - ),* $(,)? }) => { - impl<'t> DslExpNs<'t, $type> for $State { - const EXPS: DslNs<'t, fn (&'t $State, &str)->$type> = - DslNs(&[]); } }); - // TODO DEPRECATE: /// `T` + [Dsl] -> `Self`. diff --git a/dsl/src/dsl_ns.rs b/dsl/src/dsl_ns.rs new file mode 100644 index 0000000..a0b2c9c --- /dev/null +++ b/dsl/src/dsl_ns.rs @@ -0,0 +1,70 @@ +use crate::*; + +/// 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)->$type> = DslNs(&[ + $(($lit, |$state: &$State|$exp)),* + ]); + } + }); + +/// 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 $(?)? : $argtype:ty)* + $(, ..$tail:ident)? + ) => $body:expr),* $(,)? }) => { + impl<'t> DslExpNs<'t, fn (&'t $State, &str)->$type> for $State { + const EXPS: DslNs<'t, fn (&'t $State, &str)->$type> = DslNs(&[ $( + ($key, |$state: &$State, mut tail: &str|{ + $(let $arg = dsl_next(&mut tail)?;)* + $(let $tail = tail;)? + $body + }) + ),* ]); + } + }); + +/// Namespace where keys are symbols. +pub trait DslSymNs<'t, T: 't>: 't { + const SYMS: DslNs<'t, fn (&'t Self)->T> = DslNs(&[]); + 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 Ok(Some(get(self))) + } + } + } + return Ok(None) + } +} + +/// Namespace where the keys are heads of expressions. +pub trait DslExpNs<'t, T: 't>: 't { + const EXPS: DslNs<'t, fn (&'t Self, &str)->T> = DslNs(&[]); + 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 Ok(Some(value(self, exp.tail()?.unwrap_or("")))) + } + } + } + return Ok(None) + } +} + +/// 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 new file mode 100644 index 0000000..02312c0 --- /dev/null +++ b/dsl/src/dsl_type.rs @@ -0,0 +1,51 @@ +use crate::*; + +#[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 {} + 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) { + 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), + }, + } + } +}); diff --git a/input/src/input_dsl.rs b/input/src/input_dsl.rs index f4cd98f..24f6f1a 100644 --- a/input/src/input_dsl.rs +++ b/input/src/input_dsl.rs @@ -128,9 +128,3 @@ impl Binding { } } } -fn unquote (x: &str) -> &str { - let mut chars = x.chars(); - chars.next(); - //chars.next_back(); - chars.as_str() -} From d7884f6289ac6c7a88f806f4453fb7c246c87f0b Mon Sep 17 00:00:00 2001 From: unspeaker Date: Fri, 15 Aug 2025 21:24:13 +0300 Subject: [PATCH 2/2] dsl: some ns progress --- dsl/src/dsl_ns.rs | 96 ++++++++++++++++++++++++----------------------- 1 file changed, 50 insertions(+), 46 deletions(-) diff --git a/dsl/src/dsl_ns.rs b/dsl/src/dsl_ns.rs index a0b2c9c..bb59abf 100644 --- a/dsl/src/dsl_ns.rs +++ b/dsl/src/dsl_ns.rs @@ -1,64 +1,68 @@ 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)->$type> = DslNs(&[ - $(($lit, |$state: &$State|$exp)),* + (|$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)))),* ]); } }); -/// 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 $(?)? : $argtype:ty)* - $(, ..$tail:ident)? - ) => $body:expr),* $(,)? }) => { - impl<'t> DslExpNs<'t, fn (&'t $State, &str)->$type> for $State { - const EXPS: DslNs<'t, fn (&'t $State, &str)->$type> = DslNs(&[ $( - ($key, |$state: &$State, mut tail: &str|{ - $(let $arg = dsl_next(&mut tail)?;)* - $(let $tail = tail;)? - $body - }) - ),* ]); - } - }); - -/// Namespace where keys are symbols. -pub trait DslSymNs<'t, T: 't>: 't { - const SYMS: DslNs<'t, fn (&'t Self)->T> = DslNs(&[]); - 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 Ok(Some(get(self))) - } +/// 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) } } -/// Namespace where the keys are heads of expressions. -pub trait DslExpNs<'t, T: 't>: 't { - const EXPS: DslNs<'t, fn (&'t Self, &str)->T> = DslNs(&[]); - 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 Ok(Some(value(self, exp.tail()?.unwrap_or("")))) - } - } +/// 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)) + }) + ),* ]); } - return Ok(None) - } + }); + +pub fn dsl_next (dsl: &mut impl Dsl) -> DslPerhaps { + todo!() } /// Namespace.