def test_br_3(self): vm.flags = 0b010 # Zero vm.mem[0] = 0b0000011000001010 # BRpz 10 vm.mem[4] = 0b1111000000100101 # HALT (TRAP 0x25) vm.mem[11] = 0b1111000000100101 # HALT (TRAP 0x25) vm.run() self.assertTrue(vm.pc == 12)
def test_add(self): vm.reg[2] = 23 vm.reg[4] = 90 vm.reg[7] = 4 vm.mem[0] = 0b0001111010000100 # ADD R7, R2, R4 vm.run() self.assertTrue(vm.reg[7] == (23+90))
def test_and(self): vm.reg[0] = 0b1010111001101010 vm.reg[1] = 0b0111010111011100 vm.mem[0] = 0b0101011000000001 # AND R3, R0, R1 vm.run() self.assertTrue(vm.reg[3] == 0b0010010001001000)
def test_br_1(self): vm.flags = 0b001 # Positive vm.mem[0] = 0b0000001000001010 # BRp 10 vm.mem[4] = 0b1111000000100101 # HALT (TRAP 0x25) vm.mem[11] = 0b1111000000100101 # HALT (TRAP 0x25) vm.run() self.assertTrue(vm.pc == 12)
def test_br_2(self): vm.flags = 0b000 # No Flags Set vm.mem[0] = 0b0000001000001010 # BRp 10 vm.mem[4] = 0b1111000000100101 # HALT (TRAP 0x25) vm.mem[11] = 0b1111000000100101 # HALT (TRAP 0x25) vm.run() self.assertTrue(vm.pc == 5)
def test_jmp(self): vm.reg[3] = 7 vm.mem[0] = 0b1100000011000000 # JMP R3 vm.mem[4] = 0b1111000000100101 # HALT (TRAP 0x25) vm.mem[7] = 0b1111000000100101 # HALT (TRAP 0x25) vm.run() self.assertTrue(vm.pc == 8)
def test_jsr(self): vm.reg[7] = 0b100 vm.mem[20] = 0b0100100000101000 # JSR #40 vm.mem[61] = 0b1111000000100101 # HALT (TRAP 0x25) vm.run() self.assertTrue(vm.pc == 62) self.assertTrue(vm.reg[7] == 21)
def test_st(self): vm.reg[6] = -9000 & 0xFFFF vm.mem[4] = 0b0011110000011001 # ST R6, #25 vm.mem[5] = 0b1111000000100101 # HALT (TRAP 0x25) vm.run() self.assertTrue(vm.mem[30] == (-9000 & 0xFFFF))
def test_str(self): vm.reg[3] = -20 & 0xFFFF vm.reg[5] = 0 vm.mem[20] = 0b0111101011011001 # STR R5, R3, #25 vm.run() self.assertTrue(vm.mem[5] == 0)
def test_and_setcc(self): vm.reg[1] = 0b1010111001101010 vm.mem[1] = 0b0101011001110010 # AND R3, R1, #-14 vm.run() f = BitField(vm.flags, 3) self.assertTrue(f[0] == 0) # Positive self.assertTrue(f[1] == 0) # Zero self.assertTrue(f[2] == 1) # Negative
def test_br_4(self): vm.mem[0] = 0b0001000000111011 # ADD R0, R0, #-5 vm.mem[1] = 0b0000100000001010 # BRn 10 vm.mem[4] = 0b1111000000100101 # HALT (TRAP 0x25) vm.mem[12] = 0b1111000000100101 # HALT (TRAP 0x25) vm.run() self.assertTrue(vm.pc == 13)
def test_jsrr(self): vm.reg[4] = 42 vm.reg[7] = 0b100 vm.mem[20] = 0b0100000100000000 # JSRR R4 vm.mem[63] = 0b1111000000100101 # HALT (TRAP 0x25) vm.run() self.assertTrue(vm.pc == 64) self.assertTrue(vm.reg[7] == 21)
def test_not(self): vm.flags = 0b000 vm.reg[4] = 0b0111111111001110 vm.mem[0] = 0b1001010100111111 # NOT R2, R4 vm.run() self.assertTrue(vm.reg[2] == 0b1000000000110001) self.assertTrue(vm.flags == 0b100) # Negative
def test_ld(self): vm.flags = 0b000 vm.mem[4] = -400 & 0xFFFF vm.mem[0] = 0b0100100000100111 # JSR #39 vm.mem[40] = 0b0010011111011011 # LD R3, -37 vm.run() self.assertTrue(vm.reg[3] == (-400 & 0xFFFF)) self.assertTrue(vm.flags == 0b100) # Negative
def test_add_setcc(self): vm.reg[0] = 44 vm.reg[1] = 56 vm.mem[0] = 0b0001101000000001 # ADD R5, R0, R1 vm.run() f = BitField(vm.flags, 3) self.assertTrue(f[0] == 1) # Positive self.assertTrue(f[1] == 0) # Zero self.assertTrue(f[2] == 0) # Negative
def test_add_immediate(self):
vm.reg[0] = 44
vm.mem[0] = 0b0001100000101111 # ADD R4, R0, #15
vm.reg[1] = -23 & 0xFFFF
vm.mem[1] = 0b0001101001110000 # ADD R5, R1, #-16
vm.run()
self.assertTrue(vm.reg[4] == (44 + 15))
self.assertTrue(vm.reg[5] == ((-23 - 16) & 0xFFFF))
def test_lea(self): vm.flags = 0b000 vm.mem[0] = 0b1110010011100110 # LEA R2, #230 vm.mem[4] = 0b1110001100000001 # LEA R1, #-255 vm.run() self.assertTrue(vm.reg[2] == 231) self.assertTrue(vm.reg[1] == ((5 - 255) & 0xFFFF)) self.assertTrue(vm.flags == 0b100) # Negative
def test_and_immediate(self): vm.reg[0] = 0b1010111001101010 vm.mem[0] = 0b0101010000100111 # AND R2, R0, #7 vm.reg[1] = 0b1010111001101010 vm.mem[1] = 0b0101011001110010 # AND R3, R1, #-14 vm.run() self.assertTrue(vm.reg[2] == 0b0000000000000010) self.assertTrue(vm.reg[3] == 0b1010111001100010)
def test_sti(self): vm.mem[5] = 40 vm.reg[7] = 80 vm.mem[0] = 0b0000111000010011 # BRnzp #19 vm.mem[20] = 0b1011111111110000 # STI R7, #-16 vm.mem[21] = 0b1111000000100101 # HALT (TRAP 0x25) vm.run() self.assertTrue(vm.mem[40] == 80)
def test_ldr(self): vm.flags = 0b000 vm.mem[80] = 0 vm.reg[5] = 65 vm.mem[0] = 0b0110001101001111 # LDR R1, R5, #15 vm.mem[2] = 0b1111000000100101 # HALT (TRAP 0x25) vm.run() self.assertTrue(vm.reg[1] == 0) self.assertTrue(vm.flags == 0b010) # Zero
def test_ldi(self): vm.flags = 0b000 vm.mem[70] = 80 vm.mem[80] = -20 & 0xFFFF vm.mem[0] = 0b1010100001000101 # LDI R4, 69 vm.mem[20] = 0b1111000000100101 # HALT (TRAP 0x25) vm.run() self.assertTrue(vm.reg[4] == (-20 & 0xFFFF)) self.assertTrue(vm.flags == 0b100) # Negative
def test_add_negative(self): vm.reg[2] = -23 & 0xFFFF vm.reg[4] = 10 vm.reg[7] = 10 vm.mem[0] = 0b0001111010000100 # ADD R7, R2, R4 vm.reg[0] = -99 & 0xFFFF vm.reg[3] = -2 & 0xFFFF vm.mem[1] = 0b0001101000000011 # ADD R5, R0, R3 vm.run() self.assertTrue(vm.reg[7] == ((-23+10) & 0xFFFF)) self.assertTrue(vm.reg[5] == ((-99-2) & 0xFFFF))
def test_trap_0x21_out(self):
capture = StringIO()
save_stdout = sys.stdout
sys.stdout = capture
vm.reg[0] = ord('J')
vm.mem[0] = 0b1111000000100001 # TRAP 0x21 (OUT)
vm.mem[1] = 0b0001000000100001 # ADD R0, R0, #1
vm.mem[2] = 0b1111000000100001 # TRAP 0x21 (OUT)
vm.run()
sys.stdout = save_stdout
self.assertTrue(capture.getvalue() == "JK")
def createVm(self, vmParams, vmRecover=False):
with self.vmContainerLock:
self.log.info("vmContainerLock acquired by vm %s",
vmParams['vmId'])
try:
if not vmRecover:
if vmParams['vmId'] in self.vmContainer:
self.log.warning('vm %s already exists' %
vmParams['vmId'])
return errCode['exist']
vm = Vm(self, vmParams, vmRecover)
self.vmContainer[vmParams['vmId']] = vm
finally:
container_len = len(self.vmContainer)
vm.run()
self.log.debug("Total desktops after creation of %s is %d" %
(vmParams['vmId'], container_len))
return {'status': doneCode, 'vmList': vm.status()}
def createVm(self, vmParams):
with self.vmContainerLock:
self.log.info("vmContainerLock acquired by vm %s",
vmParams['vmId'])
try:
if 'recover' not in vmParams:
if vmParams['vmId'] in self.vmContainer:
self.log.warning('vm %s already exists' %
vmParams['vmId'])
return errCode['exist']
vm = Vm(self, vmParams)
self.vmContainer[vmParams['vmId']] = vm
finally:
container_len = len(self.vmContainer)
vm.run()
self.log.debug("Total desktops after creation of %s is %d" %
(vmParams['vmId'], container_len))
return {'status': doneCode, 'vmList': vm.status()}
def test_trap_0x24_putsp(self):
capture = StringIO()
save_stdout = sys.stdout
sys.stdout = capture
vm.mem[10] = ord('A') + (ord('p') << 8)
vm.mem[11] = ord('p') + (ord('l') << 8)
vm.mem[12] = ord('e')
vm.mem[13] = 0x0
vm.mem[14] = ord('A') + (ord('p') << 8)
vm.mem[15] = ord('p') + (ord('l') << 8)
vm.mem[16] = ord('e') + (ord('s') << 8)
vm.mem[17] = 0x0
vm.mem[0] = 0b1110000000001001 # LEA R0, #9
vm.mem[1] = 0b1111000000100100 # TRAP 0x24 (PUTSP)
vm.mem[2] = 0b1110000000001011 # LEA R0, #11
vm.mem[3] = 0b1111000000100100 # TRAP 0x23 (PUTSP)
vm.mem[4] = 0b1111000000100101 # HALT (TRAP 0x25)
vm.run()
sys.stdout = save_stdout
self.assertTrue(capture.getvalue()[:12] == "Apple\0Apples")
# Print x
GLOAD,
1,
PRINT,
PUSH,
32,
OUTCHAR,
# Increment x
GLOAD,
1,
PUSH,
1,
ADD,
GSTORE,
1,
# Jump to start of loop
JMP,
8,
HALT,
]
if __name__ == '__main__':
run(POWER_OF_TWO)
print()
run(HELLO_WORLD)
print()
run(LOOP)
(vm.IMM, 3, i.a.type.offset),
(vm.ADD, 3, i.a.type.basereg),
(vm.LOAD, 4, 3),
(vm.PRNT, 4, 0)
]
return code
if __name__ == '__main__':
code = generate(
*il_gen.generate(
Parser().parse('''
_add = func(a, b) {
reflect = func(x) {
print x
y = x + 5
return y - 5
}
return reflect(a) + reflect(b)
}
add = func(f, a, b) {
return f(a, b)
}
print add(_add, 18, 37)
''', lexer=Lexer())
)
)
#print code
vm.run(code)
def test_initial_change_should_be_zero():
assert "잔액은 0원입니다" == run("잔액")
def run(s):
out = cStringIO.StringIO()
vm.run(vm_gen.generate(*il_gen.generate(Parser().parse(s, lexer=Lexer()))), out)
r = out.getvalue()
del out
return r
tmp = a[i]
a[i] = a[j]
a[j] = tmp
i = i + 1
j = j - 1
end
end
if i < r then qsort(a, i, r) end
if l < j then qsort(a, l, j) end
return a
end
print("Hello, Lua!")
print(fibonacci(16)) -- test function call
items({a=1, b=2, c=3}) -- test table
c1 = newCounter()
c2 = newCounter()
print(c1(), c1(), c2(), c1(), c2()) -- test closure
print(max(1, 100, max(1000, 10)))
local a = {1,4,7,2,5,8,3,6,9} -- test qsort
qsort(a, 1, #a)
print(a)
'''
run(code)
def test_unknown_command():
init()
assert "알 수 없는 명령입니다" == run("웅앵")
def test_accumulation_of_change():
init()
run("동전 100")
run("동전 100")
assert "잔액은 200원입니다" == run("잔액")
import argparse
from parser import parse
from prettyprinter import prettyprint
from translater import translate
from vm import HammyVM, init, run
parser = argparse.ArgumentParser(description='Hammy interpreter')
parser.add_argument('-p', '--prettyprint', action='store_true')
parser.add_argument('-d', '--decompile', action='store_true')
parser.add_argument('-t', '--trace', action='store_true')
parser.add_argument('file', nargs='?')
args = parser.parse_args()
if args.file:
src = open(args.file).read()
else:
src = sys.stdin.read()
vm = HammyVM()
init(vm)
ast = parse(src)
if ast is not None:
if args.prettyprint:
print 'Parsed code:'
print(prettyprint(ast))
print
if args.decompile:
print 'Bytecode:'
func = translate(ast, args.decompile)
run(vm, func, args.trace)
def test_insert_coin_and_check():
init()
assert "100원을 넣었습니다" == run("동전 100")
assert "잔액은 100원입니다" == run("잔액")