Python MachineUpdate Examples

Example #1

File: jump.py Project: chellmuth/cpu-emulator

    def run(self, machine):
        if (Flag.SF in machine.flags) == (Flag.OF in machine.flags):
            return MachineUpdate()

        return MachineUpdate(
            registers={
                Register.pc: machine.registers[self.value_register],
            })

Example #2

File: jump.py Project: chellmuth/cpu-emulator

    def run(self, machine):
        if Flag.ZF not in machine.flags:
            return MachineUpdate()

        return MachineUpdate(
            registers={
                Register.pc: machine.registers[self.value_register],
            })

Example #3

File: jump.py Project: chellmuth/cpu-emulator

    def run(self, machine):
        if Flag.ZF not in machine.flags:
            return MachineUpdate()

        current = machine.registers[Register.pc].int_value()
        offset = machine.registers[self.value_register].int_value()
        updated_pc = Word.from_int(current + offset + self.size)

        return MachineUpdate(registers={
            Register.pc: updated_pc,
        })

Example #4

File: jump.py Project: chellmuth/cpu-emulator

    def run(self, machine):
        if (Flag.SF in machine.flags) == (Flag.OF in machine.flags):
            return MachineUpdate()

        current = machine.registers[Register.pc].int_value()
        offset = self.value_word.int_value()
        updated_pc = Word.from_int(current + offset + self.size)

        return MachineUpdate(registers={
            Register.pc: updated_pc,
        })

Example #5

 def run(self, machine):
     dest = machine.registers[Register.sp]
     return MachineUpdate(
         memory={dest: machine.registers[self.value_register]},
         registers={
             Register.sp: machine.registers[Register.sp].incremented(-4)
         })

Example #6

File: pop.py Project: chellmuth/cpu-emulator

    def run(self, machine):
        pop_address = machine.registers[Register.sp].incremented(4)
        payload = machine.memory.read_word(pop_address.int_value())

        return MachineUpdate(registers={
            self.value_register: payload,
            Register.sp: pop_address
        })

Example #7

File: ret.py Project: chellmuth/cpu-emulator

    def run(self, machine):
        updated_sp_address = machine.registers[Register.sp].incremented(4)
        popped_pc = machine.memory.read_word(updated_sp_address.int_value())

        return MachineUpdate(registers={
            Register.pc: popped_pc,
            Register.sp: updated_sp_address
        })

Example #8

File: jump.py Project: chellmuth/cpu-emulator

    def run(self, machine):
        current = machine.registers[Register.pc].int_value()
        offset = machine.registers[self.value_register].int_value()

        return MachineUpdate(
            registers={
                Register.pc: Word.from_int(current + offset + self.size),
            })

Example #9

File: subtract.py Project: chellmuth/cpu-emulator

    def run(self, machine):
        result, flags = subtract_word(machine.registers[self.dest_register],
                                      machine.registers[self.source_register])

        return MachineUpdate(registers={
            self.dest_register: result,
        },
                             flags=flags)

Example #10

    def run(self, machine):
        return_pointer = machine.registers[Register.pc].incremented(self.size)
        updated_pc = self.value_word.incremented(13)  # todo: spec error

        return MachineUpdate(
            memory={machine.registers[Register.sp]: return_pointer},
            registers={
                Register.pc: updated_pc,
                Register.sp: machine.registers[Register.sp].incremented(-4)
            })

Example #11

File: input_op.py Project: chellmuth/cpu-emulator

    def run(self, machine):
        if machine.stdin:
            user_int = machine.stdin.pop(0)
        else:
            user_input = input()
            user_int = ord(user_input[0])

        user_byte = Byte(user_int)

        return MachineUpdate(
            memory={machine.registers[self.value_register]: user_byte}, )

Example #12

    def run(self, machine):
        return_pointer = machine.registers[Register.pc].incremented(self.size)
        increment_amount = machine.registers[self.value_register]

        return MachineUpdate(
            memory={machine.registers[Register.sp]: return_pointer},
            registers={
                Register.pc:
                machine.registers[Register.pc].incremented(increment_amount),
                Register.sp:
                machine.registers[Register.sp].incremented(-4)
            })

Example #13

 def run(self, machine):
     payload = machine.registers[self.source_register]
     return MachineUpdate(registers={self.dest_register: payload})

Example #14

    def run(self, machine):
        char = machine.registers[self.value_register].low_byte()

        return MachineUpdate(stdout=char)

Example #15

    def run(self, machine):
        char = self.value_word.low_byte()

        return MachineUpdate(stdout=char)

Example #16

File: bitwise_or.py Project: chellmuth/cpu-emulator

    def run(self, machine):
        result, _ = bitwise_or(machine.registers[self.dest_register],
                               machine.registers[self.source_register])

        return MachineUpdate(registers={self.dest_register: result})

Example #17

File: jump.py Project: chellmuth/cpu-emulator

 def run(self, machine):
     return MachineUpdate(registers={Register.pc: self.value_word})

Example #18

File: jump.py Project: chellmuth/cpu-emulator

 def run(self, machine):
     return MachineUpdate(
         registers={
             Register.pc: machine.registers[self.value_register],
         })

Example #19

    def run(self, machine):
        _, flags = bitwise_and(machine.registers[self.dest_register],
                               machine.registers[self.source_register])

        return MachineUpdate(registers={self.dest_register: result},
                             flags=flags)

Example #20

File: bitwise_not.py Project: chellmuth/cpu-emulator

    def run(self, machine):
        result = bitwise_not(machine.registers[self.value_register])

        return MachineUpdate(registers={self.value_register: result})

Example #21

 def run(self, machine):
     result = machine.registers[self.dest_register].low_byte()
     return MachineUpdate(
         memory={machine.registers[self.source_register]: result})

Example #22

 def run(self, machine):
     result = machine.registers[self.dest_register]
     return MachineUpdate(memory={self.source_word: result})

Example #23

File: bitwise_xor.py Project: chellmuth/cpu-emulator

    def run(self, machine):
        result, flags = bitwise_xor(machine.registers[self.dest_register],
                                    self.source_word)

        return MachineUpdate(registers={self.dest_register: result},
                             flags=flags)

Example #24

    def run(self, machine):
        _, flags = bitwise_and(machine.registers[self.dest_register],
                               self.source_word)

        return MachineUpdate(flags=flags)

Example #25

File: jump.py Project: chellmuth/cpu-emulator

    def run(self, machine):
        if Flag.ZF not in machine.flags:
            return MachineUpdate()

        return MachineUpdate(
            registers={Register.pc: self.value_word.incremented(13)})

Example #26

 def run(self, machine):
     return MachineUpdate()

Example #27

    def run(self, machine):
        address = self.source_word.int_value()
        loaded_word = machine.memory.read_word(address)

        return MachineUpdate(registers={self.dest_register: loaded_word})