mirror of
https://codeberg.org/unspeaker/tengri.git
synced 2025-12-06 11:46:42 +01:00
parent
31e84bf5b3
commit
f1b24d436a
20 changed files with 1081 additions and 1103 deletions
70
dsl/src/dsl_ast.rs
Normal file
70
dsl/src/dsl_ast.rs
Normal file
|
|
@ -0,0 +1,70 @@
|
|||
use crate::*;
|
||||
use std::sync::Arc;
|
||||
use std::fmt::{Debug, Display, Formatter};
|
||||
|
||||
/// Emits tokens.
|
||||
pub trait Ast: Debug {
|
||||
fn peek (&self) -> Option<AstValue>;
|
||||
fn next (&mut self) -> Option<AstValue>;
|
||||
fn rest (self) -> Option<Box<dyn Ast>>;
|
||||
}
|
||||
|
||||
/// A [Cst] can be used as an [Ast].
|
||||
impl<'source: 'static> Ast for Cst<'source> {
|
||||
fn peek (&self) -> Option<AstValue> {
|
||||
Cst::peek(self).map(|token|token.value.into())
|
||||
}
|
||||
fn next (&mut self) -> Option<AstValue> {
|
||||
Iterator::next(self).map(|token|token.value.into())
|
||||
}
|
||||
fn rest (self) -> Option<Box<dyn Ast>> {
|
||||
self.peek().is_some().then(||Box::new(self) as Box<dyn Ast>)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Default, Debug)]
|
||||
pub enum AstValue {
|
||||
#[default] Nil,
|
||||
Err(DslError),
|
||||
Num(usize),
|
||||
Sym(Arc<str>),
|
||||
Key(Arc<str>),
|
||||
Str(Arc<str>),
|
||||
Exp(Arc<Box<dyn Ast>>),
|
||||
}
|
||||
|
||||
impl std::fmt::Display for AstValue {
|
||||
fn fmt (&self, out: &mut Formatter) -> Result<(), std::fmt::Error> {
|
||||
use AstValue::*;
|
||||
write!(out, "{}", match self {
|
||||
Nil => String::new(),
|
||||
Err(e) => format!("[error: {e}]"),
|
||||
Num(n) => format!("{n}"),
|
||||
Sym(s) => format!("{s}"),
|
||||
Key(s) => format!("{s}"),
|
||||
Str(s) => format!("{s}"),
|
||||
Exp(e) => format!("{e:?}"),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl<'source: 'static> From<CstValue<'source>> for AstValue {
|
||||
fn from (other: CstValue<'source>) -> Self {
|
||||
use CstValue::*;
|
||||
match other {
|
||||
Nil => Self::Nil,
|
||||
Err(e) => Self::Err(e),
|
||||
Num(u) => Self::Num(u),
|
||||
Sym(s) => Self::Sym(s.into()),
|
||||
Key(s) => Self::Key(s.into()),
|
||||
Str(s) => Self::Str(s.into()),
|
||||
Exp(_, s) => Self::Exp(Arc::new(s.into())),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'source: 'static> Into<Box<dyn Ast>> for Cst<'source> {
|
||||
fn into (self) -> Box<dyn Ast> {
|
||||
Box::new(self)
|
||||
}
|
||||
}
|
||||
291
dsl/src/dsl_cst.rs
Normal file
291
dsl/src/dsl_cst.rs
Normal file
|
|
@ -0,0 +1,291 @@
|
|||
use crate::*;
|
||||
|
||||
/// Provides a native [Iterator] API over [CstConstIter],
|
||||
/// emitting [CstToken] items.
|
||||
///
|
||||
/// [Cst::next] returns just the [CstToken] and mutates `self`,
|
||||
/// instead of returning an updated version of the struct as [CstConstIter::next] does.
|
||||
#[derive(Copy, Clone, Debug, Default, PartialEq)]
|
||||
pub struct Cst<'a>(pub CstConstIter<'a>);
|
||||
|
||||
/// Owns a reference to the source text.
|
||||
/// [CstConstIter::next] emits subsequent pairs of:
|
||||
/// * a [CstToken] and
|
||||
/// * the source text remaining
|
||||
/// * [ ] TODO: maybe [CstConstIter::next] should wrap the remaining source in `Self` ?
|
||||
#[derive(Copy, Clone, Debug, Default, PartialEq)]
|
||||
pub struct CstConstIter<'a>(pub &'a str);
|
||||
|
||||
/// A CST token, with reference to the source slice.
|
||||
#[derive(Debug, Copy, Clone, Default, PartialEq)] pub struct CstToken<'source> {
|
||||
pub source: &'source str,
|
||||
pub start: usize,
|
||||
pub length: usize,
|
||||
pub value: CstValue<'source>,
|
||||
}
|
||||
|
||||
/// The meaning of a CST token. Strip the source from this to get an [AstValue].
|
||||
#[derive(Debug, Copy, Clone, Default, PartialEq)] pub enum CstValue<'source> {
|
||||
#[default] Nil,
|
||||
Err(DslError),
|
||||
Num(usize),
|
||||
Sym(&'source str),
|
||||
Key(&'source str),
|
||||
Str(&'source str),
|
||||
Exp(usize, Cst<'source>),
|
||||
}
|
||||
|
||||
impl<'a> Cst<'a> {
|
||||
pub const fn new (source: &'a str) -> Self {
|
||||
Self(CstConstIter::new(source))
|
||||
}
|
||||
pub const fn peek (&self) -> Option<CstToken<'a>> {
|
||||
self.0.peek()
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Iterator for Cst<'a> {
|
||||
type Item = CstToken<'a>;
|
||||
fn next (&mut self) -> Option<CstToken<'a>> {
|
||||
self.0.next().map(|(item, rest)|{self.0 = rest; item})
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> From<&'a str> for Cst<'a> {
|
||||
fn from (source: &'a str) -> Self{
|
||||
Self(CstConstIter(source))
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> From<CstConstIter<'a>> for Cst<'a> {
|
||||
fn from (source: CstConstIter<'a>) -> Self{
|
||||
Self(source)
|
||||
}
|
||||
}
|
||||
|
||||
/// 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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const_iter!(<'a>|self: CstConstIter<'a>| => CstToken<'a> => self.next_mut().map(|(result, _)|result));
|
||||
|
||||
impl<'a> From<&'a str> for CstConstIter<'a> {
|
||||
fn from (source: &'a str) -> Self{
|
||||
Self::new(source)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> CstConstIter<'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<(CstToken<'a>, Self)> {
|
||||
Self::next_mut(&mut self)
|
||||
}
|
||||
pub const fn peek (&self) -> Option<CstToken<'a>> {
|
||||
peek_src(self.0)
|
||||
}
|
||||
pub const fn next_mut (&mut self) -> Option<(CstToken<'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<CstToken<'a>> {
|
||||
use CstValue::*;
|
||||
let mut token: CstToken<'a> = CstToken::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(),
|
||||
'(' =>
|
||||
CstToken::new(source, start, 1, Exp(1, Cst::new(str_range(source, start, start + 1)))),
|
||||
'"' =>
|
||||
CstToken::new(source, start, 1, Str(str_range(source, start, start + 1))),
|
||||
':'|'@' =>
|
||||
CstToken::new(source, start, 1, Sym(str_range(source, start, start + 1))),
|
||||
'/'|'a'..='z' =>
|
||||
CstToken::new(source, start, 1, Key(str_range(source, start, start + 1))),
|
||||
'0'..='9' =>
|
||||
CstToken::new(source, start, 1, match to_digit(c) {
|
||||
Ok(c) => CstValue::Num(c),
|
||||
Result::Err(e) => CstValue::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))
|
||||
})
|
||||
}
|
||||
|
||||
impl<'source> CstToken<'source> {
|
||||
pub const fn new (
|
||||
source: &'source str, start: usize, length: usize, value: CstValue<'source>
|
||||
) -> Self {
|
||||
Self { source, start, length, value }
|
||||
}
|
||||
pub const fn end (&self) -> usize {
|
||||
self.start.saturating_add(self.length)
|
||||
}
|
||||
pub const fn slice (&'source self) -> &'source str {
|
||||
self.slice_source(self.source)
|
||||
}
|
||||
pub const fn slice_source <'range> (&'source self, source: &'range str) -> &'range str {
|
||||
str_range(source, self.start, self.end())
|
||||
}
|
||||
pub const fn slice_source_exp <'range> (&'source self, source: &'range str) -> &'range str {
|
||||
str_range(source, self.start.saturating_add(1), self.end())
|
||||
}
|
||||
pub const fn with_value (self, value: CstValue<'source>) -> Self {
|
||||
Self { value, ..self }
|
||||
}
|
||||
pub const fn value (&self) -> CstValue {
|
||||
self.value
|
||||
}
|
||||
pub const fn error (self, error: DslError) -> Self {
|
||||
Self { value: CstValue::Err(error), ..self }
|
||||
}
|
||||
pub const fn grow (self) -> Self {
|
||||
Self { length: self.length.saturating_add(1), ..self }
|
||||
}
|
||||
pub const fn grow_num (self, m: usize, c: char) -> Self {
|
||||
use CstValue::*;
|
||||
match to_digit(c) {
|
||||
Ok(n) => Self { value: Num(10*m+n), ..self.grow() },
|
||||
Result::Err(e) => Self { value: Err(e), ..self.grow() },
|
||||
}
|
||||
}
|
||||
pub const fn grow_key (self) -> Self {
|
||||
use CstValue::*;
|
||||
let token = self.grow();
|
||||
token.with_value(Key(token.slice_source(self.source)))
|
||||
}
|
||||
pub const fn grow_sym (self) -> Self {
|
||||
use CstValue::*;
|
||||
let token = self.grow();
|
||||
token.with_value(Sym(token.slice_source(self.source)))
|
||||
}
|
||||
pub const fn grow_str (self) -> Self {
|
||||
use CstValue::*;
|
||||
let token = self.grow();
|
||||
token.with_value(Str(token.slice_source(self.source)))
|
||||
}
|
||||
pub const fn grow_exp (self) -> Self {
|
||||
use CstValue::*;
|
||||
let token = self.grow();
|
||||
if let Exp(depth, _) = token.value {
|
||||
token.with_value(Exp(depth, Cst::new(token.slice_source_exp(self.source))))
|
||||
} else {
|
||||
unreachable!()
|
||||
}
|
||||
}
|
||||
pub const fn grow_in (self) -> Self {
|
||||
let token = self.grow_exp();
|
||||
if let CstValue::Exp(depth, source) = token.value {
|
||||
token.with_value(CstValue::Exp(depth.saturating_add(1), source))
|
||||
} else {
|
||||
unreachable!()
|
||||
}
|
||||
}
|
||||
pub const fn grow_out (self) -> Self {
|
||||
let token = self.grow_exp();
|
||||
if let CstValue::Exp(depth, source) = token.value {
|
||||
if depth > 0 {
|
||||
token.with_value(CstValue::Exp(depth - 1, source))
|
||||
} else {
|
||||
return self.error(Unexpected(')'))
|
||||
}
|
||||
} else {
|
||||
unreachable!()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'source> std::fmt::Display for CstValue<'source> {
|
||||
fn fmt (&self, out: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
|
||||
use CstValue::*;
|
||||
write!(out, "{}", match self {
|
||||
Nil => String::new(),
|
||||
Err(e) => format!("[error: {e}]"),
|
||||
Num(n) => format!("{n}"),
|
||||
Sym(s) => format!("{s}"),
|
||||
Key(s) => format!("{s}"),
|
||||
Str(s) => format!("{s}"),
|
||||
Exp(_, e) => format!("{e:?}"),
|
||||
})
|
||||
}
|
||||
}
|
||||
64
dsl/src/dsl_domain.rs
Normal file
64
dsl/src/dsl_domain.rs
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
use crate::*;
|
||||
|
||||
pub trait Eval<Input, Output> {
|
||||
fn eval (&self, input: Input) -> Perhaps<Output>;
|
||||
}
|
||||
|
||||
/// May construct [Self] from token stream.
|
||||
pub trait Dsl: Sized {
|
||||
type State;
|
||||
fn try_provide (state: Self::State, source: impl Ast) -> Perhaps<Self>;
|
||||
fn provide <E: Into<Box<dyn std::error::Error>>, F: Fn()->E> (
|
||||
state: Self::State, source: impl Ast, error: F
|
||||
) -> Usually<Self> {
|
||||
let next = source.peek().clone();
|
||||
if let Some(value) = Self::try_provide(state, source)? {
|
||||
Ok(value)
|
||||
} else {
|
||||
Result::Err(format!("dsl: {}: {next:?}", error().into()).into())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//pub trait Give<'state, 'source, Type> {
|
||||
///// Implement this to be able to [Give] [Type] from the [Cst].
|
||||
///// Advance the stream if returning `Ok<Some<Type>>`.
|
||||
//fn give (&'state self, words: Cst<'source>) -> Perhaps<Type>;
|
||||
///// Return custom error on [None].
|
||||
//fn give_or_fail <E: Into<Box<dyn std::error::Error>>, F: Fn()->E> (
|
||||
//&'state self, mut words: Cst<'source>, error: F
|
||||
//) -> Usually<Type> {
|
||||
//let next = words.peek().map(|x|x.value).clone();
|
||||
//if let Some(value) = Give::<Type>::give(self, words)? {
|
||||
//Ok(value)
|
||||
//} else {
|
||||
//Result::Err(format!("give: {}: {next:?}", error().into()).into())
|
||||
//}
|
||||
//}
|
||||
//}
|
||||
//#[macro_export] macro_rules! give {
|
||||
//($Type:ty|$state:ident:$State:ident,$words:ident|$expr:expr) => {
|
||||
//impl Give<$Type> for $State {
|
||||
//fn give (&self, mut $words: Cst) -> Perhaps<$Type> {
|
||||
//let $state = self;
|
||||
//$expr
|
||||
//}
|
||||
//}
|
||||
//};
|
||||
//($Type:path$(,$Arg:ident)*|$state:ident,$words:ident|$expr:expr) => {
|
||||
//impl<State: $(Give<$Arg>)++ $(, $Arg)*> Give<$Type> for State {
|
||||
//fn give (&self, mut $words: Cst) -> Perhaps<$Type> {
|
||||
//let $state = self;
|
||||
//$expr
|
||||
//}
|
||||
//}
|
||||
//}
|
||||
//}
|
||||
/////// Implement the [Give] trait, which boils down to
|
||||
/////// specifying two types and providing an expression.
|
||||
//#[macro_export] macro_rules! from_dsl {
|
||||
//($Type:ty: |$state:ident:$State:ty, $words:ident|$expr:expr) => {
|
||||
//give! { $Type|$state:$State,$words|$expr }
|
||||
//};
|
||||
//}
|
||||
|
||||
|
|
@ -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))
|
||||
})
|
||||
}
|
||||
|
|
@ -1,147 +0,0 @@
|
|||
use crate::*;
|
||||
|
||||
///// Implement the [Give] trait, which boils down to
|
||||
///// specifying two types and providing an expression.
|
||||
#[macro_export] macro_rules! from_dsl {
|
||||
($Type:ty: |$state:ident:$State:ty, $words:ident|$expr:expr) => {
|
||||
take! { $Type|$state:$State,$words|$expr }
|
||||
};
|
||||
}
|
||||
|
||||
/// [Take]s instances of [Type] given [TokenIter].
|
||||
pub trait Give<'state, Type> {
|
||||
/// Implement this to be able to [Give] [Type] from the [TokenIter].
|
||||
/// Advance the stream if returning `Ok<Some<Type>>`.
|
||||
fn give <'source: 'state> (&self, words: TokenIter<'source>) -> Perhaps<Type>;
|
||||
/// Return custom error on [None].
|
||||
fn give_or_fail <'source: 'state, E: Into<Box<dyn std::error::Error>>, F: Fn()->E> (
|
||||
&self, mut words: TokenIter<'source>, error: F
|
||||
) -> Usually<Type> {
|
||||
let next = words.peek().map(|x|x.value).clone();
|
||||
if let Some(value) = Give::<Type>::give(self, words)? {
|
||||
Ok(value)
|
||||
} else {
|
||||
Result::Err(format!("give: {}: {next:?}", error().into()).into())
|
||||
}
|
||||
}
|
||||
}
|
||||
#[macro_export] macro_rules! give {
|
||||
() => {
|
||||
impl<'state, Type: Take<'state, State>, State> Give<'state, Type> for State {
|
||||
fn give <'source: 'state> (&self, mut words:TokenIter<'source>) -> Perhaps<Type> {
|
||||
Type::take(self, words)
|
||||
}
|
||||
}
|
||||
};
|
||||
(box) => {
|
||||
//impl<'state, T, Type: Take<'state, Box<T>>> Give<'state, Box<T>> for Box<Type> {
|
||||
//fn give (&self, mut words:TokenIter<'source>) -> Perhaps<Box<Type>> {
|
||||
//Type::take(self, words)
|
||||
//}
|
||||
//}
|
||||
};
|
||||
($Type:ty: $State:ty) => {
|
||||
impl<'state, $Type: Take<'state, $State>> Give<'state, $Type> for $State {
|
||||
fn give <'source: 'state> (&self, mut words:TokenIter<'source>) -> Perhaps<$Type> {
|
||||
$Type::take(self, words)
|
||||
}
|
||||
}
|
||||
};
|
||||
($Type:ty|$state:ident:$State:ident,$words:ident|$expr:expr) => {
|
||||
impl<'state> Give<'state, $Type> for $State {
|
||||
fn give <'source: 'state> (&self, mut $words:TokenIter<'source>) -> Perhaps<$Type> {
|
||||
let $state = self;
|
||||
$expr
|
||||
}
|
||||
}
|
||||
};
|
||||
($Type:path$(,$Arg:ident)*|$state:ident,$words:ident|$expr:expr) => {
|
||||
impl<'state, State: $(Give<'state, $Arg> +)* 'state $(, $Arg)*> Give<'state, $Type> for State {
|
||||
fn give <'source: 'state> (&self, mut $words:TokenIter<'source>) -> Perhaps<$Type> {
|
||||
let $state = self;
|
||||
$expr
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/// [Give]s instances of [Self] given [TokenIter].
|
||||
pub trait Take<'state, State>: Sized {
|
||||
/// Implement this to be able to [Take] [Self] from the [TokenIter].
|
||||
/// Advance the stream if returning `Ok<Some<Self>>`.
|
||||
fn take <'source: 'state> (state: &State, words: TokenIter<'source>) -> Perhaps<Self>;
|
||||
/// Return custom error on [None].
|
||||
fn take_or_fail <'source: 'state, E: Into<Box<dyn std::error::Error>>, F: Fn()->E> (
|
||||
state: &State, mut words:TokenIter<'source>, error: F
|
||||
) -> Usually<Self> {
|
||||
let next = words.peek().map(|x|x.value).clone();
|
||||
if let Some(value) = Take::<State>::take(state, words)? {
|
||||
Ok(value)
|
||||
} else {
|
||||
Result::Err(format!("take: {}: {next:?}", error().into()).into())
|
||||
}
|
||||
}
|
||||
}
|
||||
#[macro_export] macro_rules! take {
|
||||
() => {
|
||||
impl<'state, Type: 'state, State: Give<'state, Type> + 'state> Take<'state, State> for Type {
|
||||
fn take <'source: 'state> (state: &State, mut words:TokenIter<'source>) -> Perhaps<Self> {
|
||||
state.give(words)
|
||||
}
|
||||
}
|
||||
};
|
||||
(box) => {
|
||||
impl<'state, T, State: Give<'state, Box<T>> + 'state> Take<'state, State> for Box<T> {
|
||||
fn take <'source: 'state> (state: &State, mut words:TokenIter<'source>) -> Perhaps<Self> {
|
||||
state.give(words)
|
||||
}
|
||||
}
|
||||
};
|
||||
($Type:ty:$State:ty) => {
|
||||
impl<'state> Take<'state, $State> for $Type {
|
||||
fn take <'source: 'state> (state: &$State, mut words:TokenIter<'source>) -> Perhaps<Self> {
|
||||
state.give(words)
|
||||
}
|
||||
}
|
||||
};
|
||||
($Type:path$(,$Arg:ident)*|$state:ident,$words:ident|$expr:expr) => {
|
||||
impl<'state,
|
||||
State: Give<'state, bool> + $(Give<'state, $Arg> + )* 'state
|
||||
$(, $Arg: Take<'state, State> + 'state)*
|
||||
> Take<'state, State> for $Type {
|
||||
fn take <'source: 'state> ($state: &State, mut $words:TokenIter<'source>) -> Perhaps<Self> {
|
||||
$expr
|
||||
}
|
||||
}
|
||||
};
|
||||
($Type:path$(,$Arg:ident)*|$state:ident:$State:path,$words:ident|$expr:expr) => {
|
||||
impl<'state $(, $Arg: 'state)*> Take<'state, $State> for $Type {
|
||||
fn take <'source: 'state> ($state: &$State, mut $words:TokenIter<'source>) -> Perhaps<Self> {
|
||||
$expr
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// auto impl graveyard:
|
||||
|
||||
//impl<'state, State: Give<Type>, Type: 'state> Take<'state, State> for Type {
|
||||
//fn take <'state> (state: &State, mut words:TokenIter<'source>)
|
||||
//-> Perhaps<Self>
|
||||
//{
|
||||
//state.take(words)
|
||||
//}
|
||||
//}
|
||||
|
||||
//#[cfg(feature="dsl")]
|
||||
//impl<'state, E: 'state, State: Give<'state, Box<dyn Render<E> + 'state>>>
|
||||
//Take<'state, State> for Box<dyn Render<E> + 'state> {
|
||||
//fn take <'source: 'state> (state: &State, words: TokenIter<'source>) -> Perhaps<Self> {
|
||||
//state.give(words)
|
||||
//}
|
||||
//}
|
||||
|
||||
impl<'state, Type: Take<'state, State>, State> Give<'state, Type> for State {
|
||||
fn give <'source: 'state> (&self, words: TokenIter<'source>) -> Perhaps<Type> {
|
||||
Type::take(self, words)
|
||||
}
|
||||
}
|
||||
|
|
@ -1,110 +0,0 @@
|
|||
use crate::*;
|
||||
|
||||
#[derive(Debug, Copy, Clone, Default, PartialEq)] pub struct Token<'source> {
|
||||
pub source: &'source str,
|
||||
pub start: usize,
|
||||
pub length: usize,
|
||||
pub value: Value<'source>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Copy, Clone, Default, PartialEq)] pub enum Value<'source> {
|
||||
#[default] Nil,
|
||||
Err(DslError),
|
||||
Num(usize),
|
||||
Sym(&'source str),
|
||||
Key(&'source str),
|
||||
Str(&'source str),
|
||||
Exp(usize, TokenIter<'source>),
|
||||
}
|
||||
|
||||
impl<'source> std::fmt::Display for Value<'source> {
|
||||
fn fmt (&self, out: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
|
||||
write!(out, "{}", match self {
|
||||
Nil => String::new(),
|
||||
Err(e) => format!("[error: {e}]"),
|
||||
Num(n) => format!("{n}"),
|
||||
Sym(s) => format!("{s}"),
|
||||
Key(s) => format!("{s}"),
|
||||
Str(s) => format!("{s}"),
|
||||
Exp(_, e) => format!("{e:?}"),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl<'source> Token<'source> {
|
||||
pub const fn new (
|
||||
source: &'source str, start: usize, length: usize, value: Value<'source>
|
||||
) -> Self {
|
||||
Self { source, start, length, value }
|
||||
}
|
||||
pub const fn end (&self) -> usize {
|
||||
self.start.saturating_add(self.length)
|
||||
}
|
||||
pub const fn slice (&'source self) -> &'source str {
|
||||
self.slice_source(self.source)
|
||||
}
|
||||
pub const fn slice_source <'range> (&'source self, source: &'range str) -> &'range str {
|
||||
str_range(source, self.start, self.end())
|
||||
}
|
||||
pub const fn slice_source_exp <'range> (&'source self, source: &'range str) -> &'range str {
|
||||
str_range(source, self.start.saturating_add(1), self.end())
|
||||
}
|
||||
pub const fn with_value (self, value: Value<'source>) -> Self {
|
||||
Self { value, ..self }
|
||||
}
|
||||
pub const fn value (&self) -> Value {
|
||||
self.value
|
||||
}
|
||||
pub const fn error (self, error: DslError) -> Self {
|
||||
Self { value: Value::Err(error), ..self }
|
||||
}
|
||||
pub const fn grow (self) -> Self {
|
||||
Self { length: self.length.saturating_add(1), ..self }
|
||||
}
|
||||
pub const fn grow_num (self, m: usize, c: char) -> Self {
|
||||
match to_digit(c) {
|
||||
Ok(n) => Self { value: Num(10*m+n), ..self.grow() },
|
||||
Result::Err(e) => Self { value: Err(e), ..self.grow() },
|
||||
}
|
||||
}
|
||||
pub const fn grow_key (self) -> Self {
|
||||
let token = self.grow();
|
||||
token.with_value(Key(token.slice_source(self.source)))
|
||||
}
|
||||
pub const fn grow_sym (self) -> Self {
|
||||
let token = self.grow();
|
||||
token.with_value(Sym(token.slice_source(self.source)))
|
||||
}
|
||||
pub const fn grow_str (self) -> Self {
|
||||
let token = self.grow();
|
||||
token.with_value(Str(token.slice_source(self.source)))
|
||||
}
|
||||
pub const fn grow_exp (self) -> Self {
|
||||
let token = self.grow();
|
||||
if let Exp(depth, _) = token.value {
|
||||
token.with_value(Exp(depth, TokenIter::new(token.slice_source_exp(self.source))))
|
||||
} else {
|
||||
unreachable!()
|
||||
}
|
||||
}
|
||||
pub const fn grow_in (self) -> Self {
|
||||
let token = self.grow_exp();
|
||||
if let Value::Exp(depth, source) = token.value {
|
||||
token.with_value(Value::Exp(depth.saturating_add(1), source))
|
||||
} else {
|
||||
unreachable!()
|
||||
}
|
||||
}
|
||||
pub const fn grow_out (self) -> Self {
|
||||
let token = self.grow_exp();
|
||||
if let Value::Exp(depth, source) = token.value {
|
||||
if depth > 0 {
|
||||
token.with_value(Value::Exp(depth - 1, source))
|
||||
} else {
|
||||
return self.error(Unexpected(')'))
|
||||
}
|
||||
} else {
|
||||
unreachable!()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -42,13 +42,12 @@ pub(crate) use std::fmt::Debug;
|
|||
pub(crate) use konst::iter::{ConstIntoIter, IsIteratorKind};
|
||||
pub(crate) use konst::string::{split_at, str_range, char_indices};
|
||||
pub(crate) use thiserror::Error;
|
||||
pub(crate) use self::Value::*;
|
||||
pub(crate) use self::DslError::*;
|
||||
|
||||
mod dsl_ast; pub use self::dsl_ast::*;
|
||||
mod dsl_cst; pub use self::dsl_cst::*;
|
||||
mod dsl_domain; pub use self::dsl_domain::*;
|
||||
mod dsl_error; pub use self::dsl_error::*;
|
||||
mod dsl_token; pub use self::dsl_token::*;
|
||||
mod dsl_parse; pub use self::dsl_parse::*;
|
||||
mod dsl_provide; pub use self::dsl_provide::*;
|
||||
|
||||
#[cfg(test)] mod test_token_iter {
|
||||
use crate::*;
|
||||
|
|
|
|||
|
|
@ -1,138 +1,66 @@
|
|||
use crate::*;
|
||||
use std::marker::PhantomData;
|
||||
|
||||
/// [Input] state that can be matched against a [Value].
|
||||
pub trait DslInput: Input { fn matches_dsl (&self, token: &str) -> bool; }
|
||||
|
||||
/// A pre-configured mapping of input events to commands.
|
||||
pub trait KeyMap<'k, S, C: Take<'k, S> + Command<S>, I: DslInput> {
|
||||
/// Try to find a command that matches the current input event.
|
||||
fn keybind_resolve (&self, state: &S, input: &I) -> Perhaps<C>;
|
||||
/// List of input layers with optional conditional filters.
|
||||
#[derive(Default, Debug)] pub struct InputLayers<S>(Vec<InputLayer<S>>);
|
||||
#[derive(Default, Debug)] pub struct InputLayer<S>{
|
||||
__: PhantomData<S>,
|
||||
condition: Option<Box<dyn Ast>>,
|
||||
bindings: Box<dyn Ast>,
|
||||
}
|
||||
|
||||
/// A [SourceIter] can be a [KeyMap].
|
||||
impl<'k, S, C: Take<'k, S> + Command<S>, I: DslInput> KeyMap<'k, S, C, I> for SourceIter<'k> {
|
||||
fn keybind_resolve (&self, state: &S, input: &I) -> Perhaps<C> {
|
||||
let mut iter = self.clone();
|
||||
while let Some((token, rest)) = iter.next() {
|
||||
iter = rest;
|
||||
match token {
|
||||
Token { value: Value::Exp(0, exp_iter), .. } => {
|
||||
let mut exp_iter = exp_iter.clone();
|
||||
match exp_iter.next() {
|
||||
Some(Token { value: Value::Sym(binding), .. }) => {
|
||||
if input.matches_dsl(binding) {
|
||||
if let Some(command) = Take::take(state, exp_iter)? {
|
||||
impl<S> InputLayers<S> {
|
||||
pub fn new (layer: Box<dyn Ast>) -> Self
|
||||
{ Self(vec![]).layer(layer) }
|
||||
pub fn layer (mut self, layer: Box<dyn Ast>) -> Self
|
||||
{ self.add_layer(layer); self }
|
||||
pub fn layer_if (mut self, condition: Box<dyn Ast>, layer: Box<dyn Ast>) -> Self
|
||||
{ self.add_layer_if(Some(condition), layer); self }
|
||||
pub fn add_layer (&mut self, layer: Box<dyn Ast>) -> &mut Self
|
||||
{ self.add_layer_if(None, layer.into()); self }
|
||||
pub fn add_layer_if (
|
||||
&mut self,
|
||||
condition: Option<Box<dyn Ast>>,
|
||||
bindings: Box<dyn Ast>
|
||||
) -> &mut Self {
|
||||
self.0.push(InputLayer { condition, bindings, __: Default::default() });
|
||||
self
|
||||
}
|
||||
}
|
||||
impl<S: Eval<I, O>, I: Input, O: Command<S>> Eval<I, O> for InputLayers<S> {
|
||||
fn eval (&self, input: I) -> Perhaps<O> {
|
||||
for layer in self.0.iter() {
|
||||
if let Some(command) = Ok(if let Some(condition) = layer.condition.as_ref() {
|
||||
if self.matches(condition)? {
|
||||
self.state().eval(*self)?
|
||||
} else {
|
||||
None
|
||||
}
|
||||
} else {
|
||||
self.state().eval(*self)?
|
||||
})? {
|
||||
return Ok(Some(command))
|
||||
}
|
||||
}
|
||||
},
|
||||
_ => panic!("invalid config (expected symbol)")
|
||||
}
|
||||
},
|
||||
_ => panic!("invalid config (expected expression)")
|
||||
}
|
||||
}
|
||||
Ok(None)
|
||||
}
|
||||
}
|
||||
|
||||
/// A [TokenIter] can be a [KeyMap].
|
||||
impl<'k, S, C: Take<'k, S> + Command<S>, I: DslInput> KeyMap<'k, S, C, I> for TokenIter<'k> {
|
||||
fn keybind_resolve (&self, state: &S, input: &I) -> Perhaps<C> {
|
||||
let mut iter = self.clone();
|
||||
while let Some(next) = iter.next() {
|
||||
match next {
|
||||
Token { value: Value::Exp(0, exp_iter), .. } => {
|
||||
let mut e = exp_iter.clone();
|
||||
match e.next() {
|
||||
Some(Token { value: Value::Sym(binding), .. }) => {
|
||||
if input.matches_dsl(binding) {
|
||||
if let Some(command) = Take::take(state, e)? {
|
||||
return Ok(Some(command))
|
||||
}
|
||||
}
|
||||
},
|
||||
_ => panic!("invalid config (expected symbol, got: {exp_iter:?})")
|
||||
}
|
||||
},
|
||||
_ => panic!("invalid config (expected expression, got: {next:?})")
|
||||
}
|
||||
}
|
||||
Ok(None)
|
||||
}
|
||||
}
|
||||
|
||||
pub type InputCondition<'k, S> = Box<dyn Fn(&S)->Usually<bool> + Send + Sync + 'k>;
|
||||
|
||||
/// A collection of pre-configured mappings of input events to commands,
|
||||
/// which may be made available subject to given conditions.
|
||||
pub struct InputMap<'k,
|
||||
S,
|
||||
C: Command<S> + Take<'k, S>,
|
||||
I: DslInput,
|
||||
M: KeyMap<'k, S, C, I>
|
||||
> {
|
||||
__: PhantomData<&'k (S, C, I)>,
|
||||
pub layers: Vec<(InputCondition<'k, S>, M)>,
|
||||
}
|
||||
|
||||
impl<'k,
|
||||
S,
|
||||
C: Command<S> + Take<'k, S>,
|
||||
I: DslInput,
|
||||
M: KeyMap<'k, S, C, I>
|
||||
> Default for InputMap<'k, S, C, I, M>{
|
||||
fn default () -> Self {
|
||||
Self { __: PhantomData, layers: vec![] }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'k, S, C: Command<S> + Take<'k, S>, I: DslInput, M: KeyMap<'k, S, C, I>>
|
||||
InputMap<'k, S, C, I, M> {
|
||||
pub fn new (keymap: M) -> Self {
|
||||
Self::default().layer(keymap)
|
||||
}
|
||||
pub fn layer (mut self, keymap: M) -> Self {
|
||||
self.add_layer(keymap);
|
||||
self
|
||||
}
|
||||
pub fn add_layer (&mut self, keymap: M) -> &mut Self {
|
||||
self.add_layer_if(Box::new(|_|Ok(true)), keymap);
|
||||
self
|
||||
}
|
||||
pub fn layer_if (mut self, condition: InputCondition<'k, S>, keymap: M) -> Self {
|
||||
self.add_layer_if(condition, keymap);
|
||||
self
|
||||
}
|
||||
pub fn add_layer_if (&mut self, condition: InputCondition<'k, S>, keymap: M) -> &mut Self {
|
||||
self.layers.push((Box::new(condition), keymap));
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
impl<'k, S, C: Command<S> + Take<'k, S>, I: DslInput, M: KeyMap<'k, S, C, I>>
|
||||
std::fmt::Debug for InputMap<'k, S, C, I, M> {
|
||||
fn fmt (&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
|
||||
write!(f, "[InputMap: {} layer(s)]", self.layers.len())
|
||||
}
|
||||
}
|
||||
|
||||
/// An [InputMap] can be a [KeyMap].
|
||||
impl<'k,
|
||||
S,
|
||||
C: Command<S> + Take<'k, S>,
|
||||
I: DslInput,
|
||||
M: KeyMap<'k, S, C, I>
|
||||
> KeyMap<'k, S, C, I> for InputMap<'k, S, C, I, M> {
|
||||
fn keybind_resolve (&self, state: &S, input: &I) -> Perhaps<C> {
|
||||
for (condition, keymap) in self.layers.iter() {
|
||||
if !condition(state)? {
|
||||
continue
|
||||
}
|
||||
if let Some(command) = keymap.keybind_resolve(state, input)? {
|
||||
return Ok(Some(command))
|
||||
}
|
||||
/// [Input] state that can be matched against a [CstValue].
|
||||
pub trait InputState<S>: Input {
|
||||
fn state (&self) -> &S;
|
||||
fn matches (&self, condition: &Box<dyn Ast>) -> Usually<bool>;
|
||||
}
|
||||
impl<S: Eval<I, O>, I: InputState<S>, O: Command<S>> Eval<I, O>
|
||||
for InputLayer<S> {
|
||||
fn eval (&self, input: I) -> Perhaps<O> {
|
||||
if let Some(AstToken::Exp(exp)) = iter.peek() {
|
||||
let mut e = exp.clone();
|
||||
if let Some(AstToken::Sym(binding)) = e.next()
|
||||
&& input.matches_dsl(binding)
|
||||
&& let Some(command) = Dsl::from_dsl(input.state(), e)? {
|
||||
return Ok(Some(command))
|
||||
} else {
|
||||
unreachable!("InputLayer: expected symbol, got: {e:?}")
|
||||
}
|
||||
} else {
|
||||
panic!("InputLayer: expected expression, got: {self:?}")
|
||||
}
|
||||
Ok(None)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,8 +3,16 @@
|
|||
#![feature(impl_trait_in_assoc_type)]
|
||||
pub(crate) use tengri_core::*;
|
||||
pub(crate) use std::marker::PhantomData;
|
||||
#[cfg(feature = "dsl")] pub(crate) use ::tengri_dsl::*;
|
||||
|
||||
#[cfg(feature = "dsl")]
|
||||
pub(crate) use ::tengri_dsl::*;
|
||||
|
||||
mod space; pub use self::space::*;
|
||||
|
||||
mod ops; pub use self::ops::*;
|
||||
|
||||
#[cfg(feature = "dsl")] mod ops_dsl;
|
||||
|
||||
mod output; pub use self::output::*;
|
||||
|
||||
#[cfg(test)] mod test;
|
||||
|
|
|
|||
|
|
@ -1,10 +1,382 @@
|
|||
//mod reduce; pub use self::reduce::*;
|
||||
mod align; pub use self::align::*;
|
||||
mod bsp; pub use self::bsp::*;
|
||||
mod either; pub use self::either::*;
|
||||
//! Transform:
|
||||
//! ```
|
||||
//! use ::tengri::{output::*, tui::*};
|
||||
//! let area: [u16;4] = [10, 10, 20, 20];
|
||||
//! fn test (area: [u16;4], item: &impl Content<TuiOut>, expected: [u16;4]) {
|
||||
//! assert_eq!(Content::layout(item, area), expected);
|
||||
//! assert_eq!(Render::layout(item, area), expected);
|
||||
//! };
|
||||
//! test(area, &(), [20, 20, 0, 0]);
|
||||
//!
|
||||
//! test(area, &Fill::xy(()), area);
|
||||
//! test(area, &Fill::x(()), [10, 20, 20, 0]);
|
||||
//! test(area, &Fill::y(()), [20, 10, 0, 20]);
|
||||
//!
|
||||
//! //FIXME:test(area, &Fixed::x(4, ()), [18, 20, 4, 0]);
|
||||
//! //FIXME:test(area, &Fixed::y(4, ()), [20, 18, 0, 4]);
|
||||
//! //FIXME:test(area, &Fixed::xy(4, 4, unit), [18, 18, 4, 4]);
|
||||
//! ```
|
||||
//! Align:
|
||||
//! ```
|
||||
//! use ::tengri::{output::*, tui::*};
|
||||
//! let area: [u16;4] = [10, 10, 20, 20];
|
||||
//! fn test (area: [u16;4], item: &impl Content<TuiOut>, expected: [u16;4]) {
|
||||
//! assert_eq!(Content::layout(item, area), expected);
|
||||
//! assert_eq!(Render::layout(item, area), expected);
|
||||
//! };
|
||||
//!
|
||||
//! let four = ||Fixed::xy(4, 4, "");
|
||||
//! test(area, &Align::nw(four()), [10, 10, 4, 4]);
|
||||
//! test(area, &Align::n(four()), [18, 10, 4, 4]);
|
||||
//! test(area, &Align::ne(four()), [26, 10, 4, 4]);
|
||||
//! test(area, &Align::e(four()), [26, 18, 4, 4]);
|
||||
//! test(area, &Align::se(four()), [26, 26, 4, 4]);
|
||||
//! test(area, &Align::s(four()), [18, 26, 4, 4]);
|
||||
//! test(area, &Align::sw(four()), [10, 26, 4, 4]);
|
||||
//! test(area, &Align::w(four()), [10, 18, 4, 4]);
|
||||
//!
|
||||
//! let two_by_four = ||Fixed::xy(4, 2, "");
|
||||
//! test(area, &Align::nw(two_by_four()), [10, 10, 4, 2]);
|
||||
//! test(area, &Align::n(two_by_four()), [18, 10, 4, 2]);
|
||||
//! test(area, &Align::ne(two_by_four()), [26, 10, 4, 2]);
|
||||
//! test(area, &Align::e(two_by_four()), [26, 19, 4, 2]);
|
||||
//! test(area, &Align::se(two_by_four()), [26, 28, 4, 2]);
|
||||
//! test(area, &Align::s(two_by_four()), [18, 28, 4, 2]);
|
||||
//! test(area, &Align::sw(two_by_four()), [10, 28, 4, 2]);
|
||||
//! test(area, &Align::w(two_by_four()), [10, 19, 4, 2]);
|
||||
//! ```
|
||||
|
||||
use crate::*;
|
||||
use Direction::*;
|
||||
|
||||
mod map; pub use self::map::*;
|
||||
mod memo; pub use self::memo::*;
|
||||
mod stack; pub use self::stack::*;
|
||||
mod thunk; pub use self::thunk::*;
|
||||
mod transform; pub use self::transform::*;
|
||||
mod when; pub use self::when::*;
|
||||
|
||||
/// Renders multiple things on top of each other,
|
||||
#[macro_export] macro_rules! lay {
|
||||
($($expr:expr),* $(,)?) => {{ let bsp = (); $(let bsp = Bsp::b(bsp, $expr);)*; bsp }}
|
||||
}
|
||||
|
||||
/// Stack southward.
|
||||
#[macro_export] macro_rules! col {
|
||||
($($expr:expr),* $(,)?) => {{ let bsp = (); $(let bsp = Bsp::s(bsp, $expr);)*; bsp }};
|
||||
}
|
||||
|
||||
/// Stack northward.
|
||||
#[macro_export] macro_rules! col_up {
|
||||
($($expr:expr),* $(,)?) => {{ let bsp = (); $(let bsp = Bsp::n(bsp, $expr);)*; bsp }}
|
||||
}
|
||||
|
||||
/// Stack eastward.
|
||||
#[macro_export] macro_rules! row {
|
||||
($($expr:expr),* $(,)?) => {{ let bsp = (); $(let bsp = Bsp::e(bsp, $expr);)*; bsp }};
|
||||
}
|
||||
|
||||
/// Show an item only when a condition is true.
|
||||
pub struct When<A>(pub bool, pub A);
|
||||
impl<A> When<A> {
|
||||
/// Create a binary condition.
|
||||
pub const fn new (c: bool, a: A) -> Self { Self(c, a) }
|
||||
}
|
||||
impl<E: Output, A: Render<E>> Content<E> for When<A> {
|
||||
fn layout (&self, to: E::Area) -> E::Area {
|
||||
let Self(cond, item) = self;
|
||||
let mut area = E::Area::zero();
|
||||
if *cond {
|
||||
let item_area = item.layout(to);
|
||||
area[0] = item_area.x();
|
||||
area[1] = item_area.y();
|
||||
area[2] = item_area.w();
|
||||
area[3] = item_area.h();
|
||||
}
|
||||
area.into()
|
||||
}
|
||||
fn render (&self, to: &mut E) {
|
||||
let Self(cond, item) = self;
|
||||
if *cond { item.render(to) }
|
||||
}
|
||||
}
|
||||
|
||||
/// Show one item if a condition is true and another if the condition is false
|
||||
pub struct Either<A, B>(pub bool, pub A, pub B);
|
||||
impl<A, B> Either<A, B> {
|
||||
/// Create a ternary view condition.
|
||||
pub const fn new (c: bool, a: A, b: B) -> Self { Self(c, a, b) }
|
||||
}
|
||||
impl<E: Output, A: Render<E>, B: Render<E>> Content<E> for Either<A, B> {
|
||||
fn layout (&self, to: E::Area) -> E::Area {
|
||||
let Self(cond, a, b) = self;
|
||||
if *cond { a.layout(to) } else { b.layout(to) }
|
||||
}
|
||||
fn render (&self, to: &mut E) {
|
||||
let Self(cond, a, b) = self;
|
||||
if *cond { a.render(to) } else { b.render(to) }
|
||||
}
|
||||
}
|
||||
|
||||
/// 9th of area to place.
|
||||
#[derive(Debug, Copy, Clone, Default)]
|
||||
pub enum Alignment { #[default] Center, X, Y, NW, N, NE, E, SE, S, SW, W }
|
||||
|
||||
pub struct Align<A>(Alignment, A);
|
||||
|
||||
impl<A> Align<A> {
|
||||
#[inline] pub const fn c (a: A) -> Self { Self(Alignment::Center, a) }
|
||||
#[inline] pub const fn x (a: A) -> Self { Self(Alignment::X, a) }
|
||||
#[inline] pub const fn y (a: A) -> Self { Self(Alignment::Y, a) }
|
||||
#[inline] pub const fn n (a: A) -> Self { Self(Alignment::N, a) }
|
||||
#[inline] pub const fn s (a: A) -> Self { Self(Alignment::S, a) }
|
||||
#[inline] pub const fn e (a: A) -> Self { Self(Alignment::E, a) }
|
||||
#[inline] pub const fn w (a: A) -> Self { Self(Alignment::W, a) }
|
||||
#[inline] pub const fn nw (a: A) -> Self { Self(Alignment::NW, a) }
|
||||
#[inline] pub const fn sw (a: A) -> Self { Self(Alignment::SW, a) }
|
||||
#[inline] pub const fn ne (a: A) -> Self { Self(Alignment::NE, a) }
|
||||
#[inline] pub const fn se (a: A) -> Self { Self(Alignment::SE, a) }
|
||||
}
|
||||
|
||||
impl<E: Output, A: Content<E>> Content<E> for Align<A> {
|
||||
fn content (&self) -> impl Render<E> + '_ {
|
||||
&self.1
|
||||
}
|
||||
fn layout (&self, on: E::Area) -> E::Area {
|
||||
use Alignment::*;
|
||||
let it = Render::layout(&self.content(), on).xywh();
|
||||
let cx = on.x()+(on.w().minus(it.w())/2.into());
|
||||
let cy = on.y()+(on.h().minus(it.h())/2.into());
|
||||
let fx = (on.x()+on.w()).minus(it.w());
|
||||
let fy = (on.y()+on.h()).minus(it.h());
|
||||
let [x, y] = match self.0 {
|
||||
Center => [cx, cy],
|
||||
X => [cx, it.y()],
|
||||
Y => [it.x(), cy],
|
||||
NW => [on.x(), on.y()],
|
||||
N => [cx, on.y()],
|
||||
NE => [fx, on.y()],
|
||||
W => [on.x(), cy],
|
||||
E => [fx, cy],
|
||||
SW => [on.x(), fy],
|
||||
S => [cx, fy],
|
||||
SE => [fx, fy],
|
||||
}.into();
|
||||
[x, y, it.w(), it.h()].into()
|
||||
}
|
||||
fn render (&self, to: &mut E) {
|
||||
to.place(Content::layout(self, to.area()), &self.content())
|
||||
}
|
||||
}
|
||||
|
||||
/// A split or layer.
|
||||
pub struct Bsp<A, B>(
|
||||
pub(crate) Direction,
|
||||
pub(crate) A,
|
||||
pub(crate) B,
|
||||
);
|
||||
impl<A, B> Bsp<A, B> {
|
||||
#[inline] pub const fn n (a: A, b: B) -> Self { Self(North, a, b) }
|
||||
#[inline] pub const fn s (a: A, b: B) -> Self { Self(South, a, b) }
|
||||
#[inline] pub const fn e (a: A, b: B) -> Self { Self(East, a, b) }
|
||||
#[inline] pub const fn w (a: A, b: B) -> Self { Self(West, a, b) }
|
||||
#[inline] pub const fn a (a: A, b: B) -> Self { Self(Above, a, b) }
|
||||
#[inline] pub const fn b (a: A, b: B) -> Self { Self(Below, a, b) }
|
||||
}
|
||||
impl<E: Output, A: Content<E>, B: Content<E>> Content<E> for Bsp<A, B> {
|
||||
fn layout (&self, outer: E::Area) -> E::Area { let [_, _, c] = self.areas(outer); c }
|
||||
fn render (&self, to: &mut E) {
|
||||
let [area_a, area_b, _] = self.areas(to.area());
|
||||
let (a, b) = self.contents();
|
||||
match self.0 {
|
||||
Below => { to.place(area_a, a); to.place(area_b, b); },
|
||||
_ => { to.place(area_b, b); to.place(area_a, a); }
|
||||
}
|
||||
}
|
||||
}
|
||||
impl<E: Output, A: Content<E>, B: Content<E>> BspAreas<E, A, B> for Bsp<A, B> {
|
||||
fn direction (&self) -> Direction { self.0 }
|
||||
fn contents (&self) -> (&A, &B) { (&self.1, &self.2) }
|
||||
}
|
||||
pub trait BspAreas<E: Output, A: Content<E>, B: Content<E>> {
|
||||
fn direction (&self) -> Direction;
|
||||
fn contents (&self) -> (&A, &B);
|
||||
fn areas (&self, outer: E::Area) -> [E::Area;3] {
|
||||
let direction = self.direction();
|
||||
let [x, y, w, h] = outer.xywh();
|
||||
let (a, b) = self.contents();
|
||||
let [aw, ah] = a.layout(outer).wh();
|
||||
let [bw, bh] = b.layout(match direction {
|
||||
Above | Below => outer,
|
||||
South => [x, y + ah, w, h.minus(ah)].into(),
|
||||
North => [x, y, w, h.minus(ah)].into(),
|
||||
East => [x + aw, y, w.minus(aw), h].into(),
|
||||
West => [x, y, w.minus(aw), h].into(),
|
||||
}).wh();
|
||||
match direction {
|
||||
Above | Below => {
|
||||
let [x, y, w, h] = outer.center_xy([aw.max(bw), ah.max(bh)]);
|
||||
let a = [(x + w/2.into()).minus(aw/2.into()), (y + h/2.into()).minus(ah/2.into()), aw, ah];
|
||||
let b = [(x + w/2.into()).minus(bw/2.into()), (y + h/2.into()).minus(bh/2.into()), bw, bh];
|
||||
[a.into(), b.into(), [x, y, w, h].into()]
|
||||
},
|
||||
South => {
|
||||
let [x, y, w, h] = outer.center_xy([aw.max(bw), ah + bh]);
|
||||
let a = [(x + w/2.into()).minus(aw/2.into()), y, aw, ah];
|
||||
let b = [(x + w/2.into()).minus(bw/2.into()), y + ah, bw, bh];
|
||||
[a.into(), b.into(), [x, y, w, h].into()]
|
||||
},
|
||||
North => {
|
||||
let [x, y, w, h] = outer.center_xy([aw.max(bw), ah + bh]);
|
||||
let a = [(x + (w/2.into())).minus(aw/2.into()), y + bh, aw, ah];
|
||||
let b = [(x + (w/2.into())).minus(bw/2.into()), y, bw, bh];
|
||||
[a.into(), b.into(), [x, y, w, h].into()]
|
||||
},
|
||||
East => {
|
||||
let [x, y, w, h] = outer.center_xy([aw + bw, ah.max(bh)]);
|
||||
let a = [x, (y + h/2.into()).minus(ah/2.into()), aw, ah];
|
||||
let b = [x + aw, (y + h/2.into()).minus(bh/2.into()), bw, bh];
|
||||
[a.into(), b.into(), [x, y, w, h].into()]
|
||||
},
|
||||
West => {
|
||||
let [x, y, w, h] = outer.center_xy([aw + bw, ah.max(bh)]);
|
||||
let a = [x + bw, (y + h/2.into()).minus(ah/2.into()), aw, ah];
|
||||
let b = [x, (y + h/2.into()).minus(bh/2.into()), bw, bh];
|
||||
[a.into(), b.into(), [x, y, w, h].into()]
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Defines an enum that transforms its content
|
||||
/// along either the X axis, the Y axis, or both.
|
||||
macro_rules! transform_xy {
|
||||
($x:literal $y:literal $xy:literal |$self:ident : $Enum:ident, $to:ident|$area:expr) => {
|
||||
pub enum $Enum<A> { X(A), Y(A), XY(A) }
|
||||
impl<A> $Enum<A> {
|
||||
#[inline] pub const fn x (item: A) -> Self { Self::X(item) }
|
||||
#[inline] pub const fn y (item: A) -> Self { Self::Y(item) }
|
||||
#[inline] pub const fn xy (item: A) -> Self { Self::XY(item) }
|
||||
}
|
||||
impl<E: Output, T: Content<E>> Content<E> for $Enum<T> {
|
||||
fn content (&self) -> impl Render<E> + '_ {
|
||||
match self {
|
||||
Self::X(item) => item,
|
||||
Self::Y(item) => item,
|
||||
Self::XY(item) => item,
|
||||
}
|
||||
}
|
||||
fn layout (&$self, $to: <E as Output>::Area) -> <E as Output>::Area {
|
||||
use $Enum::*;
|
||||
$area
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Defines an enum that parametrically transforms its content
|
||||
/// along either the X axis, the Y axis, or both.
|
||||
macro_rules! transform_xy_unit {
|
||||
($x:literal $y:literal $xy:literal |$self:ident : $Enum:ident, $to:ident|$layout:expr) => {
|
||||
pub enum $Enum<U, A> { X(U, A), Y(U, A), XY(U, U, A), }
|
||||
impl<U, A> $Enum<U, A> {
|
||||
#[inline] pub const fn x (x: U, item: A) -> Self { Self::X(x, item) }
|
||||
#[inline] pub const fn y (y: U, item: A) -> Self { Self::Y(y, item) }
|
||||
#[inline] pub const fn xy (x: U, y: U, item: A) -> Self { Self::XY(x, y, item) }
|
||||
}
|
||||
impl<E: Output, T: Content<E>> Content<E> for $Enum<E::Unit, T> {
|
||||
fn layout (&$self, $to: E::Area) -> E::Area {
|
||||
$layout.into()
|
||||
}
|
||||
fn content (&self) -> impl Render<E> + '_ {
|
||||
use $Enum::*;
|
||||
Some(match self { X(_, c) => c, Y(_, c) => c, XY(_, _, c) => c, })
|
||||
}
|
||||
}
|
||||
impl<U: Coordinate, T> $Enum<U, T> {
|
||||
#[inline] pub fn dx (&self) -> U {
|
||||
use $Enum::*;
|
||||
match self { X(x, _) => *x, Y(_, _) => 0.into(), XY(x, _, _) => *x, }
|
||||
}
|
||||
#[inline] pub fn dy (&self) -> U {
|
||||
use $Enum::*;
|
||||
match self { X(_, _) => 0.into(), Y(y, _) => *y, XY(_, y, _) => *y, }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
transform_xy!("fill/x" "fill/y" "fill/xy" |self: Fill, to|{
|
||||
let [x0, y0, wmax, hmax] = to.xywh();
|
||||
let [x, y, w, h] = self.content().layout(to).xywh();
|
||||
match self {
|
||||
X(_) => [x0, y, wmax, h],
|
||||
Y(_) => [x, y0, w, hmax],
|
||||
XY(_) => [x0, y0, wmax, hmax],
|
||||
}.into()
|
||||
});
|
||||
|
||||
transform_xy_unit!("fixed/x" "fixed/y" "fixed/xy"|self: Fixed, area|{
|
||||
let [x, y, w, h] = area.xywh();
|
||||
let fixed_area = match self {
|
||||
Self::X(fw, _) => [x, y, *fw, h],
|
||||
Self::Y(fh, _) => [x, y, w, *fh],
|
||||
Self::XY(fw, fh, _) => [x, y, *fw, *fh],
|
||||
};
|
||||
let [x, y, w, h] = Render::layout(&self.content(), fixed_area.into()).xywh();
|
||||
let fixed_area = match self {
|
||||
Self::X(fw, _) => [x, y, *fw, h],
|
||||
Self::Y(fh, _) => [x, y, w, *fh],
|
||||
Self::XY(fw, fh, _) => [x, y, *fw, *fh],
|
||||
};
|
||||
fixed_area
|
||||
});
|
||||
|
||||
transform_xy_unit!("min/x" "min/y" "min/xy"|self: Min, area|{
|
||||
let area = Render::layout(&self.content(), area);
|
||||
match self {
|
||||
Self::X(mw, _) => [area.x(), area.y(), area.w().max(*mw), area.h()],
|
||||
Self::Y(mh, _) => [area.x(), area.y(), area.w(), area.h().max(*mh)],
|
||||
Self::XY(mw, mh, _) => [area.x(), area.y(), area.w().max(*mw), area.h().max(*mh)],
|
||||
}
|
||||
});
|
||||
|
||||
transform_xy_unit!("max/x" "max/y" "max/xy"|self: Max, area|{
|
||||
let [x, y, w, h] = area.xywh();
|
||||
Render::layout(&self.content(), match self {
|
||||
Self::X(fw, _) => [x, y, *fw, h],
|
||||
Self::Y(fh, _) => [x, y, w, *fh],
|
||||
Self::XY(fw, fh, _) => [x, y, *fw, *fh],
|
||||
}.into())
|
||||
});
|
||||
|
||||
transform_xy_unit!("shrink/x" "shrink/y" "shrink/xy"|self: Shrink, area|Render::layout(
|
||||
&self.content(),
|
||||
[area.x(), area.y(), area.w().minus(self.dx()), area.h().minus(self.dy())].into()));
|
||||
|
||||
transform_xy_unit!("expand/x" "expand/y" "expand/xy"|self: Expand, area|Render::layout(
|
||||
&self.content(),
|
||||
[area.x(), area.y(), area.w().plus(self.dx()), area.h().plus(self.dy())].into()));
|
||||
|
||||
transform_xy_unit!("push/x" "push/y" "push/xy"|self: Push, area|{
|
||||
let area = Render::layout(&self.content(), area);
|
||||
[area.x().plus(self.dx()), area.y().plus(self.dy()), area.w(), area.h()]
|
||||
});
|
||||
|
||||
transform_xy_unit!("pull/x" "pull/y" "pull/xy"|self: Pull, area|{
|
||||
let area = Render::layout(&self.content(), area);
|
||||
[area.x().minus(self.dx()), area.y().minus(self.dy()), area.w(), area.h()]
|
||||
});
|
||||
|
||||
transform_xy_unit!("margin/x" "margin/y" "margin/xy"|self: Margin, area|{
|
||||
let area = Render::layout(&self.content(), area);
|
||||
let dx = self.dx();
|
||||
let dy = self.dy();
|
||||
[area.x().minus(dx), area.y().minus(dy), area.w().plus(dy.plus(dy)), area.h().plus(dy.plus(dy))]
|
||||
});
|
||||
|
||||
transform_xy_unit!("padding/x" "padding/y" "padding/xy"|self: Padding, area|{
|
||||
let area = Render::layout(&self.content(), area);
|
||||
let dx = self.dx();
|
||||
let dy = self.dy();
|
||||
[area.x().plus(dx), area.y().plus(dy), area.w().minus(dy.plus(dy)), area.h().minus(dy.plus(dy))]
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1,110 +0,0 @@
|
|||
//! Aligns things to the container. Comes with caveats.
|
||||
//! ```
|
||||
//! use ::tengri::{output::*, tui::*};
|
||||
//! let area: [u16;4] = [10, 10, 20, 20];
|
||||
//! fn test (area: [u16;4], item: &impl Content<TuiOut>, expected: [u16;4]) {
|
||||
//! assert_eq!(Content::layout(item, area), expected);
|
||||
//! assert_eq!(Render::layout(item, area), expected);
|
||||
//! };
|
||||
//!
|
||||
//! let four = ||Fixed::xy(4, 4, "");
|
||||
//! test(area, &Align::nw(four()), [10, 10, 4, 4]);
|
||||
//! test(area, &Align::n(four()), [18, 10, 4, 4]);
|
||||
//! test(area, &Align::ne(four()), [26, 10, 4, 4]);
|
||||
//! test(area, &Align::e(four()), [26, 18, 4, 4]);
|
||||
//! test(area, &Align::se(four()), [26, 26, 4, 4]);
|
||||
//! test(area, &Align::s(four()), [18, 26, 4, 4]);
|
||||
//! test(area, &Align::sw(four()), [10, 26, 4, 4]);
|
||||
//! test(area, &Align::w(four()), [10, 18, 4, 4]);
|
||||
//!
|
||||
//! let two_by_four = ||Fixed::xy(4, 2, "");
|
||||
//! test(area, &Align::nw(two_by_four()), [10, 10, 4, 2]);
|
||||
//! test(area, &Align::n(two_by_four()), [18, 10, 4, 2]);
|
||||
//! test(area, &Align::ne(two_by_four()), [26, 10, 4, 2]);
|
||||
//! test(area, &Align::e(two_by_four()), [26, 19, 4, 2]);
|
||||
//! test(area, &Align::se(two_by_four()), [26, 28, 4, 2]);
|
||||
//! test(area, &Align::s(two_by_four()), [18, 28, 4, 2]);
|
||||
//! test(area, &Align::sw(two_by_four()), [10, 28, 4, 2]);
|
||||
//! test(area, &Align::w(two_by_four()), [10, 19, 4, 2]);
|
||||
//! ```
|
||||
use crate::*;
|
||||
#[derive(Debug, Copy, Clone, Default)]
|
||||
pub enum Alignment { #[default] Center, X, Y, NW, N, NE, E, SE, S, SW, W }
|
||||
pub struct Align<A>(Alignment, A);
|
||||
#[cfg(feature = "dsl")]
|
||||
impl<'state, State: Give<'state, A>, A: 'state> Take<'state, State> for Align<A> {
|
||||
fn take <'source: 'state> (state: &State, words: TokenIter<'source>) -> Perhaps<Self> {
|
||||
todo!()
|
||||
}
|
||||
}
|
||||
//give!(Align<A>, A|state, words|Ok(Some(match words.peek() {
|
||||
//Some(Token { value: Value::Key(key), .. }) => match key {
|
||||
//"align/c"|"align/x"|"align/y"|
|
||||
//"align/n"|"align/s"|"align/e"|"al;qign/w"|
|
||||
//"align/nw"|"align/sw"|"align/ne"|"align/se" => {
|
||||
//let _ = words.next().unwrap();
|
||||
//let content = Take::take_or_fail(state, &mut words.clone(), ||"expected content")?;
|
||||
//match key {
|
||||
//"align/c" => Self::c(content),
|
||||
//"align/x" => Self::x(content),
|
||||
//"align/y" => Self::y(content),
|
||||
//"align/n" => Self::n(content),
|
||||
//"align/s" => Self::s(content),
|
||||
//"align/e" => Self::e(content),
|
||||
//"align/w" => Self::w(content),
|
||||
//"align/nw" => Self::nw(content),
|
||||
//"align/ne" => Self::ne(content),
|
||||
//"align/sw" => Self::sw(content),
|
||||
//"align/se" => Self::se(content),
|
||||
//_ => unreachable!()
|
||||
//}
|
||||
//},
|
||||
//_ => return Ok(None)
|
||||
//},
|
||||
//_ => return Ok(None)
|
||||
//})));
|
||||
|
||||
impl<A> Align<A> {
|
||||
#[inline] pub const fn c (a: A) -> Self { Self(Alignment::Center, a) }
|
||||
#[inline] pub const fn x (a: A) -> Self { Self(Alignment::X, a) }
|
||||
#[inline] pub const fn y (a: A) -> Self { Self(Alignment::Y, a) }
|
||||
#[inline] pub const fn n (a: A) -> Self { Self(Alignment::N, a) }
|
||||
#[inline] pub const fn s (a: A) -> Self { Self(Alignment::S, a) }
|
||||
#[inline] pub const fn e (a: A) -> Self { Self(Alignment::E, a) }
|
||||
#[inline] pub const fn w (a: A) -> Self { Self(Alignment::W, a) }
|
||||
#[inline] pub const fn nw (a: A) -> Self { Self(Alignment::NW, a) }
|
||||
#[inline] pub const fn sw (a: A) -> Self { Self(Alignment::SW, a) }
|
||||
#[inline] pub const fn ne (a: A) -> Self { Self(Alignment::NE, a) }
|
||||
#[inline] pub const fn se (a: A) -> Self { Self(Alignment::SE, a) }
|
||||
}
|
||||
|
||||
impl<E: Output, A: Content<E>> Content<E> for Align<A> {
|
||||
fn content (&self) -> impl Render<E> + '_ {
|
||||
&self.1
|
||||
}
|
||||
fn layout (&self, on: E::Area) -> E::Area {
|
||||
use Alignment::*;
|
||||
let it = Render::layout(&self.content(), on).xywh();
|
||||
let cx = on.x()+(on.w().minus(it.w())/2.into());
|
||||
let cy = on.y()+(on.h().minus(it.h())/2.into());
|
||||
let fx = (on.x()+on.w()).minus(it.w());
|
||||
let fy = (on.y()+on.h()).minus(it.h());
|
||||
let [x, y] = match self.0 {
|
||||
Center => [cx, cy],
|
||||
X => [cx, it.y()],
|
||||
Y => [it.x(), cy],
|
||||
NW => [on.x(), on.y()],
|
||||
N => [cx, on.y()],
|
||||
NE => [fx, on.y()],
|
||||
W => [on.x(), cy],
|
||||
E => [fx, cy],
|
||||
SW => [on.x(), fy],
|
||||
S => [cx, fy],
|
||||
SE => [fx, fy],
|
||||
}.into();
|
||||
[x, y, it.w(), it.h()].into()
|
||||
}
|
||||
fn render (&self, to: &mut E) {
|
||||
to.place(Content::layout(self, to.area()), &self.content())
|
||||
}
|
||||
}
|
||||
|
|
@ -1,122 +0,0 @@
|
|||
use crate::*;
|
||||
pub use Direction::*;
|
||||
/// A split or layer.
|
||||
pub struct Bsp<A, B>(
|
||||
pub(crate) Direction,
|
||||
pub(crate) A,
|
||||
pub(crate) B,
|
||||
);
|
||||
impl<E: Output, A: Content<E>, B: Content<E>> Content<E> for Bsp<A, B> {
|
||||
fn layout (&self, outer: E::Area) -> E::Area {
|
||||
let [_, _, c] = self.areas(outer);
|
||||
c
|
||||
}
|
||||
fn render (&self, to: &mut E) {
|
||||
let [area_a, area_b, _] = self.areas(to.area());
|
||||
let (a, b) = self.contents();
|
||||
match self.0 {
|
||||
Below => { to.place(area_a, a); to.place(area_b, b); },
|
||||
_ => { to.place(area_b, b); to.place(area_a, a); }
|
||||
}
|
||||
}
|
||||
}
|
||||
#[cfg(feature = "dsl")] take!(Bsp<A, B>, A, B|state, words|Ok(if let Some(Token {
|
||||
value: Value::Key("bsp/n"|"bsp/s"|"bsp/e"|"bsp/w"|"bsp/a"|"bsp/b"),
|
||||
..
|
||||
}) = words.peek() {
|
||||
if let Value::Key(key) = words.next().unwrap().value() {
|
||||
let base = words.clone();
|
||||
let a: A = state.give_or_fail(words, ||"bsp: expected content 1")?;
|
||||
let b: B = state.give_or_fail(words, ||"bsp: expected content 2")?;
|
||||
return Ok(Some(match key {
|
||||
"bsp/n" => Self::n(a, b),
|
||||
"bsp/s" => Self::s(a, b),
|
||||
"bsp/e" => Self::e(a, b),
|
||||
"bsp/w" => Self::w(a, b),
|
||||
"bsp/a" => Self::a(a, b),
|
||||
"bsp/b" => Self::b(a, b),
|
||||
_ => unreachable!(),
|
||||
}))
|
||||
} else {
|
||||
unreachable!()
|
||||
}
|
||||
} else {
|
||||
None
|
||||
}));
|
||||
impl<A, B> Bsp<A, B> {
|
||||
#[inline] pub const fn n (a: A, b: B) -> Self { Self(North, a, b) }
|
||||
#[inline] pub const fn s (a: A, b: B) -> Self { Self(South, a, b) }
|
||||
#[inline] pub const fn e (a: A, b: B) -> Self { Self(East, a, b) }
|
||||
#[inline] pub const fn w (a: A, b: B) -> Self { Self(West, a, b) }
|
||||
#[inline] pub const fn a (a: A, b: B) -> Self { Self(Above, a, b) }
|
||||
#[inline] pub const fn b (a: A, b: B) -> Self { Self(Below, a, b) }
|
||||
}
|
||||
pub trait BspAreas<E: Output, A: Content<E>, B: Content<E>> {
|
||||
fn direction (&self) -> Direction;
|
||||
fn contents (&self) -> (&A, &B);
|
||||
fn areas (&self, outer: E::Area) -> [E::Area;3] {
|
||||
let direction = self.direction();
|
||||
let [x, y, w, h] = outer.xywh();
|
||||
let (a, b) = self.contents();
|
||||
let [aw, ah] = a.layout(outer).wh();
|
||||
let [bw, bh] = b.layout(match direction {
|
||||
Above | Below => outer,
|
||||
South => [x, y + ah, w, h.minus(ah)].into(),
|
||||
North => [x, y, w, h.minus(ah)].into(),
|
||||
East => [x + aw, y, w.minus(aw), h].into(),
|
||||
West => [x, y, w.minus(aw), h].into(),
|
||||
}).wh();
|
||||
match direction {
|
||||
Above | Below => {
|
||||
let [x, y, w, h] = outer.center_xy([aw.max(bw), ah.max(bh)]);
|
||||
let a = [(x + w/2.into()).minus(aw/2.into()), (y + h/2.into()).minus(ah/2.into()), aw, ah];
|
||||
let b = [(x + w/2.into()).minus(bw/2.into()), (y + h/2.into()).minus(bh/2.into()), bw, bh];
|
||||
[a.into(), b.into(), [x, y, w, h].into()]
|
||||
},
|
||||
South => {
|
||||
let [x, y, w, h] = outer.center_xy([aw.max(bw), ah + bh]);
|
||||
let a = [(x + w/2.into()).minus(aw/2.into()), y, aw, ah];
|
||||
let b = [(x + w/2.into()).minus(bw/2.into()), y + ah, bw, bh];
|
||||
[a.into(), b.into(), [x, y, w, h].into()]
|
||||
},
|
||||
North => {
|
||||
let [x, y, w, h] = outer.center_xy([aw.max(bw), ah + bh]);
|
||||
let a = [(x + (w/2.into())).minus(aw/2.into()), y + bh, aw, ah];
|
||||
let b = [(x + (w/2.into())).minus(bw/2.into()), y, bw, bh];
|
||||
[a.into(), b.into(), [x, y, w, h].into()]
|
||||
},
|
||||
East => {
|
||||
let [x, y, w, h] = outer.center_xy([aw + bw, ah.max(bh)]);
|
||||
let a = [x, (y + h/2.into()).minus(ah/2.into()), aw, ah];
|
||||
let b = [x + aw, (y + h/2.into()).minus(bh/2.into()), bw, bh];
|
||||
[a.into(), b.into(), [x, y, w, h].into()]
|
||||
},
|
||||
West => {
|
||||
let [x, y, w, h] = outer.center_xy([aw + bw, ah.max(bh)]);
|
||||
let a = [x + bw, (y + h/2.into()).minus(ah/2.into()), aw, ah];
|
||||
let b = [x, (y + h/2.into()).minus(bh/2.into()), bw, bh];
|
||||
[a.into(), b.into(), [x, y, w, h].into()]
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
impl<E: Output, A: Content<E>, B: Content<E>> BspAreas<E, A, B> for Bsp<A, B> {
|
||||
fn direction (&self) -> Direction { self.0 }
|
||||
fn contents (&self) -> (&A, &B) { (&self.1, &self.2) }
|
||||
}
|
||||
/// Renders multiple things on top of each other,
|
||||
#[macro_export] macro_rules! lay {
|
||||
($($expr:expr),* $(,)?) => {{ let bsp = (); $(let bsp = Bsp::b(bsp, $expr);)*; bsp }}
|
||||
}
|
||||
/// Stack southward.
|
||||
#[macro_export] macro_rules! col {
|
||||
($($expr:expr),* $(,)?) => {{ let bsp = (); $(let bsp = Bsp::s(bsp, $expr);)*; bsp }};
|
||||
}
|
||||
/// Stack northward.
|
||||
#[macro_export] macro_rules! col_up {
|
||||
($($expr:expr),* $(,)?) => {{ let bsp = (); $(let bsp = Bsp::n(bsp, $expr);)*; bsp }}
|
||||
}
|
||||
/// Stack eastward.
|
||||
#[macro_export] macro_rules! row {
|
||||
($($expr:expr),* $(,)?) => {{ let bsp = (); $(let bsp = Bsp::e(bsp, $expr);)*; bsp }};
|
||||
}
|
||||
|
|
@ -1,32 +0,0 @@
|
|||
use crate::*;
|
||||
|
||||
/// Show one item if a condition is true and another if the condition is false
|
||||
pub struct Either<A, B>(pub bool, pub A, pub B);
|
||||
impl<A, B> Either<A, B> {
|
||||
/// Create a ternary condition.
|
||||
pub const fn new (c: bool, a: A, b: B) -> Self {
|
||||
Self(c, a, b)
|
||||
}
|
||||
}
|
||||
#[cfg(feature = "dsl")] take!(Either<A, B>, A, B|state, words|Ok(
|
||||
if let Some(Token { value: Value::Key("either"), .. }) = words.peek() {
|
||||
let base = words.clone();
|
||||
let _ = words.next().unwrap();
|
||||
return Ok(Some(Self(
|
||||
state.give_or_fail(words, ||"either: no condition")?,
|
||||
state.give_or_fail(words, ||"either: no content 1")?,
|
||||
state.give_or_fail(words, ||"either: no content 2")?,
|
||||
)))
|
||||
} else {
|
||||
None
|
||||
}));
|
||||
impl<E: Output, A: Render<E>, B: Render<E>> Content<E> for Either<A, B> {
|
||||
fn layout (&self, to: E::Area) -> E::Area {
|
||||
let Self(cond, a, b) = self;
|
||||
if *cond { a.layout(to) } else { b.layout(to) }
|
||||
}
|
||||
fn render (&self, to: &mut E) {
|
||||
let Self(cond, a, b) = self;
|
||||
if *cond { a.render(to) } else { b.render(to) }
|
||||
}
|
||||
}
|
||||
|
|
@ -1,192 +0,0 @@
|
|||
//! [Content] items that modify the inherent
|
||||
//! dimensions of their inner [Render]ables.
|
||||
//!
|
||||
//! Transform may also react to the [Area] taked.
|
||||
//! ```
|
||||
//! use ::tengri::{output::*, tui::*};
|
||||
//! let area: [u16;4] = [10, 10, 20, 20];
|
||||
//! fn test (area: [u16;4], item: &impl Content<TuiOut>, expected: [u16;4]) {
|
||||
//! assert_eq!(Content::layout(item, area), expected);
|
||||
//! assert_eq!(Render::layout(item, area), expected);
|
||||
//! };
|
||||
//! test(area, &(), [20, 20, 0, 0]);
|
||||
//!
|
||||
//! test(area, &Fill::xy(()), area);
|
||||
//! test(area, &Fill::x(()), [10, 20, 20, 0]);
|
||||
//! test(area, &Fill::y(()), [20, 10, 0, 20]);
|
||||
//!
|
||||
//! //FIXME:test(area, &Fixed::x(4, ()), [18, 20, 4, 0]);
|
||||
//! //FIXME:test(area, &Fixed::y(4, ()), [20, 18, 0, 4]);
|
||||
//! //FIXME:test(area, &Fixed::xy(4, 4, unit), [18, 18, 4, 4]);
|
||||
//! ```
|
||||
|
||||
use crate::*;
|
||||
|
||||
/// Defines an enum that transforms its content
|
||||
/// along either the X axis, the Y axis, or both.
|
||||
macro_rules! transform_xy {
|
||||
($x:literal $y:literal $xy:literal |$self:ident : $Enum:ident, $to:ident|$area:expr) => {
|
||||
pub enum $Enum<A> { X(A), Y(A), XY(A) }
|
||||
impl<A> $Enum<A> {
|
||||
#[inline] pub const fn x (item: A) -> Self { Self::X(item) }
|
||||
#[inline] pub const fn y (item: A) -> Self { Self::Y(item) }
|
||||
#[inline] pub const fn xy (item: A) -> Self { Self::XY(item) }
|
||||
}
|
||||
#[cfg(feature = "dsl")] take!($Enum<A>, A|state, words|Ok(
|
||||
if let Some(Token { value: Value::Key(k), .. }) = words.peek() {
|
||||
let mut base = words.clone();
|
||||
let content = state.give_or_fail(words, ||format!("{k}: no content"))?;
|
||||
return Ok(Some(match words.next() {
|
||||
Some(Token{value: Value::Key($x),..}) => Self::x(content),
|
||||
Some(Token{value: Value::Key($y),..}) => Self::y(content),
|
||||
Some(Token{value: Value::Key($xy),..}) => Self::xy(content),
|
||||
_ => unreachable!()
|
||||
}))
|
||||
} else {
|
||||
None
|
||||
}));
|
||||
impl<E: Output, T: Content<E>> Content<E> for $Enum<T> {
|
||||
fn content (&self) -> impl Render<E> + '_ {
|
||||
match self {
|
||||
Self::X(item) => item,
|
||||
Self::Y(item) => item,
|
||||
Self::XY(item) => item,
|
||||
}
|
||||
}
|
||||
fn layout (&$self, $to: <E as Output>::Area) -> <E as Output>::Area {
|
||||
use $Enum::*;
|
||||
$area
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Defines an enum that parametrically transforms its content
|
||||
/// along either the X axis, the Y axis, or both.
|
||||
macro_rules! transform_xy_unit {
|
||||
($x:literal $y:literal $xy:literal |$self:ident : $Enum:ident, $to:ident|$layout:expr) => {
|
||||
pub enum $Enum<U, A> { X(U, A), Y(U, A), XY(U, U, A), }
|
||||
impl<U, A> $Enum<U, A> {
|
||||
#[inline] pub const fn x (x: U, item: A) -> Self { Self::X(x, item) }
|
||||
#[inline] pub const fn y (y: U, item: A) -> Self { Self::Y(y, item) }
|
||||
#[inline] pub const fn xy (x: U, y: U, item: A) -> Self { Self::XY(x, y, item) }
|
||||
}
|
||||
#[cfg(feature = "dsl")] take!($Enum<U, A>, U, A|state, words|Ok(
|
||||
if let Some(Token { value: Value::Key($x|$y|$xy), .. }) = words.peek() {
|
||||
let mut base = words.clone();
|
||||
Some(match words.next() {
|
||||
Some(Token { value: Value::Key($x), .. }) => Self::x(
|
||||
state.give_or_fail(words, ||"x: no unit")?,
|
||||
state.give_or_fail(words, ||"x: no content")?,
|
||||
),
|
||||
Some(Token { value: Value::Key($y), .. }) => Self::y(
|
||||
state.give_or_fail(words, ||"y: no unit")?,
|
||||
state.give_or_fail(words, ||"y: no content")?,
|
||||
),
|
||||
Some(Token { value: Value::Key($x), .. }) => Self::xy(
|
||||
state.give_or_fail(words, ||"xy: no unit x")?,
|
||||
state.give_or_fail(words, ||"xy: no unit y")?,
|
||||
state.give_or_fail(words, ||"xy: no content")?
|
||||
),
|
||||
_ => unreachable!(),
|
||||
})
|
||||
} else {
|
||||
None
|
||||
}));
|
||||
impl<E: Output, T: Content<E>> Content<E> for $Enum<E::Unit, T> {
|
||||
fn layout (&$self, $to: E::Area) -> E::Area {
|
||||
$layout.into()
|
||||
}
|
||||
fn content (&self) -> impl Render<E> + '_ {
|
||||
use $Enum::*;
|
||||
Some(match self { X(_, c) => c, Y(_, c) => c, XY(_, _, c) => c, })
|
||||
}
|
||||
}
|
||||
impl<U: Coordinate, T> $Enum<U, T> {
|
||||
#[inline] pub fn dx (&self) -> U {
|
||||
use $Enum::*;
|
||||
match self { X(x, _) => *x, Y(_, _) => 0.into(), XY(x, _, _) => *x, }
|
||||
}
|
||||
#[inline] pub fn dy (&self) -> U {
|
||||
use $Enum::*;
|
||||
match self { X(_, _) => 0.into(), Y(y, _) => *y, XY(_, y, _) => *y, }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
transform_xy!("fill/x" "fill/y" "fill/xy" |self: Fill, to|{
|
||||
let [x0, y0, wmax, hmax] = to.xywh();
|
||||
let [x, y, w, h] = self.content().layout(to).xywh();
|
||||
match self {
|
||||
X(_) => [x0, y, wmax, h],
|
||||
Y(_) => [x, y0, w, hmax],
|
||||
XY(_) => [x0, y0, wmax, hmax],
|
||||
}.into()
|
||||
});
|
||||
|
||||
transform_xy_unit!("fixed/x" "fixed/y" "fixed/xy"|self: Fixed, area|{
|
||||
let [x, y, w, h] = area.xywh();
|
||||
let fixed_area = match self {
|
||||
Self::X(fw, _) => [x, y, *fw, h],
|
||||
Self::Y(fh, _) => [x, y, w, *fh],
|
||||
Self::XY(fw, fh, _) => [x, y, *fw, *fh],
|
||||
};
|
||||
let [x, y, w, h] = Render::layout(&self.content(), fixed_area.into()).xywh();
|
||||
let fixed_area = match self {
|
||||
Self::X(fw, _) => [x, y, *fw, h],
|
||||
Self::Y(fh, _) => [x, y, w, *fh],
|
||||
Self::XY(fw, fh, _) => [x, y, *fw, *fh],
|
||||
};
|
||||
fixed_area
|
||||
});
|
||||
|
||||
transform_xy_unit!("min/x" "min/y" "min/xy"|self: Min, area|{
|
||||
let area = Render::layout(&self.content(), area);
|
||||
match self {
|
||||
Self::X(mw, _) => [area.x(), area.y(), area.w().max(*mw), area.h()],
|
||||
Self::Y(mh, _) => [area.x(), area.y(), area.w(), area.h().max(*mh)],
|
||||
Self::XY(mw, mh, _) => [area.x(), area.y(), area.w().max(*mw), area.h().max(*mh)],
|
||||
}
|
||||
});
|
||||
|
||||
transform_xy_unit!("max/x" "max/y" "max/xy"|self: Max, area|{
|
||||
let [x, y, w, h] = area.xywh();
|
||||
Render::layout(&self.content(), match self {
|
||||
Self::X(fw, _) => [x, y, *fw, h],
|
||||
Self::Y(fh, _) => [x, y, w, *fh],
|
||||
Self::XY(fw, fh, _) => [x, y, *fw, *fh],
|
||||
}.into())
|
||||
});
|
||||
|
||||
transform_xy_unit!("shrink/x" "shrink/y" "shrink/xy"|self: Shrink, area|Render::layout(
|
||||
&self.content(),
|
||||
[area.x(), area.y(), area.w().minus(self.dx()), area.h().minus(self.dy())].into()));
|
||||
|
||||
transform_xy_unit!("expand/x" "expand/y" "expand/xy"|self: Expand, area|Render::layout(
|
||||
&self.content(),
|
||||
[area.x(), area.y(), area.w().plus(self.dx()), area.h().plus(self.dy())].into()));
|
||||
|
||||
transform_xy_unit!("push/x" "push/y" "push/xy"|self: Push, area|{
|
||||
let area = Render::layout(&self.content(), area);
|
||||
[area.x().plus(self.dx()), area.y().plus(self.dy()), area.w(), area.h()]
|
||||
});
|
||||
|
||||
transform_xy_unit!("pull/x" "pull/y" "pull/xy"|self: Pull, area|{
|
||||
let area = Render::layout(&self.content(), area);
|
||||
[area.x().minus(self.dx()), area.y().minus(self.dy()), area.w(), area.h()]
|
||||
});
|
||||
|
||||
transform_xy_unit!("margin/x" "margin/y" "margin/xy"|self: Margin, area|{
|
||||
let area = Render::layout(&self.content(), area);
|
||||
let dx = self.dx();
|
||||
let dy = self.dy();
|
||||
[area.x().minus(dx), area.y().minus(dy), area.w().plus(dy.plus(dy)), area.h().plus(dy.plus(dy))]
|
||||
});
|
||||
|
||||
transform_xy_unit!("padding/x" "padding/y" "padding/xy"|self: Padding, area|{
|
||||
let area = Render::layout(&self.content(), area);
|
||||
let dx = self.dx();
|
||||
let dy = self.dy();
|
||||
[area.x().plus(dx), area.y().plus(dy), area.w().minus(dy.plus(dy)), area.h().minus(dy.plus(dy))]
|
||||
});
|
||||
|
|
@ -1,38 +0,0 @@
|
|||
use crate::*;
|
||||
/// Show an item only when a condition is true.
|
||||
pub struct When<A>(pub bool, pub A);
|
||||
impl<A> When<A> {
|
||||
/// Create a binary condition.
|
||||
pub const fn new (c: bool, a: A) -> Self {
|
||||
Self(c, a)
|
||||
}
|
||||
}
|
||||
#[cfg(feature = "dsl")]take!(When<A>, A|state, words|Ok(Some(match words.peek() {
|
||||
Some(Token { value: Value::Key("when"), .. }) => {
|
||||
let _ = words.next();
|
||||
let base = words.clone();
|
||||
let cond = state.give_or_fail(words, ||"cond: no condition")?;
|
||||
let cont = state.give_or_fail(words, ||"cond: no content")?;
|
||||
Self(cond, cont)
|
||||
},
|
||||
_ => return Ok(None)
|
||||
})));
|
||||
|
||||
impl<E: Output, A: Render<E>> Content<E> for When<A> {
|
||||
fn layout (&self, to: E::Area) -> E::Area {
|
||||
let Self(cond, item) = self;
|
||||
let mut area = E::Area::zero();
|
||||
if *cond {
|
||||
let item_area = item.layout(to);
|
||||
area[0] = item_area.x();
|
||||
area[1] = item_area.y();
|
||||
area[2] = item_area.w();
|
||||
area[3] = item_area.h();
|
||||
}
|
||||
area.into()
|
||||
}
|
||||
fn render (&self, to: &mut E) {
|
||||
let Self(cond, item) = self;
|
||||
if *cond { item.render(to) }
|
||||
}
|
||||
}
|
||||
185
output/src/ops_dsl.rs
Normal file
185
output/src/ops_dsl.rs
Normal file
|
|
@ -0,0 +1,185 @@
|
|||
use crate::*;
|
||||
|
||||
impl<I: Ast, S, A> Eval<I, When<A>> for S where
|
||||
S: Eval<AstValue, bool> + Eval<AstValue, A>
|
||||
{
|
||||
fn eval (&self, source: I) -> Perhaps<Self> {
|
||||
Ok(match source.peek() {
|
||||
Some(Value::Key("when")) => Some(Self(
|
||||
self.provide(source, ||"when: expected condition")?,
|
||||
self.provide(source, ||"when: expected content")?,
|
||||
)),
|
||||
_ => None
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl<I: Ast, S, A, B> Eval<I, Either<A, B>> for S where
|
||||
S: Eval<AstValue, bool> + Eval<AstValue, A> + Eval<AstValue, B>
|
||||
{
|
||||
fn eval (&self, source: I) -> Perhaps<Self> {
|
||||
Ok(match source.peek() {
|
||||
Some(Value::Key("either")) => Some(Self(
|
||||
self.provide(source, ||"either: expected condition")?,
|
||||
self.provide(source, ||"either: expected content 1")?,
|
||||
self.provide(source, ||"either: expected content 2")?
|
||||
)),
|
||||
_ => None
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl<I: Ast, S, A, B> Eval<I, Bsp<A, B>> for S where
|
||||
S: Eval<AstValue, A> + Eval<AstValue, B>
|
||||
{
|
||||
fn eval (&self, source: I) -> Perhaps<Self> {
|
||||
Ok(if let Some(Value::Key(key)) = source.peek() {
|
||||
Some(match key {
|
||||
"bsp/n" => {
|
||||
let _ = source.next();
|
||||
let a: A = self.provide(source, ||"bsp/n: expected content 1")?;
|
||||
let b: B = self.provide(source, ||"bsp/n: expected content 2")?;
|
||||
Self::n(a, b)
|
||||
},
|
||||
"bsp/s" => {
|
||||
let _ = source.next();
|
||||
let a: A = self.provide(source, ||"bsp/s: expected content 1")?;
|
||||
let b: B = self.provide(source, ||"bsp/s: expected content 2")?;
|
||||
Self::s(a, b)
|
||||
},
|
||||
"bsp/e" => {
|
||||
let _ = source.next();
|
||||
let a: A = self.provide(source, ||"bsp/e: expected content 1")?;
|
||||
let b: B = self.provide(source, ||"bsp/e: expected content 2")?;
|
||||
Self::e(a, b)
|
||||
},
|
||||
"bsp/w" => {
|
||||
let _ = source.next();
|
||||
let a: A = self.provide(source, ||"bsp/w: expected content 1")?;
|
||||
let b: B = self.provide(source, ||"bsp/w: expected content 2")?;
|
||||
Self::w(a, b)
|
||||
},
|
||||
"bsp/a" => {
|
||||
let _ = source.next();
|
||||
let a: A = self.provide(source, ||"bsp/a: expected content 1")?;
|
||||
let b: B = self.provide(source, ||"bsp/a: expected content 2")?;
|
||||
Self::a(a, b)
|
||||
},
|
||||
"bsp/b" => {
|
||||
let _ = source.next();
|
||||
let a: A = self.provide(source, ||"bsp/b: expected content 1")?;
|
||||
let b: B = self.provide(source, ||"bsp/b: expected content 2")?;
|
||||
Self::b(a, b)
|
||||
},
|
||||
_ => return Ok(None),
|
||||
})
|
||||
} else {
|
||||
None
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl<I: Ast, S, A> Eval<I, Align<A>> for S where
|
||||
S: Eval<AstValue, A>
|
||||
{
|
||||
fn eval (&self, source: I) -> Perhaps<Self> {
|
||||
Ok(if let Some(Value::Key(key)) = source.peek() {
|
||||
Some(match key {
|
||||
"align/c" => {
|
||||
let _ = source.next();
|
||||
let content: A = self.provide(source, ||"align/c: expected content")?;
|
||||
Self::c(content)
|
||||
},
|
||||
"align/x" => {
|
||||
let _ = source.next();
|
||||
let content: A = self.provide(source, ||"align/x: expected content")?;
|
||||
Self::x(content)
|
||||
},
|
||||
"align/y" => {
|
||||
let _ = source.next();
|
||||
let content: A = self.provide(source, ||"align/y: expected content")?;
|
||||
Self::y(content)
|
||||
},
|
||||
"align/n" => {
|
||||
let _ = source.next();
|
||||
let content: A = self.provide(source, ||"align/n: expected content")?;
|
||||
Self::n(content)
|
||||
},
|
||||
"align/s" => {
|
||||
let _ = source.next();
|
||||
let content: A = self.provide(source, ||"align/s: expected content")?;
|
||||
Self::s(content)
|
||||
},
|
||||
"align/e" => {
|
||||
let _ = source.next();
|
||||
let content: A = self.provide(source, ||"align/e: expected content")?;
|
||||
Self::e(content)
|
||||
},
|
||||
"align/w" => {
|
||||
let _ = source.next();
|
||||
let content: A = self.provide(source, ||"align/w: expected content")?;
|
||||
Self::w(content)
|
||||
},
|
||||
"align/nw" => {
|
||||
let _ = source.next();
|
||||
let content: A = self.provide(source, ||"align/nw: expected content")?;
|
||||
Self::nw(content)
|
||||
},
|
||||
"align/ne" => {
|
||||
let _ = source.next();
|
||||
let content: A = self.provide(source, ||"align/ne: expected content")?;
|
||||
Self::ne(content)
|
||||
},
|
||||
"align/sw" => {
|
||||
let _ = source.next();
|
||||
let content: A = self.provide(source, ||"align/sw: expected content")?;
|
||||
Self::sw(content)
|
||||
},
|
||||
"align/se" => {
|
||||
let _ = source.next();
|
||||
let content: A = self.provide(source, ||"align/se: expected content")?;
|
||||
Self::se(content)
|
||||
},
|
||||
_ => return Ok(None),
|
||||
})
|
||||
} else {
|
||||
None
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
//#[cfg(feature = "dsl")] take!($Enum<A>, A|state, words|Ok(
|
||||
//if let Some(Token { value: Value::Key(k), .. }) = words.peek() {
|
||||
//let mut base = words.clone();
|
||||
//let content = state.give_or_fail(words, ||format!("{k}: no content"))?;
|
||||
//return Ok(Some(match words.next() {
|
||||
//Some(Token{value: Value::Key($x),..}) => Self::x(content),
|
||||
//Some(Token{value: Value::Key($y),..}) => Self::y(content),
|
||||
//Some(Token{value: Value::Key($xy),..}) => Self::xy(content),
|
||||
//_ => unreachable!()
|
||||
//}))
|
||||
//} else {
|
||||
//None
|
||||
//}));
|
||||
//#[cfg(feature = "dsl")] take!($Enum<U, A>, U, A|state, words|Ok(
|
||||
//if let Some(Token { value: Value::Key($x|$y|$xy), .. }) = words.peek() {
|
||||
//let mut base = words.clone();
|
||||
//Some(match words.next() {
|
||||
//Some(Token { value: Value::Key($x), .. }) => Self::x(
|
||||
//state.give_or_fail(words, ||"x: no unit")?,
|
||||
//state.give_or_fail(words, ||"x: no content")?,
|
||||
//),
|
||||
//Some(Token { value: Value::Key($y), .. }) => Self::y(
|
||||
//state.give_or_fail(words, ||"y: no unit")?,
|
||||
//state.give_or_fail(words, ||"y: no content")?,
|
||||
//),
|
||||
//Some(Token { value: Value::Key($x), .. }) => Self::xy(
|
||||
//state.give_or_fail(words, ||"xy: no unit x")?,
|
||||
//state.give_or_fail(words, ||"xy: no unit y")?,
|
||||
//state.give_or_fail(words, ||"xy: no content")?
|
||||
//),
|
||||
//_ => unreachable!(),
|
||||
//})
|
||||
//} else {
|
||||
//None
|
||||
//}));
|
||||
|
|
@ -1,4 +1,5 @@
|
|||
use crate::*;
|
||||
use crate::Direction::*;
|
||||
|
||||
/// A cardinal direction.
|
||||
#[derive(Copy, Clone, PartialEq, Debug)]
|
||||
|
|
|
|||
|
|
@ -149,10 +149,8 @@ impl ToTokens for CommandDef {
|
|||
}
|
||||
}
|
||||
/// Generated by [tengri_proc::command].
|
||||
impl<'state> ::tengri::dsl::Take<'state, #state> for #command_enum {
|
||||
fn take <'source: 'state> (
|
||||
state: &#state, mut words: ::tengri::dsl::TokenIter<'source>
|
||||
) -> Perhaps<Self> {
|
||||
impl ::tengri::dsl::Take<#state> for #command_enum {
|
||||
fn take (state: &#state, mut words: ::tengri::dsl::Cst) -> Perhaps<Self> {
|
||||
let mut words = words.clone();
|
||||
let token = words.next();
|
||||
todo!()//Ok(match token { #(#matchers)* _ => None })
|
||||
|
|
|
|||
|
|
@ -85,10 +85,8 @@ impl ToTokens for ExposeImpl {
|
|||
});
|
||||
write_quote_to(out, quote! {
|
||||
/// Generated by [tengri_proc::expose].
|
||||
impl<'n> ::tengri::dsl::Take<'n, #state> for #t {
|
||||
fn take <'source: 'n> (
|
||||
state: &#state, mut words: ::tengri::dsl::TokenIter<'source>
|
||||
) -> Perhaps<Self> {
|
||||
impl ::tengri::dsl::Take<#state> for #t {
|
||||
fn take (state: &#state, mut words: ::tengri::dsl::Cst) -> Perhaps<Self> {
|
||||
Ok(Some(match words.next().map(|x|x.value) {
|
||||
#predefined
|
||||
#(#values)*
|
||||
|
|
|
|||
|
|
@ -43,50 +43,38 @@ impl ToTokens for ViewDef {
|
|||
let self_ty = &block.self_ty;
|
||||
// Expressions are handled by built-in functions
|
||||
// that operate over constants and symbols.
|
||||
let builtin = builtins_with_boxes_output(quote! { #output });
|
||||
let builtin = builtins_with_boxes_output(quote! { #output }).map(|builtin|quote! {
|
||||
::tengri::dsl::Value::Exp(_, expr) => return Ok(Some(
|
||||
#builtin::take_or_fail(state, expr, ||"failed to load builtin")?.boxed()
|
||||
)),
|
||||
});
|
||||
// Symbols are handled by user-taked functions
|
||||
// that take no parameters but `&self`.
|
||||
let exposed = exposed.iter().map(|(key, value)|write_quote(quote! {
|
||||
::tengri::dsl::Value::Sym(#key) => Some(Box::new(Thunk::new(
|
||||
move||#self_ty::#value(state))))}));
|
||||
::tengri::dsl::Value::Sym(#key) => return Ok(Some(
|
||||
state.#value().boxed()
|
||||
)),
|
||||
}));
|
||||
write_quote_to(out, quote! {
|
||||
// Original user-taked implementation:
|
||||
#block
|
||||
/// Generated by [tengri_proc].
|
||||
///
|
||||
/// Makes [#self_ty] able to construct the [Render]able
|
||||
/// which might correspond to a given [TokenStream],
|
||||
/// while taking [#self_ty]'s state into consideration.
|
||||
impl<'state: 'static> Take<'state, #self_ty> for Box<dyn Render<#output> + 'state> {
|
||||
fn take <'source: 'state> (state: &#self_ty, mut words: TokenIter<'source>)
|
||||
-> Perhaps<Box<dyn Render<#output> + 'state>>
|
||||
impl<'source, 'state: 'source>
|
||||
Take<'state, 'source, #self_ty>
|
||||
for Box<dyn Render<#output> + 'state>
|
||||
{
|
||||
//let state = self;
|
||||
fn take (state: &'state #self_ty, mut words: Cst<'source>) -> Perhaps<Self> {
|
||||
Ok(if let Some(::tengri::dsl::Token { value, .. }) = words.peek() {
|
||||
match value {
|
||||
#(::tengri::dsl::Value::Exp(_, expr) => {
|
||||
Give::<'state, #builtin>::give(state, expr)?.map(|value|value.boxed())
|
||||
},)*
|
||||
#(
|
||||
#exposed,
|
||||
)*
|
||||
_ => None
|
||||
}
|
||||
match value { #(#builtin)* #(#exposed)* _ => None }
|
||||
} else {
|
||||
None
|
||||
})
|
||||
}
|
||||
}
|
||||
/// Generated by [tengri_proc].
|
||||
///
|
||||
/// Delegates the rendering of [#self_ty] to the [#self_ty::view} method,
|
||||
/// which you will need to implement, e.g. passing a [TokenIter]
|
||||
/// containing a layout and keybindings config from user dirs.
|
||||
impl ::tengri::output::Content<#output> for #self_ty {
|
||||
fn content (&self) -> impl Render<#output> + '_ {
|
||||
#self_ty::view(self)
|
||||
}
|
||||
}
|
||||
// Original user-taked implementation:
|
||||
#block
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
@ -96,11 +84,11 @@ fn builtins_with_holes () -> impl Iterator<Item=TokenStream2> {
|
|||
}
|
||||
|
||||
fn builtins_with_boxes () -> impl Iterator<Item=TokenStream2> {
|
||||
builtins_with(quote! { _ }, quote! { Box<dyn Render<_>+'state> })
|
||||
builtins_with(quote! { _ }, quote! { Box<dyn Render<_>> })
|
||||
}
|
||||
|
||||
fn builtins_with_boxes_output (o: TokenStream2) -> impl Iterator<Item=TokenStream2> {
|
||||
builtins_with(quote! { _ }, quote! { Box<dyn Render<#o>+'state> })
|
||||
builtins_with(quote! { _ }, quote! { Box<dyn Render<#o>> })
|
||||
}
|
||||
|
||||
fn builtins_with (n: TokenStream2, c: TokenStream2) -> impl Iterator<Item=TokenStream2> {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue