dsl: fixed expression handling

dsl/src/dsl.rs

@@ -6,87 +6,45 @@
 extern crate const_panic;
 use const_panic::PanicFmt;
 use std::fmt::Debug;
-pub(crate) use std::error::Error;
-pub(crate) use std::sync::Arc;
-pub(crate) use konst::string::{str_range, char_indices};
+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 self::DslError::*;
 mod dsl_conv; pub use self::dsl_conv::*;
-mod dsl_parse;
-pub(crate) use self::dsl_parse::*;
-pub mod parse { pub use crate::dsl_parse::*; }
-
-#[cfg(test)]
-mod dsl_test;
-
+#[cfg(test)] mod dsl_test;
 flex_trait!(Dsl: Debug + Send + Sync + Sized {
-    fn src (&self) -> &str {
-        unreachable!("Dsl::src default impl")
-    }
+    fn src (&self) -> DslPerhaps<&str> { unreachable!("Dsl::src default impl") }
 });
-impl Dsl for Arc<str> {
-    fn src (&self) -> &str { self.as_ref() }
-}
-impl<'s> Dsl for &'s str {
-    fn src (&self) -> &str { self.as_ref() }
-}
+impl Dsl for Arc<str> { 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<D: Dsl> Dsl for Option<D> {
-    fn src (&self) -> &str { if let Some(dsl) = self { dsl.src() } else { "" } }
+    fn src (&self) -> DslPerhaps<&str> {Ok(if let Some(dsl) = self { dsl.src()? } else { None })}
 }
-
-impl<D: Dsl> DslExp for D {}
-pub trait DslExp: Dsl {
-    fn exp (&self) -> DslPerhaps<&str> {
-        Ok(exp_peek(self.src())?)
-    }
-    fn head (&self) -> DslPerhaps<&str> {
-        let start = 1;
-        let src   = self.src();
-        let src   = &src[start.min(src.len().saturating_sub(1))..];
-        peek(src)
-    }
-    fn tail (&self) -> DslPerhaps<&str> {
-        let start = 1;
-        let src   = self.src();
-        let src   = &src[start.min(src.len().saturating_sub(1))..];
-        Ok(if let Some((head_start, head_len)) = seek(src)? {
-            let start = 1 + head_start + head_len;
-            let src   = self.src();
-            let src   = &src[start.min(src.len().saturating_sub(1))..];
-            peek(src)?
-        } else {
-            None
-        })
-    }
+impl<D: Dsl> Dsl for Result<D, DslError> {
+    fn src (&self) -> DslPerhaps<&str> {match self {Ok(dsl) => Ok(dsl.src()?), Err(e) => Err(*e)}}
 }
-
-impl<D: Dsl> DslSym for D {}
-pub trait DslSym: Dsl {
-    fn sym (&self) -> DslPerhaps<&str> { crate::parse::sym_peek(self.src()) }
+impl<D: Dsl> 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(self.head())))}
 }
-
-impl<D: Dsl> DslKey for D {}
-pub trait DslKey: Dsl {
-    fn key (&self) -> DslPerhaps<&str> { crate::parse::key_peek(self.src()) }
+impl<D: Dsl> DslText for D {} pub trait DslText: Dsl {
+    fn text (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(text_peek_only))}
 }
-
-impl<D: Dsl> DslText for D {}
-pub trait DslText: Dsl {
-    fn text (&self) -> DslPerhaps<&str> { crate::parse::text_peek(self.src()) }
+impl<D: Dsl> DslSym for D {} pub trait DslSym: Dsl {
+    fn sym  (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(sym_peek_only))}
 }
-
-impl<D: Dsl> DslNum for D {}
-pub trait DslNum: Dsl {
-    fn num (&self) -> DslPerhaps<&str> { crate::parse::num_peek(self.src()) }
+impl<D: Dsl> DslKey for D {} pub trait DslKey: Dsl {
+    fn key  (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(key_peek_only))}
+}
+impl<D: Dsl> DslNum for D {} pub trait DslNum: Dsl {
+    fn num  (&self) -> DslPerhaps<&str> {ok_flat(self.src()?.map(num_peek_only))}
 }
-
 /// DSL-specific result type.
 pub type DslResult<T> = Result<T, DslError>;
-
 /// DSL-specific optional result type.
 pub type DslPerhaps<T> = Result<Option<T>, DslError>;
-
 /// DSL-specific error codes.
 #[derive(Error, Debug, Copy, Clone, PartialEq, PanicFmt)]
 pub enum DslError {
@@ -97,3 +55,245 @@ pub enum DslError {
     #[error("parse failed: error #{0}")] Code(u8),
     #[error("end reached")] End
 }
+#[macro_export] macro_rules! dsl_for_each (($dsl:expr => |$next:ident|$body:expr)=>{
+    let mut dsl:   Arc<str>         = $dsl.src().into();
+    let mut $next: Option<Arc<str>> = dsl.next()?.map(Into::into);
+    let mut rest:  Option<Arc<str>> = dsl.rest()?.map(Into::into);
+    loop {
+        if let Some($next) = $next { $body } else { break };
+        if let Some(next) = rest {
+            $next = next.next()?.map(Into::into);
+            rest  = next.rest()?.map(Into::into);
+        } else {
+            break
+        }
+    }
+});
+fn ok_flat <T> (x: Option<DslPerhaps<T>>) -> DslPerhaps<T> { Ok(x.transpose()?.flatten()) }
+fn peek_tail <'a> (head: DslPerhaps<&'a str>) -> impl Fn(&'a str)->DslPerhaps<&'a str> {
+    move|src|match head {
+        Ok(Some(next)) => {
+            let src = &src[src.len().min(1 + next.len())..];
+            for c in src.chars() { if !is_whitespace(c) { return Ok(Some(src)) } }
+            Ok(None)
+        },
+        e => e
+    }
+}
+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_whitespace(source, start + length) { 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),
+            },
+        }
+    }
+});
+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) {
+        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))))
+        },
+        e => e
+    }
+}
+pub const fn exp_peek_inner_only (source: &str) -> DslPerhaps<&str> {
+    match exp_seek(source) {
+        Err(e) => Err(e),
+        Ok(None) => Ok(None),
+        Ok(Some((start, length))) => {
+            if let Err(e) = no_trailing_non_whitespace(source, start + length) { return Err(e) }
+            let peeked = str_range(source, 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<usize> {
+    for_each!((i, c) in char_indices(source) => if is_exp_start(c) {
+        return Ok(Some(i))
+    } else if !is_whitespace(c) {
+        return Err(Unexpected(c))
+    });
+    Ok(None)
+}
+pub const fn exp_seek_length (source: &str) -> DslPerhaps<usize> {
+    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))
+        } 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 { matches!(c, 'a'..='z'|'A'..='Z'|'0'..='9'|'-') }
+pub const fn is_sym_end (c: char) -> bool { matches!(c, ' '|'\n'|'\r'|'\t'|')') }
+pub const fn sym_seek_start (source: &str) -> DslPerhaps<usize> {
+    for_each!((i, c) in char_indices(source) => if is_sym_start(c) {
+        return Ok(Some(i))
+    } else if !is_whitespace(c) {
+        return Err(Unexpected(c))
+    });
+    Ok(None)
+}
+pub const fn sym_seek_length (source: &str) -> DslPerhaps<usize> {
+    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))
+    });
+    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 { matches!(c, ' '|'\n'|'\r'|'\t'|')') }
+pub const fn key_seek_start (source: &str) -> DslPerhaps<usize> {
+    for_each!((i, c) in char_indices(source) => if is_key_start(c) {
+        return Ok(Some(i))
+    } else if !is_whitespace(c) {
+        return Err(Unexpected(c))
+    });
+    Ok(None)
+}
+pub const fn key_seek_length (source: &str) -> DslPerhaps<usize> {
+    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))
+    });
+    Ok(Some(source.len()))
+}
+def_peek_seek!(text_peek, text_peek_only, text_seek, text_seek_start, text_seek_length);
+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<usize> {
+    for_each!((i, c) in char_indices(source) => if is_text_start(c) {
+        return Ok(Some(i))
+    } else if !is_whitespace(c) {
+        return Err(Unexpected(c))
+    });
+    Ok(None)
+}
+pub const fn text_seek_length (source: &str) -> DslPerhaps<usize> {
+    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<usize> {
+    for_each!((i, c) in char_indices(source) => if is_digit(c) {
+        return Ok(Some(i));
+    } else if !is_whitespace(c) {
+        return Err(Unexpected(c))
+    });
+    Ok(None)
+}
+pub const fn num_seek_length (source: &str) -> DslPerhaps<usize> {
+    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))
+    });
+    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 <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))
+    })
+}
+pub const fn peek (src: &str) -> DslPerhaps<&str> {
+    Ok(Some(match () {
+        _ if let Ok(Some(exp))  = exp_peek(src) => exp,
+        _ if let Ok(Some(sym))  = sym_peek(src) => sym,
+        _ if let Ok(Some(key))  = key_peek(src) => key,
+        _ if let Ok(Some(num))  = num_peek(src) => num,
+        _ if let Ok(Some(text)) = text_peek(src) => text,
+        _ => {
+            for_each!((_, c) in char_indices(src) => if !is_whitespace(c) {
+                return Err(Unexpected(c))
+            });
+            return Ok(None)
+        }
+    }))
+}
+pub const fn seek (src: &str) -> DslPerhaps<(usize, usize)> {
+    Ok(Some(match () {
+        _ if let Ok(Some(exp))  = exp_seek(src) => exp,
+        _ if let Ok(Some(sym))  = sym_seek(src) => sym,
+        _ if let Ok(Some(key))  = key_seek(src) => key,
+        _ if let Ok(Some(num))  = num_seek(src) => num,
+        _ if let Ok(Some(text)) = text_seek(src) => text,
+        _ => {
+            for_each!((_, c) in char_indices(src) => if !is_whitespace(c) {
+                return Err(Unexpected(c))
+            });
+            return Ok(None)
+        }
+    }))
+}
+pub const fn is_whitespace (c: char) -> bool {
+    matches!(c, ' '|'\n'|'\r'|'\t')
+}
+pub const fn no_trailing_non_whitespace (source: &str, offset: usize) -> DslResult<()> {
+    let tail = str_range(source, offset, source.len());
+    for_each!((_, c) in char_indices(tail) => if !is_whitespace(c) {
+        return Err(Unexpected(c))
+    });
+    Ok(())
+}