wip: ast/cst

dsl/src/dsl_parse.rs

@@ -1,173 +0,0 @@
-use crate::*;
-
-/// Implement the const iterator pattern.
-#[macro_export] macro_rules! const_iter {
-    ($(<$l:lifetime>)?|$self:ident: $Struct:ty| => $Item:ty => $expr:expr) => {
-        impl$(<$l>)? Iterator for $Struct {
-            type Item = $Item;
-            fn next (&mut $self) -> Option<$Item> { $expr }
-        }
-        impl$(<$l>)? ConstIntoIter for $Struct {
-            type Kind = IsIteratorKind;
-            type Item = $Item;
-            type IntoIter = Self;
-        }
-    }
-}
-
-/// Provides a native [Iterator] API over the [ConstIntoIter] [SourceIter]
-/// [TokenIter::next] returns just the [Token] and mutates `self`,
-/// instead of returning an updated version of the struct as [SourceIter::next] does.
-#[derive(Copy, Clone, Debug, Default, PartialEq)]
-pub struct TokenIter<'a>(
-    pub SourceIter<'a>
-);
-
-impl<'a> TokenIter<'a> {
-    pub const fn new (source: &'a str) -> Self {
-        Self(SourceIter::new(source))
-    }
-    pub const fn peek (&self) -> Option<Token<'a>> {
-        self.0.peek()
-    }
-}
-
-impl<'a> Iterator for TokenIter<'a> {
-    type Item = Token<'a>;
-    fn next (&mut self) -> Option<Token<'a>> {
-        self.0.next().map(|(item, rest)|{self.0 = rest; item})
-    }
-}
-
-impl<'a> From<&'a str> for TokenIter<'a> {
-    fn from (source: &'a str) -> Self{
-        Self(SourceIter(source))
-    }
-}
-
-impl<'a> From<SourceIter<'a>> for TokenIter<'a> {
-    fn from (source: SourceIter<'a>) -> Self{
-        Self(source)
-    }
-}
-
-/// Owns a reference to the source text.
-/// [SourceIter::next] emits subsequent pairs of:
-///   * a [Token] and
-///   * the source text remaining
-///     * [ ] TODO: maybe [SourceIter::next] should wrap the remaining source in `Self` ?
-#[derive(Copy, Clone, Debug, Default, PartialEq)]
-pub struct SourceIter<'a>(pub &'a str);
-
-const_iter!(<'a>|self: SourceIter<'a>| => Token<'a> => self.next_mut().map(|(result, _)|result));
-
-impl<'a> From<&'a str> for SourceIter<'a> {
-    fn from (source: &'a str) -> Self{
-        Self::new(source)
-    }
-}
-
-impl<'a> SourceIter<'a> {
-    pub const fn new (source: &'a str) -> Self {
-        Self(source)
-    }
-    pub const fn chomp (&self, index: usize) -> Self {
-        Self(split_at(self.0, index).1)
-    }
-    pub const fn next (mut self) -> Option<(Token<'a>, Self)> {
-        Self::next_mut(&mut self)
-    }
-    pub const fn peek (&self) -> Option<Token<'a>> {
-        peek_src(self.0)
-    }
-    pub const fn next_mut (&mut self) -> Option<(Token<'a>, Self)> {
-        match self.peek() {
-            Some(token) => Some((token, self.chomp(token.end()))),
-            None => None
-        }
-    }
-}
-
-/// Static iteration helper.
-#[macro_export] macro_rules! iterate {
-    ($expr:expr => $arg: pat => $body:expr) => {
-        let mut iter = $expr;
-        while let Some(($arg, next)) = iter.next() {
-            $body;
-            iter = next;
-        }
-    }
-}
-
-pub const fn peek_src <'a> (source: &'a str) -> Option<Token<'a>> {
-    let mut token: Token<'a> = Token::new(source, 0, 0, Nil);
-    iterate!(char_indices(source) => (start, c) => token = match token.value() {
-        Err(_) => return Some(token),
-        Nil => match c {
-            ' '|'\n'|'\r'|'\t' =>
-                token.grow(),
-            '(' =>
-                Token::new(source, start, 1, Exp(1, TokenIter::new(str_range(source, start, start + 1)))),
-            '"' =>
-                Token::new(source, start, 1, Str(str_range(source, start, start + 1))),
-            ':'|'@' =>
-                Token::new(source, start, 1, Sym(str_range(source, start, start + 1))),
-            '/'|'a'..='z' =>
-                Token::new(source, start, 1, Key(str_range(source, start, start + 1))),
-            '0'..='9' =>
-                Token::new(source, start, 1, match to_digit(c) {
-                    Ok(c) => Value::Num(c),
-                    Result::Err(e) => Value::Err(e)
-                }),
-            _ => token.error(Unexpected(c))
-        },
-        Str(_) => match c {
-            '"' => return Some(token),
-            _ => token.grow_str(),
-        },
-        Num(n) => match c {
-            '0'..='9' => token.grow_num(n, c),
-            ' '|'\n'|'\r'|'\t'|')' => return Some(token),
-            _ => token.error(Unexpected(c))
-        },
-        Sym(_) => match c {
-            'a'..='z'|'A'..='Z'|'0'..='9'|'-' => token.grow_sym(),
-            ' '|'\n'|'\r'|'\t'|')' => return Some(token),
-            _ => token.error(Unexpected(c))
-        },
-        Key(_) => match c {
-            'a'..='z'|'0'..='9'|'-'|'/' => token.grow_key(),
-            ' '|'\n'|'\r'|'\t'|')' => return Some(token),
-            _ => token.error(Unexpected(c))
-        },
-        Exp(depth, _) => match depth {
-            0 => return Some(token.grow_exp()),
-            _ => match c {
-                ')' => token.grow_out(),
-                '(' => token.grow_in(),
-                 _  => token.grow_exp(),
-            }
-        },
-    });
-    match token.value() {
-        Nil => None,
-        _ => Some(token),
-    }
-}
-
-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)
-}
-
-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))
-    })
-}