mirror of
https://codeberg.org/unspeaker/tengri.git
synced 2025-12-06 03:36:42 +01:00
221 lines
9.2 KiB
Rust
221 lines
9.2 KiB
Rust
use crate::*;
|
|
/// A collection of input bindings.
|
|
///
|
|
/// Each contained layer defines a mapping from input event to command invocation
|
|
/// over a given state. Furthermore, each layer may have an associated cond,
|
|
/// so that only certain layers are active at a given time depending on state.
|
|
#[derive(Debug, Default)] pub struct InputMap<I, T: Dsl>(
|
|
/// Map of input event (key combination) to
|
|
/// all command expressions bound to it by
|
|
/// all loaded input layers.
|
|
pub BTreeMap<I, Vec<InputBinding<T>>>
|
|
);
|
|
#[derive(Debug, Default)] pub struct InputBinding<T: Dsl> {
|
|
condition: Option<T>,
|
|
command: T,
|
|
description: Option<Arc<str>>,
|
|
source: Option<Arc<PathBuf>>,
|
|
}
|
|
impl<I: Debug + Ord, T: Dsl> InputMap<I, T> {
|
|
/// Create input layer collection from path to text file.
|
|
pub fn from_path <P: Debug + AsRef<Path>> (path: P) -> Usually<Self> {
|
|
if !exists(path.as_ref())? {
|
|
return Err(format!("(e5) not found: {path:?}").into())
|
|
}
|
|
Self::from_source(read_and_leak(path)?)
|
|
}
|
|
/// Create input layer collection from string.
|
|
pub fn from_source <S: AsRef<str>> (source: S) -> Usually<Self> {
|
|
Self::from_dsl(CstIter::from(source.as_ref()))
|
|
}
|
|
/// Create input layer collection from DSL.
|
|
pub fn from_dsl <D: Dsl> (dsl: D) -> Usually<Self> {
|
|
use DslVal::*;
|
|
let mut input_map: BTreeMap<I, Vec<InputBinding<T>>> = Default::default();
|
|
let mut index = 0;
|
|
while let Some(Exp(_, mut exp)) = dsl.nth(index) {
|
|
let val = exp.nth(0).map(|x|x.val());
|
|
match val {
|
|
Some(Str(path)) => {
|
|
let path = PathBuf::from(path.as_ref());
|
|
let module = InputMap::<I, T>::from_path(&path)?;
|
|
for (key, val) in module.0.into_iter() {
|
|
todo!("import {exp:?} {key:?} {val:?} {path:?}");
|
|
if !input_map.contains_key(&key) {
|
|
input_map.insert(key, vec![]);
|
|
}
|
|
}
|
|
},
|
|
Some(Sym(sym)) => {
|
|
//let key: I = sym.into();
|
|
//if !input_map.contains_key(&key) {
|
|
//input_map.insert(key, vec![]);
|
|
//}
|
|
todo!("binding {exp:?} {sym:?}");
|
|
},
|
|
Some(Key(key)) if key.as_ref() == "if" => {
|
|
todo!("conditional binding {exp:?} {key:?}");
|
|
},
|
|
_ => return Result::Err(format!("invalid token in keymap: {val:?}").into()),
|
|
}
|
|
index += 1;
|
|
}
|
|
Ok(Self(input_map))
|
|
}
|
|
/// Evaluate the active layers for a given state,
|
|
/// returning the command to be executed, if any.
|
|
pub fn handle <S, O> (&self, state: &mut S, input: I) -> Perhaps<O> where
|
|
S: DslInto<bool> + DslInto<O>,
|
|
O: Command<S>
|
|
{
|
|
todo!();
|
|
//let layers = self.0.as_slice();
|
|
//for InputLayer { cond, bind } in layers.iter() {
|
|
//let mut matches = true;
|
|
//if let Some(cond) = cond {
|
|
//matches = state.dsl_into(cond, ||format!("input: no cond").into())?;
|
|
//}
|
|
//if matches
|
|
//&& let Some(exp) = bind.val().exp_head()
|
|
//&& input.dsl_into(exp, ||format!("InputMap: input.eval(binding) failed").into())?
|
|
//&& let Some(command) = state.try_dsl_into(exp)? {
|
|
//return Ok(Some(command))
|
|
//}
|
|
//}
|
|
Ok(None)
|
|
}
|
|
/*
|
|
/// Create an input map with a single non-condal layer.
|
|
/// (Use [Default::default] to get an empty map.)
|
|
pub fn new (layer: DslVal<T::Str, T::Exp>) -> Self {
|
|
Self::default().layer(layer)
|
|
}
|
|
/// Add layer, return `Self`.
|
|
pub fn layer (mut self, layer: DslVal<T::Str, T::Exp>) -> Self {
|
|
self.add_layer(layer); self
|
|
}
|
|
/// Add condal layer, return `Self`.
|
|
pub fn layer_if (mut self, cond: DslVal<T::Str, T::Exp>, layer: DslVal<T::Str, T::Exp>) -> Self {
|
|
self.add_layer_if(Some(cond), layer); self
|
|
}
|
|
/// Add layer, return `&mut Self`.
|
|
pub fn add_layer (&mut self, layer: DslVal<T::Str, T::Exp>) -> &mut Self {
|
|
self.add_layer_if(None, layer.into()); self
|
|
}
|
|
/// Add condal layer, return `&mut Self`.
|
|
pub fn add_layer_if (&mut self, cond: Option<DslVal<T::Str, T::Exp>>, bind: DslVal<T::Str, T::Exp>) -> &mut Self {
|
|
self.0.push(InputLayer { cond, bind });
|
|
self
|
|
}
|
|
*/
|
|
}
|
|
|
|
|
|
|
|
//let mut keys = iter.unwrap();
|
|
//let mut map = InputMap::default();
|
|
//while let Some(token) = keys.next() {
|
|
//if let Value::Exp(_, mut exp) = token.value {
|
|
//let next = exp.next();
|
|
//if let Some(Token { value: Value::Key(sym), .. }) = next {
|
|
//match sym {
|
|
//"layer" => {
|
|
//if let Some(Token { value: Value::Str(path), .. }) = exp.peek() {
|
|
//let path = base.as_ref().parent().unwrap().join(unquote(path));
|
|
//if !std::fs::exists(&path)? {
|
|
//return Err(format!("(e5) not found: {path:?}").into())
|
|
//}
|
|
//map.add_layer(read_and_leak(path)?.into());
|
|
//print!("layer:\n path: {:?}...", exp.0.0.trim());
|
|
//println!("ok");
|
|
//} else {
|
|
//return Err(format!("(e4) unexpected non-string {next:?}").into())
|
|
//}
|
|
//},
|
|
|
|
//"layer-if" => {
|
|
//let mut cond = None;
|
|
|
|
//if let Some(Token { value: Value::Sym(sym), .. }) = exp.next() {
|
|
//cond = Some(leak(sym));
|
|
//} else {
|
|
//return Err(format!("(e4) unexpected non-symbol {next:?}").into())
|
|
//};
|
|
|
|
//if let Some(Token { value: Value::Str(path), .. }) = exp.peek() {
|
|
//let path = base.as_ref().parent().unwrap().join(unquote(path));
|
|
//if !std::fs::exists(&path)? {
|
|
//return Err(format!("(e5) not found: {path:?}").into())
|
|
//}
|
|
//print!("layer-if:\n cond: {}\n path: {path:?}...",
|
|
//cond.unwrap_or_default());
|
|
//let keys = read_and_leak(path)?.into();
|
|
//let cond = cond.unwrap();
|
|
//println!("ok");
|
|
//map.add_layer_if(
|
|
//Box::new(move |state: &App|Take::take_or_fail(
|
|
//state, exp, ||"missing input layer conditional"
|
|
//)), keys
|
|
//);
|
|
//} else {
|
|
//return Err(format!("(e4) unexpected non-symbol {next:?}").into())
|
|
//}
|
|
//},
|
|
|
|
//_ => return Err(format!("(e3) unexpected symbol {sym:?}").into())
|
|
//}
|
|
//} else {
|
|
//return Err(format!("(e2) unexpected exp {:?}", next.map(|x|x.value)).into())
|
|
//}
|
|
//} else {
|
|
//return Err(format!("(e1) unexpected token {token:?}").into())
|
|
//}
|
|
//}
|
|
//Ok(map)
|
|
//}
|
|
//{
|
|
//}
|
|
//fn from (source: &'s str) -> Self {
|
|
//// this should be for single layer:
|
|
//use DslVal::*;
|
|
//let mut layers = vec![];
|
|
//let mut source = CstIter::from(source);
|
|
//while let Some(Exp(_, mut iter)) = source.next().map(|x|x.value) {
|
|
//let mut iter = iter.clone();
|
|
//layers.push(match iter.next().map(|x|x.value) {
|
|
//Some(Sym(sym)) if sym.starts_with("@") => InputLayer {
|
|
//cond: None,
|
|
//bind: vec![[
|
|
//dsl_val(source.nth(1).unwrap()),
|
|
//dsl_val(source.nth(2).unwrap()),
|
|
//]],
|
|
//},
|
|
//Some(Str(layer)) => InputLayer {
|
|
//cond: None,
|
|
//bind: dsl_val(source.nth(1).unwrap()),
|
|
//},
|
|
//Some(Key("if")) => InputLayer {
|
|
//cond: Some(dsl_val(source.nth(1).unwrap())),
|
|
//bind: dsl_val(source.nth(2).unwrap()),
|
|
//},
|
|
//_ => panic!("invalid token in keymap"),
|
|
//})
|
|
//}
|
|
//Self(layers)
|
|
//}
|
|
//}
|
|
|
|
fn unquote (x: &str) -> &str {
|
|
let mut chars = x.chars();
|
|
chars.next();
|
|
//chars.next_back();
|
|
chars.as_str()
|
|
}
|
|
|
|
fn read_and_leak (path: impl AsRef<Path>) -> Usually<&'static str> {
|
|
Ok(leak(String::from_utf8(std::fs::read(path.as_ref())?)?))
|
|
}
|
|
|
|
fn leak (x: impl AsRef<str>) -> &'static str {
|
|
Box::leak(x.as_ref().into())
|
|
}
|