diff --git a/.gitignore b/.gitignore deleted file mode 100644 index 7e99e36..0000000 --- a/.gitignore +++ /dev/null @@ -1 +0,0 @@ -*.pyc \ No newline at end of file diff --git a/README.mdown b/README.mdown index 9c59a9d..0076430 100644 --- a/README.mdown +++ b/README.mdown @@ -2,19 +2,19 @@ A DCPU-16 implementation in Python. See [the spec][0]. -# Goal +# But what's the goal of this? There's another one already! -Many high-level implementations looked like C-in-other-language, so let's have a pythonic enough (whatever that means, but you should [read][1] [this][2]) implementation. The spirit of the thing is to be educative for everyone. +Well, what's wrong with taking another stab at it? Besides, I personnally felt it was too C-ish, and not pythonic enough (whatever that means, but you should [read][1] [this][2]). I wanted to revive whatever low-level (admittedly limited) ASM knowledge I had (from 6800/68000) and sharpen my Python-fu. The spirit of the thing is to be educative for everyone (including me). -# Usage +# How do I use this? -It's meant to be used interactively via the Python REPL as well as programmatically. A specific ASM REPL might be implemented at some point. +It's meant to be used interactively via the Python REPL as well as programmatically. I might implement a specific ASM REPL at some point. An example of a Python REPL session: - >>> from dcpu_16 import CPU, spec_demo + >>> from dcpu_16 import CPU >>> c = CPU(debug=True) - >>> c.load_m(spec_demo) # loads demo program + >>> c.load_m() # loads demo program >>> c.step() # step by one instruction << SET << c.r[0x0] @@ -31,9 +31,9 @@ An example of a Python REPL session: >>> c.dump_r() # get CPU register state as string 'A=0000 B=0000 C=0000 X=0000 Y=0000 Z=0000 I=0000 J=0000 PC=0000 SP=0000 O=0000' -# Status +# What is the status of this? -As of v1.0 the CPU implementation ought to be complete according to DCPU-16 spec v1.1. +It's not bug-free yet, the implementation itself is still a WIP and the whole of the spec example does not pass yet. But hey, that's what you get in a few late hours. Fixes coming, I promise. # Features diff --git a/dcpu_16.py b/dcpu_16.py index b0e60c1..3b25456 100644 --- a/dcpu_16.py +++ b/dcpu_16.py @@ -1,48 +1,32 @@ -"""DCPU-16 implementation. (c) 2012, Loic Nageleisen - -Spec: http://0x10c.com/doc/dcpu-16.txt - -See LICENSE for licensing information. -""" - - from __future__ import print_function, division - -# DCPU-16 spec version -spec = '1.1' - - -# log tool def log(string): print(" << %s" % string) -# width constants +#http://0x10c.com/doc/dcpu-16.txt +spec = '1.1' + w = 16 -wmask = 2**w - 1 +wmask = 2**w-1 + +literals = [l for l in xrange(0, 0x20)] + +opcode_map = {} +valcode_map = {} -_opcode_map = {} class opcode(object): - """Opcode decorator""" def __init__(self, *opcode): self.opcode = opcode def __call__(self, f): _opcode_f = f _opcode_f.opcode = self.opcode - if len(self.opcode) == 1: - _opcode_map[self.opcode[0]] = _opcode_f - else: - if not self.opcode[0] in _opcode_map.keys(): - _opcode_map[self.opcode[0]] = {} - _opcode_map[self.opcode[0]][self.opcode[1]] = _opcode_f + opcode_map[self.opcode] = _opcode_f return _opcode_f -_valcode_map = {} class valcode(object): - """Valcode decorator""" def __init__(self, valcode): self.valcode = valcode @@ -52,58 +36,17 @@ class valcode(object): try: for code in self.valcode: # currify with (bound) code - _valcode_map[code] = lambda c, code=code: _valcode_f(c, code) - _valcode_map[code].__name__ = '%s(code=0x%02X)' % (_valcode_f.__name__, code) + valcode_map[code] = lambda c, code=code: _valcode_f(c, code) + valcode_map[code].__name__ = '%s(code=0x%02X)' % (_valcode_f.__name__, code) except TypeError: - _valcode_map[self.valcode] = _valcode_f + valcode_map[self.valcode] = _valcode_f return _valcode_f -class Register(object): - """Register descriptor""" - def __init__(self, regcode=None): - self.regcode = regcode - - def __get__(self, c, type=None): - if self.regcode is not None: - return c.r[self.regcode] - else: - return self.value - - def __set__(self, c, value): - if self.regcode is not None: - c.r[self.regcode] = value & wmask - else: - self.value = value & wmask - -def make_pointer(c, codestr): - """creates a pointer func that evaluates codestr""" - def getter(c=c): - return eval("%s" % codestr) - def setter(data, c=c): - exec("%s = %r" % (codestr, data)) in {}, {'c': c, 'data': data} - pointer = getter - pointer.codestr = codestr - pointer.set = setter - return pointer - -def pointerize(f): - """wraps a function that generates a codestr to create a pointer""" - if f.func_code.co_argcount == 1: - ptrz = lambda c: make_pointer(c, f(c)) - elif f.func_code.co_argcount == 2: - ptrz = lambda c, code: make_pointer(c, f(c, code)) - else: - raise Exception('%s has too many arguments' % f.__name__) - ptrz.__name__ = 'ptr_to_%s' % f.__name__ - ptrz.__doc__ = f.__doc__ - return ptrz - - @opcode(0x0, 0x01) def JSR(c, a): """pushes the address of the next instruction to the stack, then sets PC to a""" - c.sp -= 1 + c.sp = (c.sp - 1) & wmask c.m[c.sp] = c.pc c.pc = a() @@ -221,11 +164,35 @@ def IFB(c, a, b): c.skip = True +def make_pointer(c, codestr): + """creates a pointer func that evaluates codestr""" + def getter(c=c): + return eval("%s" % codestr) + def setter(data, c=c): + exec("%s = %r" % (codestr, data)) in {}, {'c': c, 'data': data} + pointer = getter + pointer.codestr = codestr + pointer.set = setter + return pointer + +def pointerize(f): + """wraps a function that generates a codestr to create a pointer""" + if f.func_code.co_argcount == 1: + ptrz = lambda c: make_pointer(c, f(c)) + elif f.func_code.co_argcount == 2: + ptrz = lambda c, code: make_pointer(c, f(c, code)) + else: + raise Exception('%s has too many arguments' % f.__name__) + ptrz.__name__ = 'ptr_to_%s' % f.__name__ + ptrz.__doc__ = f.__doc__ + return ptrz + @valcode(range(0x00, 0x08)) @pointerize def register(c, code): """register""" v = "c.r[0x%01X]" % code + if c.debug: log(v) return v @valcode(range(0x08, 0x10)) @@ -233,6 +200,7 @@ def register(c, code): def register_value(c, code): """[register]""" v = "c.m[c.r[0x%01X]]" % (code-0x07) + if c.debug: log(v) return v @valcode(range(0x10, 0x18)) @@ -240,7 +208,8 @@ def register_value(c, code): def next_word_plus_register_value(c, code): """[next word + register]""" v = "c.m[0x%04X + c.r[0x%01X]]" % (c.m[c.pc], code-0x0F) - c.pc += 1 + if c.debug: log(v) + c.pc = (c.pc + 1) & wmask return v @valcode(0x18) @@ -248,7 +217,8 @@ def next_word_plus_register_value(c, code): def pop(c): """POP / [SP++]""" v = "c.m[0x%04X]" % c.sp - c.sp += 1 + if c.debug: log(v) + c.sp = (c.sp + 1) & wmask return v @valcode(0x19) @@ -256,14 +226,16 @@ def pop(c): def peek(c): """PEEK / [SP]""" v = "c.m[0x%04X]" % c.sp + if c.debug: log(v) return v @valcode(0x1A) @pointerize def push(c): """PUSH / [--SP]""" - c.sp -= 1 + c.sp = (c.sp - 1) & wmask v = "c.m[0x%04X]" % c.sp + if c.debug: log(v) return v @valcode(0x1B) @@ -271,6 +243,7 @@ def push(c): def stack_pointer(c): """stack pointer""" v = "c.sp" + if c.debug: log(v) return v @valcode(0x1C) @@ -278,6 +251,7 @@ def stack_pointer(c): def program_counter(c): """program counter""" v = "c.pc" + if c.debug: log(v) return v @valcode(0x1D) @@ -285,6 +259,7 @@ def program_counter(c): def overflow(c): """overflow""" v = "c.o" + if c.debug: log(v) return v @valcode(0x1E) @@ -292,7 +267,8 @@ def overflow(c): def next_word_value(c): """[next_word]""" v = "c.m[0x%04X]" % c.m[c.pc] - c.pc += 1 + c.pc = (c.pc + 1) & wmask + if c.debug: log(v) return v @valcode(0x1F) @@ -300,7 +276,8 @@ def next_word_value(c): def next_word(c): """next_word (literal)""" v = "c.m[0x%04X]" % c.pc - c.pc += 1 + c.pc = (c.pc + 1) & wmask + if c.debug: log(v) return v @valcode(range(0x20, 0x40)) @@ -308,34 +285,13 @@ def next_word(c): def literal(c, code): """literal value 0x00-0x1F (literal)""" v = "0x%04X" % (code - 0x20) + if c.debug: log(v) return v -class Memory(object): - """array of 16-bit words""" - def __init__(m, debug=False): - m.clear() - - def clear(m): - """clear memory""" - # TODO: (addr, len) memory range to clear - m.w = [0 for _ in xrange(0, 2**w)] - - def __getitem__(m, addr): - """get word at addr""" - return m.w[addr] - - def __setitem__(m, addr, value): - """assignment truncates values to 16-bit words""" - # TODO: multi-word assignment starting at addr when value is list - m.w[addr] = value & wmask - class CPU(object): - """DCPU-16""" - def __init__(c, memory=Memory(), debug=False): - """If you don't specify memory, CPUs will share the same, default memory object""" - c.m = memory + def __init__(c, debug=False): c.clear() c.reset() c.debug = debug @@ -350,78 +306,107 @@ class CPU(object): def clear(c): """clear memory""" - c.m.clear() + c.m = [0 for _ in xrange(0, 2**w)] + + @property + def a(c): + return c.r[0] + @a.setter + def a(c, val): + c.r[0] = val + + @property + def b(c): + return c.r[1] + @b.setter + def b(c, val): + c.r[1] = val + + @property + def c(c): + return c.r[2] + @c.setter + def c(c, val): + c.r[2] = val + + @property + def x(c): + return c.r[3] + @x.setter + def x(c, val): + c.r[3] = val + + @property + def y(c): + return c.r[4] + @y.setter + def y(c, val): + c.r[4] = val + + @property + def z(c): + return c.r[5] + @z.setter + def z(c, val): + c.r[5] = val + + @property + def i(c): + return c.r[6] + @i.setter + def i(c, val): + c.r[6] = val + + @property + def j(c): + return c.r[7] + @j.setter + def j(c, val): + c.r[7] = val - a = Register(0x0) - b = Register(0x1) - c = Register(0x2) - x = Register(0x3) - y = Register(0x4) - z = Register(0x5) - i = Register(0x6) - j = Register(0x7) - pc = Register() - sp = Register() - o = Register() - def _op(c, word): - """dispatch word to op and args""" - opcode = word & 0xF - a_code = word >> 4 & 0x3F - b_code = word >> 10 & 0x3F - try: - op = _opcode_map[opcode] - try: - op = op[a_code] - except TypeError: - args = (c._pointer(a_code), - c._pointer(b_code)) - else: - args = (c._pointer(b_code),) - finally: - if c.debug: - log(' '.join([op.__name__] + [arg.codestr for arg in args])) - except KeyError: - raise Exception('Invalid opcode %s at PC=%04X' % (["%02X"%x for x in opcode], c.pc)) - return op, args def _pointer(c, code): - """get pointer to valcode""" + """get pointer to value code""" try: - return _valcode_map[code](c) + return valcode_map[code](c) except KeyError: - raise Exception("Invalid valcode") + raise Exception("Invalid value code") def __getitem__(c, code): - """get value of valcode""" + """get pointer to value""" return c._pointer(code)() def __setitem__(c, code, value): - """set value at valcode""" + """set value at pointer""" c._pointer(code).set(value) def step(c): """start handling [PC]""" word = c.m[c.pc] - c.pc += 1 - op, args = c._op(word) + c.pc = (c.pc + 1) & wmask + if (word & 0xF) > 0: + opcode = (word & 0xF,) + a = c._pointer(word >> 4 & 0x3F) + b = c._pointer(word >> 10 & 0x3F) + args = (a, b) + elif (word >> 4 & 0x3F) > 0: + opcode = (0x0, word >> 4 & 0x3F) + a = c._pointer(word >> 10 & 0x3F) + args = (a, ) + else: + raise Exception('Invalid opcode %s at PC=%04X' % (["%02X"%x for x in opcode], c.pc)) + try: + op = opcode_map[opcode] + if c.debug: log(op.__name__) + except KeyError: + raise Exception('Invalid opcode %s at PC=%04X' % (["%02X"%x for x in opcode], c.pc)) if c.skip: c.skip = False - if c.debug: log("Skipped") else: op(c, *args) if c.debug: log(c.dump_r()) - def run(c): - """step until PC is constant""" - last_pc = 0xFFFF - last_sp = 0xFFFF - while c.pc != last_pc or c.sp != last_sp: - last_pc = c.pc - last_sp = c.sp - c.step() - log("Infinite loop") - def dump_r(c): """human-readable register status""" return " ".join( "%s=%04X" % @@ -433,9 +418,15 @@ class CPU(object): (c.r + [c.pc, c.sp, c.o])[i]) for i in range(11)) - def load_m(c, data=None, io=None): + def load_m(c, io=None): """load data in memory""" # TODO: load from io object + data = [ + 0x7c01, 0x0030, 0x7de1, 0x1000, 0x0020, 0x7803, 0x1000, 0xc00d, + 0x7dc1, 0x001a, 0xa861, 0x7c01, 0x2000, 0x2161, 0x2000, 0x8463, + 0x806d, 0x7dc1, 0x000d, 0x9031, 0x7c10, 0x0018, 0x7dc1, 0x001a, + 0x9037, 0x61c1, 0x7dc1, 0x001a, 0x0000, 0x0000, 0x0000, 0x0000, + ] for i in xrange(len(data)): c.m[i] = data[i] @@ -445,9 +436,3 @@ class CPU(object): pass -spec_demo = [ - 0x7c01, 0x0030, 0x7de1, 0x1000, 0x0020, 0x7803, 0x1000, 0xc00d, - 0x7dc1, 0x001a, 0xa861, 0x7c01, 0x2000, 0x2161, 0x2000, 0x8463, - 0x806d, 0x7dc1, 0x000d, 0x9031, 0x7c10, 0x0018, 0x7dc1, 0x001a, - 0x9037, 0x61c1, 0x7dc1, 0x001a, 0x0000, 0x0000, 0x0000, 0x0000, -] diff --git a/test.py b/test.py index 640601c..5232f5e 100644 --- a/test.py +++ b/test.py @@ -190,7 +190,6 @@ class TestInstructions(unittest.TestCase): self.assertEqual(c.sp, 0xFFFF) self.assertEqual(c.m[0xFFFF], 0xBEEF) - class TestCPU(unittest.TestCase): """CPU behavior""" @@ -233,95 +232,7 @@ class TestCPU(unittest.TestCase): for r in c.m: self.assertEqual(r, 0) -class TestCPUWithPrograms(unittest.TestCase): - def setUP(self): - pass - - def test_spec_demo(self): - c = CPU() - data = [ - 0x7c01, 0x0030, 0x7de1, 0x1000, 0x0020, 0x7803, 0x1000, 0xc00d, - 0x7dc1, 0x001a, 0xa861, 0x7c01, 0x2000, 0x2161, 0x2000, 0x8463, - 0x806d, 0x7dc1, 0x000d, 0x9031, 0x7c10, 0x0018, 0x7dc1, 0x001a, - 0x9037, 0x61c1, 0x7dc1, 0x001a, 0x0000, 0x0000, 0x0000, 0x0000, - ] - c.load_m(data=data) - - self.assertEqual(c.pc, 0) - c.step() # SET A, 0x30 - self.assertEqual(c.a, 0x30) - - self.assertEqual(c.pc, 2) - c.step() # SET [0x1000], 0x20 - self.assertEqual(c.m[0x1000], 0x20) - - self.assertEqual(c.pc, 5) - c.step() # SUB A, [0x1000] - self.assertEqual(c.a, 0x10) - - self.assertEqual(c.pc, 7) - c.step() # IFN A, 0x10 - self.assertEqual(c.pc, 8) - self.assertEqual(c.skip, True) - - c.step() # skip SET PC, crash - self.assertEqual(c.skip, False) - - self.assertEqual(c.pc, 10) - c.step() # SET I, 10 - self.assertEqual(c.i, 0x0A) - - self.assertEqual(c.pc, 11) - c.step() # SET A, 0x2000 - self.assertEqual(c.a, 0x2000) - - for i in range(10, 0, -1): - self.assertEqual(c.pc, 13) - c.step() # SET [0x2000+I], [A] - self.assertEqual(c.m[0x2000+i], 0x0) - - self.assertEqual(c.pc, 15) - c.step() # SUB I, 1 - self.assertEqual(c.i, i-1) - - self.assertEqual(c.pc, 16) - c.step() # IFN I, 0 - self.assertEqual(c.skip, i-1==0) - - self.assertEqual(c.pc, 17) - c.step() # SET PC, loop (with skip if c.i==0) - - self.assertEqual(c.pc, 19) - c.step() # SET X, 0x4 - self.assertEqual(c.x, 0x4) - - self.assertEqual(c.pc, 20) - c.step() # JSR testsub - self.assertEqual(c.sp, 0xFFFF) - self.assertEqual(c.m[0xFFFF], 22) - - self.assertEqual(c.pc, 24) - c.step() # SHL X, 4 - self.assertEqual(c.x, 0x40) - - self.assertEqual(c.pc, 25) - c.step() # SET PC, POP - - self.assertEqual(c.pc, 22) - c.step() # SET PC, crash - - self.assertEqual(c.pc, 26) - c.step() # SET PC, crash - - self.assertEqual(c.pc, 26) - # endless loop - if __name__ == '__main__': - cases = [ - 'test.TestInstructions', - 'test.TestCPU', - 'test.TestCPUWithPrograms' - ] - suite = unittest.TestLoader().loadTestsFromNames(cases) + suite = unittest.TestLoader().loadTestsFromNames(['test.TestInstructions', 'test.TestCPU']) unittest.TextTestRunner(verbosity=2).run(suite)