def test1(self):
textCode = "\n".join([
"x = 0", "i = 0", "while i < 10:", " i = i + 1",
" x = x + i", "print(x)"
])
code = CP.parse(code=textCode)
engine = Processor16Bits()
cm = CM(engine, code)
actionsList = cm.compile()
asm = engine.getAsm(actionsList, False)
good = "\n".join([
" MOVE r7, #0",
" STORE @x, r7",
" MOVE r7, #0",
" STORE @i, r7",
"Lab2 LOAD r7, @i",
" MOVE r6, #10",
" CMP r7, r6",
" BLT Lab1",
" JMP Lab3",
"Lab1 LOAD r7, @i",
" ADD r7, r7, #1",
" STORE @i, r7",
" LOAD r7, @x",
" LOAD r6, @i",
" ADD r7, r7, r6",
" STORE @x, r7",
" JMP Lab2",
"Lab3 LOAD r7, @x",
" PRINT r7",
" HALT",
])
self.assertEqual(asm, good)
def test3(self):
engine = Processor16Bits()
fifo = ActionsFIFO()
fifo.append(Register(1, False), Litteral(45), Register(5, False),
Operators.ADD)
binaryCode = "\n".join(engine.getBinary([fifo]))
self.assertEqual(binaryCode, "1000101001101101")
def test1(self):
varX = Variable('x')
varY = Variable('y')
affectationX = TransfertNode(
4, varX, EP.buildExpression('-3*x+1')) # mypy: ignore
affectationY = TransfertNode(5, varY,
EP.buildExpression('y+x')) # mypy: ignore
structuredList = [
TransfertNode(1, varX, EP.buildExpression('0')),
TransfertNode(2, varY, EP.buildExpression('0')),
WhileNode(3, EP.buildExpression('x < 10 or y < 100'),
[affectationX, affectationY]),
TransfertNode(6, None, EP.buildExpression('y'))
]
engine = Processor16Bits()
cm = CM(engine, structuredList)
actionsList = cm.compile()
strGlobal = "\n".join([str(item) for item in actionsList])
good = "\n".join([
" #0 r7 move", " r7 @x store", " #0 r7 move", " r7 @y store",
"Lab2 @x r7 load", " #10 r6 move", " r7 r6 <", " Lab1 goto",
" @y r7 load", " #100 r6 move", " r7 r6 <", " Lab1 goto",
" Lab3 goto", "Lab1 @x r7 load", " r7 #3 r7 *", " r7 r7 -",
" r7 #1 r7 +", " r7 @x store", " @y r7 load", " @x r6 load",
" r7 r6 r7 +", " r7 @y store", " Lab2 goto", "Lab3 @y r7 load",
" r7 print", " halt"
])
self.assertEqual(strGlobal, good)
def test2(self):
r0 = Register(0, False)
r1 = Register(1, False)
op = Operators.ADD
engine = Processor16Bits()
actions = ActionsFIFO()
actions.append(r1, r0, r0, op)
asm = engine.getAsm(actions)
self.assertEqual(asm, " ADD r0, r1, r0")
def test3(self):
r0 = Register(0, False)
r1 = Register(1, False)
l4 = Litteral(4)
op = Operators.ADD
engine = Processor16Bits()
actions = ActionsFIFO()
actions.append(r1, l4, r0, op, r1, r0, r0, op)
asm = engine.getAsm(actions)
good = "\n".join([" ADD r0, r1, #4", " ADD r0, r1, r0"])
self.assertEqual(asm, good)
def test1(self):
textCode = "\n".join([
"x = 0", "i = 0", "while i < 10:", " i = i + 1",
" x = x + i", "print(x)"
])
code = CP.parse(code=textCode)
engine = Processor16Bits()
cm = CM(engine, code)
actionsList = cm.compile()
addressList = engine._getAdresses(actionsList)
result = "\n".join(
sorted(["{} : {}".format(it, n) for it, n in addressList.items()]))
good = "\n".join(
["@i : 21", "@x : 20", "Lab1 : 4", "Lab2 : 9", "Lab3 : 17"])
self.assertEqual(result, good)
def test4(self):
strExpression = "3*x > 4"
engine = Processor16Bits()
regManager = RegistersManager(engine.registersNumber())
cem = CompileExpressionManager(engine, regManager)
parsed = ExpressionParser.buildExpression(strExpression)
fifo = parsed.getFIFO(engine.litteralDomain)
actions = cem.compile(fifo)
good = "\n".join([
" @x r7 load",
" r7 #3 r7 *",
" #4 r6 move",
" r7 r6 >"
])
self.assertEqual(str(actions), good)
def test3(self):
code = CP.parse(filename="example2.code")
engine = Processor16Bits()
cm = CM(engine, code)
actionsList = cm.compile()
strGlobal = "\n".join([str(item) for item in actionsList])
good = "\n".join([
" #0 r7 move", " r7 @s store", " #0 r7 move", " r7 @i store",
" @m input", "Lab2 @i r7 load", " @m r6 load", " r7 r6 <",
" Lab1 goto", " Lab3 goto", "Lab1 @i r7 load", " r7 #2 r7 %",
" #0 r6 move", " r7 r6 ==", " Lab4 goto", " Lab5 goto",
"Lab4 @s r7 load", " @i r6 load", " r7 r6 r7 +", " r7 @s store",
" @s r7 load", " #10 r6 move", " r7 r6 <", " Lab6 goto",
" Lab5 goto", "Lab6 @s r7 load", " r7 #2 r7 *", " r7 @y store",
" @y r7 load", " r7 print", "Lab5 @i r7 load", " r7 #3 r7 +",
" r7 @i store", " Lab2 goto", "Lab3 @s r7 load", " r7 print",
" halt"
])
self.assertEqual(strGlobal, good)
def test1(self):
textCode = "\n".join([
"x = 0", "i = 0", "while i < 10:", " i = i + 1",
" x = x + i", "print(x)"
])
code = CP.parse(code=textCode)
engine = Processor16Bits()
cm = CM(engine, code)
fifos = cm.compile()
binaryCode = "\n".join(engine.getBinary(fifos))
good = "\n".join([
"0100111100000000", "0111000010100111", "0100111100000000",
"0111000010101111", "0011111000010101", "0100111000001010",
"0001100000111110", "0001010000001001", "0000100000010001",
"0011111000010101", "1000111111000001", "0111000010101111",
"0011111000010100", "0011110000010101", "0110000111111110",
"0111000010100111", "0000100000000100", "0011111000010100",
"0010000000000111", "0000000000000000", "0000000000000000",
"0000000000000000"
])
self.assertEqual(binaryCode, good)
def test2(self):
strExpression = "5*(2*x+4)-x*y"
engine = Processor16Bits()
regManager = RegistersManager(engine.registersNumber())
cem = CompileExpressionManager(engine, regManager)
parsed = ExpressionParser.buildExpression(strExpression)
fifo = parsed.getFIFO(engine.litteralDomain)
actions = cem.compile(fifo)
good = "\n".join([
" @x r7 load",
" @y r6 load",
" r7 r6 r7 *",
" @x r6 load",
" r6 #2 r6 *",
" r6 #4 r6 +",
" r6 #5 r6 *",
" r6 r7 r7 -"
])
self.assertEqual(str(actions), good)