ZombieCPU/main.py

151 lines
4.9 KiB
Python

#made by zombie
#02/01/21
#0-255 is internal registers and flags and etc
# program execcution starts at 256
#stack starts at end of memory FILO
#flags
#nil nil nil nil nil nil negative zero
import numpy as np
import opcodes as ops
from registers import Registers
np.set_printoptions(threshold=np.inf)
class ZombieCPU:
_regs = Registers()
def __init__(self, memorysize=None, debug=None):
self._memorysize = memorysize
self._memory = np.zeros(memorysize)
self._debug = debug
def reset(self):
if self._debug:
print('Processor Reseting')
self._memory = np.zeros(self._memorysize) #clear memory
self._regs.esp = self._memorysize - 1 #set stackpointer
self._regs.eip = 256 #set instructiojn pointer #fuck you thomas
print(self._regs.eip)
def exec(self):
Halted = False
while not Halted: #change this to if not halt
#fetch
opcode = self._memory[int(self._regs.eip)]
address = self._memory[int(self._regs.eip + 1)]
value = self._memory[int(self._regs.eip + 2)]
if self._debug:
print(f'Opcode: {opcode}\nAddress: {address}\nValue: {value}\nIP: {self._regs.eip}')
if opcode == ops.NOP:
pass
elif opcode == ops.HLT:
Halted = True
if self._debug:
print('Processor Halted')
elif opcode == ops.RST: #reset
self.reset()
elif opcode == ops.DBG: #debug toggle
self._debug = value
elif opcode == ops.LDI: #mov but actually load immediate
self.write_memory(address, value)
self.flags_zero(value)
self.flags_negative(value)
elif opcode == ops.PUSH: #push
self.write_memory(self._regs.esp, value) #put value onto stack
self._regs.esp -= 1 #dec stackpointer
elif opcode == ops.POP: #pop
self.write_memory(address, self.read_memory_address(self._regs.esp + 1)) #read the last value and put it into address (not the empty space)
self._regs.esp += 1 #inc stackpointer
elif opcode == ops.JMP:
self._regs.eip = address - 3
elif opcode == ops.JZ:
if self._regs.flags & 0b00000001:
self._regs.eip = address - 3
elif opcode == ops.CMP:
self.flags_zero(address - value)
elif opcode == ops.INC:
self.write_memory(address, self.read_memory_address(address) + 1)
self.flags_zero(self.read_memory_address(address))
self.flags_negative(self.read_memory_address(address))
elif opcode == ops.DEC:
self.write_memory(address, self.read_memory_address(address) - 1)
self.flags_zero(self.read_memory_address(address))
self.flags_negative(self.read_memory_address(address))
self._regs.eip += 3 #increment instruction pointer
#flag shit
def read_flags(self, i):
return self._regs
def flags_zero(self, value):
if value == 0:
self._regs.flags = self._regs.flags | 0b00000001
else:
self._regs.flags = self._regs.flags & ~0b00000001
def flags_negative(self, value):
if value < 0:
self._regs.flags = self._regs.flags | 0b00000010
else:
self._regs.flags = self._regs.flags & ~0b00000010
#memory
def set_memory(self, memory):
self._memory = memory
def write_memory(self, address, value):
self._memory[int(address)] = value
def read_memory(self):
return self._memory
def read_memory_address(self, address):
return self._memory[int(address)]
if __name__ == "__main__":
cpu = ZombieCPU(65536, False)
cpu.reset()
#hard coded opcodes
cpu.write_memory(256, ops.LDI) #mov
cpu.write_memory(257, 27) #address 27
cpu.write_memory(258, 105) #105 into ^
cpu.write_memory(259, ops.PUSH) #push
cpu.write_memory(260, 0) #unused in this op
cpu.write_memory(261, 27) #the value at address 27 onto the stack
cpu.write_memory(262, ops.POP) #pop
cpu.write_memory(263, 100) #into 100
cpu.write_memory(264, 0) #unused in this op
cpu.write_memory(265, ops.CMP)
cpu.write_memory(266, 10)
cpu.write_memory(267, 11) #should set the zero flag
cpu.write_memory(268, ops.INC) #increment
cpu.write_memory(269, 100)
cpu.write_memory(270, 0) #unused
cpu.write_memory(271, ops.HLT)
cpu.exec()
print(cpu.read_memory_address(100))
#c = Console(cpu.read_memory()) ima finish this later
#c.draw()