calx_vm 0.2.0

Stack-based VM, with dynamic data, for experiment
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

use bincode::{Decode, Encode};
use core::fmt;
use std::rc::Rc;

use crate::{calx::CalxType, syntax::CalxSyntax};

use super::instr::CalxInstr;

#[derive(Debug, Clone, PartialEq, PartialOrd, Encode, Decode)]
pub struct CalxFunc {
  pub name: Rc<String>,
  pub params_types: Rc<Vec<CalxType>>,
  pub ret_types: Rc<Vec<CalxType>>,
  pub syntax: Rc<Vec<CalxSyntax>>,
  pub instrs: Option<Rc<Vec<CalxInstr>>>,
  pub local_names: Rc<Vec<String>>,
}

impl fmt::Display for CalxFunc {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    write!(f, "CalxFunc {} (", self.name)?;
    for p in &*self.params_types {
      write!(f, "{:?} ", p)?;
    }
    f.write_str("-> ")?;
    for p in &*self.ret_types {
      write!(f, "{:?} ", p)?;
    }
    f.write_str(")")?;
    if !self.local_names.is_empty() {
      f.write_str("\n  local_names:")?;
      for (idx, l) in self.local_names.iter().enumerate() {
        write!(f, " {}_{}", idx, l)?;
      }
      f.write_str(" .")?;
    }
    match &self.instrs {
      Some(instrs) => {
        for (idx, instr) in instrs.iter().enumerate() {
          write!(f, "\n  {:02} {:?}", idx, instr)?;
        }
      }
      None => {
        write!(f, "\n  <none>")?;
      }
    }
    f.write_str("\n")?;
    Ok(())
  }
}