mech-interpreter 0.3.2

The Mech language runtime.
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

#[macro_use]
use crate::stdlib::*;

// Record Access --------------------------------------------------------------

#[derive(Debug)]
pub struct RecordAccessField {
  pub source: Value,
}
impl MechFunctionImpl for RecordAccessField {
  fn solve(&self) {
    ()
  }
  fn out(&self) -> Value { self.source.clone() }
  fn to_string(&self) -> String { format!("{:#?}", self) }
}
#[cfg(feature = "compiler")]
impl MechFunctionCompiler for RecordAccessField {
  fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
    let mut registers = [0];

    registers[0] = compile_register!(self.source, ctx);

    ctx.features.insert(FeatureFlag::Builtin(FeatureKind::Access));

    ctx.emit_nullop(
      hash_str("RecordAccessField"),
      registers[0],
    );

    return Ok(registers[0]);
  }
}

pub fn impl_access_record_fxn(source: Value, key: Value) -> MResult<Box<dyn MechFunction>> {
  match (source,key) {
    (Value::Record(rcd), Value::Id(id)) => {
      let k = id;
      match rcd.borrow().get(&k) {
        Some(value) => Ok(Box::new(RecordAccessField{source: value.clone()})),
        None => Err(MechError::new(
            UndefinedRecordFieldError { id: k.clone() },
            None
          ).with_compiler_loc()),
      }
    }
    (source,key) => return Err(MechError::new(
        UnhandledFunctionArgumentKind2 { arg: (source.kind(), key.kind()), fxn_name: "RecordAccess".to_string() },
        None
      ).with_compiler_loc()
    ),
  }
}

pub struct RecordAccess {}
impl NativeFunctionCompiler for RecordAccess {
  fn compile(&self, arguments: &Vec<Value>) -> MResult<Box<dyn MechFunction>> {
    if arguments.len() != 2 {
      return Err(MechError::new(IncorrectNumberOfArguments { expected: 1, found: arguments.len() }, None).with_compiler_loc());
    }
    let key = &arguments[1];
    let src = &arguments[0];
    match impl_access_record_fxn(src.clone(), key.clone()) {
      Ok(fxn) => Ok(fxn),
      Err(_) => {
        match src {
          Value::MutableReference(rcrd) => { impl_access_record_fxn(rcrd.borrow().clone(), key.clone()) },
          x => Err(MechError::new(
              UnhandledFunctionArgumentKind2 { arg: (src.kind(), key.kind()), fxn_name: "RecordAccess".to_string() },
              None
            ).with_compiler_loc()
          ),
        }
      }
    }
  }
}


#[derive(Debug)]
pub struct RecordAccessSwizzle {
  pub source: Value,
}

impl MechFunctionImpl for RecordAccessSwizzle {
  fn solve(&self) {
    ()
  }
  fn out(&self) -> Value { self.source.clone() }
  fn to_string(&self) -> String { format!("{:#?}", self) }
}
#[cfg(feature = "compiler")]
impl MechFunctionCompiler for RecordAccessSwizzle {
  fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
    let mut registers = [0];

    registers[0] = compile_register!(self.source, ctx);

    ctx.features.insert(FeatureFlag::Builtin(FeatureKind::Swizzle));

    ctx.emit_nullop(
      hash_str("RecordAccessSwizzle"),
      registers[0],
    );

    return Ok(registers[0]);
  }
}