def main():
'''
Entry point of script
'''
parser = argparse.ArgumentParser()
parser.add_argument('file', nargs='+', help='ALD source code file')
parser.add_argument('-v',
'--verbose',
action='count',
default=0,
help='Verbosity')
args = parser.parse_args()
_set_logging(args.verbose)
try:
assembler = Assembler(
instruction_set=INSTRUCTION_SET,
registers={
'byte': BYTE_REGISTERS,
'word': WORD_REGISTERS,
},
)
for source_file in args.file:
assembler.assemble_file(source_file)
except AldebaranError as ex:
logger.error(ex)
def compile(name, quiet=False):
if quiet:
p = subprocess.Popen([MIN_CAML, "-inline", "100", name],
stdout = subprocess.PIPE,
stderr = subprocess.PIPE,
shell = False)
ret_code = p.wait()
else:
ret_code = subprocess.call([MIN_CAML, "-inline", "100", name])
if ret_code == 0:
os.system("cat {}/min-caml/libmincaml.S >> {}.s".format(ROOT, name))
os.system("cat {}/min-caml/read.S >> {}.s".format(ROOT, name))
asmblr = Assembler()
asmblr.assemble(name + ".s")
else:
assert False, "compile error"
def setUp(self):
self.instruction_set = [
(0x12, instruction_set.arithmetic.ADD),
(0x34, instruction_set.data_transfer.MOV),
(0x56, instruction_set.jump.JMP),
(0x78, instruction_set.misc.NOP),
(0x9A, instruction_set.misc.SHUTDOWN),
(0xBC, instruction_set.control_flow.ENTER),
]
self.assembler = Assembler(
instruction_set=self.instruction_set,
registers={
'byte': BYTE_REGISTERS,
'word': WORD_REGISTERS,
},
)
logging.getLogger('assembler').setLevel(logging.CRITICAL)
def __init__(self):
self.memory = Memory()
self.assembler = Assembler(knew_instructions, knew_registers)
self.linker = Linker()
self.loader = Loader()
self.Z80 = Operations()
self.stack = []
self.assembler.readFile()
machine_code = self.assembler.assemble()
mc_memory = self.linker.resolve(machine_code)
self.loader.load(mc_memory, self.memory.get_memory())
self.memory.show()
self.p_size = len(machine_code) * 3
self.registers = {}
for reg in knew_registers.values():
self.registers[reg] = 0
self.ports = {}
for i in range(1, 6):
self.ports[i] = 0
class TestAssembler(unittest.TestCase):
def setUp(self):
self.instruction_set = [
(0x12, instruction_set.arithmetic.ADD),
(0x34, instruction_set.data_transfer.MOV),
(0x56, instruction_set.jump.JMP),
(0x78, instruction_set.misc.NOP),
(0x9A, instruction_set.misc.SHUTDOWN),
(0xBC, instruction_set.control_flow.ENTER),
]
self.assembler = Assembler(
instruction_set=self.instruction_set,
registers={
'byte': BYTE_REGISTERS,
'word': WORD_REGISTERS,
},
)
logging.getLogger('assembler').setLevel(logging.CRITICAL)
def test_instructions(self):
opcode = self.assembler.assemble_code('''
NOP
NOP
SHUTDOWN
''')
expected_opcode = [
0x78,
0x78,
0x9A,
]
self.assertListEqual(opcode, expected_opcode)
def test_operands(self):
opcode = self.assembler.assemble_code('''
MOV AX 0x1234
NOP
SHUTDOWN
''')
expected_opcode = [0x34]
expected_opcode += get_operand_opcode(
Token(TokenType.WORD_REGISTER, 'AX', None))
expected_opcode += get_operand_opcode(
Token(TokenType.WORD_LITERAL, 0x1234, None))
expected_opcode += [0x78]
expected_opcode += [0x9A]
self.assertListEqual(opcode, expected_opcode)
def test_label_ok(self):
opcode = self.assembler.assemble_code('''
loop:
NOP
JMP loop
SHUTDOWN
''')
expected_opcode = [0x78]
expected_opcode += [0x56]
expected_opcode += get_operand_opcode(
Token(TokenType.ADDRESS_WORD_LITERAL, -1, None))
expected_opcode += [0x9A]
self.assertListEqual(opcode, expected_opcode)
def test_label_error(self):
with self.assertRaises(AssemblerError):
self.assembler.assemble_code('''
loop:
NOP
JMP other_loop
SHUTDOWN
''')
def test_macro_dat_and_datn(self):
opcode = self.assembler.assemble_code('''
MOV AX [stuff]
NOP
SHUTDOWN
stuff: .DAT 0x1234 0x56 'ABC'
.DATN 0x05 0xFF
.DATN 0x03 0x1234
.DATN 0x02 'ABC'
''')
expected_opcode = [0x34]
expected_opcode += get_operand_opcode(
Token(TokenType.WORD_REGISTER, 'AX', None))
expected_opcode += get_operand_opcode(
Token(
TokenType.REL_REF_WORD,
Reference(7, None, 'W'),
None,
))
expected_opcode += [0x78]
expected_opcode += [0x9A]
expected_opcode += [0x12, 0x34, 0x56, 0x41, 0x42, 0x43]
expected_opcode += [0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
expected_opcode += [0x12, 0x34, 0x12, 0x34, 0x12, 0x34]
expected_opcode += [0x41, 0x42, 0x43, 0x41, 0x42, 0x43]
self.assertListEqual(opcode, expected_opcode)
def test_macro_dat_and_datn_error(self):
with self.assertRaises(MacroError):
self.assembler.assemble_code('''
.DAT
''')
with self.assertRaises(MacroError):
self.assembler.assemble_code('''
.DAT a
''')
with self.assertRaises(MacroError):
self.assembler.assemble_code('''
.DATN
''')
with self.assertRaises(MacroError):
self.assembler.assemble_code('''
.DATN 0x00
''')
with self.assertRaises(MacroError):
self.assembler.assemble_code('''
.DATN 0x00 0x00 0x00
''')
with self.assertRaises(MacroError):
self.assembler.assemble_code('''
.DATN a 0x00
''')
with self.assertRaises(MacroError):
self.assembler.assemble_code('''
.DATN 'a' 0x00
''')
with self.assertRaises(MacroError):
self.assembler.assemble_code('''
.DATN 0x00 a
''')
def test_macro_const(self):
opcode = self.assembler.assemble_code('''
.CONST $stuff 0x1234
.CONST $other_stuff $stuff
MOV AX $other_stuff
NOP
SHUTDOWN
''')
expected_opcode = [0x34]
expected_opcode += get_operand_opcode(
Token(TokenType.WORD_REGISTER, 'AX', None))
expected_opcode += get_operand_opcode(
Token(TokenType.WORD_LITERAL, 0x1234, None))
expected_opcode += [0x78]
expected_opcode += [0x9A]
self.assertListEqual(opcode, expected_opcode)
def test_macro_const_error(self):
with self.assertRaises(MacroError):
self.assembler.assemble_code('''
.CONST
''')
with self.assertRaises(MacroError):
self.assembler.assemble_code('''
.CONST $x
''')
with self.assertRaises(MacroError):
self.assembler.assemble_code('''
.CONST a 0x00
''')
with self.assertRaises(MacroError):
self.assembler.assemble_code('''
.CONST $x a
''')
with self.assertRaises(VariableError):
self.assembler.assemble_code('''
.CONST $x $y
''')
with self.assertRaises(VariableError):
self.assembler.assemble_code('''
.CONST $x 0x00
.CONST $x 0x01
''')
def test_macro_param_and_var(self):
opcode = self.assembler.assemble_code('''
ENTER 0x02 0x04
.CONST $default_value 0x1234
.PARAM $p
.VAR $v1
.VAR $v2 $default_value
MOV AX $p
MOV AX $v1
MOV AX $v2
NOP
SHUTDOWN
''')
expected_opcode = [0xBC]
expected_opcode += get_operand_opcode(
Token(TokenType.BYTE_LITERAL, 0x02, None))
expected_opcode += get_operand_opcode(
Token(TokenType.BYTE_LITERAL, 0x04, None))
expected_opcode += [0x34]
expected_opcode += get_operand_opcode(
Token(
TokenType.ABS_REF_REG,
Reference('BP', -3, 'W'),
None,
))
expected_opcode += get_operand_opcode(
Token(TokenType.WORD_LITERAL, 0x1234, None))
expected_opcode += [0x34]
expected_opcode += get_operand_opcode(
Token(TokenType.WORD_REGISTER, 'AX', None))
expected_opcode += get_operand_opcode(
Token(
TokenType.ABS_REF_REG,
Reference('BP', 7, 'W'),
None,
))
expected_opcode += [0x34]
expected_opcode += get_operand_opcode(
Token(TokenType.WORD_REGISTER, 'AX', None))
expected_opcode += get_operand_opcode(
Token(
TokenType.ABS_REF_REG,
Reference('BP', -1, 'W'),
None,
))
expected_opcode += [0x34]
expected_opcode += get_operand_opcode(
Token(TokenType.WORD_REGISTER, 'AX', None))
expected_opcode += get_operand_opcode(
Token(
TokenType.ABS_REF_REG,
Reference('BP', -3, 'W'),
None,
))
expected_opcode += [0x78]
expected_opcode += [0x9A]
self.assertListEqual(opcode, expected_opcode)
def test_macro_param_and_var_error(self):
with self.assertRaises(MacroError):
self.assembler.assemble_code('''
.PARAM $p
''')
with self.assertRaises(ScopeError):
self.assembler.assemble_code('''
ENTER 0x02 0x00
.PARAM $p1
.PARAM $p2
''')
with self.assertRaises(VariableError):
self.assembler.assemble_code('''
ENTER 0x04 0x00
.PARAM $p
.PARAM $p
''')
import sys
from utils import log
# from utils import log_debug
from assembler.assembler import Assembler
if __name__ == '__main__':
# log_debug("sys.argv - {}".format(sys.argv))
if len(sys.argv) == 2:
file_name = sys.argv[1]
assembler = Assembler(file_name)
assembler.parse_asm_program()
assembler.write_output_to_hack_file()
else:
log("usage: ")
log(" python main.py <asm_file>")
log("example: ")
log(" python main.py prog.asm")
class Computer:
def __init__(self):
self.memory = Memory()
self.assembler = Assembler(knew_instructions, knew_registers)
self.linker = Linker()
self.loader = Loader()
self.Z80 = Operations()
self.stack = []
self.assembler.readFile()
machine_code = self.assembler.assemble()
mc_memory = self.linker.resolve(machine_code)
self.loader.load(mc_memory, self.memory.get_memory())
self.memory.show()
self.p_size = len(machine_code) * 3
self.registers = {}
for reg in knew_registers.values():
self.registers[reg] = 0
self.ports = {}
for i in range(1, 6):
self.ports[i] = 0
def execute(self):
index = 0
while self.memory.get(hex(index)) is not None:
instruction = self.memory.get(hex(index))
first_arg = self.memory.get(hex(index + 1))
second_arg = self.memory.get(hex(index + 2))
if instruction == 1: # LD
self.Z80.LDR(first_arg, second_arg, self.registers)
elif instruction == 2: # IN
self.Z80.INR(first_arg, self.registers, self.ports)
elif instruction == 3: # OUT
self.Z80.OUT(first_arg, self.ports, self.registers)
elif instruction == 4: # PUSH
self.Z80.PUSH(self.stack, self.registers, first_arg)
elif instruction == 5: # POP
self.Z80.POP(self.stack, self.registers)
elif instruction == 7: # ADD
self.Z80.ADDR(first_arg, self.registers)
elif instruction == 8: # SUB
self.Z80.SUBR(first_arg, self.registers)
elif instruction == 9: # INC
self.Z80.INCR(first_arg, self.registers)
elif instruction == 10: # DEC
self.Z80.DECR(first_arg, self.registers)
elif instruction == 11: # CPL
self.Z80.CPL(first_arg, self.registers)
elif instruction == 12: # NEG
self.Z80.NEG(first_arg, self.registers)
elif instruction == 13: # AND
self.Z80.AND(first_arg, self.registers)
elif instruction == 14: # OR
self.Z80.OR(first_arg, self.registers)
elif instruction == 15: # XOR
self.Z80.XOR(first_arg, self.registers)
elif instruction == 16: # RLA
self.Z80.RLA(first_arg, self.registers)
elif instruction == 17: # RRA
self.Z80.RRA(first_arg, self.registers)
elif instruction == 20: # SET
self.Z80.SET(first_arg, self.registers, second_arg)
elif instruction == 21: # RESET
self.Z80.RESET(first_arg, self.registers, second_arg)
elif instruction == 26: # HALT
self.Z80.HALT()
elif instruction == 27: # ORG
self.Z80.ORG(first_arg, self.registers)
elif instruction == 28: # END
self.Z80.END()
index += 3
print('\nRegisters')
names = list(knew_registers.keys())
for key, value in self.registers.items():
print(f'Register {names[key - 1]}: {value}')
print('\nPorts')
for key, value in self.ports.items():
print(f'Port {key}: {value}')
from assembler.assembler import Assembler
if __name__ == '__main__':
assembler = Assembler('Prog.asm')
print(assembler._raw_commands)
print(assembler._parser._commands)
assembler.assemble()
def run(self):
self.role['state'] = 'CREATING'
ldap_role = ldap_tools.to_ldap(self.role, 'OpenLDAProle')
ret = self.inst.add_obj(ldap_role, 'roles', 'cid', throw_error=True)
assert ret == 0
virtue_path = 'images/non_provisioned_virtues/' + self.role[
'id'] + '.img'
key_path = USER_KEY_DIR + '/default-virtue-key.pem'
valor_manager = ValorManager()
try:
# Create the role standby image files
standby_roles = StandbyRoles(self.base_img_name, self.role)
standby_roles.create_role_image_file()
if (self.use_ssh):
# Launch by adding a 'virtue' to RethinkDB
valor = valor_manager.get_empty_valor()
virtue_ip = valor_manager.add_virtue(
valor['address'], valor['valor_id'], self.role['id'],
virtue_path, True) # send role_create=True)
time.sleep(5)
# Get Docker login command
# Use the AWS Account ID of the Account which has the docker registry,
# currently this is in the StarLab account.
docker_cmd = subprocess.check_output(
shlex.split(
'aws ecr get-login --registry-ids {} --no-include-email '
'--region us-east-2'.format(AWS_ECR_ACCOUNT_NUMBER)))
print('docker_cmd: ' + docker_cmd)
# Run assembler
assembler = Assembler(work_dir='{0}/.{1}_assembly'.format(
os.environ['HOME'], self.role['id']))
assembler.assemble_running_vm(self.role['applicationIds'],
docker_cmd, key_path, virtue_ip)
# Create the virtue standby image files
standby_virtues = StandbyVirtues(self.role['id'])
standby_virtues.create_standby_virtues()
self.role['state'] = 'CREATED'
ldap_role = ldap_tools.to_ldap(self.role, 'OpenLDAProle')
ret = self.inst.modify_obj('cid',
self.role['id'],
ldap_role,
objectClass='OpenLDAProle',
throw_error=True)
assert ret == 0
except:
print('Error while assembling role {0}:\n{1}'.format(
self.role['id'], traceback.format_exc()))
self.role['state'] = 'FAILED'
ldap_role = ldap_tools.to_ldap(self.role, 'OpenLDAProle')
ret = self.inst.modify_obj('cid',
self.role['id'],
ldap_role,
objectClass='OpenLDAProle',
throw_error=True)
finally:
if valor_manager.rethinkdb_manager.get_virtue(self.role['id']):
valor_manager.rethinkdb_manager.remove_virtue(self.role['id'])
parser.add_argument('-e',
'--excalibur_key',
type=str,
required=True,
help="Excalibur's public key")
parser.add_argument('--user_key',
type=str,
required=True,
help="The user's public SSH key")
parser.add_argument('-r', '--rethinkdb_cert', type=str, required=True)
parser.add_argument('-n',
'--network_rules',
type=str,
required=True,
help='file containing network rules for the virtue')
args = parser.parse_args()
return args
if (__name__ == '__main__'):
args = parse_args()
assembler = Assembler()
assembler.provision_virtue(args.username, args.virtue_id, args.base_img,
args.output_path, args.virtue_key,
args.excalibur_key, args.user_key,
args.rethinkdb_cert, args.network_rules)
'--work_dir',
type=str,
required=False,
help=
'Path to use as a temporary work directory. Does not have to exist.')
args = parser.parse_args()
return args
if (__name__ == '__main__'):
args = parse_args()
kwargs = {}
if (args.elastic_node != None):
kwargs['es_node'] = args.elastic_node
if (args.syslog_server != None):
kwargs['syslog_server'] = args.syslog_server
if (args.rethink_host != None):
kwargs['rethinkdb_host'] = args.rethink_host
if (args.work_dir != None):
kwargs['work_dir'] = args.work_dir
assembler = Assembler(**kwargs)
assembler.construct_unity(args.base_img,
args.output_path,
args.ssh_pub_key,
clean=True)