cambridge-asm 0.18.0

Run pseudoassembly from Cambridge International syllabus 9618
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

// Copyright (c) 2021 Saadi Save
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

use super::{Context, PasmError::*, PasmResult};
use crate::inst::Op::{self, *};

/// Jump
///
/// # Syntax
/// 1. `JMP [ref]` - jump to addr
/// 2. `JMP [ref],[ref]` - jump to first if CMP true, second if CMP false
pub fn jmp(ctx: &mut Context, op: &Op) -> PasmResult {
    match op {
        &Addr(x) => {
            ctx.override_flow_control();
            ctx.mar = x;
        }
        MultiOp(ops) => match ops[..] {
            [Addr(eq), Addr(ne)] => {
                ctx.override_flow_control();
                if ctx.cmp {
                    ctx.mar = eq;
                } else {
                    ctx.mar = ne;
                }
            }
            _ => return Err(InvalidMultiOp),
        },
        Null => return Err(NoOperand),
        _ => return Err(InvalidOperand),
    }

    Ok(())
}

/// Compare
///
/// # Syntax
/// 1. `CMP [lit | reg | addr]` - compare to ACC
/// 2. `CMP [lit | reg | addr],[lit | reg | addr]` - compare both values
pub fn cmp(ctx: &mut Context, op: &Op) -> PasmResult {
    match op {
        MultiOp(ops) => match ops[..] {
            [ref a, ref b] if a.is_usizeable() && b.is_usizeable() => {
                ctx.cmp = ctx.read(a)? == ctx.read(b)?;
            }
            _ => return Err(InvalidMultiOp),
        },
        val if val.is_usizeable() => ctx.cmp = ctx.acc == ctx.read(val)?,
        Null => return Err(NoOperand),
        _ => return Err(InvalidOperand),
    }

    Ok(())
}

/// Compare with indirect addressing
///
/// # Syntax
/// 1. `CMI [addr]`
/// 2. `CMI [lit | reg | addr],[addr]`
pub fn cmi(ctx: &mut Context, op: &Op) -> PasmResult {
    match op {
        &Addr(addr) => {
            let addr2 = ctx.mem.get(&addr)?;

            ctx.cmp = ctx.acc
                == ctx
                    .mem
                    .get(addr2)
                    .copied()
                    .map_err(|_| InvalidIndirectAddress(addr))?;

            Ok(())
        }
        MultiOp(ops) => match ops[..] {
            [ref dest, Addr(addr)] if dest.is_usizeable() => {
                let addr2 = ctx.mem.get(&addr)?;

                ctx.cmp = ctx.read(dest)?
                    == ctx
                        .mem
                        .get(addr2)
                        .copied()
                        .map_err(|_| InvalidIndirectAddress(addr))?;

                Ok(())
            }
            _ => Err(InvalidMultiOp),
        },
        Null => Err(NoOperand),
        _ => Err(InvalidOperand),
    }
}

/// Jump if equal
///
/// # Syntax
/// `JPE [addr]`
pub fn jpe(ctx: &mut Context, op: &Op) -> PasmResult {
    match op {
        &Addr(addr) => {
            if ctx.cmp {
                ctx.override_flow_control();
                ctx.mar = addr;
            }

            Ok(())
        }
        Null => Err(NoOperand),
        _ => Err(InvalidOperand),
    }
}

/// Jump if not equal
///
/// # Syntax
/// `JPN [addr]`
pub fn jpn(ctx: &mut Context, op: &Op) -> PasmResult {
    match op {
        &Addr(addr) => {
            if !ctx.cmp {
                ctx.override_flow_control();
                ctx.mar = addr;
            }

            Ok(())
        }
        Null => Err(NoOperand),
        _ => Err(InvalidOperand),
    }
}