From 8fed353a83cc53a6ef262a375dc86020da50f375 Mon Sep 17 00:00:00 2001 From: bunnie Date: Mon, 5 Apr 2021 00:30:46 +0800 Subject: [PATCH] refactor of the imef interface part 1 --- Cargo.lock | 4 + services/ime-plugin-api/Cargo.toml | 7 +- services/ime-plugin-api/src/lib.rs | 178 ++++++++-------------- services/ime-plugin-shell/Cargo.toml | 7 +- services/ime-plugin-shell/src/main.rs | 211 ++++++++++---------------- xtask/src/main.rs | 2 +- 6 files changed, 161 insertions(+), 248 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 79df56125..10e5c10e7 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -580,6 +580,8 @@ version = "0.1.0" dependencies = [ "graphics-server", "log", + "num-derive", + "num-traits", "rkyv 0.4.3", "xous", "xous-ipc", @@ -594,6 +596,8 @@ dependencies = [ "ime-plugin-api", "log", "log-server", + "num-derive", + "num-traits", "rkyv 0.4.3", "ticktimer-server", "utralib", diff --git a/services/ime-plugin-api/Cargo.toml b/services/ime-plugin-api/Cargo.toml index ccba7945b..cb29ef649 100644 --- a/services/ime-plugin-api/Cargo.toml +++ b/services/ime-plugin-api/Cargo.toml @@ -12,7 +12,6 @@ xous = {path = "../../xous-rs"} xous-ipc = {path = "../../xous-ipc"} xous-names = {path = "../xous-names"}# used by the IMEF for registering listeners -[dependencies.rkyv] -default-features = false -features = ["const_generics"] -version = "0.4.1" +num-derive = {version = "0.3", default-features = false} +num-traits = {version = "0.2", default-features = false} +rkyv = {version = "0.4.3", default-features = false, features = ["const_generics"]} diff --git a/services/ime-plugin-api/src/lib.rs b/services/ime-plugin-api/src/lib.rs index f37adb0d8..44901f8e8 100644 --- a/services/ime-plugin-api/src/lib.rs +++ b/services/ime-plugin-api/src/lib.rs @@ -1,18 +1,14 @@ #![cfg_attr(target_os = "none", no_std)] -use xous::{Message, ScalarMessage, CID}; -use xous_ipc::String; -use graphics_server::Gid; -use rkyv::ser::Serializer; +use xous::{Message, CID, send_message}; +use xous_ipc::{Buffer, String}; +use num_traits::ToPrimitive; #[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)] pub struct Prediction { pub index: u32, pub valid: bool, - // to *return* a value in rkyv, we can't have a variable-length string, as the "pos" argument changes - // this is OK for predictions, we only show the first few characters anyways. - pub string: [u8; 31], // 31 is the longest fixed-length array rkyv supports - pub len: u32, + pub string: String::<1000>, } #[derive(Debug, Default, Copy, Clone)] @@ -44,14 +40,13 @@ impl From for PredictionTriggers { } } -#[allow(dead_code)] -#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)] +#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)] pub enum Opcode { /// update with the latest input candidate. Replaces the previous input. - Input(String<4000>), + Input, //(String<4000>), /// feed back to the IME plugin as to what was picked, so predictions can be updated - Picked(String<4000>), + Picked, //(String<4000>), /// Undo the last Picked value. To be used when a user hits backspace after picking a prediction /// note that repeated calls to Unpick will have an implementation-defined behavior @@ -59,44 +54,17 @@ pub enum Opcode { /// fetch the prediction at a given index, where the index is ordered from 0..N, where 0 is the most likely prediction /// if there is no prediction available, just return an empty string - Prediction(Prediction), + Prediction, //(Prediction), /// return the prediction triggers used by this IME. These are characters that can indicate that a /// whole predictive unit has been entered. GetPredictionTriggers, } -impl core::convert::TryFrom<& Message> for Opcode { - type Error = &'static str; - fn try_from(message: & Message) -> Result { - match message { - Message::Scalar(m) => match m.id { - 0 => Ok(Opcode::Unpick), - _ => Err("IME_SH api: unknown Scalar ID"), - }, - Message::BlockingScalar(m) => match m.id { - 1 => Ok(Opcode::GetPredictionTriggers), - _ => Err("IME_SH api: unknown BlockingScalar ID"), - }, - _ => Err("IME_SH api: unhandled message type"), - } - } -} - -impl Into for Opcode { - fn into(self) -> Message { - match self { - Opcode::Unpick => Message::Scalar(ScalarMessage { - id: 0, - arg1: 0, arg2: 0, arg3: 0, arg4: 0, - }), - Opcode::GetPredictionTriggers => Message::BlockingScalar(ScalarMessage { - id: 1, - arg1: 0, arg2: 0, arg3: 0, arg4: 0, - }), - _ => panic!("IME_SH api: Opcode type not handled by Into(), refer to helper method"), - } - } +#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)] +pub enum Return { + Prediction(Prediction), + Failure, } pub trait PredictionApi { @@ -117,7 +85,8 @@ impl PredictionApi for PredictionPlugin { fn get_prediction_triggers(&self) -> Result { match self.connection { Some(cid) => { - let response = xous::send_message(cid, Opcode::GetPredictionTriggers.into())?; + let response = send_message(cid, + Message::new_blocking_scalar(Opcode::GetPredictionTriggers.to_usize().unwrap(), 0, 0, 0, 0))?; if let xous::Result::Scalar1(code) = response { Ok(code.into()) } else { @@ -131,7 +100,8 @@ impl PredictionApi for PredictionPlugin { fn unpick(&self) -> Result<(), xous::Error> { match self.connection { Some(cid) => { - xous::send_message(cid, Opcode::Unpick.into())?; + send_message(cid, + Message::new_scalar(Opcode::Unpick.to_usize().unwrap(), 0, 0, 0, 0))?; Ok(()) }, _ => Err(xous::Error::UseBeforeInit) @@ -141,13 +111,8 @@ impl PredictionApi for PredictionPlugin { fn set_input(&self, s: String<4000>) -> Result<(), xous::Error> { match self.connection { Some(cid) => { - let rkyv_input = Opcode::Input(s); - let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096)); - - let pos = writer.serialize_value(&rkyv_input).expect("IME|API: couldn't archive input string"); - let xous_buffer = writer.into_inner(); - - xous_buffer.lend(cid, pos as u32).expect("IME|API: set_input operation failure"); + let buf = Buffer::into_buf(s).or(Err(xous::Error::InternalError))?; + buf.lend(cid, Opcode::Input.to_u32().unwrap()).expect("|API: set_input operation failure"); Ok(()) }, _ => Err(xous::Error::UseBeforeInit), @@ -157,13 +122,8 @@ impl PredictionApi for PredictionPlugin { fn feedback_picked(&self, s: String<4000>) -> Result<(), xous::Error> { match self.connection { Some(cid) => { - let rkyv_picked = Opcode::Picked(s); - let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096)); - - let pos = writer.serialize_value(&rkyv_picked).expect("IME|API: couldn't archive picked string"); - let xous_buffer = writer.into_inner(); - - xous_buffer.lend(cid, pos as u32).expect("IME|API: feedback_picked operation failure"); + let buf = Buffer::into_buf(s).or(Err(xous::Error::InternalError))?; + buf.lend(cid, Opcode::Picked.to_u32().unwrap()).expect("|API: feedback_picked operation failure"); Ok(()) }, _ => Err(xous::Error::UseBeforeInit), @@ -171,42 +131,34 @@ impl PredictionApi for PredictionPlugin { } fn get_prediction(&self, index: u32) -> Result>, xous::Error> { - use rkyv::Deserialize; - let debug1 = false; match self.connection { Some(cid) => { let prediction = Prediction { index, - string: [0; 31], - len: 0, + string: String::<1000>::new(), valid: false, }; - let pred_op = Opcode::Prediction(prediction); - let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096)); + let mut buf = Buffer::into_buf(prediction).or(Err(xous::Error::InternalError))?; + buf.lend_mut(cid, Opcode::Prediction.to_u32().unwrap()).or(Err(xous::Error::InternalError))?; - let pos = writer.serialize_value(&pred_op).expect("IME|API: couldn't archive prediction request"); - let mut xous_buffer = writer.into_inner(); - if debug1{log::info!("IME|API: lending Prediction with pos {}", pos);} + log::trace!("IME|API: returned from get_prediction"); - xous_buffer.lend_mut(cid, pos as u32).expect("IME|API: prediction fetch operation failure"); - - if debug1{log::info!("IME|API: returned from get_prediction");} - let returned = unsafe { rkyv::archived_value::(xous_buffer.as_ref(), pos)}; - if let rkyv::Archived::::Prediction(result) = returned { - let pred_r: Prediction = result.deserialize(&mut xous_ipc::XousDeserializer {}).unwrap(); - if debug1{log::info!("IME|API: got {:?}", pred_r);} - if pred_r.valid { - let mut ret = String::<4000>::new(); - use core::fmt::Write as CoreWrite; - write!(ret, "{}", core::str::from_utf8(&pred_r.string[0..pred_r.len as usize]).unwrap()).unwrap(); - Ok(Some(ret)) - } else { - Ok(None) + match buf.to_original().unwrap() { + Return::Prediction(pred) => { + log::trace!("|API: got {:?}", pred); + if pred.valid { + let mut ret = String::<4000>::new(); + use core::fmt::Write as CoreWrite; + write!(ret, "{}", pred.string).unwrap(); + Ok(Some(ret)) + } else { + Ok(None) + } + } + _ => { + log::error!("API get_prediction returned an invalid result"); + Err(xous::Error::InternalError) } - } else { - let r = returned.deserialize(&mut xous_ipc::XousDeserializer {}).unwrap(); - log::error!("IME: API get_prediction returned an invalid result {:?}", r); - Err(xous::Error::InvalidString) } }, _ => Err(xous::Error::UseBeforeInit), @@ -222,24 +174,30 @@ impl PredictionApi for PredictionPlugin { // in this crate so we can break circular dependencies // between the IMEF, GAM, and graphics server -#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)] +#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)] pub enum ImefOpcode { /// informs me where my input canvas is - SetInputCanvas(Gid), + SetInputCanvas, //(Gid), /// informs me where my prediction canvas is - SetPredictionCanvas(Gid), + SetPredictionCanvas, //(Gid), /// set prediction server. Must be a String of the name of a server that is loaded in the system. - SetPredictionServer(String<64>), + SetPredictionServer, //(String<64>), /// register a listener for finalized inputs - RegisterListener(String<64>), + RegisterListener, //(String<64>), - /// this is the event opcode used by listeners + // this is the event opcode used by listeners + //GotInputLine, //(String<4000>), +} +#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)] +pub(crate) enum ImefReturn { GotInputLine(String<4000>), + Failure, } +/* impl core::convert::TryFrom<& Message> for ImefOpcode { type Error = &'static str; fn try_from(message: & Message) -> Result { @@ -266,7 +224,7 @@ impl Into for ImefOpcode { _ => panic!("IMEF api: Opcode type not handled by into()"), } } -} +}*/ pub trait ImeFrontEndApi { fn set_input_canvas(&self, g: graphics_server::Gid) -> Result<(), xous::Error>; @@ -283,7 +241,10 @@ impl ImeFrontEndApi for ImeFrontEnd { fn set_input_canvas(&self, g: graphics_server::Gid) -> Result<(), xous::Error> { match self.connection { Some(cid) => { - xous::send_message(cid, ImefOpcode::SetInputCanvas(g).into())?; + send_message(cid, + Message::new_scalar(ImefOpcode::SetInputCanvas.to_usize().unwrap(), + g.gid()[0] as _, g.gid()[1] as _, g.gid()[2] as _, g.gid()[3] as _ + ))?; Ok(()) }, _ => Err(xous::Error::UseBeforeInit) @@ -293,7 +254,10 @@ impl ImeFrontEndApi for ImeFrontEnd { fn set_prediction_canvas(&self, g: graphics_server::Gid) -> Result<(), xous::Error> { match self.connection { Some(cid) => { - xous::send_message(cid, ImefOpcode::SetPredictionCanvas(g).into())?; + send_message(cid, + Message::new_scalar(ImefOpcode::SetPredictionCanvas.to_usize().unwrap(), + g.gid()[0] as _, g.gid()[1] as _, g.gid()[2] as _, g.gid()[3] as _ + ))?; Ok(()) }, _ => Err(xous::Error::UseBeforeInit) @@ -305,14 +269,9 @@ impl ImeFrontEndApi for ImeFrontEnd { Some(cid) => { let mut server = String::<64>::new(); use core::fmt::Write; - write!(server, "{}", servername).expect("IMEF: couldn't write set_predictor server name"); - let ime_op = ImefOpcode::SetPredictionServer(server); - - let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096)); - - let pos = writer.serialize_value(&ime_op).expect("IMEF: couldn't archive SetPredictionServer"); - writer.into_inner().lend(cid, pos as u32).expect("IMEF: SetPredictionServer request failure"); - Ok(()) + write!(server, "{}", servername).expect("couldn't write set_predictor server name"); + let buf = Buffer::into_buf(server).or(Err(xous::Error::InternalError))?; + buf.lend(cid, ImefOpcode::SetPredictionServer.to_u32().unwrap()).map(|_|()) }, _ => Err(xous::Error::UseBeforeInit) } @@ -323,14 +282,9 @@ impl ImeFrontEndApi for ImeFrontEnd { Some(cid) => { let mut server = String::<64>::new(); use core::fmt::Write; - write!(server, "{}", servername).expect("IMEF: couldn't write set_predictor server name"); - let ime_op = ImefOpcode::RegisterListener(server); - - let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096)); - - let pos = writer.serialize_value(&ime_op).expect("IMEF: couldn't archive SetPredictionServer"); - writer.into_inner().lend(cid, pos as u32).expect("IMEF: SetPredicitonServer request failure"); - Ok(()) + write!(server, "{}", servername).expect("couldn't write set_predictor server name"); + let buf = Buffer::into_buf(server).or(Err(xous::Error::InternalError))?; + buf.lend(cid, ImefOpcode::RegisterListener.to_u32().unwrap()).map(|_|()) }, _ => Err(xous::Error::UseBeforeInit) } diff --git a/services/ime-plugin-shell/Cargo.toml b/services/ime-plugin-shell/Cargo.toml index 7fd45543a..00f1991f3 100644 --- a/services/ime-plugin-shell/Cargo.toml +++ b/services/ime-plugin-shell/Cargo.toml @@ -15,10 +15,9 @@ xous = {path = "../../xous-rs"} xous-ipc = {path = "../../xous-ipc"} xous-names = {path = "../xous-names"} -[dependencies.rkyv] -default-features = false -features = ["const_generics"] -version = "0.4.1" +num-derive = {version = "0.3", default-features = false} +num-traits = {version = "0.2", default-features = false} +rkyv = {version = "0.4.3", default-features = false, features = ["const_generics"]} [target.'cfg(not(any(windows,unix)))'.dependencies] utralib = {path = "../../utralib"} diff --git a/services/ime-plugin-shell/src/main.rs b/services/ime-plugin-shell/src/main.rs index dffbc8406..c4395a72e 100644 --- a/services/ime-plugin-shell/src/main.rs +++ b/services/ime-plugin-shell/src/main.rs @@ -2,27 +2,22 @@ #![cfg_attr(target_os = "none", no_main)] use ime_plugin_api::*; -use core::convert::TryFrom; use log::{error, info}; use heapless::spsc::Queue; use heapless::consts::U4; -use rkyv::Deserialize; -use rkyv::ser::Serializer; -use core::pin::Pin; -use rkyv::{archived_value, archived_value_mut}; -use xous_ipc::String; +use xous_ipc::{String, Buffer}; +use num_traits::FromPrimitive; #[xous::xous_main] fn xmain() -> ! { - let debug1 = false; log_server::init_wait().unwrap(); - info!("IME_SH: my PID is {}", xous::process::id()); + info!("my PID is {}", xous::process::id()); let xns = xous_names::XousNames::new().unwrap(); - let ime_sh_sid = xns.register_name(xous::names::SERVER_NAME_IME_PLUGIN_SHELL).expect("IME_SH: can't register server"); - if debug1{info!("IME_SH: registered with NS -- {:?}", ime_sh_sid);} + let ime_sh_sid = xns.register_name(xous::names::SERVER_NAME_IME_PLUGIN_SHELL).expect("can't register server"); + log::trace!("registered with NS -- {:?}", ime_sh_sid); let mut history: Queue, U4> = Queue::new(); // this has 2^4 elements = 16??? or does it just have 4 elements. let history_max = 4; @@ -46,125 +41,87 @@ fn xmain() -> ! { whitespace: false, }; - info!("IME_SH: ready to accept requests"); + info!("ready to accept requests"); loop { - let envelope = xous::receive_message(ime_sh_sid).unwrap(); - if debug1{info!("IME_SH: received message {:?}", envelope);} - if let xous::Message::Borrow(m) = &envelope.body { - let buf = unsafe { xous::XousBuffer::from_memory_message(m) }; - let bytes = Pin::new(buf.as_ref()); - let value = unsafe { - archived_value::(&bytes, m.id as usize) - }; - match &*value { - rkyv::Archived::::Input(_rkyv_s) => { - // shell does nothing with the input, it only keeps track of - // the picked results - }, - rkyv::Archived::::Picked(rkyv_s) => { - let s: String<4000> = rkyv_s.deserialize(&mut xous_ipc::XousDeserializer {}).unwrap(); - let mut local_s: String<64> = String::new(); - use core::fmt::Write; - write!(local_s, "{:32}", s).expect("IME_SH: overflowed history variable"); - if debug1{info!("IME_SH: storing history value | {}", s);} - if history.len() == history_max { - history.dequeue().expect("IME_SH: couldn't dequeue history"); - } - history.enqueue(local_s).expect("IME_SH: couldn't store history"); - if debug1{info!("IME_SH: history has length {}", history.len());} - }, - _ => error!("IME_SH: unknown Borrow message") - }; - } else if let xous::Message::MutableBorrow(m) = &envelope.body { - let mut buf = unsafe { xous::XousBuffer::from_memory_message(m) }; - let value = unsafe { - archived_value_mut::(Pin::new(buf.as_mut()), m.id as usize) - }; - match &*value { - rkyv::Archived::::Prediction(pred_r) => { - let mut prediction: Prediction = pred_r.deserialize(&mut xous_ipc::XousDeserializer {}).unwrap(); - if debug1{info!("IME_SH: querying prediction index {}", prediction.index);} - if debug1{info!("IME_SH: {:?}", prediction);} - if history.len() > 0 && ((prediction.index as usize) < history.len()) { - let mut index = prediction.index; - if index >= history.len() as u32 { - index = history.len() as u32 - 1; - } - let mut i = 1; - for &s in history.iter() { - // iterator is from oldest to newest, so do some math to go from newest to oldest - // TIL: there is a .rev() feature in iterators. Next time maybe use that instead. - if (history.len() as u32 - i) == index { - // decompose the string into a character-by-character sequence - // and then stuff byte-by-byte, as fits, into the return array - prediction.len = 0; - for ch in s.as_str().unwrap().chars() { - match ch.len_utf8() { - 1 => { - if prediction.len < prediction.string.len() as u32 { - prediction.string[prediction.len as usize] = ch as u8; - prediction.len += 1; - } else { - break; - } - }, - _ => { - let mut data: [u8; 4] = [0; 4]; - let subslice = ch.encode_utf8(&mut data); - if prediction.len + (subslice.len() as u32) < prediction.string.len() as u32 { - for c in subslice.bytes() { - prediction.string[prediction.len as usize] = c; - prediction.len += 1; - } - } else { - break; - } - }, - } - } - prediction.valid = true; - break; - } - i = i + 1; - } - } else { // there is no history - prediction.valid = false; - if debug1{info!("IME_SH: no prediction found");} - } - if debug1{info!("IME_SH: returning index {} string {:?}", prediction.index, prediction.string);} - - // pack our data back into the buffer to return - let ret_op = Opcode::Prediction(prediction); - let mut writer = rkyv::ser::serializers::BufferSerializer::new(buf); - let _pos = writer.serialize_value(&ret_op).expect("IME_SH: Prediction query couldn't re-archive return value"); - if debug1{info!("IME_SH: archived with pos {}", _pos);} - }, - _ => error!("IME_SH: Got invalid MutableBorrow") - }; - } else if let Ok(opcode) = Opcode::try_from(&envelope.body) { - match opcode { - Opcode::Unpick => { - if history.len() == 1 { - history.dequeue().expect("IME_SH: couldn't dequeue in Unpick (1)"); - } else if history.len() > 1 { - // rotate everything around except the last entry - for _ in 0 .. history.len() - 1 { - let s = history.dequeue().expect("IME_SH: couldn't dequee in Unpick (>1)"); - history.enqueue(s).expect("IME_SH: couldn't enqueue in Unpick"); - } - // discard the last entry - history.dequeue().expect("IME_SH: couldn't dequeue in Unpick (>1 last)"); - } - // in case of 0 length, do nothing - }, - Opcode::GetPredictionTriggers => { - xous::return_scalar(envelope.sender, mytriggers.into()).expect("IME_SH: couldn't return GetPredictionTriggers"); - }, - _ => error!("IME_SH: unknown Opcode"), + let mut msg = xous::receive_message(ime_sh_sid).unwrap(); + log::trace!("received message {:?}", msg); + match FromPrimitive::from_usize(msg.body.id()) { + Some(Opcode::Input) => { + // shell does nothing with the input, it only keeps track of + // the picked results } - } else { - info!("IME_SH: received unknown message type {:?}", envelope); - panic!("IME_SH: received unknown message type"); + Some(Opcode::Picked) => { + let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; + let s = buffer.as_flat::, _>().unwrap(); + // the API allows for large picked feedback, but this implementation only keeps the first 64 characters + let mut local_s: String<64> = String::new(); + use core::fmt::Write; + write!(local_s, "{:32}", s.as_str()).expect("overflowed history variable"); + log::trace!("storing history value | {}", s.as_str()); + if history.len() == history_max { + history.dequeue().expect("couldn't dequeue history"); + } + history.enqueue(local_s).expect("couldn't store history"); + log::trace!("history has length {}", history.len()); + } + Some(Opcode::Prediction) => { + let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) }; + let mut prediction: Prediction = buffer.to_original::().unwrap(); + log::trace!("querying prediction index {}", prediction.index); + log::trace!("{:?}", prediction); + if history.len() > 0 && ((prediction.index as usize) < history.len()) { + let mut index = prediction.index; + if index >= history.len() as u32 { + index = history.len() as u32 - 1; + } + let mut i = 1; + for &s in history.iter() { + // iterator is from oldest to newest, so do some math to go from newest to oldest + // TIL: there is a .rev() feature in iterators. Next time maybe use that instead. + if (history.len() as u32 - i) == index { + // decompose the string into a character-by-character sequence + // and then stuff byte-by-byte, as fits, into the return array + prediction.string.clear(); + for ch in s.as_str().unwrap().chars() { + if let Ok(_) = prediction.string.push(ch) { + // it's ok, carry on. + } else { + // we ran out of space, stop copying + break; + } + } + prediction.valid = true; + break; + } + i = i + 1; + } + } else { // there is no history + prediction.valid = false; + log::trace!("no prediction found"); + } + log::trace!("returning index {} string {:?}", prediction.index, prediction.string); + + // pack our data back into the buffer to return + buffer.replace(Return::Prediction(prediction)).expect("couldn't return Prediction"); + } + Some(Opcode::Unpick) => { + if history.len() == 1 { + history.dequeue().expect("couldn't dequeue in Unpick (1)"); + } else if history.len() > 1 { + // rotate everything around except the last entry + for _ in 0 .. history.len() - 1 { + let s = history.dequeue().expect("couldn't dequee in Unpick (>1)"); + history.enqueue(s).expect("couldn't enqueue in Unpick"); + } + // discard the last entry + history.dequeue().expect("couldn't dequeue in Unpick (>1 last)"); + } + // in case of 0 length, do nothing + } + Some(Opcode::GetPredictionTriggers) => { + xous::return_scalar(msg.sender, mytriggers.into()).expect("couldn't return GetPredictionTriggers"); + } + None => error!("unknown Opcode") } } } diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 0830b24a0..f11aae997 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -40,7 +40,7 @@ fn try_main() -> Result<(), DynError> { //"gam", //"shellchat", //"ime-frontend", - //"ime-plugin-shell", + "ime-plugin-shell", "graphics-server", "ticktimer-server", "log-server",