mahlang/code_interpreter.py at main · sina-salahshour/mahlang · GitHub

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
import math
import sys
from typing import Any, Iterable


def run_code(code_block: list):
    stack: Iterable[Any] = [None] * 1500
    pc = 0
    sp = 1000
    while True:
        operation = code_block[pc]
        pc += 1

        match operation:
            case (None, None, None, None):
                # print("program ended")
                break
            case ("print", arg, None, None):
                val = stack[arg]
                if val % 1 == 0:
                    print(int(val))
                else:
                    print(val)
            case ("input", None, None, loc):
                raw_num = ""
                has_num_started = False
                while True:
                    char = sys.stdin.read(1)
                    if char.isdigit():
                        has_num_started = True
                        raw_num += char
                    else:
                        if not has_num_started:
                            continue
                        else:
                            break
                num = int(raw_num)
                stack[loc] = num
            case ("jmpf", cond_addr, None, loc):
                if not stack[cond_addr]:
                    pc = loc
            case ("jmpt", cond_addr, None, loc):
                if stack[cond_addr]:
                    pc = loc
            case ("jmp", None, None, loc):
                pc = loc
            case ("+", lhs, rhs, dest):
                b = stack[lhs]
                a = stack[rhs]
                stack[dest] = a + b
            case ("sin", lhs, None, dest):
                b = stack[lhs]
                stack[dest] = math.sin(b)
            case ("cos", lhs, None, dest):
                b = stack[lhs]
                stack[dest] = math.cos(b)
            case ("neg", lhs, None, dest):
                b = stack[lhs]
                stack[dest] = -b
            case ("**", lhs, rhs, dest):
                b = stack[lhs]
                a = stack[rhs]
                stack[dest] = a**b
            case ("*", lhs, rhs, dest):
                b = stack[lhs]
                a = stack[rhs]
                stack[dest] = a * b
            case ("-", lhs, rhs, dest):
                b = stack[lhs]
                a = stack[rhs]
                stack[dest] = a - b
            case ("/", lhs, rhs, dest):
                b = stack[lhs]
                a = stack[rhs]
                stack[dest] = a / b
            case ("//", lhs, rhs, dest):
                b = stack[lhs]
                a = stack[rhs]
                stack[dest] = a // b
            case ("%", lhs, rhs, dest):
                b = stack[lhs]
                a = stack[rhs]
                stack[dest] = a % b
            case ("lt", lhs, rhs, dest):
                b = stack[lhs]
                a = stack[rhs]
                stack[dest] = int(a < b)
            case ("gt", lhs, rhs, dest):
                b = stack[lhs]
                a = stack[rhs]
                stack[dest] = int(a > b)
            case ("and", lhs, rhs, dest):
                b = stack[lhs]
                a = stack[rhs]
                stack[dest] = int(bool(a and b))
            case ("or", lhs, rhs, dest):
                b = stack[lhs]
                a = stack[rhs]
                stack[dest] = int(bool(a or b))
            case ("neq", lhs, rhs, dest):
                b = stack[lhs]
                a = stack[rhs]
                stack[dest] = int(a != b)
            case ("eq", lhs, rhs, dest):
                b = stack[lhs]
                a = stack[rhs]
                stack[dest] = int(a == b)
            case ("=", src, None, dest):
                stack[dest] = stack[src]
            case ("ld", num, None, loc):
                stack[loc] = num
            case ("call", None, None, addr):
                stack[sp] = pc
                sp += 1
                pc = addr
            case ("ret", None, None, None):
                sp -= 1
                pc = stack[sp]
            case catchall:
                raise RuntimeError(f"invalid operation {catchall}")