mirror of
https://codeberg.org/unspeaker/tengri.git
synced 2025-12-06 19:56:44 +01:00
wip: fix(dsl): kinda patch it up
This commit is contained in:
parent
e72225f83c
commit
d99b20c99d
3 changed files with 253 additions and 239 deletions
425
dsl/src/lib.rs
425
dsl/src/lib.rs
|
|
@ -14,72 +14,135 @@ pub(crate) use konst::string::{split_at, str_range, char_indices};
|
|||
pub(crate) use thiserror::Error;
|
||||
pub(crate) use self::DslError::*;
|
||||
#[cfg(test)] mod test;
|
||||
|
||||
pub type DslUsually<T> = Result<T, DslError>;
|
||||
pub type DslPerhaps<T> = Result<Option<T>, DslError>;
|
||||
|
||||
/// Pronounced dizzle.
|
||||
/// A DSL expression. Generic over string and expression storage.
|
||||
pub trait Dsl: Clone + Debug {
|
||||
/// The string representation for a dizzle.
|
||||
type Str: DslStr;
|
||||
/// The expression representation for a dizzle.
|
||||
type Exp: DslExp;
|
||||
/// Return a token iterator for this dizzle.
|
||||
fn dsl (&self) -> DslUsually<&Val<Self>>;
|
||||
/// Request the top-level DSL [Val]ue.
|
||||
/// May perform cloning or parsing.
|
||||
fn dsl (&self) -> Val<Self>;
|
||||
fn err (&self) -> Option<DslError> {self.dsl().err()}
|
||||
fn nil (&self) -> bool {self.dsl().nil()}
|
||||
fn num (&self) -> Option<usize> {self.dsl().num()}
|
||||
fn sym (&self) -> Option<Self::Str> {self.dsl().sym()}
|
||||
fn key (&self) -> Option<Self::Str> {self.dsl().key()}
|
||||
fn str (&self) -> Option<Self::Str> {self.dsl().str()}
|
||||
fn exp (&self) -> Option<Self::Exp> {self.dsl().exp()}
|
||||
}
|
||||
|
||||
/// Enumeration of values representable by a DSL [Token]s.
|
||||
/// Generic over string and expression storage.
|
||||
/// Enumeration of values that may figure in an expression.
|
||||
/// Generic over [Dsl] implementation.
|
||||
#[derive(Clone, Debug, PartialEq, Default)]
|
||||
pub enum Val<D: Dsl> {
|
||||
#[default]
|
||||
Nil,
|
||||
/// Empty expression
|
||||
#[default] Nil,
|
||||
/// Unsigned integer literal
|
||||
Num(usize),
|
||||
/// Tokens that start with `:`
|
||||
/// An identifier that starts with `.`
|
||||
Sym(D::Str),
|
||||
/// Tokens that don't start with `:`
|
||||
/// An identifier that doesn't start with `:`
|
||||
Key(D::Str),
|
||||
/// Quoted string literals
|
||||
/// A quoted string literal
|
||||
Str(D::Str),
|
||||
/// Expressions.
|
||||
/// A sub-expression.
|
||||
Exp(
|
||||
/// Expression depth checksum. Must be 0, otherwise you have an unclosed delimiter.
|
||||
usize,
|
||||
isize,
|
||||
/// Expression content.
|
||||
D::Exp
|
||||
),
|
||||
/// An error.
|
||||
Error(DslError),
|
||||
}
|
||||
|
||||
impl<Str: Copy, Exp: Copy, D: Dsl<Str=Str,Exp=Exp>> Copy for Val<D> {}
|
||||
|
||||
impl<D: Dsl> Val<D> {
|
||||
pub fn convert <T: Dsl> (&self) -> Val<T> where
|
||||
B::Str: for<'a> From<&'a D::Str>,
|
||||
B::Exp: for<'a> From<&'a D::Exp>
|
||||
{
|
||||
match self { Val::Nil => Val::Nil,
|
||||
Val::Num(u) => Val::Num(*u),
|
||||
Val::Sym(s) => Val::Sym(s.into()),
|
||||
Val::Key(s) => Val::Key(s.into()),
|
||||
Val::Str(s) => Val::Str(s.into()),
|
||||
Val::Exp(d, x) => Val::Exp(*d, x.into()),
|
||||
Val::Error(e) => Val::Error(*e) } }
|
||||
pub fn is_nil (&self) -> bool { matches!(self, Self::Nil) }
|
||||
pub fn as_error (&self) -> Option<&DslError> { if let Self::Error(e) = self { Some(e) } else { None } }
|
||||
pub fn as_num (&self) -> Option<usize> {match self{Self::Num(n)=>Some(*n),_=>None}}
|
||||
pub fn as_sym (&self) -> Option<&str> {match self{Self::Sym(s )=>Some(s.as_ref()),_=>None}}
|
||||
pub fn as_key (&self) -> Option<&str> {match self{Self::Key(k )=>Some(k.as_ref()),_=>None}}
|
||||
pub fn as_str (&self) -> Option<&str> {match self{Self::Str(s )=>Some(s.as_ref()),_=>None}}
|
||||
pub fn as_exp (&self) -> Option<&D::Exp> {match self{Self::Exp(_, x)=>Some(x),_=>None}}
|
||||
pub fn exp_depth (&self) -> Option<usize> { todo!() }
|
||||
pub fn err (&self) -> Option<DslError> {match self{Val::Error(e)=>Some(*e), _=>None}}
|
||||
pub fn nil (&self) -> bool {match self{Val::Nil=>true, _=>false}}
|
||||
pub fn num (&self) -> Option<usize> {match self{Val::Num(n)=>Some(*n), _=>None}}
|
||||
pub fn sym (&self) -> Option<D::Str> {match self{Val::Sym(s)=>Some(s.clone()), _=>None}}
|
||||
pub fn key (&self) -> Option<D::Str> {match self{Val::Key(k)=>Some(k.clone()), _=>None}}
|
||||
pub fn str (&self) -> Option<D::Str> {match self{Val::Str(s)=>Some(s.clone()), _=>None}}
|
||||
pub fn exp (&self) -> Option<D::Exp> {match self{Val::Exp(_, x)=>Some(x.clone()),_=>None}}
|
||||
}
|
||||
/// The abstract syntax tree (AST) can be produced from the CST
|
||||
/// by cloning source slices into owned ([Arc]) string slices.
|
||||
#[derive(Debug, Clone, Default, PartialEq)]
|
||||
pub struct Ast(Arc<VecDeque<Arc<Token<Ast>>>>);
|
||||
impl Dsl for Ast {
|
||||
type Str = Arc<str>;
|
||||
type Exp = Arc<VecDeque<Arc<Token<Ast>>>>;
|
||||
fn dsl (&self) -> Val<Self> { Val::Exp(0, self.0.clone()) }
|
||||
}
|
||||
/// The concrete syntax tree (CST) implements zero-copy
|
||||
/// parsing of the DSL from a string reference. CST items
|
||||
/// preserve info about their location in the source.
|
||||
/// CST stores strings as source references and expressions as [CstIter] instances.
|
||||
#[derive(Debug, Copy, Clone, Default, PartialEq)]
|
||||
pub struct Cst<'s>(CstConstIter<'s>);
|
||||
impl<'s> Dsl for Cst<'s> {
|
||||
type Str = &'s str;
|
||||
type Exp = CstConstIter<'s>;
|
||||
fn dsl (&self) -> Val<Self> { Val::Exp(0, self.0) }
|
||||
}
|
||||
impl<'s> From<&'s str> for Cst<'s> {
|
||||
fn from (source: &'s str) -> Self {
|
||||
Self(CstConstIter(source))
|
||||
}
|
||||
}
|
||||
/// The string representation for a [Dsl] implementation.
|
||||
/// [Cst] uses `&'s str`. [Ast] uses `Arc<str>`.
|
||||
pub trait DslStr: PartialEq + Clone + Default + Debug + AsRef<str> + std::ops::Deref<Target = str> {}
|
||||
impl<T: PartialEq + Clone + Default + Debug + AsRef<str> + std::ops::Deref<Target = str>> DslStr for T {}
|
||||
/// The expression representation for a [Dsl] implementation.
|
||||
/// [Cst] uses [CstIter]. [Ast] uses [VecDeque].
|
||||
pub trait DslExp: PartialEq + Clone + Default + Debug {
|
||||
fn head <D: Dsl> (&self) -> Val<D>;
|
||||
fn tail (&self) -> Self;
|
||||
}
|
||||
impl DslExp for Arc<VecDeque<Arc<Token<Ast>>>> {
|
||||
fn head <D: Dsl> (&self) -> Val<D> {
|
||||
self.get(0).cloned().unwrap_or_else(||Arc::new(Default::default())).value.into()
|
||||
}
|
||||
fn tail (&self) -> Self {
|
||||
Self::new(self.iter().skip(1).cloned().collect())
|
||||
}
|
||||
}
|
||||
impl<'s> DslExp for CstConstIter<'s> {
|
||||
fn head <D: Dsl> (&self) -> Val<D> {
|
||||
peek(self.0).value.into()
|
||||
}
|
||||
fn tail (&self) -> Self {
|
||||
let Token { span: Span { start, length, source }, .. } = peek(self.0);
|
||||
Self(&source[(start+length)..])
|
||||
}
|
||||
}
|
||||
impl<Str: Copy, Exp: Copy, D: Dsl<Str=Str,Exp=Exp> + Copy> Copy for Val<D> {}
|
||||
impl<D: Dsl> Val<D> {
|
||||
pub fn is_nil (&self) -> bool { matches!(self, Self::Nil) }
|
||||
pub fn as_error (&self) -> Option<&DslError> { if let Self::Error(e) = self { Some(e) } else { None } }
|
||||
pub fn as_num (&self) -> Option<usize> {match self{Self::Num(n)=>Some(*n),_=>None}}
|
||||
pub fn as_sym (&self) -> Option<&str> {match self{Self::Sym(s )=>Some(s.as_ref()),_=>None}}
|
||||
pub fn as_key (&self) -> Option<&str> {match self{Self::Key(k )=>Some(k.as_ref()),_=>None}}
|
||||
pub fn as_str (&self) -> Option<&str> {match self{Self::Str(s )=>Some(s.as_ref()),_=>None}}
|
||||
//pub fn as_exp (&self) -> Option<&D::Exp> {match self{Self::Exp(_, x)=>Some(x),_=>None}}
|
||||
pub fn exp_depth (&self) -> Option<usize> { todo!() }
|
||||
pub fn exp_head_tail (&self) -> (Option<&Self>, Option<&D::Exp>) { (self.exp_head(), self.exp_tail()) }
|
||||
pub fn exp_head (&self) -> Option<&Self> { todo!() } // TODO
|
||||
pub fn exp_tail (&self) -> Option<&D::Exp> { todo!() }
|
||||
pub fn peek (&self) -> Option<Self> { todo!() }
|
||||
pub fn next (&mut self) -> Option<Self> { todo!() }
|
||||
pub fn rest (self) -> Vec<Self> { todo!() }
|
||||
pub fn exp_head (&self) -> Option<&Self> { todo!() } // TODO
|
||||
pub fn exp_tail (&self) -> Option<&D::Exp> { todo!() }
|
||||
pub fn peek (&self) -> Option<Self> { todo!() }
|
||||
pub fn next (&mut self) -> Option<Self> { todo!() }
|
||||
pub fn rest (self) -> Vec<Self> { todo!() }
|
||||
//pub fn convert <T: Dsl> (&self) -> Val<T> where
|
||||
//T::Str: for<'a> From<&'a D::Str>,
|
||||
//T::Exp: for<'a> From<&'a D::Exp>
|
||||
//{
|
||||
//match self { Val::Nil => Val::Nil,
|
||||
//Val::Num(u) => Val::Num(*u),
|
||||
//Val::Sym(s) => Val::Sym(s.into()),
|
||||
//Val::Key(s) => Val::Key(s.into()),
|
||||
//Val::Str(s) => Val::Str(s.into()),
|
||||
//Val::Exp(d, x) => Val::Exp(*d, x.into()),
|
||||
//Val::Error(e) => Val::Error(*e) } }
|
||||
//pub fn exp_match <T, F> (&self, namespace: &str, cb: F) -> DslPerhaps<T>
|
||||
//where F: Fn(&str, &Exp)-> DslPerhaps<T> {
|
||||
//if let Some(Self::Key(key)) = self.exp_head()
|
||||
|
|
@ -92,61 +155,6 @@ impl<D: Dsl> Val<D> {
|
|||
//}
|
||||
}
|
||||
|
||||
/// The string representation for a [Dsl] implementation.
|
||||
/// [Cst] uses `&'s str`. [Ast] uses `Arc<str>`.
|
||||
pub trait DslStr: PartialEq + Clone + Default + Debug + AsRef<str> + std::ops::Deref<Target = str> {}
|
||||
impl<T: PartialEq + Clone + Default + Debug + AsRef<str> + std::ops::Deref<Target = str>> DslStr for T {}
|
||||
|
||||
/// The expression representation for a [Dsl] implementation.
|
||||
/// [Cst] uses [CstIter]. [Ast] uses [VecDeque].
|
||||
pub trait DslExp: PartialEq + Clone + Default + Debug {}
|
||||
impl <T: PartialEq + Clone + Default + Debug> DslExp for T {}
|
||||
|
||||
/// The abstract syntax tree (AST) can be produced from the CST
|
||||
/// by cloning source slices into owned ([Arc]) string slices.
|
||||
#[derive(Debug, Clone, Default, PartialEq)]
|
||||
pub struct Ast(Token<Ast>);
|
||||
impl Dsl for Ast {
|
||||
type Str = Arc<str>;
|
||||
type Exp = VecDeque<Arc<Token<Ast>>>;
|
||||
fn dsl (&self) -> DslUsually<&Val<Self>> {
|
||||
Ok(self.0.value())
|
||||
}
|
||||
}
|
||||
|
||||
/// The concrete syntax tree (CST) implements zero-copy
|
||||
/// parsing of the DSL from a string reference. CST items
|
||||
/// preserve info about their location in the source.
|
||||
/// CST stores strings as source references and expressions as [CstIter] instances.
|
||||
#[derive(Debug, Clone, Default, PartialEq)]
|
||||
pub struct Cst<'s>(Token<Cst<'s>>);
|
||||
impl<'s> Dsl for Cst<'s> {
|
||||
type Str = &'s str;
|
||||
type Exp = CstConstIter<'s>;
|
||||
fn dsl (&self) -> DslUsually<&Val<Self>> {
|
||||
Ok(self.0.value())
|
||||
}
|
||||
}
|
||||
|
||||
/// `State` + [Dsl] -> `Self`.
|
||||
pub trait FromDsl<State>: Sized {
|
||||
fn try_from_dsl (state: &State, dsl: &impl Dsl) -> Perhaps<Self>;
|
||||
fn from_dsl (state: &State, dsl: &impl Dsl, err: impl Fn()->Box<dyn Error>) -> Usually<Self> {
|
||||
match Self::try_from_dsl(state, dsl)? { Some(dsl) => Ok(dsl), _ => Err(err()) } } }
|
||||
|
||||
/// `self` + `Options` -> [Dsl]
|
||||
pub trait IntoDsl { /*TODO*/ }
|
||||
|
||||
/// `self` + [Dsl] -> `Item`
|
||||
pub trait DslInto<Item> {
|
||||
fn try_dsl_into (&self, dsl: &impl Dsl) -> Perhaps<Item>;
|
||||
fn dsl_into (&self, dsl: &impl Dsl, err: impl Fn()->Box<dyn Error>) -> Usually<Item> {
|
||||
match Self::try_dsl_into(self, dsl)? { Some(dsl) => Ok(dsl), _ => Err(err()) } } }
|
||||
|
||||
/// `self` + `Item` -> [Dsl]
|
||||
pub trait DslFrom { /*TODO*/ }
|
||||
/// Standard result type for DSL-specific operations.
|
||||
pub type DslResult<T> = Result<T, DslError>;
|
||||
/// DSL-specific error codes.
|
||||
#[derive(Error, Debug, Copy, Clone, PartialEq, PanicFmt)] pub enum DslError {
|
||||
#[error("parse failed: not implemented")]
|
||||
|
|
@ -175,9 +183,8 @@ impl<'s> Iterator for CstIter<'s> {
|
|||
type Item = Token<Cst<'s>>;
|
||||
fn next (&mut self) -> Option<Self::Item> {
|
||||
match self.0.advance() {
|
||||
Ok(Some((item, rest))) => { self.0 = rest; item.into() },
|
||||
Ok(None) => None,
|
||||
Err(e) => panic!("{e:?}")
|
||||
Some((item, rest)) => { self.0 = rest; item.into() },
|
||||
None => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -193,7 +200,7 @@ impl<'s> From <&'s str> for CstConstIter<'s> {
|
|||
}
|
||||
impl<'s> Iterator for CstConstIter<'s> {
|
||||
type Item = Token<Cst<'s>>;
|
||||
fn next (&mut self) -> Option<Token<Cst<'s>>> { self.advance().unwrap().map(|x|x.0) }
|
||||
fn next (&mut self) -> Option<Token<Cst<'s>>> { self.advance().map(|x|x.0) }
|
||||
}
|
||||
impl<'s> ConstIntoIter for CstConstIter<'s> {
|
||||
type Kind = IsIteratorKind;
|
||||
|
|
@ -203,21 +210,98 @@ impl<'s> ConstIntoIter for CstConstIter<'s> {
|
|||
impl<'s> CstConstIter<'s> {
|
||||
pub const fn new (source: &'s str) -> Self { Self(source) }
|
||||
pub const fn chomp (&self, index: usize) -> Self { Self(split_at(self.0, index).1) }
|
||||
pub const fn peek (&self) -> DslPerhaps<Token<Cst<'s>>> { Token::peek(self.0) }
|
||||
//pub const fn next (mut self) -> Option<(Token<Cst<'s>>, Self)> {
|
||||
//Self::advance(&mut self).unwrap() }
|
||||
pub const fn advance (&mut self) -> DslPerhaps<(Token<Cst<'s>>, Self)> {
|
||||
match self.peek() {
|
||||
Ok(Some(token)) => {
|
||||
pub const fn advance (&mut self) -> Option<(Token<Cst<'s>>, Self)> {
|
||||
match peek(self.0) {
|
||||
Token { value: Val::Nil, .. } => None,
|
||||
token => {
|
||||
let end = self.chomp(token.span.end());
|
||||
Ok(Some((token.copy(), end)))
|
||||
Some((token.copy(), end))
|
||||
},
|
||||
Ok(None) => Ok(None),
|
||||
Err(e) => Err(e)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const fn is_whitespace (c: char) -> bool { matches!(c, ' '|'\n'|'\r'|'\t') }
|
||||
const fn is_digit (c: char) -> bool { matches!(c, '0'..='9') }
|
||||
const fn is_num_end (c: char) -> bool { matches!(c, ' '|'\n'|'\r'|'\t'|')') }
|
||||
const fn is_key_start (c: char) -> bool { matches!(c, '/'|'a'..='z') }
|
||||
const fn is_key_char (c: char) -> bool { matches!(c, 'a'..='z'|'0'..='9'|'-'|'/') }
|
||||
const fn is_key_end (c: char) -> bool { matches!(c, ' '|'\n'|'\r'|'\t'|')') }
|
||||
const fn is_sym_start (c: char) -> bool { matches!(c, ':'|'@') }
|
||||
const fn is_sym_char (c: char) -> bool { matches!(c, 'a'..='z'|'A'..='Z'|'0'..='9'|'-') }
|
||||
const fn is_sym_end (c: char) -> bool { matches!(c, ' '|'\n'|'\r'|'\t'|')') }
|
||||
const fn is_str_start (c: char) -> bool { matches!(c, '"') }
|
||||
const fn is_str_end (c: char) -> bool { matches!(c, '"') }
|
||||
const fn is_exp_start (c: char) -> bool { matches!(c, '(') }
|
||||
|
||||
pub const fn peek <'s> (src: &'s str) -> Token<Cst<'s>> {
|
||||
use Val::*;
|
||||
let mut t = Token { value: Val::Nil, span: Span { source: src, start: 0, length: 0 } };
|
||||
let mut iter = char_indices(src);
|
||||
while let Some(((i, c), next)) = iter.next() {
|
||||
t = match (t.value(), c) {
|
||||
(Error(_), _) => return t,
|
||||
|
||||
(Nil, _) if is_exp_start(c) => Token::new(src, i, 1, Exp(1, CstConstIter(str_range(src, i, i+1)))),
|
||||
(Nil, _) if is_str_start(c) => Token::new(src, i, 1, Str(str_range(src, i, i+1))),
|
||||
(Nil, _) if is_sym_start(c) => Token::new(src, i, 1, Sym(str_range(src, i, i+1))),
|
||||
(Nil, _) if is_key_start(c) => Token::new(src, i, 1, Key(str_range(src, i, i+1))),
|
||||
(Nil, _) if is_digit(c) => Token::new(src, i, 1, match to_digit(c) { Ok(c) => Num(c), Err(e) => Error(e) }),
|
||||
(Nil, _) if is_whitespace(c) => t.grown(),
|
||||
(Nil, _) => { t.value = Val::Error(Unexpected(c)); t },
|
||||
|
||||
(Str(_), _) if is_str_end(c) => return t,
|
||||
(Str(_), _) => { t.value = Str(t.span.grow().slice()); t },
|
||||
|
||||
(Sym(_), _) if is_sym_end(c) => return t,
|
||||
(Sym(_), _) if is_sym_char(c) => { t.value = Sym(t.span.grow().slice()); t },
|
||||
(Sym(_), _) => { t.value = Error(Unexpected(c)); t },
|
||||
|
||||
(Key(_), _) if is_key_end(c) => return t,
|
||||
(Key(_), _) if is_key_char(c) => { t.value = Key(t.span.grow().slice()); t },
|
||||
(Key(_), _) => { t.value = Error(Unexpected(c)); t },
|
||||
|
||||
(Exp(0, _), _) => { t.value = Exp(0, CstConstIter(t.span.grow().slice_exp())); return t },
|
||||
(Exp(d, _), ')') => { t.value = Exp((*d)-1, CstConstIter(t.span.grow().slice_exp())); t },
|
||||
(Exp(d, _), '(') => { t.value = Exp((*d)+1, CstConstIter(t.span.grow().slice_exp())); t },
|
||||
(Exp(d, _), _ ) => { t.value = Exp(*d, CstConstIter(t.span.grow().slice_exp())); t },
|
||||
|
||||
(Num(m), _) if is_num_end(c) => return t,
|
||||
(Num(m), _) => match to_digit(c) {
|
||||
Ok(n) => { let m = *m; t.span.grow(); t.value = Num(n+10*m); t },
|
||||
Err(e) => { t.span.grow(); t.value = Error(e); t } },
|
||||
};
|
||||
iter = next;
|
||||
}
|
||||
t
|
||||
}
|
||||
pub const fn to_number <D: Dsl> (digits: &str) -> Result<usize, DslError> {
|
||||
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<usize, DslError> {
|
||||
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))
|
||||
})
|
||||
}
|
||||
/// Parsed substring with range and value.
|
||||
#[derive(Debug, Clone, Default, PartialEq)]
|
||||
pub struct Token<D: Dsl> {
|
||||
/// Source span of token.
|
||||
span: Span<D>,
|
||||
/// Meaning of token.
|
||||
value: Val<D>,
|
||||
}
|
||||
#[derive(Debug, Copy, Clone, Default, PartialEq)]
|
||||
pub struct Span<D: Dsl> {
|
||||
/// Reference to source text.
|
||||
|
|
@ -235,20 +319,13 @@ impl<'s, D: Dsl<Str=&'s str>> Span<D> {
|
|||
str_range(self.source, self.start, self.end()) }
|
||||
pub const fn slice_exp (&self) -> &'s str {
|
||||
str_range(self.source, self.start.saturating_add(1), self.end()) }
|
||||
pub const fn grow (&mut self) -> DslUsually<&mut Self> {
|
||||
if self.length + self.start >= self.source.len() { return Err(End) }
|
||||
self.length = self.length.saturating_add(1);
|
||||
Ok(self) }
|
||||
pub const fn grow (&mut self) -> &mut Self {
|
||||
let max_length = self.source.len().saturating_sub(self.start);
|
||||
self.length = self.length + 1;
|
||||
if self.length > max_length { self.length = max_length }
|
||||
self }
|
||||
}
|
||||
|
||||
/// Parsed substring with range and value.
|
||||
#[derive(Debug, Clone, Default, PartialEq)]
|
||||
pub struct Token<D: Dsl> {
|
||||
/// Source span of token.
|
||||
span: Span<D>,
|
||||
/// Meaning of token.
|
||||
value: Val<D>,
|
||||
}
|
||||
impl<D: Dsl> Token<D> {
|
||||
pub const fn value (&self) -> &Val<D> { &self.value }
|
||||
pub const fn span (&self) -> &Span<D> { &self.span }
|
||||
|
|
@ -256,76 +333,14 @@ impl<D: Dsl> Token<D> {
|
|||
if let Val::Error(e) = self.value { Some(e) } else { None } }
|
||||
pub const fn new (source: D::Str, start: usize, length: usize, value: Val<D>) -> Self {
|
||||
Self { value, span: Span { source, start, length } } }
|
||||
pub const fn copy (&self) -> Self where D::Str: Copy, D::Exp: Copy {
|
||||
pub const fn copy (&self) -> Self where D::Str: Copy, D::Exp: Copy, Val<D>: Copy {
|
||||
Self { span: Span { ..self.span }, value: self.value } }
|
||||
}
|
||||
const fn or_panic <T> (result: DslUsually<T>) -> T {
|
||||
match result { Ok(t) => t, Err(e) => const_panic::concat_panic!(e) }
|
||||
}
|
||||
impl<'s, D: Dsl<Str = &'s str>> Token<D> {
|
||||
pub const fn peek (src: D::Str) -> DslPerhaps<Self> where D::Exp: From<&'s str> {
|
||||
use Val::*;
|
||||
let mut t = Self::new(src, 0, 0, Nil);
|
||||
let mut iter = char_indices(src);
|
||||
while let Some(((i, c), next)) = iter.next() {
|
||||
t = match (t.value(), c) {
|
||||
(Error(_), _) =>
|
||||
return Ok(Some(t)),
|
||||
(Nil, ' '|'\n'|'\r'|'\t') =>
|
||||
*or_panic(t.grow()),
|
||||
(Nil, '(') =>
|
||||
Self::new(src, i, 1, Exp(1, D::Exp::from(str_range(src, i, i + 1)))),
|
||||
(Nil, '"') =>
|
||||
Self::new(src, i, 1, Str(str_range(src, i, i + 1))),
|
||||
(Nil, ':'|'@') =>
|
||||
Self::new(src, i, 1, Sym(str_range(src, i, i + 1))),
|
||||
(Nil, '/'|'a'..='z') =>
|
||||
Self::new(src, i, 1, Key(str_range(src, i, i + 1))),
|
||||
(Nil, '0'..='9') =>
|
||||
Self::new(src, i, 1, match to_digit(c) { Ok(c) => Num(c), Err(e) => Error(e) }),
|
||||
(Nil, _) =>
|
||||
{ t.value = Val::Error(Unexpected(c)); t },
|
||||
(Str(_), '"') =>
|
||||
return Ok(Some(t)),
|
||||
(Str(_), _) =>
|
||||
{ or_panic(t.grow()); t.value = Str(t.span.slice()); t },
|
||||
(Num(m), ' '|'\n'|'\r'|'\t'|')') =>
|
||||
return Ok(Some(t)),
|
||||
(Num(m), _) => match to_digit(c) {
|
||||
Ok(n) => { t.grow()?; t.value = Num(10*m+n); t },
|
||||
Err(e) => { t.grow()?; t.value = Error(e); t } },
|
||||
(Sym(_), ' '|'\n'|'\r'|'\t'|')') =>
|
||||
return Ok(Some(t)),
|
||||
(Sym(_), 'a'..='z'|'A'..='Z'|'0'..='9'|'-') => {
|
||||
t.grow()?; t.value = Sym(t.span.slice()); t },
|
||||
(Sym(_), _) =>
|
||||
{ t.value = Error(Unexpected(c)); t },
|
||||
(Key(_), ' '|'\n'|'\r'|'\t'|')') =>
|
||||
return Ok(Some(t)),
|
||||
(Key(_), 'a'..='z'|'0'..='9'|'-'|'/') =>
|
||||
{ t.grow()?; t.value = Key(t.span.slice()); t },
|
||||
(Key(_), _ ) =>
|
||||
{ t.value = Error(Unexpected(c)); t },
|
||||
(Exp(0, _), _) =>
|
||||
{ t.grow()?; t.value = Exp(0, D::Exp::from(t.span.slice_exp())); return Ok(Some(t)) },
|
||||
(Exp(d, _), ')') =>
|
||||
{ t.grow()?; t.value = Exp(d-1, D::Exp::from(t.span.slice_exp())); t },
|
||||
(Exp(d, _), '(') =>
|
||||
{ t.grow()?; t.value = Exp(d+1, D::Exp::from(t.span.slice_exp())); t },
|
||||
(Exp(d, _), _ ) =>
|
||||
{ t.grow()?; t.value = Exp(*d, D::Exp::from(t.span.slice_exp())); t },
|
||||
};
|
||||
iter = next;
|
||||
}
|
||||
Ok(match t.value() {
|
||||
Nil => None,
|
||||
_ => Some(t)
|
||||
})
|
||||
}
|
||||
pub const fn grow (&mut self) -> DslUsually<&mut Self> { self.span.grow()?; Ok(self) }
|
||||
impl<'s, D: Dsl<Str = &'s str, Exp = CstConstIter<'s>>> Token<D> {
|
||||
pub const fn grown (mut self) -> Self { self.span.grow(); self }
|
||||
pub const fn grow_exp (&mut self, d: isize) -> &mut Self where D::Exp: From<&'s str> {
|
||||
if let Val::Exp(depth, _) = self.value() {
|
||||
self.value = Val::Exp((*depth as isize + d) as usize, D::Exp::from(self.span.slice_exp()));
|
||||
self.value = Val::Exp(*depth as isize + d, CstConstIter(self.span.slice_exp()));
|
||||
self
|
||||
} else {
|
||||
unreachable!()
|
||||
|
|
@ -333,20 +348,22 @@ impl<'s, D: Dsl<Str = &'s str>> Token<D> {
|
|||
}
|
||||
}
|
||||
|
||||
pub const fn to_digit (c: char) -> DslResult<usize> {
|
||||
Ok(match c {
|
||||
'0' => 0, '1' => 1, '2' => 2, '3' => 3, '4' => 4,
|
||||
'5' => 5, '6' => 6, '7' => 7, '8' => 8, '9' => 9,
|
||||
_ => return Result::Err(Unexpected(c)) }) }
|
||||
|
||||
macro_rules! iterate(($expr:expr => $arg: pat => $body:expr) => {
|
||||
let mut iter = $expr; while let Some(($arg, next)) = iter.next() { $body; iter = next; } });
|
||||
pub const fn to_number (digits: &str) -> DslResult<usize> {
|
||||
let mut value = 0;
|
||||
iterate!(char_indices(digits) => (_, c) => match to_digit(c) {
|
||||
Ok(digit) => value = 10 * value + digit,
|
||||
Result::Err(e) => return Result::Err(e) });
|
||||
Ok(value) }
|
||||
/// `State` + [Dsl] -> `Self`.
|
||||
pub trait FromDsl<State>: Sized {
|
||||
fn try_from_dsl (state: &State, dsl: &impl Dsl) -> Perhaps<Self>;
|
||||
fn from_dsl (state: &State, dsl: &impl Dsl, err: impl Fn()->Box<dyn Error>) -> Usually<Self> {
|
||||
match Self::try_from_dsl(state, dsl)? { Some(dsl) => Ok(dsl), _ => Err(err()) } }
|
||||
}
|
||||
/// `self` + `Options` -> [Dsl]
|
||||
pub trait IntoDsl { /*TODO*/ }
|
||||
/// `self` + [Dsl] -> `Item`
|
||||
pub trait DslInto<Item> {
|
||||
fn try_dsl_into (&self, dsl: &impl Dsl) -> Perhaps<Item>;
|
||||
fn dsl_into (&self, dsl: &impl Dsl, err: impl Fn()->Box<dyn Error>) -> Usually<Item> {
|
||||
match Self::try_dsl_into(self, dsl)? { Some(dsl) => Ok(dsl), _ => Err(err()) } }
|
||||
}
|
||||
/// `self` + `Item` -> [Dsl]
|
||||
pub trait DslFrom { /*TODO*/ }
|
||||
|
||||
/// Implement type conversions.
|
||||
macro_rules! from(($($Struct:ty { $(
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue