1mod autosave;
43mod command;
44mod pacing;
45mod recover;
46mod watch;
47
48#[cfg(test)]
49mod tests;
50
51pub use autosave::DELAY_MS as AUTO_SAVE_MS;
52pub use command::{CommandKind, HttpEndpoint, Policy};
53pub use pacing::{LoopState, MAX_BEHIND_MS, Pacing, Speed};
54pub use watch::{EVENT_MS as MEMORY_EVENT_MS, LOOK_MS as MEMORY_LOOK_MS};
55
56use saturnus_core::{Machine, Model};
57use serde::Serialize;
58use serde_json::{Value, json};
59
60use crate::host::{Frame, KeysDown, base64_decode, model_for_rom};
61use crate::transfer::{MAX_FILE_BYTES, Op, Target};
62use crate::{Emulator, Error, Result};
63use autosave::AutoSave;
64use pacing::Loop;
65use recover::{Recover, Step};
66use watch::Watch;
67
68pub const VERSION: u64 = 1;
70pub const MAX_STATE_BYTES: usize = 4 * 1024 * 1024;
73pub const TYPING_STEP_MS: f64 = 20.0;
75pub const WALL_LIMIT_MS: f64 = 30_000.0;
78const WAIT_END_STEPS: usize = 64;
81pub const MAX_SERIAL_PENDING: usize = 16 * 1024;
84pub const SERIAL_IN_USE: &str = "the serial port is in use (serialClose frees it)";
86pub const SERIAL_EVENT_MS: f64 = 10.0;
90
91pub trait Clock {
93 fn now_ms(&self) -> f64;
95}
96
97#[derive(Clone, Debug, PartialEq, Serialize)]
99#[serde(tag = "type", rename = "status", rename_all = "camelCase")]
100pub struct Status {
101 pub model: Option<&'static str>,
103 pub rom_name: String,
105 pub running: bool,
107 pub halted: Option<String>,
109 pub speed: Speed,
111 #[serde(rename = "loop")]
113 pub loop_state: LoopState,
114 pub busy: bool,
116 pub starting: bool,
120}
121
122#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
125#[serde(tag = "type", rename = "error")]
126pub struct ErrorEvent {
127 pub message: String,
129}
130
131#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
133#[serde(tag = "type", rename = "memoryChanged")]
134pub struct MemoryChanged {}
135
136#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
139#[serde(tag = "type", rename = "serial")]
140pub struct SerialEvent {
141 #[serde(serialize_with = "crate::host::as_base64")]
143 pub bytes: Vec<u8>,
144}
145
146#[derive(Clone, Debug, PartialEq, Serialize)]
149#[serde(untagged)]
150pub enum Event {
151 Serial(SerialEvent),
153 Frame(Frame),
155 Keys(KeysDown),
157 Status(Status),
159 Error(ErrorEvent),
161 MemoryChanged(MemoryChanged),
163 Menu(crate::host::MenuKeys),
165}
166
167#[derive(Clone, Debug, PartialEq)]
169pub struct Reply {
170 pub tag: u64,
172 pub result: std::result::Result<Value, String>,
174 pub bytes: Option<(&'static str, Vec<u8>)>,
178}
179
180#[derive(Clone, Debug, PartialEq, Eq)]
184pub struct Saved {
185 pub model: &'static str,
187 pub rom_name: String,
189 pub cycles: u64,
191 pub state: Vec<u8>,
193}
194
195#[derive(Clone, Debug, PartialEq)]
197pub enum Output {
198 Event(Event),
200 Reply(Reply),
202 Save(Saved),
204}
205
206#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
208#[serde(rename_all = "camelCase")]
209pub struct Booted {
210 pub model: &'static str,
212 pub rom_name: String,
214 #[serde(skip_serializing_if = "std::ops::Not::not")]
217 pub restored: bool,
218 #[serde(skip_serializing_if = "Option::is_none")]
221 pub restore_error: Option<String>,
222}
223
224#[derive(Clone, Debug, PartialEq, Serialize)]
226#[serde(rename_all = "camelCase")]
227pub struct Stats {
228 pub cycles: u64,
230 pub emulated_ms: f64,
232 pub work_ms: f64,
234 pub ticks: u64,
236 pub wakes: u64,
238 pub memory_looks: u64,
240 pub memory_ms: f64,
242 #[serde(rename = "loop")]
244 pub loop_state: LoopState,
245 pub owed_ms: f64,
247 pub now_ms: f64,
249}
250
251#[derive(Clone, Debug, PartialEq, Eq)]
253pub struct RunError {
254 pub message: String,
256 pub halted: bool,
258}
259
260#[derive(Clone, Debug, Default)]
265struct SerialOut {
266 held: Vec<u8>,
267 last: Option<f64>,
269}
270
271impl SerialOut {
272 fn take(&mut self, t: f64, slack: f64, now: bool) -> Option<Vec<u8>> {
276 if self.held.is_empty()
277 || (!now && self.last.is_some_and(|l| t + slack < l + SERIAL_EVENT_MS))
278 {
279 return None;
280 }
281 self.last = Some(t);
282 Some(std::mem::take(&mut self.held))
283 }
284
285 fn due(&self) -> Option<f64> {
287 (!self.held.is_empty()).then(|| self.last.map_or(0.0, |l| l + SERIAL_EVENT_MS))
288 }
289}
290
291#[derive(Clone, Debug)]
293struct Send {
294 tag: Option<u64>,
296 freezes: bool,
298 transfer: bool,
300 started: f64,
302 due: f64,
304 stopping: Option<Error>,
307 waiting: Option<Waiting>,
310}
311
312#[derive(Clone, Debug)]
314enum Waiting {
315 Typing(String, String),
317 Transfer(Op),
319}
320
321#[derive(Debug)]
323pub struct Engine {
324 host: &'static str,
326 emu: Option<Emulator>,
327 model: Option<Model>,
328 rom_name: String,
329 halted: Option<String>,
330 lp: Loop,
331 watch: Watch,
332 send: Option<Send>,
333 out: Vec<Output>,
334 last_status: Option<Status>,
335 last_frame: Option<f64>,
337 autosave: AutoSave,
338 answer_recover: bool,
341 recover: Option<Recover>,
342 serial: bool,
345 serial_out: SerialOut,
346}
347
348enum Look {
351 Wait,
353 GiveUp,
355 Answer(Option<Recover>),
358}
359
360fn look(e: &Emulator, r: Recover) -> Look {
361 if e.emulated_ms() > r.until_ms {
362 return Look::GiveUp;
363 }
364 let rows = &e.machine().framebuffer().pixels.pixels;
365 match r.step {
366 Step::Prompt if recover::is_prompt(rows) => {
367 Look::Answer((e.model() == Model::Hp49g).then(|| Recover {
368 step: Step::Dismiss,
369 until_ms: e.emulated_ms() + recover::DISMISS_WAIT_MS,
370 }))
371 }
372 Step::Dismiss if recover::is_memory_clear(rows) => Look::Answer(None),
373 _ => Look::Wait,
374 }
375}
376
377fn answer_boot(e: &mut Emulator, recover: &mut Option<Recover>) -> Result<bool> {
382 if pacing::asleep(e) {
383 match recover.map(|r| look(e, r)) {
384 None => return Ok(true),
385 Some(Look::Wait) => {}
386 Some(Look::GiveUp) => *recover = None,
387 Some(Look::Answer(next)) => {
390 e.type_keys("f");
391 *recover = next;
392 }
393 }
394 }
395 e.run_slice(TYPING_STEP_MS, true)?;
396 Ok(false)
397}
398
399fn str_field<'a>(msg: &'a Value, name: &str) -> Result<&'a str> {
401 msg.get(name)
402 .and_then(Value::as_str)
403 .ok_or_else(|| format!("missing string field {name:?}").into())
404}
405
406fn text_field(msg: &Value) -> Result<String> {
413 let text = str_field(msg, "text")?;
414 Ok(if msg.get("codes").and_then(Value::as_bool) == Some(true) {
415 saturnus_objects::charset::from_trigraphs(text)
416 } else {
417 text.to_string()
418 })
419}
420
421fn value_of<T: Serialize>(v: &T) -> Result<Value> {
423 serde_json::to_value(v).map_err(|e| e.to_string().into())
424}
425
426fn unknown_key(e: &Emulator, key: &str) -> Error {
427 format!("no key {key:?} on the {}", e.model().name()).into()
428}
429
430enum Answer {
433 Now(Value, Option<(&'static str, Vec<u8>)>),
434 Later,
435}
436
437impl From<Value> for Answer {
438 fn from(v: Value) -> Self {
439 Answer::Now(v, None)
440 }
441}
442
443impl Engine {
444 pub fn new(host: &'static str, pacing: Pacing) -> Engine {
447 Engine {
448 host,
449 emu: None,
450 model: None,
451 rom_name: String::new(),
452 halted: None,
453 lp: Loop::new(pacing),
454 watch: Watch::default(),
455 send: None,
456 out: Vec::new(),
457 last_status: None,
458 last_frame: None,
459 autosave: AutoSave::default(),
460 answer_recover: false,
461 recover: None,
462 serial: false,
463 serial_out: SerialOut::default(),
464 }
465 }
466
467 pub fn set_answer_recover(&mut self, on: bool) {
472 self.answer_recover = on;
473 if !on {
474 self.recover = None;
475 }
476 }
477
478 pub fn answering_recover(&self) -> bool {
480 self.recover.is_some()
481 }
482
483 pub fn set_auto_save(&mut self, on: bool) {
486 self.autosave.on = on;
487 if !on {
488 self.autosave.clear();
489 }
490 }
491
492 pub fn auto_saves(&self) -> u64 {
494 self.autosave.saves
495 }
496
497 pub fn save_owed(&self) -> bool {
499 self.autosave.owed()
500 }
501
502 pub fn save_now(&mut self) {
510 if self.autosave.owed() && self.settled() {
511 self.emit_save();
512 }
513 }
514
515 pub fn admit<'a>(&self, msg: &'a Value) -> Result<&'a str> {
519 match msg.get("v") {
520 Some(v) if v.as_u64() == Some(VERSION) => {}
521 Some(v) => {
522 return Err(format!(
523 "protocol version {v} not supported (this host speaks {VERSION})"
524 )
525 .into());
526 }
527 None => {
528 return Err(
529 format!("protocol version missing (this host speaks {VERSION})").into(),
530 );
531 }
532 }
533 let cmd = str_field(msg, "cmd")?;
534 match self.refusal(cmd) {
535 Some(e) => Err(e),
536 None => Ok(cmd),
537 }
538 }
539
540 pub fn refusal(&self, cmd: &str) -> Option<Error> {
545 let policy = cmd.parse::<CommandKind>().ok()?.policy();
546 if self.serial && (policy.write || policy.server) {
547 return Some(SERIAL_IN_USE.into());
548 }
549 let send = self.send.as_ref()?;
550 let refused = policy.refused_while_typing || (send.transfer && policy.serial);
551 refused.then(|| {
552 if send.transfer {
553 "a transfer is in progress (releaseAll stops it)".into()
554 } else {
555 "typing is in progress (releaseAll stops it)".into()
556 }
557 })
558 }
559
560 pub fn command(
567 &mut self,
568 clock: &dyn Clock,
569 msg: &Value,
570 bytes: Option<Vec<u8>>,
571 reply: Option<u64>,
572 ) {
573 let answer = self
574 .admit(msg)
575 .and_then(|cmd| self.handle(clock, cmd, msg, bytes, reply));
576 match answer {
577 Ok(Answer::Later) => self.flush(clock, true),
578 Ok(Answer::Now(v, b)) => self.respond(clock, reply, Ok(v), b),
579 Err(e) => self.respond(clock, reply, Err(e), None),
580 }
581 }
582
583 pub fn answer(&mut self, clock: &dyn Clock, reply: Option<u64>, result: Result<Value>) {
587 self.respond(clock, reply, result, None);
588 }
589
590 fn respond(
591 &mut self,
592 clock: &dyn Clock,
593 reply: Option<u64>,
594 result: Result<Value>,
595 bytes: Option<(&'static str, Vec<u8>)>,
596 ) {
597 self.flush(clock, true);
598 self.reply_to(reply, result, bytes);
599 }
600
601 fn reply_to(
602 &mut self,
603 reply: Option<u64>,
604 result: Result<Value>,
605 bytes: Option<(&'static str, Vec<u8>)>,
606 ) {
607 match (reply, result) {
608 (Some(tag), result) => self.out.push(Output::Reply(Reply {
609 tag,
610 result: result.map_err(|e| e.to_string()),
611 bytes,
612 })),
613 (None, Err(e)) => self.event(Event::Error(ErrorEvent {
614 message: e.to_string(),
615 })),
616 (None, Ok(_)) => {}
617 }
618 }
619
620 fn event(&mut self, e: Event) {
621 self.out.push(Output::Event(e));
622 }
623
624 pub fn take_output(&mut self) -> Vec<Output> {
626 std::mem::take(&mut self.out)
627 }
628
629 pub fn deadline(&self) -> Option<f64> {
633 [
634 self.send.as_ref().map(|s| s.due),
635 self.lp.due(),
636 self.watch.due,
637 self.serial_out.due(),
638 self.settled().then(|| self.autosave.due()).flatten(),
640 ]
641 .into_iter()
642 .flatten()
643 .reduce(f64::min)
644 }
645
646 pub fn timer(&mut self, clock: &dyn Clock) {
649 let now = clock.now_ms();
650 let slack = self.lp.pacing.timer_slack_ms;
651 if self.send.as_ref().is_some_and(|s| s.due <= now + slack) {
652 self.typing_turn(clock);
653 }
654 if let Some(e) = self.emu.as_mut()
655 && let Err(err) = self.lp.fire(e, clock, now)
656 {
657 self.halt(clock, err);
658 }
659 if self.watch.due.is_some_and(|d| d <= now + slack) {
660 self.watch.due = None;
661 }
662 self.flush(clock, !self.lp.passing());
665 self.poll_recover(clock);
666 }
667
668 fn poll_recover(&mut self, clock: &dyn Clock) {
671 let Some(r) = self.recover else {
672 return;
673 };
674 if !self.settled() {
675 return;
676 }
677 let Some(e) = self.emu.as_mut() else {
678 self.recover = None;
679 return;
680 };
681 match look(e, r) {
682 Look::Wait => {}
683 Look::GiveUp => self.recover = None,
684 Look::Answer(next) => {
685 e.type_keys("f");
686 self.recover = next;
687 self.after_keys(clock);
688 }
689 }
690 }
691
692 pub fn input(&mut self, clock: &dyn Clock) {
696 self.autosave.touch(clock.now_ms());
697 if self.lp.sleeping() {
698 self.wake(clock);
699 self.flush(clock, !self.lp.passing());
700 }
701 }
702
703 pub fn serial_open(&self) -> bool {
705 self.serial
706 }
707
708 fn close_serial(&mut self) {
712 self.serial_out = SerialOut::default();
713 if std::mem::take(&mut self.serial)
714 && let Some(e) = self.emu.as_mut()
715 {
716 let m = e.machine_mut();
717 m.serial_clear_inbound();
718 m.serial_drain();
719 }
720 }
721
722 pub fn transferring(&self) -> bool {
726 self.send.as_ref().is_some_and(|s| s.transfer)
727 }
728
729 pub fn sending(&self) -> Option<u64> {
731 self.send.as_ref().and_then(|s| s.tag)
732 }
733
734 pub fn cancel_send(&mut self, clock: &dyn Clock, why: &str) {
736 if self.send.is_some() {
737 self.end_typing(clock, Some(why.into()));
738 }
739 }
740
741 pub fn status(&self) -> Status {
743 Status {
744 model: self.model.map(Model::name),
745 rom_name: self.rom_name.clone(),
746 running: self.lp.running,
747 halted: self.halted.clone(),
748 speed: self.lp.speed,
749 loop_state: self.lp.state(),
750 busy: self.send.as_ref().is_some_and(|s| s.freezes),
751 starting: self.recover.is_some() && self.lp.running && self.halted.is_none(),
754 }
755 }
756
757 pub fn emulator_mut(&mut self) -> Option<&mut Emulator> {
760 self.emu.as_mut()
761 }
762
763 pub fn emulator(&self) -> Result<&Emulator> {
765 self.emu.as_ref().ok_or_else(|| "no ROM loaded".into())
766 }
767
768 pub fn into_emulator(self) -> Option<Emulator> {
770 self.emu
771 }
772
773 pub fn start(&mut self, clock: &dyn Clock, emu: Emulator, rom_name: &str) {
776 self.serial = false;
777 self.serial_out = SerialOut::default();
778 self.model = Some(emu.model());
779 self.emu = Some(emu);
780 self.rom_name = rom_name.to_string();
781 self.recover = None;
783 self.halted = None;
784 self.watch.force = true;
785 self.autosave.clear();
786 self.set_running(clock, true);
787 self.flush(clock, true);
788 }
789
790 pub fn poke(&mut self, clock: &dyn Clock, address: u32, nibbles: &[u8]) -> Result<()> {
794 if let Some(e) = self.refusal("poke") {
795 return Err(e);
796 }
797 let e = self.emu.as_mut().ok_or("no ROM loaded")?;
798 self.recover = None;
799 for (a, &n) in (address..).zip(nibbles) {
800 e.machine_mut().poke(a, n);
801 }
802 e.reshow();
803 self.watch.force = true;
804 if self.send.is_none() {
805 self.lp.schedule(&*e, clock.now_ms());
806 }
807 self.autosave.touch(clock.now_ms());
808 Ok(())
809 }
810
811 pub fn exclusive<T>(
817 &mut self,
818 clock: &dyn Clock,
819 f: impl FnOnce(Machine) -> (Machine, std::result::Result<T, RunError>),
820 ) -> Result<T> {
821 if let Some(e) = self.refusal("keyScript") {
822 return Err(e);
823 }
824 self.wake_running(clock)?;
826 let mut emu = self.emu.take().ok_or("no ROM loaded")?;
827 emu.release_keys();
828 self.recover = None;
829 let start = clock.now_ms();
830 let (machine, result) = f(emu.into_machine());
831 self.lp.work_ms += clock.now_ms() - start;
832 self.emu = Some(Emulator::from_machine(machine));
833 self.autosave.touch(clock.now_ms());
834 match result {
835 Ok(t) => {
836 self.set_running(clock, self.lp.running);
837 Ok(t)
838 }
839 Err(e) => {
840 if e.halted {
841 self.halted = Some(e.message.clone());
842 self.set_running(clock, false);
843 } else {
844 self.set_running(clock, self.lp.running);
845 }
846 Err(e.message.into())
847 }
848 }
849 }
850
851 pub fn boot(
855 &mut self,
856 clock: &dyn Clock,
857 model: &str,
858 rom: &[u8],
859 rom_name: &str,
860 ) -> Result<Booted> {
861 self.boot_restoring(clock, model, rom, rom_name, None)
862 }
863
864 pub fn boot_restoring(
874 &mut self,
875 clock: &dyn Clock,
876 model: &str,
877 rom: &[u8],
878 rom_name: &str,
879 kept: Option<&[u8]>,
880 ) -> Result<Booted> {
881 if let Some(e) = self.refusal("boot") {
882 return Err(e);
883 }
884 let model = model_for_rom(rom, model.parse()?);
885 let mut emu = Emulator::new(model, rom)?;
886 let mut restored = false;
887 let mut restore_error = None;
888 if let Some(state) = kept {
889 if state.len() > MAX_STATE_BYTES {
890 restore_error = Some(format!("state is larger than {MAX_STATE_BYTES} bytes"));
891 } else {
892 match emu.load_state(state) {
893 Ok(()) => restored = true,
894 Err(e) => restore_error = Some(e.to_string()),
895 }
896 }
897 }
898 self.recover =
900 (self.answer_recover && !restored && recover::asks(model)).then(|| Recover {
901 step: Step::Prompt,
902 until_ms: emu.emulated_ms() + recover::PROMPT_WAIT_MS,
903 });
904 self.serial = false;
906 self.serial_out = SerialOut::default();
907 self.emu = Some(emu);
908 self.model = Some(model);
909 self.rom_name = rom_name.to_string();
910 self.halted = None;
911 self.watch.force = true;
912 self.autosave.clear();
913 self.set_running(clock, true);
914 self.flush(clock, true);
915 Ok(Booted {
916 model: model.name(),
917 rom_name: self.rom_name.clone(),
918 restored,
919 restore_error,
920 })
921 }
922
923 pub fn save_state(&self) -> Result<Vec<u8>> {
925 if let Some(e) = self.refusal("saveState") {
926 return Err(e);
927 }
928 Ok(self.emulator()?.save_state())
929 }
930
931 pub fn load_state(&mut self, clock: &dyn Clock, state: &[u8]) -> Result<()> {
936 if let Some(e) = self.refusal("loadState") {
937 return Err(e);
938 }
939 if state.len() > MAX_STATE_BYTES {
940 return Err(format!("state is larger than {MAX_STATE_BYTES} bytes").into());
941 }
942 let e = self.emu.as_mut().ok_or("no ROM loaded")?;
943 e.load_state(state)?;
944 e.reshow();
945 self.recover = None;
947 self.halted = None;
948 self.watch.force = true;
949 self.autosave.touch(clock.now_ms());
950 self.set_running(clock, self.lp.running);
951 self.flush(clock, true);
952 Ok(())
953 }
954
955 pub fn stats(&self, clock: &dyn Clock) -> Stats {
957 let now = clock.now_ms();
958 Stats {
959 cycles: self.emu.as_ref().map_or(0, |e| e.machine().cycles()),
960 emulated_ms: self.emu.as_ref().map_or(0.0, Emulator::emulated_ms),
961 work_ms: self.lp.work_ms,
962 ticks: self.lp.ticks,
963 wakes: self.lp.wakes,
964 memory_looks: self.watch.looks,
965 memory_ms: self.watch.spent_ms,
966 loop_state: self.lp.state(),
967 owed_ms: self.lp.owed_ms(now),
968 now_ms: now,
969 }
970 }
971
972 fn emu(&mut self) -> Result<&mut Emulator> {
973 self.emu.as_mut().ok_or_else(|| "no ROM loaded".into())
974 }
975
976 fn handle(
978 &mut self,
979 clock: &dyn Clock,
980 cmd: &str,
981 msg: &Value,
982 bytes: Option<Vec<u8>>,
983 reply: Option<u64>,
984 ) -> Result<Answer> {
985 let kind: CommandKind = cmd.parse()?;
989 use CommandKind as C;
990 if matches!(kind, C::KeyDown | C::TypeLetter | C::TypeKeys) {
991 self.recover = None;
992 }
993 Ok(match kind {
994 C::Hello => {
995 self.last_status = None;
999 self.watch.on = false;
1000 self.close_serial();
1001 if let Some(e) = self.emu.as_mut() {
1002 e.reshow();
1003 }
1004 let models: Vec<&str> = crate::skins::hosted_models().map(|m| m.name()).collect();
1005 json!({
1007 "protocol": VERSION,
1008 "host": self.host,
1009 "models": models,
1010 "version": env!("CARGO_PKG_VERSION"),
1011 })
1012 .into()
1013 }
1014 C::Skin => {
1015 let m: Model = str_field(msg, "model")?.parse()?;
1016 let view = crate::skins::skin_view(m)
1017 .ok_or_else(|| format!("no drawn keyboard for the {} yet", m.name()))?;
1018 value_of(&view)?.into()
1019 }
1020 C::Layout => {
1021 let m: Model = str_field(msg, "model")?.parse()?;
1022 value_of(&crate::layout::grid(m))?.into()
1023 }
1024 C::Boot => {
1025 let model = str_field(msg, "model")?;
1026 let rom = bytes.ok_or("missing bytes field \"rom\"")?;
1027 let name = msg.get("romName").and_then(Value::as_str).unwrap_or("");
1028 value_of(&self.boot(clock, model, &rom, name)?)?.into()
1029 }
1030 C::KeyDown => {
1031 let key = str_field(msg, "key")?;
1032 let shift = msg.get("shift").and_then(Value::as_str);
1033 let e = self.emu()?;
1034 let queued = match shift {
1035 None => e.press(key),
1036 Some(shift) => {
1037 if !e.has_key(shift) {
1038 return Err(unknown_key(e, shift));
1039 }
1040 e.press_shifted(key, shift)
1041 }
1042 };
1043 if !queued {
1044 if let Some(shift) = shift.filter(|_| e.has_key(key)) {
1045 return Err(format!("{shift:?} is not a shift key").into());
1046 }
1047 return Err(unknown_key(e, key));
1048 }
1049 self.autosave.touch(clock.now_ms());
1050 self.after_keys(clock);
1051 Value::Null.into()
1052 }
1053 C::KeyUp => {
1054 let key = str_field(msg, "key")?;
1055 let e = self.emu()?;
1056 if !e.has_key(key) {
1057 return Err(unknown_key(e, key));
1058 }
1059 e.release(key);
1060 e.pump();
1061 self.autosave.touch(clock.now_ms());
1062 Value::Null.into()
1063 }
1064 C::KeyUpAll => {
1065 if self.send.is_none()
1069 && let Some(e) = self.emu.as_mut()
1070 {
1071 e.release_held();
1072 e.pump();
1073 }
1074 Value::Null.into()
1075 }
1076 C::TypeLetter => {
1077 let letter = str_field(msg, "letter")?;
1078 let Some(e) = self.emu.as_mut() else {
1079 return Ok(Value::Bool(false).into());
1080 };
1081 let ok = e.type_letter(letter);
1082 self.autosave.touch(clock.now_ms());
1083 self.after_keys(clock);
1084 Value::Bool(ok).into()
1085 }
1086 C::TypeKeys => {
1087 let keys = msg
1088 .get("keys")
1089 .and_then(Value::as_array)
1090 .ok_or("missing array field \"keys\"")?;
1091 if keys.len() > crate::typing::MAX_CHARS {
1093 return Err(format!(
1094 "\"keys\" holds more than {} keys",
1095 crate::typing::MAX_CHARS
1096 )
1097 .into());
1098 }
1099 let keys: Vec<&str> = keys
1100 .iter()
1101 .map(Value::as_str)
1102 .collect::<Option<_>>()
1103 .ok_or("\"keys\" must hold key names (strings)")?;
1104 let e = self.emu()?;
1105 if let Some(k) = keys.iter().find(|k| !e.has_key(k)) {
1107 return Err(unknown_key(e, k));
1108 }
1109 e.queue().type_keys(&keys);
1110 self.autosave.touch(clock.now_ms());
1111 self.after_keys(clock);
1112 Value::Null.into()
1113 }
1114 C::ReleaseAll => {
1115 self.cancel_send(clock, "cancelled");
1117 if let Some(e) = self.emu.as_mut() {
1118 e.release_keys();
1119 }
1120 Value::Null.into()
1121 }
1122 C::SetSpeed => {
1123 self.lp.speed = Speed::parse(str_field(msg, "speed")?);
1126 Value::Null.into()
1127 }
1128 C::Pause => {
1129 let paused = msg.get("paused").and_then(Value::as_bool).unwrap_or(true);
1131 self.set_running(clock, !paused);
1132 Value::Null.into()
1133 }
1134 C::Unload => {
1135 if self.autosave.owed() {
1140 self.emit_save();
1141 }
1142 self.serial = false;
1143 self.serial_out = SerialOut::default();
1144 self.emu = None;
1145 self.model = None;
1146 self.rom_name.clear();
1147 self.halted = None;
1148 self.recover = None;
1149 self.watch.on = false;
1150 self.autosave.clear();
1151 self.set_running(clock, false);
1152 self.send_status();
1153 Value::Null.into()
1154 }
1155 C::Reset => {
1156 self.recover = None;
1157 let e = self.emu()?;
1158 e.release_keys();
1159 e.reset();
1160 self.halted = None;
1161 self.autosave.touch(clock.now_ms());
1162 self.set_running(clock, true);
1163 Value::Null.into()
1164 }
1165 C::SaveState => {
1166 let state = self.save_state()?;
1167 let cycles = self.emulator()?.machine().cycles();
1168 Answer::Now(json!({"cycles": cycles}), Some(("state", state)))
1169 }
1170 C::LoadState => {
1171 let state = match bytes {
1172 Some(b) => b,
1173 None => {
1174 let b64 = str_field(msg, "state")?;
1175 if b64.len() > MAX_STATE_BYTES.div_ceil(3) * 4 {
1176 return Err(
1177 format!("state is larger than {MAX_STATE_BYTES} bytes").into()
1178 );
1179 }
1180 base64_decode(b64).map_err(|e| format!("state: {e}"))?
1181 }
1182 };
1183 self.load_state(clock, &state)?;
1184 json!({}).into()
1185 }
1186 C::Visibility => {
1187 let hidden = msg.get("hidden").and_then(Value::as_bool).unwrap_or(false);
1188 if hidden {
1194 self.autosave.hide();
1195 }
1196 let idle = self.send.is_none();
1197 self.lp
1198 .set_hidden(hidden, self.emu.as_ref(), idle, clock.now_ms());
1199 Value::Null.into()
1200 }
1201 C::Stats => value_of(&self.stats(clock))?.into(),
1202 C::WatchMemory => {
1203 let on = msg.get("on").and_then(Value::as_bool).unwrap_or(false);
1204 self.watch.subscribe(on, self.emu.as_ref());
1205 let Some(e) = &self.emu else {
1206 return Ok(json!({"supported": null, "reason": null}).into());
1207 };
1208 let reason = e.memory_refusal();
1209 json!({"supported": reason.is_none(), "reason": reason}).into()
1210 }
1211 C::MemoryTree => value_of(&self.emu()?.memory_tree()?)?.into(),
1212 C::Stack => Value::Array(self.emu()?.stack()?).into(),
1213 C::StackTop => self.emu()?.stack_top()?.into(),
1214 C::Flags => value_of(&self.emu()?.flags()?)?.into(),
1215 C::ObjectAt => {
1216 let address = msg
1217 .get("address")
1218 .and_then(Value::as_u64)
1219 .ok_or("missing number field \"address\"")?;
1220 let address = u32::try_from(address)
1221 .ok()
1222 .filter(|&a| a <= 0xF_FFFF)
1223 .ok_or("address is outside the address space")?;
1224 self.emu()?.object_at(address)?.into()
1225 }
1226 C::CommandLine => value_of(&self.emu()?.command_line()?)?.into(),
1227 C::EntryModes => value_of(&crate::typing::entry_modes(self.emu()?.machine())?)?.into(),
1228 C::UiState => value_of(&self.emu()?.ui_state()?)?.into(),
1229 C::SerialOpen => {
1230 let serial = self.serial;
1231 let e = self.emu()?;
1232 if !e.machine().has_serial() {
1233 return Err(format!(
1234 "the {} has no serial port",
1235 e.model().name().to_uppercase()
1236 )
1237 .into());
1238 }
1239 if !serial {
1242 e.machine_mut().serial_drain();
1243 self.serial = true;
1244 }
1245 Value::Null.into()
1246 }
1247 C::SerialWrite => {
1248 self.emu()?;
1250 if !self.serial {
1251 return Err("the serial port is not open (serialOpen first)".into());
1252 }
1253 let too_many =
1254 || format!("more than {MAX_SERIAL_PENDING} bytes for the serial port");
1255 let data = match bytes {
1256 Some(b) => b,
1257 None => {
1258 let b64 = str_field(msg, "bytes")?;
1259 if b64.len() > MAX_SERIAL_PENDING.div_ceil(3) * 4 {
1260 return Err(too_many().into());
1261 }
1262 base64_decode(b64).map_err(|e| format!("bytes: {e}"))?
1263 }
1264 };
1265 if data.len() > MAX_SERIAL_PENDING {
1266 return Err(too_many().into());
1267 }
1268 let m = self.emu()?.machine_mut();
1269 let waiting = m.serial_pending();
1270 if waiting + data.len() > MAX_SERIAL_PENDING {
1271 return Err(format!(
1272 "the serial port's input is full ({waiting} bytes still waiting)"
1273 )
1274 .into());
1275 }
1276 m.serial_push(&data);
1277 self.input(clock);
1278 Value::Null.into()
1279 }
1280 C::SerialClose => {
1281 self.close_serial();
1282 Value::Null.into()
1283 }
1284 C::EditText => {
1285 let (dir, target) = self.text_target(msg)?;
1286 let (text, was) = self.emu()?.edit_text(&dir, &target)?;
1287 json!({"text": text, "was": was}).into()
1288 }
1289 C::Insert | C::TypeText => self.start_typing(clock, "insert", msg, reply)?,
1290 C::Run => self.start_typing(clock, "run", msg, reply)?,
1291 C::ProbeServer | C::EndServer => {
1292 let m = self.emu()?.machine();
1295 if !crate::transfer::may_serve(m) && m.has_serial() {
1296 return Ok(json!({"server": false, "emulatedMs": 0.0, "keys": false}).into());
1297 }
1298 let op = Op::Server {
1299 end: kind == C::EndServer,
1300 };
1301 self.start_transfer(clock, op, reply)?
1302 }
1303 C::StoreFile
1304 | C::FetchFile
1305 | C::Purge
1306 | C::Rename
1307 | C::CreateDir
1308 | C::ChangeDir
1309 | C::SetFlag
1310 | C::Copy
1311 | C::Move
1312 | C::StoreScreen
1313 | C::StoreText
1314 | C::Backup => {
1315 let op = self.write_op(kind, msg, bytes)?;
1316 self.start_transfer(clock, op, reply)?
1317 }
1318 C::Replace => self.start_typing(clock, "replace", msg, reply)?,
1319 C::SetClock => self.set_clock(clock, msg, reply)?,
1320 C::Screen
1323 | C::Info
1324 | C::Model
1325 | C::Peek
1326 | C::Poke
1327 | C::KeyScript
1328 | C::StateSlot
1329 | C::OpenState
1330 | C::SaveFile
1331 | C::RomSlots
1332 | C::BootModel
1333 | C::ChooseRom
1334 | C::DownloadRom
1335 | C::ForgetRom
1336 | C::RomSettings
1337 | C::Join
1338 | C::Ping
1339 | C::Attach
1340 | C::Leave => return Err(format!("unknown command {cmd:?}").into()),
1341 })
1342 }
1343
1344 fn after_keys(&mut self, clock: &dyn Clock) {
1348 self.wake(clock);
1349 if let Some(e) = self.emu.as_mut() {
1350 e.pump();
1351 }
1352 }
1353
1354 fn wake(&mut self, clock: &dyn Clock) {
1356 if let Some(e) = self.emu.as_mut()
1357 && let Err(err) = self.lp.wake(e, clock)
1358 {
1359 self.halt(clock, err);
1360 }
1361 }
1362
1363 fn wake_running(&mut self, clock: &dyn Clock) -> Result<()> {
1367 if self.halted.is_none() {
1368 self.wake(clock);
1369 }
1370 match &self.halted {
1371 Some(h) => Err(format!("the CPU is halted: {h}").into()),
1372 None => Ok(()),
1373 }
1374 }
1375
1376 fn halt(&mut self, clock: &dyn Clock, err: Error) {
1377 self.halted = Some(err.to_string());
1378 self.set_running(clock, false);
1379 }
1380
1381 fn set_running(&mut self, clock: &dyn Clock, on: bool) {
1384 self.lp.running = on && self.emu.is_some() && self.halted.is_none();
1385 self.lp.stop();
1386 if self.send.is_some() {
1388 return;
1389 }
1390 if let Some(e) = &self.emu {
1391 self.lp.start(e, clock.now_ms());
1392 }
1393 }
1394
1395 fn start_typing(
1398 &mut self,
1399 clock: &dyn Clock,
1400 verb: &str,
1401 msg: &Value,
1402 reply: Option<u64>,
1403 ) -> Result<Answer> {
1404 let text = &text_field(msg)?;
1405 self.emu()?;
1406 self.wake_running(clock)?;
1408 let waiting = self.recover.is_some() && self.lp.running;
1412 let freezes = if waiting {
1413 self.emu()?.check_typing(verb, text)?
1414 } else {
1415 self.emu()?.start_typing(verb, text)?
1416 };
1417 self.lp.stop();
1418 let now = clock.now_ms();
1419 self.autosave.touch(now);
1420 self.send = Some(Send {
1421 tag: reply,
1422 freezes,
1423 transfer: false,
1424 started: now,
1425 due: now,
1426 stopping: None,
1427 waiting: waiting.then(|| Waiting::Typing(verb.to_string(), text.to_string())),
1428 });
1429 Ok(Answer::Later)
1430 }
1431
1432 fn write_op(&mut self, cmd: CommandKind, msg: &Value, bytes: Option<Vec<u8>>) -> Result<Op> {
1436 let given = match msg.get("dir") {
1437 None | Some(Value::Null) => None,
1438 Some(v) => Some(
1439 v.as_array()
1440 .and_then(|a| {
1441 a.iter()
1442 .map(|s| s.as_str().map(str::to_string))
1443 .collect::<Option<Vec<_>>>()
1444 })
1445 .ok_or("\"dir\" must be an array of directory names")?,
1446 ),
1447 };
1448 let name = || str_field(msg, "name").map(str::to_string);
1449 let dir = Vec::new();
1450 if cmd == CommandKind::StoreText {
1451 let text = text_field(msg)?;
1452 let (dir, target) = self.text_target(msg)?;
1453 if let Some(was) = msg.get("was").and_then(Value::as_str) {
1458 self.emu()?.check_unchanged(&dir, &target, was)?;
1459 }
1460 return Ok(Op::StoreText { dir, target, text });
1461 }
1462 if cmd == CommandKind::StoreScreen {
1463 let name = match msg.get("name") {
1464 None | Some(Value::Null) => None,
1465 Some(_) => Some(name()?),
1466 };
1467 let screen = self.screen_of(msg)?;
1468 let dir = match (given, &name) {
1469 (Some(d), _) => d,
1470 (None, Some(_)) => self.emu()?.memory_tree()?.path,
1471 (None, None) => Vec::new(),
1472 };
1473 return Ok(Op::StoreScreen {
1474 dir,
1475 name,
1476 replace: msg.get("replace").and_then(Value::as_bool).unwrap_or(false),
1477 screen,
1478 });
1479 }
1480 if cmd == CommandKind::Backup {
1481 return Ok(Op::Backup);
1482 }
1483 let mut op = match cmd {
1484 CommandKind::StoreFile => {
1485 let data = match bytes {
1486 Some(b) => b,
1487 None => {
1488 let b64 = str_field(msg, "data")?;
1489 if b64.len() > MAX_FILE_BYTES.div_ceil(3) * 4 {
1490 return Err(
1491 format!("the file is larger than {MAX_FILE_BYTES} bytes").into()
1492 );
1493 }
1494 base64_decode(b64).map_err(|e| format!("data: {e}"))?
1495 }
1496 };
1497 Op::Store {
1498 dir,
1499 name: name()?,
1500 data,
1501 replace: msg.get("replace").and_then(Value::as_bool),
1502 }
1503 }
1504 CommandKind::FetchFile => Op::Fetch {
1505 dir,
1506 name: name()?,
1507 text: msg.get("text").and_then(Value::as_bool).unwrap_or(false),
1508 },
1509 CommandKind::Purge => Op::Purge { dir, name: name()? },
1510 CommandKind::Rename => Op::Rename {
1511 dir,
1512 name: name()?,
1513 to: str_field(msg, "to")?.to_string(),
1514 },
1515 CommandKind::CreateDir => Op::CreateDir { dir, name: name()? },
1516 CommandKind::Copy | CommandKind::Move => Op::Copy {
1517 dir,
1518 name: name()?,
1519 to: msg
1520 .get("to")
1521 .and_then(Value::as_array)
1522 .and_then(|a| {
1523 a.iter()
1524 .map(|s| s.as_str().map(str::to_string))
1525 .collect::<Option<Vec<_>>>()
1526 })
1527 .ok_or("\"to\" must be an array of directory names")?,
1528 replace: msg.get("replace").and_then(Value::as_bool).unwrap_or(false),
1529 remove: cmd == CommandKind::Move,
1530 },
1531 CommandKind::ChangeDir if given.is_none() => {
1532 return Err("missing array field \"dir\"".into());
1533 }
1534 CommandKind::ChangeDir => Op::ChangeDir { dir },
1535 _ => {
1536 let flag = msg
1537 .get("flag")
1538 .and_then(Value::as_i64)
1539 .and_then(|f| i32::try_from(f).ok())
1540 .ok_or("missing number field \"flag\"")?;
1541 let on = msg
1542 .get("on")
1543 .and_then(Value::as_bool)
1544 .ok_or("missing boolean field \"on\"")?;
1545 Op::SetFlag { flag, on }
1546 }
1547 };
1548 if let Op::Store { dir, .. }
1550 | Op::Fetch { dir, .. }
1551 | Op::Purge { dir, .. }
1552 | Op::Rename { dir, .. }
1553 | Op::CreateDir { dir, .. }
1554 | Op::Copy { dir, .. }
1555 | Op::ChangeDir { dir } = &mut op
1556 {
1557 *dir = match given {
1558 Some(d) => d,
1559 None => self.emu()?.memory_tree()?.path,
1560 };
1561 }
1562 Ok(op)
1563 }
1564
1565 fn screen_of(&mut self, msg: &Value) -> Result<saturnus_objects::Graphic> {
1569 let lcd = self.emu()?.machine().lcd();
1570 let (width, height) = (lcd.width(), lcd.height());
1571 let packed = match msg.get("pixels") {
1572 None | Some(Value::Null) => crate::host::pack_bits(&lcd.pixels),
1573 Some(_) => {
1574 let b64 = str_field(msg, "pixels")?;
1575 let given =
1576 |k: &str, d: usize| msg.get(k).and_then(Value::as_u64).unwrap_or(d as u64);
1577 if given("width", width) != width as u64 || given("height", height) != height as u64
1578 {
1579 return Err(format!("the screen is {width} by {height} pixels").into());
1580 }
1581 let bytes = base64_decode(b64).map_err(|e| format!("pixels: {e}"))?;
1582 if bytes.len() != crate::host::packed_row_bytes(width) * height {
1583 return Err(format!("pixels: not {width} by {height} pixels").into());
1584 }
1585 bytes
1586 }
1587 };
1588 saturnus_objects::Graphic::from_packed(width as u32, height as u32, &packed)
1589 .map_err(Into::into)
1590 }
1591
1592 fn text_target(&mut self, msg: &Value) -> Result<(Vec<String>, Target)> {
1595 let target = match (msg.get("name"), msg.get("level")) {
1596 (Some(_), None) => Target::Variable(str_field(msg, "name")?.to_string()),
1597 (None, Some(l)) => Target::Level(
1598 l.as_u64()
1599 .and_then(|n| usize::try_from(n).ok())
1600 .filter(|&n| n >= 1)
1601 .ok_or("\"level\" must be a stack level (1 or more)")?,
1602 ),
1603 _ => return Err("give either \"name\" or \"level\"".into()),
1604 };
1605 let dir = match msg.get("dir") {
1606 None | Some(Value::Null) => self.emu()?.memory_tree()?.path,
1607 Some(v) => v
1608 .as_array()
1609 .and_then(|a| {
1610 a.iter()
1611 .map(|s| s.as_str().map(str::to_string))
1612 .collect::<Option<Vec<_>>>()
1613 })
1614 .ok_or("\"dir\" must be an array of directory names")?,
1615 };
1616 Ok((dir, target))
1617 }
1618
1619 fn set_clock(&mut self, clock: &dyn Clock, msg: &Value, reply: Option<u64>) -> Result<Answer> {
1628 let wall_ms = clock.now_ms();
1629 let time = crate::clock::ClockTime::from_json(msg)?;
1630 let ms = match msg.get("millisecond") {
1631 None | Some(Value::Null) => 0.0,
1632 Some(v) => v
1633 .as_f64()
1634 .filter(|ms| (0.0..1000.0).contains(ms))
1635 .ok_or("\"millisecond\" must be a number from 0 to 999")?,
1636 };
1637 let now = crate::clock::Now { time, ms, wall_ms };
1638 if let Some(h) = &self.halted {
1639 return Err(format!("the CPU is halted: {h}").into());
1640 }
1641 if self.recover.is_some() {
1642 return Err(crate::clock::BUSY.into());
1643 }
1644 if let Some(why) = self.emu()?.clock_refusal() {
1645 return Err(why.into());
1646 }
1647 self.wake_running(clock)?;
1652 if self.lp.behind_ms() > 0.0 {
1653 return Err(crate::clock::BUSY.into());
1654 }
1655 let e = self.emu()?;
1656 if crate::clock::by_command(e.model()) {
1657 let (op, _) = e.clock_write(&now, &crate::clock::Pace::UNBOUNDED, clock)?;
1659 return self.start_transfer(clock, op, reply);
1660 }
1661 let pace = self.lp.clock_pace();
1662 let e = self.emu()?;
1663 e.set_clock_by_keys(&now, &pace, clock)?;
1664 self.autosave.touch(clock.now_ms());
1665 self.after_keys(clock);
1666 Ok(Value::Null.into())
1667 }
1668
1669 fn start_transfer(&mut self, clock: &dyn Clock, op: Op, reply: Option<u64>) -> Result<Answer> {
1672 self.emu()?;
1673 self.wake_running(clock)?;
1674 let waiting = if self.recover.is_some() && self.lp.running {
1677 Some(Waiting::Transfer(op))
1678 } else {
1679 self.emu()?.start_transfer(op)?;
1680 None
1681 };
1682 self.lp.stop();
1683 let now = clock.now_ms();
1684 self.autosave.touch(now);
1685 self.send = Some(Send {
1686 tag: reply,
1687 freezes: true,
1688 transfer: true,
1689 started: now,
1690 due: now,
1691 stopping: None,
1692 waiting,
1693 });
1694 Ok(Answer::Later)
1695 }
1696
1697 fn typing_turn(&mut self, clock: &dyn Clock) {
1700 let (Some(send), Some(e)) = (self.send.as_mut(), self.emu.as_mut()) else {
1701 return;
1702 };
1703 let started = send.started;
1704 let transfer = send.transfer;
1705 let start = clock.now_ms();
1706 let mut result = Ok(false);
1707 while matches!(result, Ok(false)) && clock.now_ms() - start < self.lp.pacing.typing_tick_ms
1708 {
1709 result = if send.waiting.is_some() {
1710 match answer_boot(e, &mut self.recover) {
1711 Ok(true) => match send.waiting.take() {
1712 Some(Waiting::Typing(verb, text)) => {
1713 e.start_typing(&verb, &text).map(|_| false)
1714 }
1715 Some(Waiting::Transfer(op)) => e.start_transfer(op).map(|_| false),
1716 None => Ok(false),
1717 },
1718 other => other.map(|_| false),
1719 }
1720 } else if transfer {
1721 e.transfer_step(TYPING_STEP_MS)
1722 } else {
1723 e.typing_step(TYPING_STEP_MS)
1724 };
1725 }
1726 let now = clock.now_ms();
1727 self.lp.work_ms += now - start;
1728 if matches!(result, Ok(false))
1731 && now - started > WALL_LIMIT_MS
1732 && !transfer
1733 && send.waiting.is_none()
1734 && e.typing_end_wait()
1735 {
1736 for _ in 0..WAIT_END_STEPS {
1737 result = e.typing_step(TYPING_STEP_MS);
1738 if !matches!(result, Ok(false)) {
1739 break;
1740 }
1741 e.typing_end_wait();
1742 }
1743 }
1744 match result {
1745 Ok(false) if now - started > WALL_LIMIT_MS => self.end_typing(
1746 clock,
1747 Some(
1748 format!(
1749 "{} ran out of wall-clock time ({} s)",
1750 if transfer { "the transfer" } else { "typing" },
1751 WALL_LIMIT_MS / 1000.0
1752 )
1753 .into(),
1754 ),
1755 ),
1756 Ok(false) => {
1757 if let Some(s) = self.send.as_mut() {
1758 s.due = now;
1759 }
1760 self.flush(clock, true);
1761 }
1762 Ok(true) => self.end_typing(clock, None),
1763 Err(err) => self.end_typing(clock, Some(err)),
1764 }
1765 }
1766
1767 fn end_typing(&mut self, clock: &dyn Clock, error: Option<Error>) {
1772 let Some(mut send) = self.send.take() else {
1773 return;
1774 };
1775 if let (Some(err), Some(e)) = (&error, self.emu.as_mut())
1776 && send.transfer
1777 && e.transferring()
1778 {
1779 if send.stopping.is_none() && !matches!(err, Error::Halted(_)) {
1780 e.stop_transfer();
1781 let now = clock.now_ms();
1782 send.stopping = Some(err.clone());
1783 send.started = now;
1784 send.due = now;
1785 self.send = Some(send);
1786 return;
1787 }
1788 e.abandon_transfer();
1790 }
1791 let error = match (send.stopping.take(), error) {
1792 (Some(why), None) => Some(match self.emu.as_mut().map(Emulator::transfer_result) {
1793 Some(Err(e)) if e.to_string() != crate::transfer::STOPPED => {
1794 format!("{why}; {e}").into()
1795 }
1796 _ => why,
1797 }),
1798 (Some(why), Some(e)) => Some(format!("{why}; {e}").into()),
1799 (None, e) => e,
1800 };
1801 self.autosave.touch(clock.now_ms());
1803 let mut bytes = None;
1804 let result = match (error, self.emu.as_mut()) {
1805 (_, None) => Err("no ROM loaded".into()),
1806 (None, Some(e)) if send.transfer => e.transfer_result().and_then(|(r, file)| {
1807 bytes = file.map(|f| ("data", f));
1808 value_of(&r)
1809 }),
1810 (None, Some(e)) => e.typing_result().and_then(|r| value_of(&r)),
1811 (Some(err), Some(e)) => {
1812 e.stop_typing();
1813 e.stop_transfer();
1814 Err(err)
1815 }
1816 };
1817 if send.transfer {
1818 if let Some(e) = self.emu.as_mut() {
1820 e.reshow();
1821 }
1822 self.watch.force = true;
1823 }
1824 if send.freezes {
1826 self.send_status();
1827 }
1828 match &result {
1829 Err(e @ Error::Halted(_)) => {
1830 let e = e.clone();
1831 self.halt(clock, e);
1832 }
1833 _ => self.set_running(clock, self.lp.running),
1834 }
1835 self.respond(clock, send.tag, result, bytes);
1836 }
1837
1838 fn flush(&mut self, clock: &dyn Clock, now: bool) {
1844 if self.serial
1847 && let Some(e) = self.emu.as_mut()
1848 {
1849 self.serial_out.held.extend(e.machine_mut().serial_drain());
1850 let slack = self.lp.pacing.timer_slack_ms;
1851 if let Some(bytes) = self.serial_out.take(clock.now_ms(), slack, now) {
1852 self.event(Event::Serial(SerialEvent { bytes }));
1853 }
1854 }
1855 let frozen = self.send.as_ref().is_some_and(|s| s.freezes);
1856 if !frozen && let Some(e) = self.emu.as_mut() {
1857 let errors = e.take_errors();
1858 let keys = e.keys_if_changed();
1859 let t = clock.now_ms();
1860 let due = now
1861 || self
1862 .last_frame
1863 .is_none_or(|f| t - f >= self.lp.pacing.frame_ms);
1864 let frame = if due { e.frame_if_changed() } else { None };
1865 for err in errors {
1866 self.event(Event::Error(ErrorEvent {
1867 message: err.to_string(),
1868 }));
1869 }
1870 if let Some(k) = keys {
1871 self.event(Event::Keys(k));
1872 }
1873 if let Some(f) = frame {
1874 self.last_frame = Some(t);
1875 self.event(Event::Frame(f));
1876 }
1877 if self.send.is_none()
1880 && let Some(e) = self.emu.as_mut()
1881 && pacing::asleep(e)
1882 && let Some(m) = e.menu_if_changed()
1883 {
1884 self.event(Event::Menu(m));
1885 }
1886 }
1887 self.send_status();
1888 self.poll_memory(clock);
1889 self.poll_save(clock);
1890 }
1891
1892 fn settled(&self) -> bool {
1895 self.send.is_none()
1896 && self.halted.is_none()
1897 && self.emu.as_ref().is_some_and(pacing::asleep)
1898 }
1899
1900 fn poll_save(&mut self, clock: &dyn Clock) {
1903 let settled = self.settled();
1904 if self
1905 .autosave
1906 .poll(clock.now_ms(), self.lp.pacing.timer_slack_ms, settled)
1907 {
1908 self.emit_save();
1909 }
1910 }
1911
1912 fn emit_save(&mut self) {
1913 let Some(e) = self.emu.as_ref() else {
1914 return;
1915 };
1916 let saved = Saved {
1917 model: e.model().name(),
1918 rom_name: self.rom_name.clone(),
1919 cycles: e.machine().cycles(),
1920 state: e.save_state(),
1921 };
1922 self.autosave.clear();
1923 self.autosave.saves += 1;
1924 self.out.push(Output::Save(saved));
1925 }
1926
1927 fn send_status(&mut self) {
1928 let status = self.status();
1929 if self.last_status.as_ref() != Some(&status) {
1930 self.last_status = Some(status.clone());
1931 self.event(Event::Status(status));
1932 }
1933 }
1934
1935 fn poll_memory(&mut self, clock: &dyn Clock) {
1939 let quiet = self.send.is_none()
1940 && self
1941 .emu
1942 .as_ref()
1943 .is_none_or(|e| !self.lp.running || pacing::asleep(e));
1944 if self.watch.poll(self.emu.as_ref(), quiet, clock) {
1945 self.event(Event::MemoryChanged(MemoryChanged {}));
1946 }
1947 }
1948}