summaryrefslogtreecommitdiff
path: root/projects/06/hack-as
diff options
context:
space:
mode:
Diffstat (limited to 'projects/06/hack-as')
-rwxr-xr-xprojects/06/hack-as/hack-asbin0 -> 26000 bytes
-rw-r--r--projects/06/hack-as/hack-as.c375
-rw-r--r--projects/06/hack-as/hack-as.py269
-rw-r--r--projects/06/hack-as/test/compare.hack25
-rw-r--r--projects/06/hack-as/test/conventional.asm32
-rw-r--r--projects/06/hack-as/test/valid.asm29
6 files changed, 730 insertions, 0 deletions
diff --git a/projects/06/hack-as/hack-as b/projects/06/hack-as/hack-as
new file mode 100755
index 0000000..d6dea0f
--- /dev/null
+++ b/projects/06/hack-as/hack-as
Binary files differ
diff --git a/projects/06/hack-as/hack-as.c b/projects/06/hack-as/hack-as.c
new file mode 100644
index 0000000..6dde75d
--- /dev/null
+++ b/projects/06/hack-as/hack-as.c
@@ -0,0 +1,375 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+
+#define MAX_ASM_LINE_LEN 64
+#define MAX_INST_LEN 32768
+#define MAX_ADDR 32767
+
+#define EXIT_CODE_FILE_ERROR 1
+#define EXIT_CODE_ILLEGAL_CHAR 2
+#define EXIT_CODE_SIZE_EXCEEDED 3
+#define EXIT_CODE_SYNTAX_ERROR 4
+#define EXIT_CODE_ADDR_ERROR 5
+
+struct symbol {
+ char *label;
+ int addr;
+};
+
+char find_illegal_symbol_char(char *symbol) {
+ // symbol should not begin with number
+ // nand2tetris implementation allows it, but the standard says otherwise
+ if (*symbol >= '0' && *symbol <= '9') return *symbol;
+ for (char *c = symbol; *c != '\0'; c++) {
+ if (!((*c >= 'A' && *c <= 'Z') || (*c >= 'a' && *c <= 'z')
+ || (*c >= '0' && *c <= '9')
+ || *c == '_' || *c == '.' || *c == '$' || *c == ':')
+ ) {
+ return *c;
+ }
+ }
+ return -1;
+}
+
+void print_symbols(struct symbol *symbols, int cnt) {
+ printf("====== SYMBOLS =====\nlabel\taddr\n");
+ for (int i = 0; i < cnt; i++) {
+ printf("%s\t%d\n", symbols[i].label, symbols[i].addr);
+ }
+}
+
+void print_binary_and_asm(uint16_t *binary, char **asm_lines, int cnt) {
+ printf("\n====== RESULTS =====\naddr\tbinary \tinst\n");
+ for (int i = 0; i < cnt; i++) {
+ char binary_str[17];
+ binary_str[16] = '\0';
+ for (int b = 0; b < 16; b++) {
+ binary_str[b] = '0' + (*(binary + i) >> (15 - b)) % 2;
+ }
+ printf("%d\t%s\t%s\n", i, binary_str, asm_lines[i]);
+ }
+}
+
+void write_binary(FILE *file, uint16_t *binary, int cnt) {
+ for (int i = 0; i < cnt; i++) {
+ char binary_str[17];
+ binary_str[16] = '\0';
+ for (int b = 0; b < 16; b++) {
+ binary_str[b] = '0' + (*(binary + i) >> (15 - b)) % 2;
+ }
+ fprintf(file, "%s\n", binary_str);
+ }
+}
+
+uint16_t assemble_inst(char *asm_line) {
+ // assemble one line of assembly, terminated with \0
+ // labels and variables must be replaced with corresponding addresses beforehand
+ uint16_t inst = 0;
+ if (*asm_line == '@') {
+ // A instruction
+ char *addr_str = asm_line + 1;
+ int addr = atoi(addr_str);
+ if (addr < 0 || addr > MAX_ADDR) {
+ fprintf(stderr, "Address out of range: %d\n", addr);
+ exit(EXIT_CODE_ADDR_ERROR);
+ }
+ inst = (uint16_t) addr;
+ } else {
+ // C instruction
+ inst = 0xe000; // set 3 MSBs to 1
+ char *eq = asm_line;
+ for (char *c = asm_line; *c != '\0'; c++) {
+ // find first equal sign (eq == asm_line if not found)
+ if (*c == '=') {
+ eq = c;
+ break;
+ }
+ }
+
+ // slice out destination and copy to dest
+ int dest_len = eq - asm_line;
+ char *dest = malloc(dest_len + 1);
+ strncpy(dest, asm_line, dest_len);
+ dest[dest_len] = '\0';
+ if (dest_len == 0) {} // ignore
+ else if (strcmp(dest, "M") == 0) inst |= 0b001 << 3;
+ else if (strcmp(dest, "D") == 0) inst |= 0b010 << 3;
+ else if (strcmp(dest, "MD") == 0) inst |= 0b011 << 3;
+ else if (strcmp(dest, "A") == 0) inst |= 0b100 << 3;
+ else if (strcmp(dest, "AM") == 0) inst |= 0b101 << 3;
+ else if (strcmp(dest, "AD") == 0) inst |= 0b110 << 3;
+ else if (strcmp(dest, "AMD") == 0) inst |= 0b111 << 3;
+ else {
+ fprintf(stderr, "Invalid destination: %s\n", dest);
+ exit(EXIT_CODE_SYNTAX_ERROR);
+ }
+ free(dest);
+
+ char *semi = eq;
+ for (; *semi != '\0'; semi++) {
+ // find jump instruction after semicolon (;) (*semi == '\0' if not found)
+ if (*semi == ';') break;
+ }
+ // ignore if there's no semicolon, or there's nothing after it
+ if (*semi == '\0' || *(semi + 1) == '\0') {}
+ else if (strcmp(semi + 1, "JGT") == 0) inst |= 0b001;
+ else if (strcmp(semi + 1, "JEQ") == 0) inst |= 0b010;
+ else if (strcmp(semi + 1, "JGE") == 0) inst |= 0b011;
+ else if (strcmp(semi + 1, "JLT") == 0) inst |= 0b100;
+ else if (strcmp(semi + 1, "JNE") == 0) inst |= 0b101;
+ else if (strcmp(semi + 1, "JLE") == 0) inst |= 0b110;
+ else if (strcmp(semi + 1, "JMP") == 0) inst |= 0b111;
+ else {
+ fprintf(stderr, "Invalid jump instruction: %s\n", semi + 1);
+ exit(EXIT_CODE_SYNTAX_ERROR);
+ }
+
+ // slice out computation and copy to comp
+ int comp_len = (*eq == '=') ? (semi - eq - 1) : (semi - eq);
+ char *comp = malloc(comp_len + 1);
+ strncpy(comp, (*eq == '=') ? (eq + 1) : eq, comp_len);
+ comp[comp_len] = '\0';
+ if (strcmp(comp, "0") == 0) inst |= 0b0101010 << 6;
+ else if (strcmp(comp, "1") == 0) inst |= 0b0111111 << 6;
+ else if (strcmp(comp, "-1") == 0) inst |= 0b0111010 << 6;
+ else if (strcmp(comp, "D") == 0) inst |= 0b0001100 << 6;
+ else if (strcmp(comp, "A") == 0) inst |= 0b0110000 << 6;
+ else if (strcmp(comp, "M") == 0) inst |= 0b1110000 << 6;
+ else if (strcmp(comp, "!D") == 0) inst |= 0b0001101 << 6;
+ else if (strcmp(comp, "!A") == 0) inst |= 0b0110001 << 6;
+ else if (strcmp(comp, "!M") == 0) inst |= 0b1110001 << 6;
+ else if (strcmp(comp, "-D") == 0) inst |= 0b0001111 << 6;
+ else if (strcmp(comp, "-A") == 0) inst |= 0b0110011 << 6;
+ else if (strcmp(comp, "-M") == 0) inst |= 0b1110011 << 6;
+ else if (strcmp(comp, "D+1") == 0) inst |= 0b0011111 << 6;
+ else if (strcmp(comp, "A+1") == 0) inst |= 0b0110111 << 6;
+ else if (strcmp(comp, "M+1") == 0) inst |= 0b1110111 << 6;
+ else if (strcmp(comp, "D-1") == 0) inst |= 0b0001110 << 6;
+ else if (strcmp(comp, "A-1") == 0) inst |= 0b0110010 << 6;
+ else if (strcmp(comp, "M-1") == 0) inst |= 0b1110010 << 6;
+ else if (strcmp(comp, "D+A") == 0
+ || strcmp(comp, "A+D") == 0) inst |= 0b0000010 << 6;
+ else if (strcmp(comp, "D+M") == 0
+ || strcmp(comp, "M+D") == 0) inst |= 0b1000010 << 6;
+ else if (strcmp(comp, "D-A") == 0) inst |= 0b0010011 << 6;
+ else if (strcmp(comp, "D-M") == 0) inst |= 0b1010011 << 6;
+ else if (strcmp(comp, "A-D") == 0) inst |= 0b0000111 << 6;
+ else if (strcmp(comp, "M-D") == 0) inst |= 0b1000111 << 6;
+ else if (strcmp(comp, "D&A") == 0
+ || strcmp(comp, "A&D") == 0) inst |= 0b0000000 << 6;
+ else if (strcmp(comp, "D&M") == 0
+ || strcmp(comp, "M&D") == 0) inst |= 0b1000000 << 6;
+ else if (strcmp(comp, "D|A") == 0
+ || strcmp(comp, "A|D") == 0) inst |= 0b0010101 << 6;
+ else if (strcmp(comp, "D|M") == 0
+ || strcmp(comp, "M|D") == 0) inst |= 0b1010101 << 6;
+ else {
+ fprintf(stderr, "Invalid computation: %s\n", comp);
+ exit(EXIT_CODE_SYNTAX_ERROR);
+ }
+ free(comp);
+ }
+ return inst;
+}
+
+size_t assembler(char *input_fn, bool verbose) {
+ // open input file
+ FILE *input_file = fopen(input_fn, "r");
+ if (input_file == NULL) {
+ fprintf(stderr, "Cannot open input file: %s\n", input_fn);
+ exit(EXIT_CODE_FILE_ERROR);
+ }
+ // find size of input file
+ fseek(input_file, 0, SEEK_END);
+ size_t file_size = ftell(input_file);
+ fseek(input_file, 0, SEEK_SET);
+ // read input file
+ char *file_content = malloc(file_size);
+ fread(file_content, file_size, 1, input_file);
+ fclose(input_file);
+
+ // strip away comments, labels, blank lines and whitespace from file_content
+ // resulting in lines of what looks like instructions in assembly but is not necessarily correct
+ // labels in parentheses are assigned corresponding addresses in ROM, then collected in `symbols`
+ // the strings are scattered in the heap but asm_lines collects pointers to them
+ char *asm_lines[MAX_INST_LEN] = {NULL};
+ int asm_line_cnt = 0; // no. of lines (metaphorically) written into asm_lines
+ char *asm_line = malloc(MAX_ASM_LINE_LEN + 1); // one line of (probably) assembly
+ int asm_char_cnt = 0; // no. of chars written into asm_line
+ struct symbol symbols[MAX_INST_LEN] = {
+ {"SP", 0}, {"LCL", 1}, {"ARG", 2}, {"THIS", 3}, {"THAT", 4},
+ {"R0", 0}, {"R1", 1}, {"R2", 2}, {"R3", 3},
+ {"R4", 4}, {"R5", 5}, {"R6", 6}, {"R7", 7},
+ {"R8", 8}, {"R9", 9}, {"R10", 10}, {"R11", 11},
+ {"R12", 12}, {"R13", 13}, {"R14", 14}, {"R15", 15},
+ {"SCREEN", 16384}, {"KBD", 24576},
+ };
+ const int predef_symbol_cnt = 23; // no. of predefined symbols
+ int user_symbol_cnt = 0;
+ for (size_t i = 0; i < file_size; i++) {
+ switch (file_content[i]) {
+ case '\n':
+ // end of line; try to figure out what's in asm_line
+ if (asm_char_cnt == 0) continue; // skip blank line or comment line
+ *(asm_line + asm_char_cnt) = '\0';
+ if (*asm_line == '(' && *(asm_line + asm_char_cnt - 1) == ')') {
+ // this line may be a label; extract label from between the parentheses
+ char *label = malloc(asm_char_cnt - 1);
+ strncpy(label, asm_line + 1, asm_char_cnt - 2);
+ free(asm_line);
+ *(label + asm_char_cnt - 2) = '\0';
+ char illegal_char = find_illegal_symbol_char(label);
+ if (illegal_char != -1) {
+ fprintf(stderr, "Illegal character: %c\n", illegal_char);
+ exit(EXIT_CODE_ILLEGAL_CHAR);
+ }
+ // TODO: error on repeated label
+ symbols[predef_symbol_cnt + user_symbol_cnt] = (struct symbol) {label, asm_line_cnt};
+ user_symbol_cnt++;
+ } else {
+ // this line may be an instruction; assemble it
+ asm_lines[asm_line_cnt] = asm_line;
+ asm_line_cnt++;
+ }
+ // allocate memory for next line
+ asm_char_cnt = 0;
+ asm_line = malloc(MAX_ASM_LINE_LEN);
+ break;
+ case '/':
+ if (i + 1 < file_size && file_content[i + 1] == '/') {
+ // we encountered a comment
+ // skip to last char of line
+ while (i + 1 < file_size && file_content[i + 1] != '\n') i++;
+ } else {
+ fprintf(stderr, "Illegal character: /\n");
+ exit(EXIT_CODE_ILLEGAL_CHAR);
+ }
+ break;
+ case ' ':
+ case '\t':
+ case '\r':
+ break; // ignore whitespace and CR
+ default:
+ *(asm_line + asm_char_cnt) = file_content[i];
+ asm_char_cnt++;
+ if (asm_char_cnt > MAX_ASM_LINE_LEN) {
+ fprintf(stderr, "Max assembly line length (%d) exceeded\n", MAX_ASM_LINE_LEN);
+ exit(EXIT_CODE_SIZE_EXCEEDED);
+ }
+ }
+ }
+ free(asm_line);
+ free(file_content);
+
+ // find and assign address to variables on the fly
+ int addr = 16; // variable addresses start at 16
+ for (int i = 0; i < asm_line_cnt; i++) {
+ if (asm_lines[i] == NULL) break; // no more instructions
+ if (*(asm_lines[i]) != '@') continue; // not an A-instruction
+ char *addr_str = malloc(strlen(asm_lines[i]));
+ strcpy(addr_str, asm_lines[i] + 1); // whatever comes after the @
+ if (strlen(addr_str) == 0) {
+ fprintf(stderr, "Address cannot be empty\n");
+ exit(EXIT_CODE_SYNTAX_ERROR);
+ }
+ bool is_symbol = false;
+ for (char *c = addr_str; *c != '\0'; c++) {
+ // search for non-numeric chars in addr_str
+ if (*c < '0' || *c > '9') {
+ is_symbol = true;
+ }
+ }
+ if (!is_symbol) continue; // address is decimal constant
+ char illegal_char = find_illegal_symbol_char(addr_str);
+ if (illegal_char != -1) {
+ fprintf(stderr, "Illegal character: %c\n", illegal_char);
+ exit(EXIT_CODE_ILLEGAL_CHAR);
+ }
+ // search for symbol in list
+ bool found = false;
+ for (int s = 0; s < predef_symbol_cnt + user_symbol_cnt; s++) {
+ if (strcmp(addr_str, symbols[s].label) == 0) {
+ // overwrite asm line with decimal constant
+ sprintf(asm_lines[i], "@%d", symbols[s].addr);
+ found = true;
+ free(addr_str);
+ break;
+ }
+ }
+ if (!found) {
+ // add symbol to list
+ symbols[predef_symbol_cnt + user_symbol_cnt] = (struct symbol) {addr_str, addr};
+ sprintf(asm_lines[i], "@%d", addr);
+ user_symbol_cnt++;
+ addr++;
+ }
+ }
+
+ // start assembling
+ uint16_t *binary = calloc(32768, 2);
+ size_t inst_cnt = 0; // current no. of instructions in binary
+ for (char **line = asm_lines; *line != NULL; line++) {
+ *(binary + inst_cnt) = assemble_inst(*line);
+ inst_cnt++;
+ if (inst_cnt > MAX_INST_LEN) {
+ fprintf(stderr, "Max number of instruction (%d) exceeded\n", MAX_INST_LEN);
+ exit(EXIT_CODE_SIZE_EXCEEDED);
+ }
+ }
+
+ if (verbose) {
+ print_symbols(symbols + predef_symbol_cnt, user_symbol_cnt);
+ print_binary_and_asm(binary, asm_lines, inst_cnt);
+ printf("\n");
+ }
+
+ for (char **line = asm_lines; *line != NULL; line++) free(*line);
+ for (int s = predef_symbol_cnt; s < predef_symbol_cnt + user_symbol_cnt; s++) {
+ free(symbols[s].label);
+ }
+
+ // write binary
+ // output_fn = input_fn[:-4] + ".hack" if input_fn.endswith(".asm") else input_fn + ".hack"
+ int input_fn_len = strlen(input_fn);
+ char *output_fn = malloc(input_fn_len + 6);
+ strcpy(output_fn, input_fn);
+ if (input_fn_len >= 4 && strcmp(input_fn + input_fn_len - 4, ".asm") == 0) {
+ sprintf(output_fn + input_fn_len - 4, ".hack");
+ } else {
+ sprintf(output_fn + input_fn_len, ".hack");
+ }
+
+ FILE *output_file = fopen(output_fn, "w");
+ if (output_file == NULL) {
+ fprintf(stderr, "Cannot open output file: %s\n", output_fn);
+ exit(EXIT_CODE_FILE_ERROR);
+ }
+ write_binary(output_file, binary, inst_cnt);
+ fclose(output_file);
+ free(binary);
+ printf("Binary written to %s\n", output_fn);
+ free(output_fn);
+
+ return inst_cnt;
+}
+
+int main(int argc, char *argv[]) {
+ char *input_fn = NULL;
+ bool verbose = false;
+ for (int i = 1; i < argc; i++) {
+ if (strcmp(argv[i], "-h") == 0) {
+ printf("Usage: %s <input.asm> [-v]\n-v -- verbose mode\n", argv[0]);
+ exit(0);
+ } else if (strcmp(argv[i], "-v") == 0) {
+ verbose = true;
+ } else {
+ input_fn = argv[i];
+ }
+ }
+
+ assembler(input_fn, verbose);
+ return 0;
+}
diff --git a/projects/06/hack-as/hack-as.py b/projects/06/hack-as/hack-as.py
new file mode 100644
index 0000000..bb70abc
--- /dev/null
+++ b/projects/06/hack-as/hack-as.py
@@ -0,0 +1,269 @@
+from sys import stderr
+from argparse import ArgumentParser
+
+EXIT_CODES = {
+ "file_error": 1,
+ "illegal_char": 2,
+ "size_exceeded": 3,
+ "syntax_error": 4,
+ "addr_error": 5,
+ "symbol_error": 6,
+}
+
+PREDEFINED_SYMBOL_CNT = 23
+MAX_INST_LEN = 32768
+MAX_ADDR = 32767
+
+PREDEFINED_SYMBOLS = {
+ "SP": 0,
+ "LCL": 1,
+ "ARG": 2,
+ "THIS": 3,
+ "THAT": 4,
+ "R0": 0,
+ "R1": 1,
+ "R2": 2,
+ "R3": 3,
+ "R4": 4,
+ "R5": 5,
+ "R6": 6,
+ "R7": 7,
+ "R8": 8,
+ "R9": 9,
+ "R10": 10,
+ "R11": 11,
+ "R12": 12,
+ "R13": 13,
+ "R14": 14,
+ "R15": 15,
+ "SCREEN": 16384,
+ "KBD": 24576,
+}
+
+DEST = {
+ "": 0b000 << 3,
+ "M": 0b001 << 3,
+ "D": 0b010 << 3,
+ "MD": 0b011 << 3,
+ "A": 0b100 << 3,
+ "AM": 0b101 << 3,
+ "AD": 0b110 << 3,
+ "AMD": 0b111 << 3,
+}
+
+JMP = {
+ "": 0b000,
+ "JGT": 0b001,
+ "JEQ": 0b010,
+ "JGE": 0b011,
+ "JLT": 0b100,
+ "JNE": 0b101,
+ "JLE": 0b110,
+ "JMP": 0b111,
+}
+
+
+COMP = {
+ "0": 0b0101010 << 6,
+ "1": 0b0111111 << 6,
+ "-1": 0b0111010 << 6,
+ "D": 0b0001100 << 6,
+ "A": 0b0110000 << 6,
+ "M": 0b1110000 << 6,
+ "!D": 0b0001101 << 6,
+ "!A": 0b0110001 << 6,
+ "!M": 0b1110001 << 6,
+ "-D": 0b0001111 << 6,
+ "-A": 0b0110011 << 6,
+ "-M": 0b1110011 << 6,
+ "D+1": 0b0011111 << 6,
+ "A+1": 0b0110111 << 6,
+ "M+1": 0b1110111 << 6,
+ "D-1": 0b0001110 << 6,
+ "A-1": 0b0110010 << 6,
+ "M-1": 0b1110010 << 6,
+ "D+A": 0b0000010 << 6,
+ "A+D": 0b0000010 << 6,
+ "D+M": 0b1000010 << 6,
+ "M+D": 0b1000010 << 6,
+ "D-A": 0b0010011 << 6,
+ "D-M": 0b1010011 << 6,
+ "A-D": 0b0000111 << 6,
+ "M-D": 0b1000111 << 6,
+ "D&A": 0b0000000 << 6,
+ "A&D": 0b0000000 << 6,
+ "D&M": 0b1000000 << 6,
+ "M&D": 0b1000000 << 6,
+ "D|A": 0b0010101 << 6,
+ "A|D": 0b0010101 << 6,
+ "D|M": 0b1010101 << 6,
+ "M|D": 0b1010101 << 6,
+}
+
+
+def find_illegal_symbol_char(symbol):
+ for c in symbol:
+ if (not c.isascii()) or (not (c.isalnum() or c in "_.$:")):
+ return c
+
+ return None
+
+
+def print_symbols(symbols):
+ print("====== SYMBOLS =====")
+ print("label\taddr")
+ for label, addr in symbols.items():
+ print(f"{label}\t{addr}")
+
+
+def print_binary_and_asm(binary, asm_lines):
+ # binary and asm_lines are assumed to be of the same length
+ print("====== RESULTS =====")
+ print("addr\tbinary \tinst")
+ for line_no, bin, asm in zip(range(len(binary)), binary, asm_lines):
+ print(f"{line_no}\t{bin:016b}\t{asm}")
+
+
+def write_binary(file, binary):
+ for inst in binary:
+ file.write(f"{inst:016b}\n")
+
+
+def assemble_inst(asm_line):
+ if asm_line.startswith("@"):
+ # A instruction
+ addr_str = asm_line[1:]
+ addr = int(addr_str)
+ if addr > MAX_ADDR:
+ print(f"Address out of range: {addr}", file=stderr)
+ exit(EXIT_CODES["addr_error"])
+
+ return addr
+ else:
+ # dest=comp;jmp
+ inst = 0xE000
+ dest, _, rhs = asm_line.partition("=")
+ if not rhs:
+ rhs = dest
+ dest = ""
+
+ comp, _, jmp = rhs.partition(";")
+ if dest not in DEST:
+ print(f"Invalid destination: {dest}", file=stderr)
+ exit(EXIT_CODES["syntax_error"])
+
+ inst |= DEST[dest]
+
+ if jmp not in JMP:
+ print(f"Invalid jump instruction: {jmp}", file=stderr)
+ exit(EXIT_CODES["syntax_error"])
+
+ inst |= JMP[jmp]
+
+ if comp not in COMP:
+ print(f"Invalid computation: {comp}", file=stderr)
+ exit(EXIT_CODES["syntax_error"])
+
+ inst |= COMP[comp]
+
+ return inst
+
+
+def assembler(input_fn, verbose):
+ try:
+ input_file = open(input_fn, "r")
+ except FileNotFoundError:
+ print(f"Cannot open input file: {input_fn}", file=stderr)
+ exit(EXIT_CODES["file_error"])
+
+ asm_lines = []
+ line = input_file.readline()
+ asm_line_cnt = 0
+ user_symbols = {}
+ while line:
+ line = line.rstrip("\n")
+ # throw away comment and whitespace
+ asm_line = line.partition("//")[0].replace(" ", "").replace("\t", "")
+ if not asm_line:
+ # skip blank or comment line
+ line = input_file.readline()
+ continue
+
+ if asm_line.startswith("(") and asm_line.endswith(")"):
+ # asm_line may be a label
+ label = asm_line[1:-1]
+ illegal_char = find_illegal_symbol_char(label)
+ if illegal_char is not None:
+ print(f"Illegal character: {illegal_char}", file=stderr)
+ exit(EXIT_CODES["illegal_char"])
+
+ if label in user_symbols or label in PREDEFINED_SYMBOLS:
+ print(f"Symbol {label} already exists", file=stderr)
+ exit(EXIT_CODES["symbol_error"])
+
+ user_symbols[label] = asm_line_cnt
+ else:
+ # asm_line may be an instruction
+ asm_lines.append(asm_line)
+ asm_line_cnt += 1
+ if asm_line_cnt > MAX_INST_LEN:
+ print(
+ f"Max number of instruction ({MAX_INST_LEN}) exceeded", file=stderr
+ )
+ exit(EXIT_CODE_SIZE_EXCEEDED)
+
+ line = input_file.readline()
+
+ input_file.close()
+
+ # find and assign address to variables on the fly
+ addr = 16 # variable addresses start at 16
+ for line_no, asm_line in enumerate(asm_lines):
+ if not asm_line.startswith("@"):
+ continue
+
+ addr_str = asm_line[1:] # whatever comes after the @
+ if not addr_str:
+ print("Address cannot be empty", file=stderr)
+ exit(EXIT_CODES["addr_error"])
+
+ if addr_str.isascii() and addr_str.isdecimal():
+ # address is decimal constant
+ continue
+
+ if addr_str in PREDEFINED_SYMBOLS:
+ asm_lines[line_no] = f"@{PREDEFINED_SYMBOLS[addr_str]}"
+ elif addr_str in user_symbols:
+ asm_lines[line_no] = f"@{user_symbols[addr_str]}"
+ else:
+ user_symbols[addr_str] = addr
+ asm_lines[line_no] = f"@{addr}"
+ addr += 1
+
+ binary = []
+ for asm_line in asm_lines:
+ binary.append(assemble_inst(asm_line))
+
+ if verbose:
+ print_symbols(user_symbols)
+ print_binary_and_asm(binary, asm_lines)
+
+ output_fn = (
+ input_fn[:-4] + ".hack" if input_fn.endswith(".asm") else input_fn + ".hack"
+ )
+ try:
+ output_file = open(output_fn, "w")
+ except:
+ print(f"Cannot open output file: {output_fn}", file=stderr)
+
+ write_binary(output_file, binary)
+ output_file.close()
+ print(f"Binary written to {output_fn}")
+
+
+if __name__ == "__main__":
+ parser = ArgumentParser()
+ parser.add_argument("-v", "--verbose", action="store_true", help="verbose mode")
+ parser.add_argument("input_fn", help="input file in assembly")
+ args = parser.parse_args()
+ assembler(args.input_fn, args.verbose)
diff --git a/projects/06/hack-as/test/compare.hack b/projects/06/hack-as/test/compare.hack
new file mode 100644
index 0000000..f33a9d1
--- /dev/null
+++ b/projects/06/hack-as/test/compare.hack
@@ -0,0 +1,25 @@
+0000000000000000
+1111110000010000
+0000000000010111
+1110001100000110
+0000000000010000
+1110001100001000
+0100000000000000
+1110110000010000
+0000000000010001
+1110001100001000
+0000000000010001
+1111110000100000
+1110111010001000
+0000000000010001
+1111110000010000
+0000000000100000
+1110000010010000
+0000000000010001
+1110001100001000
+0000000000010000
+1111110010011000
+0000000000001010
+1110001100000001
+0000000000010111
+1110101010000111
diff --git a/projects/06/hack-as/test/conventional.asm b/projects/06/hack-as/test/conventional.asm
new file mode 100644
index 0000000..5510424
--- /dev/null
+++ b/projects/06/hack-as/test/conventional.asm
@@ -0,0 +1,32 @@
+// conventional asm a sane person would write
+// draw a rectangle on top left of screen
+// width 16px, height specified in RAM[0]
+@0
+D=M
+@INFINITE_LOOP
+D;JLE // reject if height is negative
+@counter
+M=D
+@SCREEN
+D=A
+@address
+M=D
+(LOOP)
+ @address
+ A=M
+ M=-1
+ @address
+ D=M
+ @32
+ D=D+A
+ @address
+ M=D
+ @counter
+ MD=M-1
+ @LOOP
+ D;JGT
+
+(INFINITE_LOOP)
+ @INFINITE_LOOP
+ 0;JMP
+
diff --git a/projects/06/hack-as/test/valid.asm b/projects/06/hack-as/test/valid.asm
new file mode 100644
index 0000000..d705f1e
--- /dev/null
+++ b/projects/06/hack-as/test/valid.asm
@@ -0,0 +1,29 @@
+// valid asm, but with unnecessary whitespace, = and ;
+@ 0 // unnecessary space
+D=M
+@INFINITE_LOOP
+=D;JLE // unnecessary =
+@counter
+M=D; // unnecessary ;
+@SCREEN
+D = A // unnecessary spaces
+@address
+M = D; // unnecessary spaces and ;
+( LOOP ) // unnecessary spaces
+ @address
+ A=M
+ M=-1
+ @address
+ D=M
+ @32
+ D=D+A
+ @address
+ M=D
+ @counter
+ MD=M-1
+ @LOOP
+ D;JGT
+
+(INFINITE_LOOP)
+ @INFINITE_LOOP
+ 0;JMP
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-22 20:37:45 +0000