Witch of Git - jade-rose/blob - toolchain/src/inst.rs

   1 pub mod decode;
   2 pub mod encode;
   3 mod format;
   4 pub mod parse;
   5 #[cfg(test)]
   6 pub mod test;
   7
   8 pub use self::{decode::Decode, encode::Encode};
   9
  10 #[cfg(test)]
  11 use proptest_derive::Arbitrary;
  12
  13 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  14 #[cfg_attr(test, derive(Arbitrary))]
  15 #[repr(u8)]
  16 pub enum Op1 {
  17     Zero,
  18     Lsl1,
  19     Lsr1,
  20     Asr1,
  21     Incr,
  22     Decr,
  23     Comp,
  24     Negt,
  25 }
  26
  27 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  28 #[cfg_attr(test, derive(Arbitrary))]
  29 #[repr(u8)]
  30 pub enum OpR {
  31     Add,
  32     Sub,
  33     And,
  34     Ior,
  35     Xor,
  36     Lsl,
  37     Lsr,
  38     Asr,
  39 }
  40
  41 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  42 #[cfg_attr(test, derive(Arbitrary))]
  43 #[repr(u8)]
  44 pub enum OpI3 {
  45     Rol,
  46     Lsl,
  47     Lsr,
  48     Asr,
  49     Clr,
  50     Set,
  51     Tog,
  52     Ext,
  53 }
  54
  55 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  56 #[cfg_attr(test, derive(Arbitrary))]
  57 #[repr(u8)]
  58 pub enum Data {
  59     D1,
  60     D2,
  61 }
  62
  63 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  64 #[cfg_attr(test, derive(Arbitrary))]
  65 pub enum Special {
  66     Data(Data),
  67     Code,
  68 }
  69
  70 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  71 #[cfg_attr(test, derive(Arbitrary))]
  72 pub struct Reg(U3);
  73 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  74 #[cfg_attr(test, derive(Arbitrary))]
  75 pub struct U3(#[cfg_attr(test, proptest(strategy = "0..=7u8"))] u8);
  76 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  77 #[cfg_attr(test, derive(Arbitrary))]
  78 pub struct AddImm(#[cfg_attr(test, proptest(strategy = "-64..=127i8"))] i8);
  79
  80 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  81 #[cfg_attr(test, derive(Arbitrary))]
  82 pub enum AluI {
  83     And(u8),
  84     Ior(u8),
  85     Xor(u8),
  86     Add(AddImm),
  87     Compact(OpI3, U3),
  88 }
  89
  90 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  91 #[cfg_attr(test, derive(Arbitrary))]
  92 pub enum Target {
  93     Abs,
  94     Off,
  95     OffImm(i8),
  96 }
  97
  98 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  99 #[cfg_attr(test, derive(Arbitrary))]
 100 #[cfg_attr(test, proptest(no_params))]
 101 pub enum Inst {
 102     Trap,
 103     Jump(Target),
 104     Call(Target),
 105     Swap(Reg),
 106     GetR(Reg),
 107     SetR(Reg),
 108     Get(Special),
 109     Set(Special),
 110     Alu1(Op1),
 111     IsLt(Reg),
 112     AluR(OpR, Reg),
 113     LdD(Data, Reg, bool),
 114     StD(Data, Reg, bool),
 115     AluI(AluI),
 116     BEzI(i8),
 117 }
 118
 119 impl Inst {
 120     pub fn parse(s: &str) -> Option<Self> {
 121         parse::parse_inst(s)
 122     }
 123 }
 124
 125 impl Reg {
 126     pub fn new(x: u8) -> Option<Reg> {
 127         U3::new(x).map(Reg)
 128     }
 129 }
 130
 131 impl U3 {
 132     pub fn new(x: u8) -> Option<U3> {
 133         match x {
 134             0..=7 => Some(U3(x)),
 135             _ => None,
 136         }
 137     }
 138 }
 139
 140 impl AddImm {
 141     pub fn new(x: i8) -> Option<AddImm> {
 142         match x {
 143             -64..=127 => Some(AddImm(x)),
 144             _ => None,
 145         }
 146     }
 147 }