Chapter 6 - Assembler

roboryman · roboryman · commit 9bab4976ddc2 · 2019-03-18T00:33:37.000-04:00
Python3 for Hack Assembler and Hack Assembler(No Symbols).
Python3 for Assembler Modules Code, Command, Parser, and SymbolTable.
diff --git a/06/assembler.py b/06/assembler.py
@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+
+
+"""Hack ASM Assembler
+Assembles the supplied Hack ASM file into its
+Hack Machine Language equivalent. If input file
+is '{some_file}.asm', output file will be in the
+same directory as '{some_file}.hack'.
+"""
+
+
+import sys
+from pathlib import Path
+from assembler_modules import code
+from assembler_modules.parser import Parser
+from assembler_modules.command import Command
+from assembler_modules.symbol_table import SymbolTable
+
+
+__author__ = "Merrick Ryman"
+__version__ = "1.0"
+
+
+def main():
+    asm_path = Path(sys.argv[-1])
+    if not (asm_path.is_file() and (asm_path.suffix == '.asm')):
+        raise IOError('Valid ASM file not supplied.')
+    hack_path = str(asm_path.parent) + '/' + (asm_path.name[:asm_path.name.find('.')] + '.hack')
+    asm_parser = Parser(asm_path)
+    asm_symbols = SymbolTable()
+
+    #Initialize Symbol Table
+    for i in range(0,16):
+        asm_symbols.add_entry('R'+str(i), i)
+    asm_symbols.add_entry('SP', 0)
+    asm_symbols.add_entry('LCL', 1)
+    asm_symbols.add_entry('ARG', 2)
+    asm_symbols.add_entry('THIS', 3)
+    asm_symbols.add_entry('THAT', 4)
+    asm_symbols.add_entry('SCREEN', 16384)
+    asm_symbols.add_entry('KBD', 24576)
+
+    #First Pass - Build label symbol maps
+    ROM_address = 0
+    while asm_parser.has_more_commands():
+        if asm_parser.command_type() is Command.A_COMMAND:
+            ROM_address += 1
+        elif asm_parser.command_type() is Command.C_COMMAND:
+            ROM_address += 1
+        elif asm_parser.command_type() is Command.L_COMMAND:
+            asm_symbols.add_entry(asm_parser.symbol(), ROM_address)
+        else:
+            raise ValueError('This command type does not exist.')
+
+    #Second Pass - Build variable symbol maps and assemble.
+    asm_parser.reset_iter()
+    RAM_address = 16
+    with open(hack_path, 'w+') as hack_file:
+        while asm_parser.has_more_commands():
+            if asm_parser.command_type() is Command.A_COMMAND:
+                symbol = asm_parser.symbol()
+                try:
+                    symbol = int(symbol)
+                except ValueError:
+                    if asm_symbols.contains(symbol):
+                        symbol = asm_symbols.get_address(symbol)
+                    else:
+                        asm_symbols.add_entry(symbol, RAM_address)
+                        symbol = RAM_address
+                        RAM_address += 1
+                hack_file.write(f'{symbol:016b}' + '\n')
+            elif asm_parser.command_type() is Command.C_COMMAND:
+                comp = ''.join(str(bit) for bit in code.comp(asm_parser.comp()))
+                dest = ''.join(str(bit) for bit in code.dest(asm_parser.dest()))
+                jump = ''.join(str(bit) for bit in code.jump(asm_parser.jump()))
+                hack_file.write('111' + comp + dest + jump + '\n')
+            elif asm_parser.command_type() is Command.L_COMMAND:
+                continue
+            else:
+                hack_file.close()
+                raise ValueError('This command type does not exist.')
+
+
+if __name__ == "__main__":
+    main()
diff --git a/06/assembler_modules/__init__.py b/06/assembler_modules/__init__.py
diff --git a/06/assembler_modules/code.py b/06/assembler_modules/code.py
@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+
+
+"""The Code Module
+Translates Hack ASM mnemonics into Hack Machine Language.
+"""
+
+
+__author__ = "Merrick Ryman"
+__version__ = "1.0"
+
+
+def dest(mnemonic):
+    """Returns the Hack Machine Language equivalent of a
+    dest mnemonic (3 bits).
+    """
+    return {    #A D M
+        'null': [0,0,0],
+           'M': [0,0,1],
+           'D': [0,1,0],
+          'MD': [0,1,1],
+           'A': [1,0,0],
+          'AM': [1,0,1],
+          'AD': [1,1,0],
+         'AMD': [1,1,1]
+    }[mnemonic]
+
+
+def comp(mnemonic):
+    """Returns the Hack Machine Language equivalent of a
+    comp mnemonic (7 bits).
+    """
+    return { #a c1 c2 c3 c4 c5 c6
+        '0': [0,1,0,1,0,1,0],
+        '1': [0,1,1,1,1,1,1],
+       '-1': [0,1,1,1,0,1,0],
+        'D': [0,0,0,1,1,0,0],
+        'A': [0,1,1,0,0,0,0],   'M': [1,1,1,0,0,0,0],
+       '!D': [0,0,0,1,1,0,1],
+       '!A': [0,1,1,0,0,0,1],  '!M': [1,1,1,0,0,0,1],
+       '-D': [0,0,0,1,1,1,1],
+       '-A': [0,1,1,0,0,1,1],  '-M': [1,1,1,0,0,1,1],
+      'D+1': [0,0,1,1,1,1,1],
+      'A+1': [0,1,1,0,1,1,1], 'M+1': [1,1,1,0,1,1,1],
+      'D-1': [0,0,0,1,1,1,0],
+      'A-1': [0,1,1,0,0,1,0], 'M-1': [1,1,1,0,0,1,0],
+      'D+A': [0,0,0,0,0,1,0], 'D+M': [1,0,0,0,0,1,0],
+      'D-A': [0,0,1,0,0,1,1], 'D-M': [1,0,1,0,0,1,1],
+      'A-D': [0,0,0,0,1,1,1], 'M-D': [1,0,0,0,1,1,1],
+      'D&A': [0,0,0,0,0,0,0], 'D&M': [1,0,0,0,0,0,0],
+      'D|A': [0,0,1,0,1,0,1], 'D|M': [1,0,1,0,1,0,1]
+    }[mnemonic]
+
+
+def jump(mnemonic):
+    """Returns the Hack Machine Language equivalent of a
+    jump mnemonic (3 bits).
+    """
+    return {    #A D M
+        'null': [0,0,0],
+         'JGT': [0,0,1],
+         'JEQ': [0,1,0],
+         'JGE': [0,1,1],
+         'JLT': [1,0,0],
+         'JNE': [1,0,1],
+         'JLE': [1,1,0],
+         'JMP': [1,1,1]
+    }[mnemonic]
diff --git a/06/assembler_modules/command.py b/06/assembler_modules/command.py
@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+
+
+"""Command Enum
+Provides an enum for the command types associated with
+the source Hack ASM (A_COMMAND, C_COMMAND, L_COMMAND)
+"""
+
+
+import enum
+
+
+__author__ = "Merrick Ryman"
+__version__ = "1.0"
+
+
+class Command(enum.Enum):
+    A_COMMAND = 1
+    C_COMMAND = 2
+    L_COMMAND = 3
diff --git a/06/assembler_modules/parser.py b/06/assembler_modules/parser.py
@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+
+
+"""The Parser Module
+Encapsulates access to the input code (ASM file). Reads
+a Hack ASM command, parses it, and provides convenient access
+to the command's components (fields and symbols). In addition,
+removes all whitespace, comments, and empty lines.
+"""
+
+
+import re
+from .command import Command
+
+
+__author__ = "Merrick Ryman"
+__version__ = "1.0"
+
+
+class Parser:
+    def __init__(self, asm_path):
+        self.asm_path = asm_path
+
+        self._asm_commands = None
+        self._asm_command_current = None
+        self._asm_commands_iter = None
+        self._parse_asm_file()
+        self.reset_iter()
+
+
+    def _parse_asm_file(self):
+        """Parse the Hack ASM file into memory so it
+        is easier to work with. Remove comments, spaces,
+        empty lines, etc, so all that remains are commands
+        (and pseudo-commands). Also, create an iterable
+        to get the next command.
+        """
+        with open(self.asm_path, 'r') as asm_file:
+            lines = asm_file.readlines() # Get the list of lines (strings) from the asm file
+            lines = list(map(lambda x: x[:x.find('//')].replace(' ', ''), lines)) # Remove comments and whitespace
+            self._asm_commands = list(filter(None, lines)) # Remove empty lines, extract to instance
+
+
+    def reset_iter(self):
+        """Resets (or sets) the iterator object that
+        iterates over the asm commands. Useful for
+        re-parsing the file as necessary.
+        """
+        self._asm_commands_iter = iter(self._asm_commands)
+
+
+    def has_more_commands(self):
+        """Are there any more commands in the file?
+        Returns True if command iterable successfully
+        gets the next command. Otherwise, return False.
+        """
+        try:
+            self._asm_command_current = next(self._asm_commands_iter)
+            return True
+        except StopIteration:
+            return False
+
+
+    def command_type(self):
+        """Returns the type of the current ASM command.
+        If command starts with '@', this is an A-Instruction
+        command. If command starts with '(', this is an
+        L-Instruction command. Otherwise, this is a
+        C-Instruction command.
+        """
+        return {
+            '@': Command.A_COMMAND,
+            '(': Command.L_COMMAND
+        }.get(self._asm_command_current[0], Command.C_COMMAND)
+
+
+    def symbol(self):
+        """Returns the symbol or decimal constant xyz
+        of the current command @xyz or (xyz). Should
+        only be called when the command type is
+        A_COMMAND or L_COMMAND.
+        """
+        return re.sub('[@()]', '', self._asm_command_current)
+
+
+    def is_dest_c_instruction(self):
+        """ Returns True if the dest mnemonic is
+        present in the current C_COMMAND. Otherwise,
+        return False because this is a jump. Should
+        only be called when the command type is
+        C_COMMAND.
+        """
+        if self._asm_command_current.find('=') < 0: # '=' not found
+            return False
+        return True
+
+
+    def dest(self):
+        """Returns the dest mnemonic in the current
+        C_COMMAND (8 possibilities). Should only be
+        called when the command type is C_COMMAND.
+        """
+        if self.is_dest_c_instruction():
+            return self._asm_command_current[:self._asm_command_current.find('=')]
+        return 'null'
+
+
+    def comp(self):
+        """Returns the comp mnemonic in the current
+        C_COMMAND (28 possibilities). Should only be
+        called when the command type is C_COMMAND.
+        """
+        if self.is_dest_c_instruction():
+            return self._asm_command_current[self._asm_command_current.find('=')+1:]
+        return self._asm_command_current[:self._asm_command_current.find(';')]
+
+
+    def jump(self):
+        """Returns the jump mnemonic in the current
+        C_COMMAND (8 possibilities). Should only be
+        called when the command type is C_COMMAND.
+        """
+        if self.is_dest_c_instruction():
+            return 'null'
+        return self._asm_command_current[self._asm_command_current.find(';')+1:]
diff --git a/06/assembler_modules/symbol_table.py b/06/assembler_modules/symbol_table.py
@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+
+
+"""The SymbolTable Module
+Keeps a correspondence between symbolic labels and numeric
+addresses. This is done easily in Python using dictionaries.
+Addresses are kept as decimal integers inside the table map.
+"""
+
+
+__author__ = "Merrick Ryman"
+__version__ = "1.0"
+
+
+class SymbolTable:
+    def __init__(self):
+        self._table = {}
+
+
+    def add_entry(self, symbol, address):
+        """Adds the mapping {symbol: address} to the table.
+        """
+        self._table.update({symbol:address})
+
+
+    def contains(self, symbol):
+        """Returns True if the table map contains the given
+        symbol.
+        """
+        return symbol in self._table
+
+
+    def get_address(self, symbol):
+        """Returns the address mapped to the symbol from the table.
+        """
+        return self._table.get(symbol)
diff --git a/06/assembler_ns.py b/06/assembler_ns.py
@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+
+
+"""Hack ASM Assembler (No Symbols)
+Assembles the supplied Hack ASM file into its
+Hack Machine Language equivalent. If input file
+is '{some_file}.asm', output file will be in the
+same directory as '{some_file}.hack'. Keep in
+mind that this particular assembler does not have
+support for symbols, i.e. a mapping of text to
+decimal addresses. Please use the other supplied
+assembler for this feature ('assembler.py').
+"""
+
+
+import sys
+from pathlib import Path
+from assembler_modules import code
+from assembler_modules.parser import Parser
+from assembler_modules.command import Command
+
+
+__author__ = "Merrick Ryman"
+__version__ = "1.0"
+
+
+def main():
+    asm_path = Path(sys.argv[-1])
+    if not (asm_path.is_file() and (asm_path.suffix == '.asm')):
+        raise IOError('Valid ASM file not supplied.')
+    asm_parser = Parser(asm_path)
+
+    hack_path = str(asm_path.parent) + '/' + (asm_path.name[:asm_path.name.find('.')] + '.hack')
+    with open(hack_path, 'w+') as hack_file:
+        while asm_parser.has_more_commands():
+            if asm_parser.command_type() is Command.A_COMMAND:
+                hack_file.write(f'{int(asm_parser.symbol()):016b}' + '\n')
+            elif asm_parser.command_type() is Command.C_COMMAND:
+                comp = ''.join(str(bit) for bit in code.comp(asm_parser.comp()))
+                dest = ''.join(str(bit) for bit in code.dest(asm_parser.dest()))
+                jump = ''.join(str(bit) for bit in code.jump(asm_parser.jump()))
+                hack_file.write('111' + comp + dest + jump + '\n')
+            elif asm_parser.command_type() is Command.L_COMMAND:
+                hack_file.close()
+                print('Encountered an L_COMMAND. This version of the assembler does not support symbols!')
+                raise NotImplementedError
+            else:
+                hack_file.close()
+                raise ValueError('This command type does not exist.')
+
+
+if __name__ == "__main__":
+    main()
diff --git a/README.md b/README.md
