from typing import Dict


class IRInterpreter:
    def __init__(self):
        self.variables: Dict = {}
        self.temps: Dict = {}

    def get_value(self, name):

        if isinstance(name, (int, float)):
            return name

        if name in self.temps:
            return self.temps[name]

        if name in self.variables:
            return self.variables[name]

        raise Exception(f"Unknown value {name}")

    def execute(self, instructions):

        for instr in instructions:
            op = instr.op

            if op == "LOAD_CONST":
                self.temps[instr.result] = instr.arg1

            elif op == "ADD":
                self.temps[instr.result] = self.get_value(instr.arg1) + self.get_value(
                    instr.arg2
                )

            elif op == "SUB":
                self.temps[instr.result] = self.get_value(instr.arg1) - self.get_value(
                    instr.arg2
                )

            elif op == "MUL":
                self.temps[instr.result] = self.get_value(instr.arg1) * self.get_value(
                    instr.arg2
                )

            elif op == "DIV":
                self.temps[instr.result] = self.get_value(instr.arg1) / self.get_value(
                    instr.arg2
                )

            elif op == "STORE":
                self.variables[instr.result] = self.get_value(instr.arg1)

            else:
                raise Exception(f"Unknown op {op}")

        return self.variables

variables = {
   "a": 12
}

temps = {
   "t1": 10,
   "t2": 12
}

from core.interpreter import IRInterpreter
from core.ir import IRBuilder
from core.lexer import Lexer
from core.optimizations.pipline import Optimizer
from core.parser import Parser
from core.semantic import SemanticAnalyzer


def main():
    code = """
    int b = 3;
    int a = 10 + b;
    int c = a * 2;
    """
    lexer = Lexer(code)
    tokens = lexer.tokenize()

    for token in tokens:
        print(token)

    parser = Parser(tokens)
    ast = parser.parse()

    print(ast)

    semantic = SemanticAnalyzer()
    semantic.analyze(ast)

    print("Semantic analysis passed")
    print("Symbol table:", semantic.symbol_table)

    ir_builder = IRBuilder()
    ir = ir_builder.build(ast)

    print("IR:")
    for instr in ir:
        print(instr)

    optimizer = Optimizer()
    ir = optimizer.optimize(ir)

    print("Optimized IR:")
    for instr in ir:
        print(instr)

    print("Generate code")
    interpreter = IRInterpreter()
    result = interpreter.execute(ir)

    print("Program result:")
    print(result)


if __name__ == "__main__":
    main()

source code
 int b = 3;
 int a = 10 + b;
 int c = a * 2;

IRInstruction(op='STORE', arg1=3, arg2=None, result='b')
IRInstruction(op='ADD', arg1=10, arg2='b', result='t3')
IRInstruction(op='STORE', arg1='t3', arg2=None, result='a')
IRInstruction(op='MUL', arg1='a', arg2=2, result='t5')
IRInstruction(op='STORE', arg1='t5', arg2=None, result='c')

...
Generate code
Program result:
{'b': 3, 'a': 13, 'c': 26}