dsl: exp -> expr, sym -> word

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<T> = Result<T, DslError>;
@@ -40,3 +39,269 @@ pub enum DslError {
     #[error("end reached")]
     End
 }
+fn ok_flat <T> (x: Option<DslPerhaps<T>>) -> DslPerhaps<T> {
+    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<D: Dsl> $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<usize> $body1
+    pub const fn $seek_length ($source2: &str) -> DslPerhaps<usize> $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<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, None, Some("parse digit")))
+    })
+}