1use saturnus_core::{Machine, Model};
52use serde::Serialize;
53
54use crate::cmdline::{self, EditorLayout};
55use crate::error::Error;
56use crate::object::{Memory, Object, decode_at};
57use crate::prolog::ObjectType;
58use crate::prolog::ObjectType::{Program, String as Str, SystemBinary as Bint};
59
60type Result<T, E = Error> = std::result::Result<T, E>;
61
62const MAX_DEPTH: u32 = 4096;
65const MAX_ENVIRONMENTS: usize = 64;
67const MAX_BINDINGS: u32 = 512;
69const KEY_WAIT: u32 = 4;
72const LOOP_FRAME: u32 = KEY_WAIT + 2;
75
76#[derive(Clone, Copy, Debug, PartialEq, Eq)]
79pub struct ScreenLayout {
80 pub return_bottom_ptr: u32,
83 pub return_top_ptr: u32,
85 pub environments_ptr: u32,
87 pub shown_grob_ptr: u32,
89 pub pict_ptr: u32,
91 pub base_depth: u32,
93 pub outer_frame: u32,
96}
97
98impl ScreenLayout {
99 pub const HP48SX: ScreenLayout = ScreenLayout {
101 return_bottom_ptr: 0x7056F,
102 return_top_ptr: 0x70574,
103 environments_ptr: 0x70583,
104 shown_grob_ptr: 0x7055B,
105 pict_ptr: 0x70565,
106 base_depth: 8,
107 outer_frame: 3,
108 };
109 pub const HP48GX: ScreenLayout = ScreenLayout {
111 return_bottom_ptr: 0x806EE,
112 return_top_ptr: 0x806F3,
113 environments_ptr: 0x80702,
114 shown_grob_ptr: 0x806DA,
115 pict_ptr: 0x806E4,
116 base_depth: 8,
117 outer_frame: 3,
118 };
119 pub const HP49G: ScreenLayout = ScreenLayout {
121 base_depth: 9,
122 outer_frame: 4,
123 ..Self::HP48GX
124 };
125
126 pub fn of(model: Model) -> Option<ScreenLayout> {
129 match model {
130 Model::Hp48sx => Some(Self::HP48SX),
131 Model::Hp48gx => Some(Self::HP48GX),
132 Model::Hp49g => Some(Self::HP49G),
133 Model::Hp38g
134 | Model::Hp39g
135 | Model::Hp40g
136 | Model::Hp42s
137 | Model::Hp27s
138 | Model::Hp17bii
139 | Model::Hp17b
140 | Model::Hp28s
141 | Model::Hp19bii => None,
142 }
143 }
144}
145
146#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
148#[serde(rename_all = "camelCase")]
149pub enum Kind {
150 Stack,
152 CommandLine,
154 Halted,
156 InputForm,
158 ChooseBox,
160 Message,
162 Graphics,
164 EquationWriter,
168 EquationView,
172 InteractiveStack,
176 ObjectEdit,
181 MatrixWriter,
184 Input,
188 Unknown,
191}
192
193#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
195#[serde(rename_all = "camelCase")]
196pub enum Source {
197 Memory,
199 Display,
201}
202
203#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
205#[serde(rename_all = "camelCase")]
206pub struct Screen {
207 pub kind: Kind,
209 pub from: Source,
211 pub stack_in_control: bool,
214 pub halted: u32,
216 pub command_line: bool,
219}
220
221fn field(mem: &dyn Memory, addr: u32, len: u32) -> Result<u32> {
222 let mut v = 0;
223 for i in (0..len).rev() {
224 v = (v << 4) | u32::from(mem.nibble(addr + i).ok_or(Error::Unreadable(addr + i))?);
225 }
226 Ok(v)
227}
228
229#[derive(Clone, Debug, PartialEq, Eq)]
231pub struct ReturnStack {
232 pub entries: Vec<u32>,
234}
235
236impl ReturnStack {
237 pub fn read(mem: &dyn Memory, layout: &ScreenLayout) -> Result<Option<ReturnStack>> {
240 let bottom = field(mem, layout.return_bottom_ptr, 5)?;
241 let top = field(mem, layout.return_top_ptr, 5)?;
242 if top <= bottom || (top - bottom) % 5 != 0 || (top - bottom) / 5 > MAX_DEPTH {
243 return Ok(None);
244 }
245 let depth = (top - bottom) / 5;
246 let mut entries = Vec::with_capacity(depth as usize);
247 for i in 1..=depth {
248 entries.push(field(mem, top - 5 * i, 5)?);
249 }
250 Ok(Some(ReturnStack { entries }))
251 }
252
253 fn top(&self, i: u32) -> Option<u32> {
255 self.entries.get(i.checked_sub(1)? as usize).copied()
256 }
257
258 fn bottom(&self, j: u32) -> Option<u32> {
260 let n = self.entries.len();
261 self.entries.get(n.checked_sub(j as usize)?).copied()
262 }
263
264 pub fn control(&self, layout: &ScreenLayout) -> Option<(bool, u32)> {
268 if (self.entries.len() as u32) < layout.base_depth || self.bottom(1)? != 0 {
269 return None;
270 }
271 let outer = self.bottom(layout.outer_frame)?;
272 if outer == 0 {
273 return None;
274 }
275 let copies = self.entries.iter().filter(|&&e| e == outer).count() as u32;
276 let in_control = self.top(LOOP_FRAME)? == outer;
277 Some((in_control, copies.saturating_sub(1)))
278 }
279}
280
281#[derive(Clone, Debug, Default, PartialEq, Eq)]
283pub struct Environment {
284 pub names: Vec<String>,
286 pub unnamed: u32,
289 pub types: Vec<Option<ObjectType>>,
293}
294
295impl Environment {
296 pub fn binds(&self, name: &str) -> bool {
298 self.names.iter().any(|n| n == name)
299 }
300
301 fn unnamed_types(&self) -> Option<&[Option<ObjectType>]> {
303 self.names.is_empty().then_some(self.types.as_slice())
304 }
305
306 fn only_saved_ui(&self) -> bool {
309 self.names == ["SavedUI"] && self.unnamed == 0
310 }
311}
312
313pub fn environments(mem: &dyn Memory, layout: &ScreenLayout) -> Result<Vec<Environment>> {
315 let mut envs = Vec::new();
316 let mut a = field(mem, layout.environments_ptr, 5)?;
317 for _ in 0..MAX_ENVIRONMENTS {
318 let link = field(mem, a, 5)?;
319 if link == 0 {
320 break;
321 }
322 let mut env = Environment::default();
323 let mut p = a + 10;
324 let mut n = 0;
325 while p + 10 <= a + link && n < MAX_BINDINGS {
326 let name = field(mem, p, 5)?;
327 match decode_at(name, mem) {
328 Ok(Object::LocalName { value }) if !value.trim_start_matches('\'').is_empty() => {
329 env.names.push(value.trim_start_matches('\'').to_string());
330 }
331 _ => env.unnamed += 1,
332 }
333 let object = field(mem, p + 5, 5)?;
334 env.types
335 .push(field(mem, object, 5).ok().and_then(ObjectType::from_prolog));
336 p += 10;
337 n += 1;
338 }
339 envs.push(env);
340 a = a.wrapping_add(link) & 0xFFFFF;
341 }
342 Ok(envs)
343}
344
345pub fn innermost_names(mem: &dyn Memory, layout: &ScreenLayout) -> Result<Vec<String>> {
350 Ok(innermost(&environments(mem, layout)?))
351}
352
353fn innermost(envs: &[Environment]) -> Vec<String> {
354 match envs.iter().position(|e| e.binds("SavedUI")) {
355 Some(i) => envs[..=i].iter().flat_map(|e| e.names.clone()).collect(),
356 None => envs.first().map(|e| e.names.clone()).unwrap_or_default(),
357 }
358}
359
360const VIEW_NAMES: [&str; 4] = ["SavedUI", "SAVEDDEPTH", "EXITFCN", "EnvOK"];
363
364fn equation_writer(envs: &[Environment]) -> Option<Kind> {
370 let at = envs
371 .iter()
372 .position(|e| e.binds("ploc") && e.binds("FontGauge"))?;
373 let above = &envs[..at];
374 if above.is_empty() {
375 return Some(Kind::EquationWriter);
376 }
377 if above.iter().any(|e| e.unnamed > 0 || e.names.is_empty()) {
378 return None;
379 }
380 let only = |allowed: &[&str]| {
381 above
382 .iter()
383 .all(|e| e.names.iter().all(|n| allowed.contains(&n.as_str())))
384 };
385 if only(&["SavedUI"]) {
386 return Some(Kind::EquationWriter);
387 }
388 if only(&VIEW_NAMES) && above.iter().any(|e| e.binds("EnvOK")) {
389 return Some(Kind::EquationView);
390 }
391 None
392}
393
394fn interactive_stack(envs: &[Environment]) -> bool {
398 let Some(types) = envs.first().and_then(Environment::unnamed_types) else {
399 return false;
400 };
401 match types {
402 [None, Some(Bint), Some(Bint), Some(Bint)] => {
403 envs.get(1).is_some_and(Environment::only_saved_ui)
404 }
405 [
406 Some(Bint),
407 _,
408 None,
409 Some(Bint),
410 None,
411 Some(Bint),
412 Some(Str),
413 Some(Program),
414 ] => true,
415 _ => false,
416 }
417}
418
419fn object_edit(envs: &[Environment]) -> bool {
426 let Some(types) = envs.first().and_then(Environment::unnamed_types) else {
427 return false;
428 };
429 if !matches!(types, [None, Some(Bint), None, Some(Str)]) {
430 return false;
431 }
432 let mut below = &envs[1..];
433 if below.first().is_some_and(Environment::only_saved_ui) {
434 below = &below[1..];
435 }
436 below
437 .first()
438 .and_then(Environment::unnamed_types)
439 .is_some_and(|t| matches!(t, [Some(edited)] if *edited != Bint))
440}
441
442fn matrix_writer(envs: &[Environment]) -> bool {
447 let Some(newest) = envs.first() else {
448 return false;
449 };
450 if newest.binds("_IDX") && newest.binds("_TAB2") {
451 return true;
452 }
453 newest
454 .unnamed_types()
455 .is_some_and(|t| t.len() == 22 && matches!(t, [Some(Bint), _, None, Some(Bint), ..]))
456 && envs.get(1).is_some_and(Environment::only_saved_ui)
457}
458
459pub fn framed_box(pixels: &[Vec<bool>]) -> Option<bool> {
464 let h = pixels.len();
465 let dark = |x: usize, y: usize| {
466 pixels
467 .get(y)
468 .and_then(|r| r.get(x))
469 .copied()
470 .unwrap_or(false)
471 };
472 for (y0, row) in pixels.iter().enumerate().take(h.saturating_sub(4)) {
473 let w = row.len();
474 let mut x = 0;
475 while x < w {
476 if !dark(x, y0) {
477 x += 1;
478 continue;
479 }
480 let x0 = x;
481 while x < w && dark(x, y0) {
482 x += 1;
483 }
484 let x1 = x - 1;
485 if x1 < x0 + 30 {
486 continue;
487 }
488 let Some(y1) =
491 (y0 + 3..h.saturating_sub(1)).find(|&y| (x0..=x1 + 1).all(|x| dark(x, y)))
492 else {
493 continue;
494 };
495 let edges = (y0 + 1..y1)
496 .all(|y| dark(x0, y) && dark(x1, y) && dark(x1 + 1, y) && !dark(x0 + 1, y));
497 let shadow = (x0 + 1..=x1 + 1).all(|x| dark(x, y1 + 1)) && !dark(x0, y1 + 1);
498 if !edges || !shadow {
499 continue;
500 }
501 let inner = (x0 + 2..=x1.saturating_sub(2)).count().max(1);
502 let banded = (y0 + 1..y1).any(|y| {
503 (x0 + 2..=x1.saturating_sub(2))
504 .filter(|&x| dark(x, y))
505 .count()
506 * 10
507 >= inner * 9
508 });
509 return Some(banded);
510 }
511 }
512 None
513}
514
515pub fn read(
518 mem: &dyn Memory,
519 layout: &ScreenLayout,
520 editor: &EditorLayout,
521 pixels: &[Vec<bool>],
522) -> Result<Screen> {
523 let command_line = cmdline::read(mem, editor)?.active;
524 let unknown = Screen {
525 kind: Kind::Unknown,
526 from: Source::Memory,
527 stack_in_control: false,
528 halted: 0,
529 command_line,
530 };
531 let Some(rs) = ReturnStack::read(mem, layout)? else {
532 return Ok(unknown);
533 };
534 let Some((in_control, halted)) = rs.control(layout) else {
535 return Ok(unknown);
536 };
537 let at = |kind, from| Screen {
538 kind,
539 from,
540 stack_in_control: in_control,
541 halted,
542 command_line,
543 };
544 if in_control {
545 let kind = if command_line {
546 Kind::CommandLine
547 } else if halted > 0 {
548 Kind::Halted
549 } else {
550 Kind::Stack
551 };
552 return Ok(at(kind, Source::Memory));
553 }
554 if field(mem, layout.shown_grob_ptr, 5)? == field(mem, layout.pict_ptr, 5)? {
555 return Ok(at(Kind::Graphics, Source::Memory));
556 }
557 let envs = environments(mem, layout)?;
558 let names = innermost(&envs);
559 let has = |n: &str| names.iter().any(|m| m == n);
560 if has("IF") || has("IfMenu") || has("CurrentField") {
561 return Ok(at(Kind::InputForm, Source::Memory));
562 }
563 if has("NbElm") {
564 return Ok(at(Kind::ChooseBox, Source::Memory));
565 }
566 if has("PlotEnv") {
567 return Ok(at(Kind::Graphics, Source::Memory));
568 }
569 match framed_box(pixels) {
570 Some(true) => return Ok(at(Kind::ChooseBox, Source::Display)),
571 Some(false) => return Ok(at(Kind::Message, Source::Display)),
572 None => {}
573 }
574 if !command_line && let Some(kind) = equation_writer(&envs) {
577 return Ok(at(kind, Source::Memory));
578 }
579 if matrix_writer(&envs) {
581 return Ok(at(Kind::MatrixWriter, Source::Memory));
582 }
583 if !command_line && interactive_stack(&envs) {
584 return Ok(at(Kind::InteractiveStack, Source::Memory));
585 }
586 if command_line && object_edit(&envs) {
587 return Ok(at(Kind::ObjectEdit, Source::Memory));
588 }
589 if command_line {
590 return Ok(at(Kind::Input, Source::Memory));
591 }
592 Ok(at(Kind::Unknown, Source::Memory))
593}
594
595pub fn screen(machine: &Machine) -> Result<Screen> {
597 let model = machine.model();
598 let editor = EditorLayout::require(model)?;
599 let layout = ScreenLayout::of(model).ok_or(Error::NoCommandLine(model))?;
600 read(machine, &layout, &editor, &machine.lcd().pixels)
601}
602
603#[cfg(test)]
604mod tests {
605 use super::*;
606 use std::collections::HashMap;
607
608 #[derive(Default)]
609 struct Ram(HashMap<u32, u8>);
610
611 impl Memory for Ram {
612 fn nibble(&self, addr: u32) -> Option<u8> {
613 Some(self.0.get(&addr).copied().unwrap_or(0))
614 }
615 }
616
617 impl Ram {
618 fn put(&mut self, addr: u32, value: u32, len: u32) {
619 for i in 0..len {
620 self.0.insert(addr + i, ((value >> (4 * i)) & 15) as u8);
621 }
622 }
623
624 fn returns(&mut self, l: &ScreenLayout, bottom_first: &[u32]) {
626 self.put(l.return_bottom_ptr, 0x71000, 5);
627 for (i, e) in bottom_first.iter().enumerate() {
628 self.put(0x71000 + 5 * i as u32, *e, 5);
629 }
630 self.put(l.return_top_ptr, 0x71000 + 5 * bottom_first.len() as u32, 5);
631 }
632 }
633
634 const KEYS: [u32; 4] = [0x4204B, 0x420AF, 0x42190, 0x421C2];
635
636 fn stack(extra: &[u32]) -> Vec<u32> {
637 let mut v = vec![0, 0x38598, 0x385B6];
638 v.extend_from_slice(extra);
639 v.extend_from_slice(&KEYS);
640 v
641 }
642
643 fn read_sx(ram: &Ram) -> Screen {
644 read(ram, &ScreenLayout::HP48SX, &EditorLayout::HP48SX, &[]).unwrap()
645 }
646
647 #[test]
648 fn the_return_stack_tells_the_stack_from_a_loop_and_counts_halts() {
649 let l = ScreenLayout::HP48SX;
651 let mut ram = Ram::default();
652 ram.put(l.shown_grob_ptr, 0x86907, 5);
653 ram.put(l.pict_ptr, 0xCE017, 5);
654 ram.returns(&l, &stack(&[0x385CA]));
655 let s = read_sx(&ram);
656 assert_eq!(
657 (s.kind, s.stack_in_control, s.halted),
658 (Kind::Stack, true, 0)
659 );
660 ram.returns(
662 &l,
663 &stack(&[0x385D4, 0x3A807, 0x40BC4, 0x143DE, 0x385B6, 0x385CA]),
664 );
665 let s = read_sx(&ram);
666 assert_eq!(
667 (s.kind, s.stack_in_control, s.halted),
668 (Kind::Halted, true, 1)
669 );
670 ram.returns(
672 &l,
673 &stack(&[
674 0x385D4, 0x40DBB, 0x43757, 0x4374D, 0x38AF5, 0x38B3B, 0x38B22,
675 ]),
676 );
677 let s = read_sx(&ram);
678 assert_eq!((s.kind, s.stack_in_control), (Kind::Unknown, false));
679 ram.put(EditorLayout::HP48SX.line, 2, 1);
681 ram.put(EditorLayout::HP48SX.text_end_ptr, 0x7FEE3, 5);
682 ram.put(EditorLayout::HP48SX.stack_end_ptr, 0x7FEB3, 5);
683 assert_eq!(read_sx(&ram).kind, Kind::Input);
684 ram.put(l.shown_grob_ptr, 0xCE017, 5);
686 assert_eq!(read_sx(&ram).kind, Kind::Graphics);
687 ram.put(l.return_top_ptr, 0x70FFF, 5);
689 assert_eq!(read_sx(&ram).kind, Kind::Unknown);
690 }
691
692 #[test]
693 fn named_temporaries_name_the_loop() {
694 let l = ScreenLayout::HP48GX;
695 let mut ram = Ram::default();
696 ram.returns(&l, &stack(&[0x385D4, 0x38AF5, 0x38B3B, 0x38B22]));
697 ram.put(l.shown_grob_ptr, 1, 5);
698 let lam = |ram: &mut Ram, at: u32, name: &str| {
700 ram.put(at, 0x02E6D, 5);
701 ram.put(at + 5, name.len() as u32, 2);
702 for (i, b) in name.bytes().enumerate() {
703 ram.put(at + 7 + 2 * i as u32, u32::from(b), 2);
704 }
705 };
706 lam(&mut ram, 0x90000, "IF");
707 lam(&mut ram, 0x90100, "SavedUI");
708 ram.put(l.environments_ptr, 0xA0000, 5);
710 ram.put(0xA0000, 20, 5);
711 ram.put(0xA000A, 0x90000, 5);
712 ram.put(0xA0014, 20, 5);
713 ram.put(0xA001E, 0x90100, 5);
714 assert_eq!(innermost_names(&ram, &l).unwrap(), ["IF", "SavedUI"]);
715 let s = read(&ram, &l, &EditorLayout::HP48GX, &[]).unwrap();
716 assert_eq!((s.kind, s.from), (Kind::InputForm, Source::Memory));
717 ram.put(l.environments_ptr, 0xA1000, 5);
720 ram.put(0xA1000, 20, 5);
721 ram.put(0xA100A, 0x90100, 5);
722 ram.put(0xA1014, 0, 5);
723 assert_eq!(innermost_names(&ram, &l).unwrap(), ["SavedUI"]);
724 }
725
726 fn in_loop(l: &ScreenLayout, envs: &[&[&str]]) -> Ram {
732 let mut ram = Ram::default();
733 ram.returns(l, &stack(&[0x385D4, 0x38AF5, 0x38B3B, 0x38B22]));
734 ram.put(l.shown_grob_ptr, 1, 5);
735 let mut names = 0x90000;
736 let mut objects = 0xB0000;
737 let mut a = 0xA0000;
738 ram.put(l.environments_ptr, a, 5);
739 for env in envs {
740 let link = 10 + 10 * env.len() as u32;
741 ram.put(a, link, 5);
742 for (i, binding) in env.iter().enumerate() {
743 let (name, ty) = binding.split_once(':').unwrap_or((binding, ""));
744 ram.put(names, 0x02E6D, 5);
746 ram.put(names + 5, name.len() as u32, 2);
747 for (j, b) in name.bytes().enumerate() {
748 ram.put(names + 7 + 2 * j as u32, u32::from(b), 2);
749 }
750 ram.put(a + 10 + 10 * i as u32, names, 5);
751 names += 0x100;
752 let prolog = match ty {
753 "bint" => 0x02911,
754 "real" => 0x02933,
755 "str" => 0x02A2C,
756 "prog" => 0x02D9D,
757 "arr" => 0x029E8,
758 "list" => 0x02A74,
759 "name" => 0x02E48,
760 "hxs" => 0x02A4E,
761 _ => 0x0312B,
762 };
763 ram.put(objects, prolog, 5);
764 ram.put(a + 15 + 10 * i as u32, objects, 5);
765 objects += 0x40;
766 }
767 a += link;
768 }
769 ram.put(a, 0, 5);
770 ram
771 }
772
773 fn open_line(ram: &mut Ram, e: &EditorLayout) {
776 ram.put(e.line, 2, 1);
777 ram.put(e.stack_end_ptr, 0x9FFD0, 5);
778 }
779
780 const WRITER: &[&str] = &["ploc", "FontGauge", "cx", "cy"];
781
782 fn kind_gx(envs: &[&[&str]]) -> Kind {
783 let l = ScreenLayout::HP48GX;
784 read(&in_loop(&l, envs), &l, &EditorLayout::HP48GX, &[])
785 .unwrap()
786 .kind
787 }
788
789 #[test]
790 fn the_equation_writers_environments_name_its_modes() {
791 assert_eq!(kind_gx(&[WRITER, &["SavedUI"]]), Kind::EquationWriter);
793 assert_eq!(
795 kind_gx(&[&["SavedUI"], WRITER, &["SavedUI"]]),
796 Kind::EquationWriter
797 );
798 assert_eq!(
800 kind_gx(&[
801 &["SavedUI"],
802 &["SAVEDDEPTH", "EXITFCN", "EnvOK"],
803 WRITER,
804 &["SavedUI"]
805 ]),
806 Kind::EquationView
807 );
808 assert_eq!(
809 kind_gx(&[&["SavedUI"], &["EXITFCN", "EnvOK"], WRITER]),
810 Kind::EquationView
811 );
812 assert_eq!(
815 kind_gx(&[&["SavedUI"], &["", ""], WRITER, &["SavedUI"]]),
816 Kind::Unknown
817 );
818 assert_eq!(
820 kind_gx(&[&["SavedUI"], &["SAVEDDEPTH", "EXITFCN"], WRITER]),
821 Kind::Unknown
822 );
823 assert_eq!(kind_gx(&[&["IF", "SavedUI"], WRITER]), Kind::InputForm);
825 assert_eq!(kind_gx(&[&["SavedUI"]]), Kind::Unknown);
827 let l = ScreenLayout::HP48GX;
830 let e = EditorLayout::HP48GX;
831 let mut ram = in_loop(&l, &[&["SavedUI"], WRITER, &["SavedUI"]]);
832 open_line(&mut ram, &e);
833 let s = read(&ram, &l, &e, &[]).unwrap();
834 assert_eq!((s.kind, s.command_line), (Kind::Input, true));
835 let l = ScreenLayout::HP48GX;
836 let ram = in_loop(&l, &[&["SavedUI", ""], WRITER]);
837 assert_eq!(
838 environments(&ram, &l).unwrap()[0],
839 Environment {
840 names: vec!["SavedUI".into()],
841 unnamed: 1,
842 types: vec![None, None],
843 }
844 );
845 }
846
847 fn kind_with_line(envs: &[&[&str]], line: bool) -> Screen {
849 let l = ScreenLayout::HP48GX;
850 let e = EditorLayout::HP48GX;
851 let mut ram = in_loop(&l, envs);
852 if line {
853 open_line(&mut ram, &e);
854 }
855 read(&ram, &l, &e, &[]).unwrap()
856 }
857
858 const ISTACK_48: &[&str] = &["", ":bint", ":bint", ":bint"];
860 const ISTACK_49: &[&str] = &[":bint", ":hxs", "", ":bint", "", ":bint", ":str", ":prog"];
861 const LINE: &[&str] = &["", ":bint", "", ":str"];
862 const SAVED: &[&str] = &["SavedUI:list"];
863 const LAST_STACK: &[&str] = &["", ":real", ":real"];
864
865 fn mw_48() -> Vec<&'static str> {
866 let mut v = vec![":bint", ":hxs", "", ":bint"];
867 v.resize(21, ":bint");
868 v.push(":arr");
869 v
870 }
871
872 #[test]
873 fn the_interactive_stack_reads_from_its_bindings() {
874 let k = |envs: &[&[&str]]| kind_with_line(envs, false).kind;
875 assert_eq!(k(&[ISTACK_48, SAVED, LAST_STACK]), Kind::InteractiveStack);
876 assert_eq!(k(&[ISTACK_49, LAST_STACK]), Kind::InteractiveStack);
877 assert_eq!(k(&[ISTACK_48, LAST_STACK]), Kind::Unknown);
879 assert_eq!(
881 k(&[&["", "", ":str", "", "", ":bint", ":bint", ""], ISTACK_49]),
882 Kind::Unknown
883 );
884 assert_eq!(
886 k(&[&["x", ":bint", ":bint", ":bint"], SAVED]),
887 Kind::Unknown
888 );
889 assert_eq!(kind_with_line(&[ISTACK_48, SAVED], true).kind, Kind::Input);
891 }
892
893 #[test]
894 fn an_edited_object_is_told_from_input() {
895 let k = |envs: &[&[&str]]| kind_with_line(envs, true).kind;
896 assert_eq!(k(&[LINE, SAVED, &[":real"], LAST_STACK]), Kind::ObjectEdit);
899 assert_eq!(k(&[LINE, SAVED, &[":name"], &[""]]), Kind::ObjectEdit);
900 assert_eq!(
901 k(&[LINE, SAVED, &[":real"], &[":bint"], ISTACK_48, SAVED]),
902 Kind::ObjectEdit
903 );
904 assert_eq!(k(&[LINE, &[":str"], LAST_STACK]), Kind::ObjectEdit);
906 assert_eq!(k(&[LINE, SAVED, &["est"], &[""]]), Kind::Input);
910 assert_eq!(k(&[LINE, SAVED, &[":bint"], &["est"]]), Kind::Input);
911 assert_eq!(k(&[LINE, SAVED, &["a:real"], &["est"]]), Kind::Input);
912 assert_eq!(k(&[LINE, SAVED, &[""]]), Kind::Input);
913 assert_eq!(k(&[LINE, &[""]]), Kind::Input);
914 assert_eq!(k(&[LINE]), Kind::Input);
915 assert_eq!(
917 k(&[LINE, SAVED, SAVED, &["ploc", "FontGauge"], SAVED]),
918 Kind::Input
919 );
920 assert_eq!(
922 kind_with_line(&[LINE, SAVED, &[":real"]], false).kind,
923 Kind::Unknown
924 );
925 }
926
927 #[test]
928 fn the_matrix_writer_reads_from_its_bindings() {
929 let mw = mw_48();
930 let k = |envs: &[&[&str]], line| kind_with_line(envs, line);
931 let s = k(&[&mw, SAVED, &[""]], false);
932 assert_eq!((s.kind, s.command_line), (Kind::MatrixWriter, false));
933 let s = k(&[&mw, SAVED, &[":arr"], LAST_STACK], true);
935 assert_eq!((s.kind, s.command_line), (Kind::MatrixWriter, true));
936 assert_eq!(
938 k(&[&mw, SAVED, &[""; 40], &["IF"], SAVED], false).kind,
939 Kind::MatrixWriter
940 );
941 assert_eq!(
943 k(
944 &[&["", "", ":bint", "_IDX:str", "_TAB2", ":list"], &[""]],
945 true
946 )
947 .kind,
948 Kind::MatrixWriter
949 );
950 assert_eq!(k(&[&mw[..21], SAVED], false).kind, Kind::Unknown);
952 assert_eq!(k(&[&mw, &[""]], false).kind, Kind::Unknown);
953 }
954
955 fn boxed(band: bool) -> Vec<Vec<bool>> {
956 let mut p = vec![vec![false; 131]; 64];
957 let (x0, x1, y0, y1) = (17, 112, 15, 44);
958 p[y0][x0..=x1].fill(true);
959 for row in p.iter_mut().take(y1).skip(y0 + 1) {
960 row[x0] = true;
961 row[x1] = true;
962 row[x1 + 1] = true;
963 }
964 p[y1][x0..=x1 + 1].fill(true);
965 p[y1 + 1][x0 + 1..=x1 + 1].fill(true);
966 if band {
967 p[20][x0 + 2..x1 - 1].fill(true);
968 }
969 p
970 }
971
972 #[test]
973 fn a_shadowed_frame_is_a_box() {
974 assert_eq!(framed_box(&boxed(false)), Some(false));
975 assert_eq!(framed_box(&boxed(true)), Some(true));
976 assert_eq!(framed_box(&vec![vec![false; 131]; 64]), None);
977 assert_eq!(framed_box(&vec![vec![true; 131]; 64]), None);
979 }
980}