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

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

// Tuple Access --------------------------------------------------------------

#[derive(Debug)]
struct TupleAccessElement {
  out: Value,
}

impl MechFunctionImpl for TupleAccessElement {
  fn solve(&self) {
    ()
  }
  fn out(&self) -> Value { self.out.clone() }
  fn to_string(&self) -> String { format!("{:#?}", self) }
}
#[cfg(feature = "compiler")]
impl MechFunctionCompiler for TupleAccessElement {
  fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
    let mut registers = [0];
    registers[0] = compile_register!(self.out, ctx);
    ctx.features.insert(FeatureFlag::Builtin(FeatureKind::Tuple));
    ctx.features.insert(FeatureFlag::Builtin(FeatureKind::Access));
    ctx.emit_nullop(
      hash_str(stringify!("TupleAccessElement")),
      registers[0],
    );
    return Ok(registers[0]);
  }
}
  
pub struct TupleAccess {}
impl NativeFunctionCompiler for TupleAccess{
  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 ix1 = &arguments[1];
    let src = &arguments[0];
    match (src.clone(),ix1.clone()) {
      (Value::Tuple(tpl), Value::Index(ix)) => {
        let tpl_brrw = tpl.borrow();
        let ix_brrw = ix.borrow();
        if *ix_brrw > tpl_brrw.elements.len() || *ix_brrw < 1 {
            return Err(MechError::new(
                TupleIndexOutOfBoundsError { ix: *ix_brrw, len: tpl_brrw.elements.len() },
                None
              ).with_compiler_loc());
        }
        let element = tpl_brrw.elements[*ix_brrw - 1].clone();
        let new_fxn = TupleAccessElement{ out: *element };
        Ok(Box::new(new_fxn))
      },
      (Value::MutableReference(tpl), Value::Index(ix)) => {
        match &*tpl.borrow() {
          Value::Tuple(tpl) => {
            let ix_brrw = ix.borrow();
            let tpl_brrw = tpl.borrow();
            if *ix_brrw > tpl_brrw.elements.len() || *ix_brrw < 1 {
              return Err(MechError::new(
                  TupleIndexOutOfBoundsError { ix: *ix_brrw, len: tpl_brrw.elements.len() },
                  None
                ).with_compiler_loc());
            }
            let element = tpl_brrw.elements[*ix_brrw - 1].clone();
            let new_fxn = TupleAccessElement{ out: *element };
            Ok(Box::new(new_fxn))
          },
          _ => Err(MechError::new(
              UnhandledFunctionArgumentKind2 { arg: (src.kind(), ix1.kind()), fxn_name: "access/tuple-element".to_string() },
              None
            ).with_compiler_loc()
          ),
        }
      },
      _ => todo!(),
    }
  }
}