gipu/python/assembler.py

import sys
import re
import struct
import IPython


class VMAssembler:
    assembled_code = bytearray()

    def parse(self, instruction):
        action = getattr(self, "{}".format(instruction.opcode.name))
        action(instruction)

    def process_code_line(self, line):
        sys.stdout.write("CODE: ")
        components = [x for x in re.split('\W', line) if x]

        instruction = VMInstruction(components[0], components[1:])
        self.parse(instruction)

    def imm2reg(self, instruction):
        """
        Intel syntax -> REG, IMM
        """
        opcode = instruction.opcode
        reg = instruction.args[0]
        imm = instruction.args[1]
        print(instruction)
        if reg.name != "ip":
            if opcode.uint8() and reg.uint8() and imm.uint16():
                self.assembled_code += opcode.uint8() + reg.uint8() + imm.uint16()
            else:
                sys.stderr.write(
                    "ERROR WHILE ASSEMBLING UNKNOWN VALUES\n")
                return False
        else:
            sys.stderr.write("CAN'T MOVI TO IP!\n")
            return False
        return True

    def reg2reg(self, instruction):
        return

    def reg2imm(self, instruction):
        """
        Intel syntax -> IMM, REG
        """
        opcode = instruction.opcode
        imm = instruction.args[0]
        reg = instruction.args[1]
        print(instruction)
        if reg.name != "ip":
            if opcode.uint8() and reg.uint8() and imm.uint16():
                self.assembled_code += opcode.uint8() + imm.uint16() + reg.uint8()
            else:
                sys.stderr.write(
                    "ERROR WHILE ASSEMBLING UNKNOWN VALUES\n")
                return False
        else:
            sys.stderr.write("CAN'T MOVI TO IP!\n")
            return False
        return True

    def imm(self, instruction):
        return

    def movi(self, instruction):
        if not self.imm2reg(instruction):
            print("WAT")
            return False
        return True

    def movr(self, instruction):
        if not self.reg2reg(instruction):
            print("WAT")
            return False
        return True

    def getm(self, instruction):
        if not self.imm2reg(instruction):
            print("WAT")
            return False
        return True

    def putm(self, instruction):
        if not self.reg2imm(instruction):
            print("WAT")
            return False
        return True

    def addi(self, instruction):
        if not self.imm2reg(instruction):
            print("WAT")
            return False
        return True


class VMComponent:
    """
    Represents a register or a operation the VM recognizes
    """
    name = ""
    value = ""

    def __init__(self, name, value):
        self.name = name
        self.value = value

    def __repr__(self):
        return "{}".format(self.name)

    def uint8(self):
        numre = re.compile("^[0-9]+$")
        if isinstance(self.value, int):
            return struct.pack("<B", self.value)
        elif self.value.startswith("0x"):
            return struct.pack("<B", int(self.value, 16))
        elif numre.match(self.value):  # only numbers
            return struct.pack("<B", int(self.value))
        return None

    def uint16(self):
        numre = re.compile("^[0-9]+$")
        if isinstance(self.value, int):
            return struct.pack("<H", self.value)
        elif self.value.startswith("0x"):
            return struct.pack("<H", int(self.value, 16))
        elif numre.match(self.value):  # only numbers
            return struct.pack("<H", int(self.value))
        return None


class VMInstruction:
    """
    Represents an instruction the VM recognizes.
    e.g: MOVI [R0, 2]
          ^       ^
        opcode  args
    """

    def __init__(self, opcode, instr_list):
        # TODO EXCEPTION SE REGISTRO / IMM / OPCODE NON VALIDO
        immediate_regexp = re.compile("^(0x*|[0-9]*$)")
        opc_name, opc_value = value_from_list(ops, opcode)
        self.opcode = VMComponent(opc_name, opc_value)
        self.args = []
        for el in instr_list:
            if not immediate_regexp.match(el):
                # create a VM component for a register
                reg_name, reg_value = value_from_list(regs, el)
                self.args.append(VMComponent(reg_name, reg_value))
            else:
                # directly append the immediate
                self.args.append(VMComponent(el, el))

    def __repr__(self):
        return "{} {}".format(self.opcode.name, ", ".join([x.name for x in self.args]))

op_names = ["MOVI",
            "MOVR",
            "GETM",
            "PUTM",
            "ADDI",
            "ADDR",
            "SUBI",
            "SUBR",
            "XORI",
            "XORR",
            "NOTI",
            "NOTR",
            "MULI",
            "MULR",
            "DIVI",
            "DIVR",
            "PUSH",
            "POOP",
            "CALL",
            "HALT",
            "NOPE"]
reg_names = ["R0", "R1", "R2", "R3", "S0", "S1", "S2", "S3", "IP", "BP", "SP"]
section_names = ["DATA:", "CODE:", "STACK:"]
section_flags = {s.casefold(): i + 1 for i, s in enumerate(section_names)}
ops = [VMComponent(s.casefold(), i) for i, s in enumerate(op_names)]
regs = [VMComponent(s.casefold(), i) for i, s in enumerate(reg_names)]

def value_from_list(fromlist, name):
    """
    returns a tuple (name, value) from a list of VMComponents
    """
    for el in fromlist:
        if el.name == name:
            return (el.name, el.value)
    return None


def name_from_list(fromlist, value):
    """
    returns a tuple (name, value) from a list of VMComponents
    """
    for el in fromlist:
        if el.value == value:
            return (el.name, el.value)
    return None

def assemble_data(line):
    sys.stdout.write("DATA:\t")
    sys.stdout.write(line.strip(",") + "\n")

def main():
    if len(sys.argv) < 3:
        print("Usage: {} file_to_assemble output".format(sys.argv[0]))
        return
    vma = VMAssembler()
    with open(sys.argv[1], 'r') as f:
        gen = (line.casefold().strip("\n") for line in f if line != "\n")
        flag = None

        for line in gen:
            if line in section_flags:
                flag = section_flags[line]
                continue
            if flag == section_flags["data:"]:
                vma.process_code_line(line)
            elif flag == section_flags["code:"]:
                vma.process_code_line(line)
        if not flag:
            sys.stderr.write(
                "Nothing was assembled! Did you use the section delimiters?\n")
    with open(sys.argv[2], 'wb') as f:
        f.write(vma.assembled_code)

if __name__ == '__main__':
    main()