From 2506ef66501378d50b0342a77ec91303029a7cfa Mon Sep 17 00:00:00 2001
From: Wes Hampson <WesleyHampson@gmail.com>
Date: Thu, 13 Jun 2019 03:04:43 -0700
Subject: [PATCH 01/18] Start on assembler

---
 CMakeLists.txt     |   4 ++
 include/as/lc3as.h |   6 +++
 include/lc3tools.h |   2 +
 src/as/main.c      | 123 +++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 135 insertions(+)
 create mode 100644 include/as/lc3as.h
 create mode 100644 src/as/main.c

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 54c3be4..7b260ff 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -6,6 +6,7 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
 
 # Source files
 file(GLOB LIB_SOURCES       "src/lib/*.c")
+file(GLOB AS_SOURCES        "src/as/*.c")
 file(GLOB EMU_SOURCES       "src/emu/*.c")
 
 # Library for shared code
@@ -13,8 +14,11 @@ add_library(lc3tools ${LIB_SOURCES})
 target_include_directories(lc3tools PUBLIC include)
 
 # Executables
+add_executable(lc3as ${AS_SOURCES})
 add_executable(lc3emu ${EMU_SOURCES})
+target_include_directories(lc3as PRIVATE include/as)
 target_include_directories(lc3emu PRIVATE include/emu)
 
 # Link shared code and executables
+target_link_libraries(lc3as lc3tools)
 target_link_libraries(lc3emu lc3tools)
diff --git a/include/as/lc3as.h b/include/as/lc3as.h
new file mode 100644
index 0000000..38d0e26
--- /dev/null
+++ b/include/as/lc3as.h
@@ -0,0 +1,6 @@
+#ifndef __LC3AS_H
+#define __LC3AS_H
+
+#define LC3AS_TEST 6969
+
+#endif /* __LC3AS_H */
diff --git a/include/lc3tools.h b/include/lc3tools.h
index 69c8cd2..09e068d 100644
--- a/include/lc3tools.h
+++ b/include/lc3tools.h
@@ -28,6 +28,8 @@
  */
 #define DEBUG 1
 
+#define TEST_DIR    "../test"
+
 /*
  * File separator character.
  */
diff --git a/src/as/main.c b/src/as/main.c
new file mode 100644
index 0000000..bf119b5
--- /dev/null
+++ b/src/as/main.c
@@ -0,0 +1,123 @@
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <lc3as.h>
+#include <lc3tools.h>
+
+#define LINE_BUFFER_SIZE 256
+
+struct source_file
+{
+    FILE *file;
+    char line[LINE_BUFFER_SIZE];
+    size_t line_len;
+    size_t line_num;
+    size_t line_pos;
+};
+
+int read_line(struct source_file *src)
+{
+    src->line_num++;
+    if (feof(src->file) || fgets(src->line, LINE_BUFFER_SIZE, src->file) == 0)
+    {
+        return -1;
+    }
+
+    src->line_len = strlen(src->line);
+    src->line_pos = 0;
+
+    return src->line_len;
+}
+
+int read_token(struct source_file *src, char **tok, char delim)
+{
+    size_t i;
+    // char *tok;
+    char *tok_head;
+    char *tok_tail;
+    char c;
+    int char_seen;
+
+    if (src->line_pos >= src->line_len)
+    {
+        return 0;
+    }
+
+    tok_head = &src->line[src->line_pos];
+    tok_tail = tok_head;
+    i = 0;
+    char_seen = 0;
+
+    while ((c = tok_head[i]) != '\0')
+    {
+        src->line_pos++;
+        if (isspace(c))
+        {
+            if (!char_seen)
+            {
+                tok_head++;
+                tok_tail++;
+                continue;
+            }
+            else if (c == '\n')
+            {
+                *tok_tail = '\0';
+                *tok = tok_head;
+                return 1;
+            }
+            else if (!isspace(delim))
+            {
+                i++;
+                continue;
+            }
+        }
+
+        char_seen = 1;
+        if (c == delim)
+        {
+            *tok_tail = '\0';
+            *tok = tok_head;
+            return 1;
+        }
+        i++;
+        tok_tail++;
+    }
+
+    return 0;
+}
+
+int main(int argc, char *argv[])
+{
+    struct source_file src;
+    char *tok;
+
+    memset(&src, 0, sizeof(struct source_file));
+    src.file = fopen(TEST_DIR"/astest2.asm", "rb");
+    if (src.file == NULL)
+    {
+        return 2;
+    }
+
+    while (read_line(&src) != -1)
+    {
+        read_token(&src, &tok, ' ');
+        // read_token(&src, &tok, '\t');
+
+        printf("tok: %s\n", tok);
+        if (strcasecmp(tok, "ADD") == 0)
+        {
+            printf("ADD\n");
+            while ((read_token(&src, &tok, ',')) != 0)
+            {
+                printf("'%s'\n", tok);
+            }
+        }
+    }
+
+    printf("Hit end of file! (line %zu)\n", src.line_num);
+    fclose(src.file);
+
+    return 0;
+}
\ No newline at end of file

From a741b2c44397549e499cc750b1196c5c4a2689b2 Mon Sep 17 00:00:00 2001
From: Wes Hampson <WesleyHampson@gmail.com>
Date: Thu, 13 Jun 2019 21:39:31 -0700
Subject: [PATCH 02/18] Second attempt at writing a parser... it still doesn't
 work

But it's not done yet ;)
---
 src/as/main.c | 191 +++++++++++++++++++++++++++++++++++---------------
 1 file changed, 134 insertions(+), 57 deletions(-)

diff --git a/src/as/main.c b/src/as/main.c
index bf119b5..f8ed943 100644
--- a/src/as/main.c
+++ b/src/as/main.c
@@ -31,67 +31,48 @@ int read_line(struct source_file *src)
     return src->line_len;
 }
 
-int read_token(struct source_file *src, char **tok, char delim)
+int get_opcode(char *mnemonic, int *opcode, int *operand_count)
 {
-    size_t i;
-    // char *tok;
-    char *tok_head;
-    char *tok_tail;
-    char c;
-    int char_seen;
-
-    if (src->line_pos >= src->line_len)
+    if (strcasecmp(mnemonic, "BR") == 0)
     {
-        return 0;
+        // TODO: nzp
+        *opcode = 0x0;
+        *operand_count = 1;
+        return 1;
     }
-
-    tok_head = &src->line[src->line_pos];
-    tok_tail = tok_head;
-    i = 0;
-    char_seen = 0;
-
-    while ((c = tok_head[i]) != '\0')
+    else if (strcasecmp(mnemonic, "ADD") == 0)
     {
-        src->line_pos++;
-        if (isspace(c))
-        {
-            if (!char_seen)
-            {
-                tok_head++;
-                tok_tail++;
-                continue;
-            }
-            else if (c == '\n')
-            {
-                *tok_tail = '\0';
-                *tok = tok_head;
-                return 1;
-            }
-            else if (!isspace(delim))
-            {
-                i++;
-                continue;
-            }
-        }
-
-        char_seen = 1;
-        if (c == delim)
-        {
-            *tok_tail = '\0';
-            *tok = tok_head;
-            return 1;
-        }
-        i++;
-        tok_tail++;
+        *opcode = 0x1;
+        *operand_count = 3;
+        return 1;
+    }
+    else if (strcasecmp(mnemonic, "RTI") == 0)
+    {
+        *opcode = 0x8;
+        *operand_count = 0;
+        return 1;
     }
 
+    *operand_count = 0;
     return 0;
 }
 
 int main(int argc, char *argv[])
 {
     struct source_file src;
-    char *tok;
+    char *tok_head;
+    char *tok_tail;
+    char *mnemonic;
+    char *label;
+    char *operands[3];
+    int opcode;
+    int operand_count;
+    int operand_idx;
+    int label_seen;
+    int mnemonic_seen;
+    int non_whitespace_seen;
+    int comment_seen;
+    int valid_mnemonic;
 
     memset(&src, 0, sizeof(struct source_file));
     src.file = fopen(TEST_DIR"/astest2.asm", "rb");
@@ -102,17 +83,113 @@ int main(int argc, char *argv[])
 
     while (read_line(&src) != -1)
     {
-        read_token(&src, &tok, ' ');
-        // read_token(&src, &tok, '\t');
+        printf(">> line %zu...\n", src.line_num);
 
-        printf("tok: %s\n", tok);
-        if (strcasecmp(tok, "ADD") == 0)
+        operand_count = 0;
+        operand_idx = 0;
+        label_seen = 0;
+        mnemonic_seen = 0;
+        non_whitespace_seen = 0;
+        comment_seen = 0;
+        valid_mnemonic = 0;
+
+        tok_head = src.line;
+        tok_tail = tok_head;
+
+        while (src.line_pos <= src.line_len)
         {
-            printf("ADD\n");
-            while ((read_token(&src, &tok, ',')) != 0)
+            switch (*tok_tail)
             {
-                printf("'%s'\n", tok);
+                case '\r':
+                {
+                    goto next_char;
+                }
+
+                case ',':
+                {
+                    *tok_tail = '\0';
+                    operands[operand_idx++] = tok_head;
+                    tok_head = tok_tail + 1;
+                    goto next_char;
+                }
+
+                case '\0':
+                case '\n':
+                case '\t':
+                case ' ':
+                {
+                    if (comment_seen)
+                    {
+                        goto next_char;
+                    }
+                    if (!non_whitespace_seen)
+                    {
+                        tok_head++;
+                        goto next_char;
+                    }
+
+                    non_whitespace_seen = 0;
+                    *tok_tail = '\0';
+                    if (!mnemonic_seen)
+                    {
+                        // Mnemonic
+                        if (get_opcode(tok_head, &opcode, &operand_count))
+                        {
+                            mnemonic_seen = 1;
+                            mnemonic = tok_head;
+                        }
+                    }
+                    if (!comment_seen && mnemonic_seen && operand_idx == operand_count - 1)
+                    {
+                        // Operand
+                        operands[operand_idx++] = tok_head;
+                    }
+                    if (!mnemonic_seen && !label_seen)
+                    {
+                        // Label
+                        label_seen = 1;
+                        label = tok_head;
+                    }
+                    tok_head = tok_tail + 1;
+                    goto next_char;
+                }
+
+                case ';':
+                {
+                    comment_seen = 1;
+                    goto next_char;
+                }
+
+                default:
+                {
+                    if (comment_seen)
+                    {
+                        goto next_char;
+                    }
+
+                    // TODO: restrict allowed characters
+                    non_whitespace_seen = 1;
+                    goto next_char;
+                }
             }
+
+        next_char:
+            tok_tail++;
+            src.line_pos++;
+        }
+
+    next_line:
+        if (label_seen)
+        {
+            printf("LABEL = '%s'\n", label);
+        }
+        if (mnemonic_seen)
+        {
+            printf("MNEMONIC = '%s'\n", mnemonic);
+        }
+        for (int i = 0; i < operand_count; i++)
+        {
+            printf("OPERAND%d = '%s'\n", i, operands[i]);
         }
     }
 
@@ -120,4 +197,4 @@ int main(int argc, char *argv[])
     fclose(src.file);
 
     return 0;
-}
\ No newline at end of file
+}

From 0a3f273d24ca622e686808d82eca37c697f7d7fe Mon Sep 17 00:00:00 2001
From: Wes Hampson <WesleyHampson@gmail.com>
Date: Fri, 14 Jun 2019 22:17:05 -0700
Subject: [PATCH 03/18] Third time's the charm (still WIP though)

---
 src/as/main.c | 333 +++++++++++++++++++++++++++-----------------------
 1 file changed, 181 insertions(+), 152 deletions(-)

diff --git a/src/as/main.c b/src/as/main.c
index f8ed943..a622672 100644
--- a/src/as/main.c
+++ b/src/as/main.c
@@ -6,195 +6,224 @@
 #include <lc3as.h>
 #include <lc3tools.h>
 
-#define LINE_BUFFER_SIZE 256
+#define LINE_BUFFER_SIZE    512
+#define TOKEN_BUFFER_SIZE   64
+
+enum token_type
+{
+    T_LABEL,
+    T_MNEMONIC,
+    T_REGISTER,
+    T_IMMEDIATE
+};
+
+struct token
+{
+    struct token *next;
+
+    int line;
+    int pos;
+    int len;
+
+    enum token_type type;
+    char raw_str[TOKEN_BUFFER_SIZE];
+    char cap_str[TOKEN_BUFFER_SIZE];
+    int val;
+};
 
 struct source_file
 {
     FILE *file;
     char line[LINE_BUFFER_SIZE];
-    size_t line_len;
-    size_t line_num;
-    size_t line_pos;
+    int line_num;
+    int line_pos;
+    int line_len;
 };
 
-int read_line(struct source_file *src)
+static struct token * read_token(struct source_file *src);
+static int read_line(struct source_file *src);
+
+int main(int argc, char *argv[])
 {
-    src->line_num++;
-    if (feof(src->file) || fgets(src->line, LINE_BUFFER_SIZE, src->file) == 0)
+    struct source_file src;
+
+    struct token *tok_list;
+    struct token *prev;
+    struct token *curr;
+
+    if (argc < 2)
     {
-        return -1;
+        fprintf(stderr, "error: missing source file\n");
+        return 1;
     }
 
-    src->line_len = strlen(src->line);
-    src->line_pos = 0;
+    memset(&src, 0, sizeof(struct source_file));
+    src.file = fopen(argv[1], "rb");
+    if (src.file == NULL)
+    {
+        fprintf(stderr, "error: failed to open source file\n");
+        return 2;
+    }
 
-    return src->line_len;
-}
+    if (read_line(&src) == -1)
+    {
+        fprintf(stderr, "error: failed to read source file\n");
+        return 2;
+    }
 
-int get_opcode(char *mnemonic, int *opcode, int *operand_count)
-{
-    if (strcasecmp(mnemonic, "BR") == 0)
+    prev = NULL;
+    while ((curr = read_token(&src)) != NULL)
     {
-        // TODO: nzp
-        *opcode = 0x0;
-        *operand_count = 1;
-        return 1;
+        printf("(%d:%d, %d): ", curr->line, curr->pos, curr->len);
+        switch (curr->type)
+        {
+            case T_LABEL:
+                printf("<LABEL> %s\n", curr->raw_str);
+                break;
+            case T_MNEMONIC:
+                printf("<MNEMONIC> %s\n", curr->cap_str);
+                break;
+            case T_REGISTER:
+                printf("<REGISTER> %d\n", curr->val);
+                break;
+            case T_IMMEDIATE:
+                printf("<IMMEDIATE> %d\n", curr->val);
+                break;
+            default:
+                printf("<UNKNOWN> %s\n", curr->raw_str);
+                break;
+        }
+
+        if (prev == NULL)
+        {
+            tok_list = curr;
+            prev = tok_list;
+        }
+        else
+        {
+            prev->next = curr;
+        }
+        curr->next = NULL;
     }
-    else if (strcasecmp(mnemonic, "ADD") == 0)
+
+    curr = tok_list;
+    while (curr != NULL)
     {
-        *opcode = 0x1;
-        *operand_count = 3;
-        return 1;
+        // printf("(%d, %d): ", curr->line, curr->pos);
+        // switch (curr->type)
+        // {
+        //     case T_LABEL:
+        //         printf("<LABEL> %s\n", curr->raw_str);
+        //         break;
+        //     case T_MNEMONIC:
+        //         printf("<MNEMONIC> %s\n", curr->cap_str);
+        //         break;
+        //     case T_REGISTER:
+        //         printf("<REGISTER> %d\n", curr->val);
+        //         break;
+        //     case T_IMMEDIATE:
+        //         printf("<IMMEDIATE> %d\n", curr->val);
+        //         break;
+        //     default:
+        //         printf("<UNKNOWN> %s\n", curr->raw_str);
+        //         break;
+        // }
+
+        prev = curr;
+        curr = curr->next;
+        free(prev);
     }
-    else if (strcasecmp(mnemonic, "RTI") == 0)
+
+    return 0;
+}
+
+int is_delim(char c)
+{
+    switch (c)
     {
-        *opcode = 0x8;
-        *operand_count = 0;
-        return 1;
+        case ' ':
+        case ',':
+        case ';':
+        case '\n':
+        case '\0':
+            return 1;
     }
 
-    *operand_count = 0;
     return 0;
 }
 
-int main(int argc, char *argv[])
+static struct token * read_token(struct source_file *src)
 {
-    struct source_file src;
+    struct token *token; /* I feel alright mamma I'm not jokin' */
     char *tok_head;
     char *tok_tail;
-    char *mnemonic;
-    char *label;
-    char *operands[3];
-    int opcode;
-    int operand_count;
-    int operand_idx;
-    int label_seen;
-    int mnemonic_seen;
-    int non_whitespace_seen;
-    int comment_seen;
-    int valid_mnemonic;
 
-    memset(&src, 0, sizeof(struct source_file));
-    src.file = fopen(TEST_DIR"/astest2.asm", "rb");
-    if (src.file == NULL)
+    token = (struct token *) malloc(sizeof(struct token));
+    if (token == NULL)
     {
-        return 2;
+        return NULL;
     }
+    memset(token, 0, sizeof(struct token));
 
-    while (read_line(&src) != -1)
-    {
-        printf(">> line %zu...\n", src.line_num);
-
-        operand_count = 0;
-        operand_idx = 0;
-        label_seen = 0;
-        mnemonic_seen = 0;
-        non_whitespace_seen = 0;
-        comment_seen = 0;
-        valid_mnemonic = 0;
-
-        tok_head = src.line;
-        tok_tail = tok_head;
+    tok_head = &src->line[src->line_pos];
+    tok_tail = tok_head;
 
-        while (src.line_pos <= src.line_len)
+start:
+    /* skip leading whitespace */
+    while (isspace(*tok_head) || *tok_head == '\0')
+    {
+        if (src->line_pos >= src->line_len)
         {
-            switch (*tok_tail)
+            if (read_line(src) == -1)
             {
-                case '\r':
-                {
-                    goto next_char;
-                }
-
-                case ',':
-                {
-                    *tok_tail = '\0';
-                    operands[operand_idx++] = tok_head;
-                    tok_head = tok_tail + 1;
-                    goto next_char;
-                }
-
-                case '\0':
-                case '\n':
-                case '\t':
-                case ' ':
-                {
-                    if (comment_seen)
-                    {
-                        goto next_char;
-                    }
-                    if (!non_whitespace_seen)
-                    {
-                        tok_head++;
-                        goto next_char;
-                    }
-
-                    non_whitespace_seen = 0;
-                    *tok_tail = '\0';
-                    if (!mnemonic_seen)
-                    {
-                        // Mnemonic
-                        if (get_opcode(tok_head, &opcode, &operand_count))
-                        {
-                            mnemonic_seen = 1;
-                            mnemonic = tok_head;
-                        }
-                    }
-                    if (!comment_seen && mnemonic_seen && operand_idx == operand_count - 1)
-                    {
-                        // Operand
-                        operands[operand_idx++] = tok_head;
-                    }
-                    if (!mnemonic_seen && !label_seen)
-                    {
-                        // Label
-                        label_seen = 1;
-                        label = tok_head;
-                    }
-                    tok_head = tok_tail + 1;
-                    goto next_char;
-                }
-
-                case ';':
-                {
-                    comment_seen = 1;
-                    goto next_char;
-                }
-
-                default:
-                {
-                    if (comment_seen)
-                    {
-                        goto next_char;
-                    }
-
-                    // TODO: restrict allowed characters
-                    non_whitespace_seen = 1;
-                    goto next_char;
-                }
+                printf("Hit end of file! (line %d)\n", src->line_num);
+                free(token);
+                return NULL;
             }
-
-        next_char:
-            tok_tail++;
-            src.line_pos++;
+            tok_head = src->line;
+            continue;
         }
+        src->line_pos++;
+        tok_head++;
+    }
 
-    next_line:
-        if (label_seen)
-        {
-            printf("LABEL = '%s'\n", label);
-        }
-        if (mnemonic_seen)
-        {
-            printf("MNEMONIC = '%s'\n", mnemonic);
-        }
-        for (int i = 0; i < operand_count; i++)
-        {
-            printf("OPERAND%d = '%s'\n", i, operands[i]);
-        }
+    tok_tail = tok_head;
+    token->line = src->line_num;
+    token->pos = src->line_pos + 1;
+
+    while (!is_delim(*tok_tail))
+    {
+        tok_tail++;
     }
 
-    printf("Hit end of file! (line %zu)\n", src.line_num);
-    fclose(src.file);
+    // switch (*tok_tail)
+    // {
+    //     case '\0':
+    //         src->line_pos = src->line_len;
+    //         goto start;
+    // }
 
-    return 0;
+    *tok_tail = '\0';
+    token->len = (tok_tail - tok_head);
+    token->type = T_LABEL;
+    strcpy(token->raw_str, tok_head);
+    src->line_pos += token->len;
+
+    return token;
+}
+
+static int read_line(struct source_file *src)
+{
+    src->line_num++;
+    if (feof(src->file) || fgets(src->line, LINE_BUFFER_SIZE, src->file) == NULL)
+    {
+        return -1;
+    }
+
+    // printf(">> %s", src->line);
+
+    src->line_pos = 0;
+    src->line_len = (int) strlen(src->line);
+
+    return src->line_len;
 }

From 5cbd1deeaad27328d3d97c4f5188695df9241e2a Mon Sep 17 00:00:00 2001
From: Wes Hampson <WesleyHampson@gmail.com>
Date: Fri, 14 Jun 2019 22:17:58 -0700
Subject: [PATCH 04/18] Mark assembler as 'In-progress'

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index d4f35fc..d04eb7a 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@ An implementation of the LC-3 instruction set architecture and assorted tools.
 | Name        |  Status       | Notes                     |
 | ----------- | ------------- | ------------------------- |
 | `lc3emu`    | In-progress   | Emulator/Debugger         |
-| `lc3as`     | Planned       | Assembler                 |
+| `lc3as`     | In-progress   | Assembler                 |
 | `lc3disas`  | Planned       | Disassembler              |
 | `lc3cc`     | Planned       | C Compiler                |
 

From e79670925ee8cf476ac92f6c316604a6991e8753 Mon Sep 17 00:00:00 2001
From: Wes Hampson <WesleyHampson@gmail.com>
Date: Fri, 14 Jun 2019 23:08:42 -0700
Subject: [PATCH 05/18] Unignore test/

---
 .gitignore | 1 -
 1 file changed, 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index a2b9577..fec9b69 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,5 @@
 .vscode/
 build/
-test/
 
 # Ignore pesky macOS files
 .DS_Store

From 4cc4222dd5e48b2d2f0d012b5ee3cfe950bab562 Mon Sep 17 00:00:00 2001
From: Wes Hampson <WesleyHampson@gmail.com>
Date: Fri, 14 Jun 2019 23:08:53 -0700
Subject: [PATCH 06/18] Add test/

---
 test/as/factorial_reg.asm  |  77 +++++++++++++++++++++++++++++++++++++
 test/as/foo.asm            |  26 +++++++++++++
 test/as/tokenizer0.asm     |  60 +++++++++++++++++++++++++++++
 test/as/tokenizer1.asm     |  15 ++++++++
 test/as/tokenizer2.asm     |  14 +++++++
 test/emu/factorial_reg.obj | Bin 0 -> 68 bytes
 test/emu/foo.asm.obj       | Bin 0 -> 42 bytes
 7 files changed, 192 insertions(+)
 create mode 100644 test/as/factorial_reg.asm
 create mode 100644 test/as/foo.asm
 create mode 100644 test/as/tokenizer0.asm
 create mode 100644 test/as/tokenizer1.asm
 create mode 100644 test/as/tokenizer2.asm
 create mode 100644 test/emu/factorial_reg.obj
 create mode 100644 test/emu/foo.asm.obj

diff --git a/test/as/factorial_reg.asm b/test/as/factorial_reg.asm
new file mode 100644
index 0000000..e3a85e7
--- /dev/null
+++ b/test/as/factorial_reg.asm
@@ -0,0 +1,77 @@
+;===============================================================================
+;   FILE: factorial.asm
+; AUTHOR: Wes Hampson (whampso2)
+;
+; DESCRIPTION:
+; Iteratively computes n! (n factorial), where n is an integer.
+; Written for ECE411 MP0, Spring 2018.
+;
+; REGISTER DETAIL:
+;   R0: (constant)  0, used as a base address register
+;   R1: (constant) -1, used for decrementing loop counters
+;   R2: (constant) -2, used for setting up initial loop counter value
+;   R3: accumulator, contains the result of each addition performed
+;   R4: multiplicand, the number currently being multiplied
+;   R5: factorial loop counter (outer loop)
+;   R6: multiply loop counter (inner loop) (i.e., multiplier)
+;   R7: (unused)
+;
+; ASSUMPTIONS:
+;   * R0 contains a value of 0 upon entry.
+;===============================================================================
+
+ORIGIN 4x0000
+
+SEGMENT CodeSegment:
+INIT:
+    ; Load constants used throughout the program.
+    LDR R1, R0, NEG_ONE
+    LDR R2, R0, NEG_TWO
+
+    ; Initialize accumulator and multiplicand.
+    LDR R3, R0, INPUT	; sum = input, accumulator
+    LDR R4, R0, INPUT   ; amt = input, multiplicand (amount added per iteration)
+
+    ; Handle case for 0!
+    BRz ZERO_INPUT
+
+    ; Initialize loop counters
+    ADD R5, R3, R2      ; i = input - 2, subtract 2 because 'sum' initialized to 'input'
+    ADD R6, R0, R5      ; k = i
+
+MULTIPLY_LOOP:
+	; Computes 'amt*k' and adds the result to 'sum'
+    BRnz STORE
+    ADD R3, R3, R4      ; sum = sum + amt
+    ADD R6, R6, R1      ; k = k - 1
+    BRnzp MULTIPLY_LOOP
+
+STORE:
+    STR R3, R0, RESULT  ; result = sum
+
+NEXT_FACTORIAL:
+    ; Decrement loop counters and update multiplcand
+    LDR R4, R0, RESULT  ; amt = sum
+    ADD R5, R5, R1      ; i = i - 1
+    BRnz HALT           ; if i < 1; halt
+    ADD R6, R0, R5      ; k = i
+    nop
+    BRnzp MULTIPLY_LOOP
+
+ZERO_INPUT:
+    ; Special case for 0!, stores 1 in the result.
+    LDR R3, R0, POS_ONE
+    STR R3, R0, RESULT
+
+HALT:
+    BRnzp HALT
+
+
+; Data input/output
+INPUT:      DATA2   5
+RESULT:     DATA2   0
+
+; Constants
+POS_ONE:    DATA2   1
+NEG_ONE:    DATA2  -1
+NEG_TWO:    DATA2  -2
diff --git a/test/as/foo.asm b/test/as/foo.asm
new file mode 100644
index 0000000..cf3ede2
--- /dev/null
+++ b/test/as/foo.asm
@@ -0,0 +1,26 @@
+ORIGIN 4x3000
+
+MAIN:
+    AND     R3, R3, R3
+    ADD     R3, R3, 1
+
+HALT:
+    ; Set up mask
+    AND     R5, R5, 0
+    ADD     R5, R5, 1
+    LSHF    R5, R5, 15
+    NOT     R5, R5
+
+    ; Load MCR
+    LEA     R6, MCR
+    LDI     R7, R6, 0
+
+    ; Turn off clock enable bit
+    AND     R7, R7, R5
+    STI     R7, R6, 0
+
+_HALT_LOOP:
+    BR _HALT_LOOP
+
+CLOCK_EN:   DATA2   4x8000
+MCR:        DATA2   4xFFFE
diff --git a/test/as/tokenizer0.asm b/test/as/tokenizer0.asm
new file mode 100644
index 0000000..5e3ceea
--- /dev/null
+++ b/test/as/tokenizer0.asm
@@ -0,0 +1,60 @@
+; this is a comment (consider // as well)
+      ; this is a comment with leading whitespace!
+jmp r0
+
+label1 add r0,r1,r3
+label2 xor r4,r5,#6
+label3 and r6,r7,x1C ; with a trailing comment!
+
+label4  ; now we've got a macro and newline!
+    .fill xA5A5
+    .blkw 50
+    .stringz "Hello, world!"
+
+
+label               ; address is 0x46 (I think... & if program above doesn't change)
+
+ADD R5, R5, R5      ; 0001 1011 0100 0101   = 0x1B45
+ADD R5, R5, #-1     ; 0001 1011 0111 1111   = 0x1B7F
+
+AND reg, reg, R5    ; 0101 1011 0100 0101   = 0x5B45
+AND reg, reg, x1F   ; 0101 1011 0111 1111   = 0x5B7F
+
+BR label            ; 0000 111 000000000    =
+BRn label
+BRz label
+BRp label
+BRnz label
+BRnp label
+BRzp label
+BRnzp label     ; same as BR (unconditional branch)
+
+JMP R5
+
+JSR label
+JSRR R5
+
+LDB R5, R5, label
+LDW R5, R5, label
+LDI R5, R5, label
+
+LEA R5, label
+
+NOT R5, R5
+
+RET
+RTI
+
+LSHF R5, R5, #15
+RSHFL R5, R5, xF
+RSHFA R5, R5, R5
+
+STB R5, R5, label
+STW R5, R5, label
+STI R5, R5, label
+
+; expand on these (HALT, PUTS, etc...)
+TRAP x25
+
+XOR R5, R5, R5
+XOR R5, R5, x1F
\ No newline at end of file
diff --git a/test/as/tokenizer1.asm b/test/as/tokenizer1.asm
new file mode 100644
index 0000000..647f5d9
--- /dev/null
+++ b/test/as/tokenizer1.asm
@@ -0,0 +1,15 @@
+LABEL0
+.MACRO0
+RTI
+
+LABEL1 .MACRO1
+LABEL2 RTI
+
+; comment
+    LABEL3
+    RTI
+    .MACRO2
+
+    LABEL4      ; comment
+    RTI         ; multi-word comment
+    .MACRO3     ; comment
diff --git a/test/as/tokenizer2.asm b/test/as/tokenizer2.asm
new file mode 100644
index 0000000..f53ecee
--- /dev/null
+++ b/test/as/tokenizer2.asm
@@ -0,0 +1,14 @@
+LABEL1                      ; label by itself
+RTI                         ; instr by itself
+
+JMP R6                      ; instr w/ one operand (reg)
+BR LABEL1                   ; instr w/ one operand (label)
+TRAP x25                    ; instr w/ one operand (imm)
+
+ADD R3, R2, R1              ; instr w/ many operands (reg)
+ADD R3, R2, R1              ; instr w/ many operands (reg)
+ADD R4,R5,#3                ; instr w/ minimal spacing & positive imm
+    ADD R4,   R5,       #-3 ; instr w/ weird spacing & negative imm
+ADD   R0   , R5  ,  xE      ; instr w/ weird spacing & hex imm
+ADD   R7   , R0  ,R6        ; instr w/ weird spacing
+	ADD	R7,	R6,		R5      ; instr w/ weird spacing (tabs)
diff --git a/test/emu/factorial_reg.obj b/test/emu/factorial_reg.obj
new file mode 100644
index 0000000000000000000000000000000000000000..3b660f9fcfa69c3d028d4607df6ab6ba4298bce5
GIT binary patch
literal 68
zcmZQzfB+LHEs-RdBAO<e!OL<;idBZ0=ZILN>>qxyGO-LtX;vOq83u;0{Nib1W&inE
NfjSr&{{R2?9{^7H4tM|n

literal 0
HcmV?d00001

diff --git a/test/emu/foo.asm.obj b/test/emu/foo.asm.obj
new file mode 100644
index 0000000000000000000000000000000000000000..72f6ded0d2a832b477ccfca448dcbfdad39d7fcc
GIT binary patch
literal 42
qcmZQDU;qOt2*q$X?4ejfbfR?r?fTiQZyMGgjc?fhpP!-O-+utO2Mz=P

literal 0
HcmV?d00001


From e50ef08153b8db19a40ce995fc64892fa232a037 Mon Sep 17 00:00:00 2001
From: Wes Hampson <WesleyHampson@gmail.com>
Date: Fri, 14 Jun 2019 23:09:01 -0700
Subject: [PATCH 07/18] add tools/

---
 tools/dbg.sh    | 5 +++++
 tools/rundbg.sh | 7 +++++++
 2 files changed, 12 insertions(+)
 create mode 100755 tools/dbg.sh
 create mode 100755 tools/rundbg.sh

diff --git a/tools/dbg.sh b/tools/dbg.sh
new file mode 100755
index 0000000..5593818
--- /dev/null
+++ b/tools/dbg.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+emu_pid=$(ps -C | awk -F ' ' '{ if ($4 ~ /lc3emu/) print $1; }')
+echo $emu_pid
+sudo gdb -p $emu_pid
diff --git a/tools/rundbg.sh b/tools/rundbg.sh
new file mode 100755
index 0000000..8d9da03
--- /dev/null
+++ b/tools/rundbg.sh
@@ -0,0 +1,7 @@
+#!/bin/bash
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" > /dev/null 2>&1 && pwd)"
+
+open -a Terminal $SCRIPT_DIR/../../build/bin/lc3emu
+ping -c 2 127.0.0.1         # delay to allow Terminal to launch
+$SCRIPT_DIR/../test/dbg.sh

From a9e6ebf3dc32e01e3a4deddcb38fdc1380102a99 Mon Sep 17 00:00:00 2001
From: Wes Hampson <WesleyHampson@gmail.com>
Date: Fri, 14 Jun 2019 23:09:43 -0700
Subject: [PATCH 08/18] Move to emu/

---
 tools/{ => emu}/dbg.sh    | 0
 tools/{ => emu}/rundbg.sh | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename tools/{ => emu}/dbg.sh (100%)
 rename tools/{ => emu}/rundbg.sh (100%)

diff --git a/tools/dbg.sh b/tools/emu/dbg.sh
similarity index 100%
rename from tools/dbg.sh
rename to tools/emu/dbg.sh
diff --git a/tools/rundbg.sh b/tools/emu/rundbg.sh
similarity index 100%
rename from tools/rundbg.sh
rename to tools/emu/rundbg.sh

From 9df9c6dfa6750f977a72124419f83ed9ba602780 Mon Sep 17 00:00:00 2001
From: Wes Hampson <WesleyHampson@gmail.com>
Date: Sat, 15 Jun 2019 00:27:17 -0700
Subject: [PATCH 09/18] Tokenizer appears to be working

---
 src/as/main.c | 128 ++++++++++++++++++++++++--------------------------
 1 file changed, 61 insertions(+), 67 deletions(-)

diff --git a/src/as/main.c b/src/as/main.c
index a622672..ee5e810 100644
--- a/src/as/main.c
+++ b/src/as/main.c
@@ -15,6 +15,7 @@ enum token_type
     T_MNEMONIC,
     T_REGISTER,
     T_IMMEDIATE
+    // TODO: string literal
 };
 
 struct token
@@ -65,70 +66,46 @@ int main(int argc, char *argv[])
         return 2;
     }
 
-    if (read_line(&src) == -1)
+    /* build token list */
+    prev = NULL;
+    while ((curr = read_token(&src)) != NULL)
     {
-        fprintf(stderr, "error: failed to read source file\n");
-        return 2;
+        if (prev == NULL)
+        {
+            tok_list = curr;
+            prev = tok_list;
+            continue;
+        }
+
+        prev->next = curr;
+        prev = curr;
     }
 
-    prev = NULL;
-    while ((curr = read_token(&src)) != NULL)
+    /* output and free token list */
+    printf("ln:pos\tlen\ttype\t\ttoken\n");
+    curr = tok_list;
+    while (curr != NULL)
     {
-        printf("(%d:%d, %d): ", curr->line, curr->pos, curr->len);
+        printf("% 3d:%d\t%d\t", curr->line, curr->pos, curr->len);
         switch (curr->type)
         {
             case T_LABEL:
-                printf("<LABEL> %s\n", curr->raw_str);
+                printf("LABEL\t\t'%s'\n", curr->raw_str);
                 break;
             case T_MNEMONIC:
-                printf("<MNEMONIC> %s\n", curr->cap_str);
+                printf("MNEMONIC\t'%s'\n", curr->cap_str);
                 break;
             case T_REGISTER:
-                printf("<REGISTER> %d\n", curr->val);
+                printf("REG\t\t%d\n", curr->val);
                 break;
             case T_IMMEDIATE:
-                printf("<IMMEDIATE> %d\n", curr->val);
+                printf("IMM\t\t%d\n", curr->val);
                 break;
             default:
-                printf("<UNKNOWN> %s\n", curr->raw_str);
+                printf("UNKNOWN\t'%s'\n", curr->raw_str);
                 break;
         }
 
-        if (prev == NULL)
-        {
-            tok_list = curr;
-            prev = tok_list;
-        }
-        else
-        {
-            prev->next = curr;
-        }
-        curr->next = NULL;
-    }
-
-    curr = tok_list;
-    while (curr != NULL)
-    {
-        // printf("(%d, %d): ", curr->line, curr->pos);
-        // switch (curr->type)
-        // {
-        //     case T_LABEL:
-        //         printf("<LABEL> %s\n", curr->raw_str);
-        //         break;
-        //     case T_MNEMONIC:
-        //         printf("<MNEMONIC> %s\n", curr->cap_str);
-        //         break;
-        //     case T_REGISTER:
-        //         printf("<REGISTER> %d\n", curr->val);
-        //         break;
-        //     case T_IMMEDIATE:
-        //         printf("<IMMEDIATE> %d\n", curr->val);
-        //         break;
-        //     default:
-        //         printf("<UNKNOWN> %s\n", curr->raw_str);
-        //         break;
-        // }
-
         prev = curr;
         curr = curr->next;
         free(prev);
@@ -141,9 +118,10 @@ int is_delim(char c)
 {
     switch (c)
     {
-        case ' ':
         case ',':
         case ';':
+        case ' ':
+        case '\t':
         case '\n':
         case '\0':
             return 1;
@@ -157,6 +135,7 @@ static struct token * read_token(struct source_file *src)
     struct token *token; /* I feel alright mamma I'm not jokin' */
     char *tok_head;
     char *tok_tail;
+    int tok_seen;
 
     token = (struct token *) malloc(sizeof(struct token));
     if (token == NULL)
@@ -165,24 +144,31 @@ static struct token * read_token(struct source_file *src)
     }
     memset(token, 0, sizeof(struct token));
 
+
+    if (src->line_pos >= src->line_len)
+    {
+    next_line:
+        if (read_line(src) == -1)
+        {
+            printf("Hit end of file! (line %d)\n", src->line_num);
+            free(token);
+            return NULL;
+        }
+    }
+
+start_over:
+    tok_seen = 0;
     tok_head = &src->line[src->line_pos];
     tok_tail = tok_head;
 
-start:
     /* skip leading whitespace */
-    while (isspace(*tok_head) || *tok_head == '\0')
+    while (isspace(*tok_head))
     {
         if (src->line_pos >= src->line_len)
         {
-            if (read_line(src) == -1)
-            {
-                printf("Hit end of file! (line %d)\n", src->line_num);
-                free(token);
-                return NULL;
-            }
-            tok_head = src->line;
-            continue;
+            goto next_line;
         }
+
         src->line_pos++;
         tok_head++;
     }
@@ -191,23 +177,33 @@ static struct token * read_token(struct source_file *src)
     token->line = src->line_num;
     token->pos = src->line_pos + 1;
 
+    /* read-in the token */
     while (!is_delim(*tok_tail))
     {
+        tok_seen = 1;
         tok_tail++;
     }
 
-    // switch (*tok_tail)
-    // {
-    //     case '\0':
-    //         src->line_pos = src->line_len;
-    //         goto start;
-    // }
+    /* handle special delimiter cases */
+    switch (*tok_tail)
+    {
+        case ',':
+            if (!tok_seen)
+            {
+                src->line_pos++;
+                goto start_over;
+            }
+            break;
+        case ';':
+        case '\0':
+            goto next_line;
+    }
 
     *tok_tail = '\0';
     token->len = (tok_tail - tok_head);
     token->type = T_LABEL;
-    strcpy(token->raw_str, tok_head);
-    src->line_pos += token->len;
+    strncpy(token->raw_str, tok_head, TOKEN_BUFFER_SIZE);
+    src->line_pos += token->len + 1;
 
     return token;
 }
@@ -220,8 +216,6 @@ static int read_line(struct source_file *src)
         return -1;
     }
 
-    // printf(">> %s", src->line);
-
     src->line_pos = 0;
     src->line_len = (int) strlen(src->line);
 

From e52228d78515d89a91f136c146b0b02a5e27388d Mon Sep 17 00:00:00 2001
From: Wes Hampson <WesleyHampson@gmail.com>
Date: Sat, 15 Jun 2019 01:53:28 -0700
Subject: [PATCH 10/18] Tokenizer complete...?

---
 src/as/main.c | 160 ++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 135 insertions(+), 25 deletions(-)

diff --git a/src/as/main.c b/src/as/main.c
index ee5e810..1bab05f 100644
--- a/src/as/main.c
+++ b/src/as/main.c
@@ -9,10 +9,13 @@
 #define LINE_BUFFER_SIZE    512
 #define TOKEN_BUFFER_SIZE   64
 
+#define ARRLEN(a)   (sizeof(a)/sizeof(a[0]))
+
 enum token_type
 {
     T_LABEL,
-    T_MNEMONIC,
+    T_OPCODE,
+    T_PSEUDO_OP,
     T_REGISTER,
     T_IMMEDIATE
     // TODO: string literal
@@ -41,8 +44,27 @@ struct source_file
     int line_len;
 };
 
+const char * const OPCODES[] =
+{
+    // NOTE: BR-BRnzp not included in this table
+    "ADD",  "AND",  "JMP",  "JSR",  "JSRR", "LDB",  "LDW",  "LDI",
+    "LEA",  "NOT",  "RET",  "RTI",  "LSHF", "RSHFL","RSHFA","STB",
+    "STW",  "STI",  "TRAP", "XOR",
+
+    "GETC", "HALT", "IN",   "OUT",  "PUTS", "PUTSP"
+};
+
+const char * const PSEUDO_OPS[] =
+{
+    ".BLKW",".END", ".FILL",".ORIG",".STRINGZ"
+};
+
 static struct token * read_token(struct source_file *src);
 static int read_line(struct source_file *src);
+static int try_read_constant(const char *s, int base, int *out);
+static void s_toupper(char *s);
+static int is_delim(char c);
+static int is_opcode(const char *tok);
 
 int main(int argc, char *argv[])
 {
@@ -90,22 +112,27 @@ int main(int argc, char *argv[])
         switch (curr->type)
         {
             case T_LABEL:
-                printf("LABEL\t\t'%s'\n", curr->raw_str);
+                printf("LABEL\t\t");
+                break;
+            case T_OPCODE:
+                printf("OPCODE\t\t");
                 break;
-            case T_MNEMONIC:
-                printf("MNEMONIC\t'%s'\n", curr->cap_str);
+            case T_PSEUDO_OP:
+                printf("PSEUDO_OP\t");
                 break;
             case T_REGISTER:
-                printf("REG\t\t%d\n", curr->val);
+                printf("REGISTER\t");
                 break;
             case T_IMMEDIATE:
-                printf("IMM\t\t%d\n", curr->val);
+                printf("IMMEDIATE\t");
                 break;
             default:
-                printf("UNKNOWN\t'%s'\n", curr->raw_str);
+                printf("UNKNOWN\t");
                 break;
         }
 
+        printf("'%s'\n", curr->cap_str);
+
         prev = curr;
         curr = curr->next;
         free(prev);
@@ -114,22 +141,6 @@ int main(int argc, char *argv[])
     return 0;
 }
 
-int is_delim(char c)
-{
-    switch (c)
-    {
-        case ',':
-        case ';':
-        case ' ':
-        case '\t':
-        case '\n':
-        case '\0':
-            return 1;
-    }
-
-    return 0;
-}
-
 static struct token * read_token(struct source_file *src)
 {
     struct token *token; /* I feel alright mamma I'm not jokin' */
@@ -199,11 +210,37 @@ static struct token * read_token(struct source_file *src)
             goto next_line;
     }
 
+    /* extract bookkeeping information */
     *tok_tail = '\0';
     token->len = (tok_tail - tok_head);
-    token->type = T_LABEL;
-    strncpy(token->raw_str, tok_head, TOKEN_BUFFER_SIZE);
     src->line_pos += token->len + 1;
+    strncpy(token->raw_str, tok_head, TOKEN_BUFFER_SIZE);
+    strncpy(token->cap_str, tok_head, TOKEN_BUFFER_SIZE);
+    s_toupper(token->cap_str);
+
+    /* determine token type */
+    if (is_opcode(token->cap_str))
+    {
+        token->type = T_OPCODE;
+        return token;
+    }
+    switch (*tok_head)
+    {
+        case '.':
+            token->type = T_PSEUDO_OP;
+            break;
+        case 'R':
+            token->type = T_REGISTER;
+            break;
+        case '#':
+        case 'x':
+        case 'X':
+            token->type = T_IMMEDIATE;
+            break;
+        default:
+            token->type = T_LABEL;
+            break;
+    }
 
     return token;
 }
@@ -221,3 +258,76 @@ static int read_line(struct source_file *src)
 
     return src->line_len;
 }
+
+static int try_read_constant(const char *s, int base, int *out)
+{
+    char *end;
+
+    *out = strtol(s, &end, base);
+    if (s == end)
+    {
+        return 0;
+    }
+
+    return 1;
+}
+
+static void s_toupper(char *s)
+{
+    while (*s != '\0')
+    {
+        *s = toupper(*s);
+        s++;
+    }
+}
+
+static int is_delim(char c)
+{
+    switch (c)
+    {
+        case ',':
+        case ';':
+        case ' ':
+        case '\t':
+        case '\n':
+        case '\0':
+            return 1;
+    }
+
+    return 0;
+}
+
+static int is_opcode(const char *tok)
+{
+    int result;
+
+    /* BR and friends */
+    if (strncmp(tok, "BR", 2) == 0)
+    {
+        result= 1;
+        tok += 2;
+
+        while (*tok != '\0')
+        {
+            if (*tok != 'N' && *tok != 'Z' && *tok != 'P')
+            {
+                result = 0;
+                break;
+            }
+            tok++;
+        }
+
+        return result;
+    }
+
+    /* all else */
+    for (int i = 0; i < ARRLEN(OPCODES); i++)
+    {
+        if (strcmp(tok, OPCODES[i]) == 0)
+        {
+            return 1;
+        }
+    }
+
+    return 0;
+}

From b9b026629dfe00f9ad1110ad92af6dff72655d87 Mon Sep 17 00:00:00 2001
From: Wes Hampson <WesleyHampson@gmail.com>
Date: Sat, 15 Jun 2019 01:53:42 -0700
Subject: [PATCH 11/18] Tweak test programs

---
 test/as/{tokenizer0.asm => blah.asm} |  2 +-
 test/as/tokenizer2.asm               | 17 ++++++++++++-----
 2 files changed, 13 insertions(+), 6 deletions(-)
 rename test/as/{tokenizer0.asm => blah.asm} (98%)

diff --git a/test/as/tokenizer0.asm b/test/as/blah.asm
similarity index 98%
rename from test/as/tokenizer0.asm
rename to test/as/blah.asm
index 5e3ceea..ab9f039 100644
--- a/test/as/tokenizer0.asm
+++ b/test/as/blah.asm
@@ -57,4 +57,4 @@ STI R5, R5, label
 TRAP x25
 
 XOR R5, R5, R5
-XOR R5, R5, x1F
\ No newline at end of file
+XOR R5, R5, x1F
diff --git a/test/as/tokenizer2.asm b/test/as/tokenizer2.asm
index f53ecee..6b93bc1 100644
--- a/test/as/tokenizer2.asm
+++ b/test/as/tokenizer2.asm
@@ -1,14 +1,21 @@
 LABEL1                      ; label by itself
 RTI                         ; instr by itself
+.END                        ; macro by itself
 
 JMP R6                      ; instr w/ one operand (reg)
 BR LABEL1                   ; instr w/ one operand (label)
 TRAP x25                    ; instr w/ one operand (imm)
+.FILL LABEL1                ; macro w/ one operand (label)
+.FILL xBEEF                 ; macro w/ one operand (imm)
 
-ADD R3, R2, R1              ; instr w/ many operands (reg)
-ADD R3, R2, R1              ; instr w/ many operands (reg)
+ADD R0, R1, R2              ; instr w/ many operands (reg)
+ADD R3, R4, #3              ; instr w/ many operands (positive imm)
+ADD R3, R4, #-6             ; instr w/ many operands (negative imm)
+ADD R5, R6, xE              ; instr w/ many operands (hex)
 ADD R4,R5,#3                ; instr w/ minimal spacing & positive imm
-    ADD R4,   R5,       #-3 ; instr w/ weird spacing & negative imm
-ADD   R0   , R5  ,  xE      ; instr w/ weird spacing & hex imm
-ADD   R7   , R0  ,R6        ; instr w/ weird spacing
+    LEA R7, LABEL           ; instr w/ leading space and label operand
+ADD R4,   R5,       #14      ; instr w/ weird spacing (extra whitespace after ,)
+ADD   R0   , R5  ,  xA      ; instr w/ weird spacing (extra whitespace before ,)
+ADD   R7   , R0  ,R6        ; instr w/ weird spacing (whitespace mixture)
+ADD   R4   ,R2  , R1        ; instr w/ weird spacing (whitespace mixture)
 	ADD	R7,	R6,		R5      ; instr w/ weird spacing (tabs)

From 3212fd721983e27e9d755a3af54257d026a208fe Mon Sep 17 00:00:00 2001
From: Wes Hampson <WesleyHampson@gmail.com>
Date: Sat, 15 Jun 2019 02:00:50 -0700
Subject: [PATCH 12/18] More tweaks

---
 test/as/blah.asm | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/test/as/blah.asm b/test/as/blah.asm
index ab9f039..f4dc179 100644
--- a/test/as/blah.asm
+++ b/test/as/blah.asm
@@ -1,12 +1,11 @@
 ; this is a comment (consider // as well)
-      ; this is a comment with leading whitespace!
 jmp r0
 
 label1 add r0,r1,r3
 label2 xor r4,r5,#6
-label3 and r6,r7,x1C ; with a trailing comment!
+label3 and r6,r7,x1C ; this is a trailing comment!
 
-label4  ; now we've got a macro and newline!
+label4
     .fill xA5A5
     .blkw 50
     .stringz "Hello, world!"
@@ -17,8 +16,8 @@ label               ; address is 0x46 (I think... & if program above doesn't cha
 ADD R5, R5, R5      ; 0001 1011 0100 0101   = 0x1B45
 ADD R5, R5, #-1     ; 0001 1011 0111 1111   = 0x1B7F
 
-AND reg, reg, R5    ; 0101 1011 0100 0101   = 0x5B45
-AND reg, reg, x1F   ; 0101 1011 0111 1111   = 0x5B7F
+AND R5, R5, R5      ; 0101 1011 0100 0101   = 0x5B45
+AND R5, R5, x1F     ; 0101 1011 0111 1111   = 0x5B7F
 
 BR label            ; 0000 111 000000000    =
 BRn label
@@ -27,7 +26,7 @@ BRp label
 BRnz label
 BRnp label
 BRzp label
-BRnzp label     ; same as BR (unconditional branch)
+BRnzp label
 
 JMP R5
 
@@ -53,8 +52,14 @@ STB R5, R5, label
 STW R5, R5, label
 STI R5, R5, label
 
-; expand on these (HALT, PUTS, etc...)
-TRAP x25
+TRAP x08
 
 XOR R5, R5, R5
 XOR R5, R5, x1F
+
+GETC        ; TRAP x20
+OUT         ; TRAP x21
+PUTS        ; TRAP x22
+IN          ; TRAP x23
+PUTSP       ; TRAP x24
+HALT        ; TRAP x25

From 8733798f6234c0d9b865d339fc549de70dec0480 Mon Sep 17 00:00:00 2001
From: Wes Hampson <WesleyHampson@gmail.com>
Date: Sat, 15 Jun 2019 02:23:49 -0700
Subject: [PATCH 13/18] Add \r delimiter

---
 src/as/main.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/as/main.c b/src/as/main.c
index 1bab05f..508bb27 100644
--- a/src/as/main.c
+++ b/src/as/main.c
@@ -104,7 +104,7 @@ int main(int argc, char *argv[])
     }
 
     /* output and free token list */
-    printf("ln:pos\tlen\ttype\t\ttoken\n");
+    printf(" ln:pos\tlen\ttype\t\ttoken\n");
     curr = tok_list;
     while (curr != NULL)
     {
@@ -289,6 +289,7 @@ static int is_delim(char c)
         case ';':
         case ' ':
         case '\t':
+        case '\r':
         case '\n':
         case '\0':
             return 1;

From 1be5c566ebc7eee4cdc426d59d4b93f6a33ff967 Mon Sep 17 00:00:00 2001
From: Wes Hampson <WesleyHampson@gmail.com>
Date: Sat, 15 Jun 2019 15:35:11 -0700
Subject: [PATCH 14/18] Use uppercase

---
 src/as/main.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/as/main.c b/src/as/main.c
index 508bb27..3533a41 100644
--- a/src/as/main.c
+++ b/src/as/main.c
@@ -224,7 +224,7 @@ static struct token * read_token(struct source_file *src)
         token->type = T_OPCODE;
         return token;
     }
-    switch (*tok_head)
+    switch (toupper(*tok_head))
     {
         case '.':
             token->type = T_PSEUDO_OP;
@@ -233,7 +233,6 @@ static struct token * read_token(struct source_file *src)
             token->type = T_REGISTER;
             break;
         case '#':
-        case 'x':
         case 'X':
             token->type = T_IMMEDIATE;
             break;

From 05eb0f9373921dd51fb35c2ee0066a6251a192fc Mon Sep 17 00:00:00 2001
From: Wes Hampson <WesleyHampson@gmail.com>
Date: Sat, 15 Jun 2019 15:35:23 -0700
Subject: [PATCH 15/18] Add README for assembler information

---
 src/as/README.md | 122 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 122 insertions(+)
 create mode 100644 src/as/README.md

diff --git a/src/as/README.md b/src/as/README.md
new file mode 100644
index 0000000..cb0f8ba
--- /dev/null
+++ b/src/as/README.md
@@ -0,0 +1,122 @@
+# Assembler Information
+## Opcodes
+The table below lists all opcodes and their accepted operand formats.
+| Opcode Format         | Function                  | RTL                                           |
+|-----------------------|---------------------------|-----------------------------------------------|
+| `ADD reg,reg,reg`     | Signed addition           | `reg <- reg + reg; setcc`                     |
+| `ADD reg,reg,imm`     | Signed addition           | `reg <- reg + imm; setcc`                     |
+| `AND reg,reg,reg`     | Bitwise AND               | `reg <- reg & reg; setcc`                     |
+| `AND reg,reg,imm`     | Bitwise AND               | `reg <- reg & imm; setcc`                     |
+| `BR addr`             | Branch (unconditional)    | `PC <- PC^ + addr` (same as `BRnzp`)          |
+| `BRn addr`            | Branch (negative)         | `PC <- PC^ + addr`                            |
+| `BRz addr`            | Branch (zero)             | `PC <- PC^ + addr`                            |
+| `BRp addr`            | Branch (positive)         | `PC <- PC^ + addr`                            |
+| `BRnz addr`           | Branch (negative,zero)    | `PC <- PC^ + addr`                            |
+| `BRnp addr`           | Branch (negative,positive)| `PC <- PC^ + addr`                            |
+| `BRzp addr`           | Branch (zero,positive)    | `PC <- PC^ + addr`                            |
+| `BRnzp addr`          | Branch (unconditional)    | `PC <- PC^ + addr`                            |
+| `JMP reg`             | Jump                      | `PC <- reg`                                   |
+| `JSR addr`            | Call subroutine           | `R7 <- PC^; PC <- PC^ + (addr << 1)`          |
+| `JSRR reg`            | Call subroutine           | `R7 <- PC^; PC <- reg`                        |
+| `LDB reg,reg,addr`    | Load byte                 | `reg <- mem[reg + addr]; setcc`               |
+| `LDW reg,reg,addr`    | Load word                 | `reg <- mem[reg + (addr << 1)]; setcc`        |
+| `LDI reg,reg,addr`    | Load word (indirect)      | `reg <- mem[mem[reg + (addr << 1)]]; setcc`   |
+| `LEA reg,addr`        | Load effective address    | `reg <- PC^ + (addr << 1); setcc`             |
+| `NOT reg,reg`         | Bitwise NOT               | `reg <- ~reg; setcc`                          |
+| `RET`                 | Return from subroutine    | `PC <- R7`                                    |
+| `RTI`                 | Return from interrupt     | TODO (it's quite complex)                     |
+| `LSHF reg,reg,imm`    | Left shift                | `reg <- reg << imm; setcc`                    |
+| `RSHFL reg,reg,imm`   | Right shift (logical)     | `reg <- reg >> imm; setcc`                    |
+| `RSHFA reg,reg,imm`   | Right shift (arithmetic)  | `reg <- reg >> imm; setcc`                    |
+| `STB reg,reg,addr`    | Store byte                | `mem[reg + addr] <- reg`                      |
+| `STW reg,reg,addr`    | Store word                | `mem[reg + (addr << 1)] <- reg`               |
+| `STI reg,reg,addr`    | Store word (indirect)     | `mem[mem[reg + (addr << 1)]] <- reg`          |
+| `TRAP addr`           | Call trap service routine | `R7 <- PC; PC <- mem[addr << 1]`              |
+| `XOR reg,reg,reg`     | Bitwise XOR               | `reg <- reg ^ reg; setcc`                     |
+| `XOR reg,reg,imm`     | Bitwise XOR               | `reg <- reg ^ imm; setcc`                     |
+
+Notes:
+  * For the store instructions (`STB`, `STW`, `STI`) the first operand is the
+    register to store while the second operand is the base address register.
+  * `PC^` refers to the incremented `PC` value (`PC` is incremented by 2 during
+    each fetch cycle).
+  * `setcc` means the instruction sets the condition codes (`nzp`) used for
+    conditional branches.
+
+## Instruction Format
+`LABEL: OPCODE OPERANDS ; COMMENTS`
+
+### Format Details
+`LABEL`:
+  * Memory address identifier.
+  * Alphanumeric, case-sensitive, underscore (_) allowed.
+  * 20 characters maximum.
+  * Label declaration must be terminated with a colon (:).
+  * Label declaration can exist on a line of its own or preceding opcode.
+
+`OPCODE`:
+  * Instruction mnemonic.
+  * Case-insensitive.
+  * Includes LC-3 instructions and assembler pseudo-ops.
+    * Pseudo-ops preceded by a period (.).
+
+`OPERANDS`:
+  * Instruction operands.
+  * Zero or more required depending on opcode.
+  * Must appear on same line as opcode.
+  * Operands separated by a comma (,).
+  * For multi-operand instructions, format is `dest,srcA,srcB`
+  * Integer literals can be represented in decimal or hexadecimal.
+    * Hexadecimal indicated by preceding 'x' or '0x' (case-insensitive).
+  * Operand types: register, immediate, address.
+    * Register:
+      * References a general purpose register.
+      * Specified by 'R' followed by a digit 0-7 (e.g. `R3`).
+    * Immediate:
+      * Constant value embedded into instruction.
+      * Used for arithmetic operations.
+      * Must be an integer literal.
+    * Address:
+      * References a memory location.
+      * Can appear as either integer literal or label name (case-sensitive).
+      * Register-relative, PC-relative, or absolute address embedded into
+        instruction.
+        * **Register-relative addressing** creates an absolute address by adding
+          the embedded value to the value of a general purpose register.
+        * **PC-relative addressing** creates an absolute address by adding the
+          embedded value to the current `PC` value. Note that `PC` is
+          incremented by 2 during each instruction fetch, so the `PC` value at
+          the time of address creation will point to the start of the *next*
+          instruction.
+        * **Absolute addressing uses** the value embedded in the instruction as
+          an absolute memory address. `TRAP` is the only instruction to use
+          absolute addressing.
+
+`COMMENT`:
+  * Preceded by a semicolon (;).
+  * Everything following semicolon until end-of-line ignored by the assembler.
+
+### Format Examples
+```
+START:                      ; label by itself
+BEGIN:  RET                 ; label w/ opcode, no operands
+
+        ; operand types
+        JMP R7              ; register
+        BR START            ; address (label)
+        BRnz -1             ; address (literal, dec)
+        TRAP 0x25           ; address (literal, hex)
+        NOT R0, R6          ; register & register
+        LEA R0, DATA0       ; register & address (as label)
+        LEA R1, 60          ; register & address (literal, dec)
+        LEA R2, 0x3C        ; register & address (literal, hex)
+        LDW R3, R5, DATA1   ; register & register & address (label)
+        STW R3, R5, 2       ; register & register & address (literal)
+        ADD R0, R1, R2      ; register & register & register
+        ADD R3, R4, -2      ; register & register & immediate (dec)
+        ADD R5, R6, x1E     ; register & register & immediate (hex)
+        ADD R7, R0, START   ; NOT ALLOWED! ADD does not take an address
+
+DATA0:  .FILL 0xBEEF        ; pseudo-op w/ hex operand
+DATA1:  .FILL 1337          ; pseudo-op w/ dec operand
+```

From 2a5dc280eba498919b0ada1b66189a8cfe07be97 Mon Sep 17 00:00:00 2001
From: Wes Hampson <WesleyHampson@gmail.com>
Date: Sat, 15 Jun 2019 15:38:28 -0700
Subject: [PATCH 16/18] Fix table rendering

---
 src/as/README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/as/README.md b/src/as/README.md
index cb0f8ba..ecfbe1d 100644
--- a/src/as/README.md
+++ b/src/as/README.md
@@ -1,6 +1,7 @@
 # Assembler Information
 ## Opcodes
 The table below lists all opcodes and their accepted operand formats.
+
 | Opcode Format         | Function                  | RTL                                           |
 |-----------------------|---------------------------|-----------------------------------------------|
 | `ADD reg,reg,reg`     | Signed addition           | `reg <- reg + reg; setcc`                     |

From 9aab3047a15f5b8b07514924962b908f36726a30 Mon Sep 17 00:00:00 2001
From: Wes Hampson <WesleyHampson@gmail.com>
Date: Sat, 15 Jun 2019 15:49:13 -0700
Subject: [PATCH 17/18] Re-architect tests

---
 test/as/blah.asm                             | 65 --------------------
 test/as/{factorial_reg.asm => factorial.asm} |  2 +-
 test/as/{foo.asm => halt.asm}                |  0
 test/as/tokenizer1.asm                       | 15 -----
 test/as/tokenizer_basic.asm                  | 21 +++++++
 5 files changed, 22 insertions(+), 81 deletions(-)
 delete mode 100644 test/as/blah.asm
 rename test/as/{factorial_reg.asm => factorial.asm} (96%)
 rename test/as/{foo.asm => halt.asm} (100%)
 delete mode 100644 test/as/tokenizer1.asm
 create mode 100644 test/as/tokenizer_basic.asm

diff --git a/test/as/blah.asm b/test/as/blah.asm
deleted file mode 100644
index f4dc179..0000000
--- a/test/as/blah.asm
+++ /dev/null
@@ -1,65 +0,0 @@
-; this is a comment (consider // as well)
-jmp r0
-
-label1 add r0,r1,r3
-label2 xor r4,r5,#6
-label3 and r6,r7,x1C ; this is a trailing comment!
-
-label4
-    .fill xA5A5
-    .blkw 50
-    .stringz "Hello, world!"
-
-
-label               ; address is 0x46 (I think... & if program above doesn't change)
-
-ADD R5, R5, R5      ; 0001 1011 0100 0101   = 0x1B45
-ADD R5, R5, #-1     ; 0001 1011 0111 1111   = 0x1B7F
-
-AND R5, R5, R5      ; 0101 1011 0100 0101   = 0x5B45
-AND R5, R5, x1F     ; 0101 1011 0111 1111   = 0x5B7F
-
-BR label            ; 0000 111 000000000    =
-BRn label
-BRz label
-BRp label
-BRnz label
-BRnp label
-BRzp label
-BRnzp label
-
-JMP R5
-
-JSR label
-JSRR R5
-
-LDB R5, R5, label
-LDW R5, R5, label
-LDI R5, R5, label
-
-LEA R5, label
-
-NOT R5, R5
-
-RET
-RTI
-
-LSHF R5, R5, #15
-RSHFL R5, R5, xF
-RSHFA R5, R5, R5
-
-STB R5, R5, label
-STW R5, R5, label
-STI R5, R5, label
-
-TRAP x08
-
-XOR R5, R5, R5
-XOR R5, R5, x1F
-
-GETC        ; TRAP x20
-OUT         ; TRAP x21
-PUTS        ; TRAP x22
-IN          ; TRAP x23
-PUTSP       ; TRAP x24
-HALT        ; TRAP x25
diff --git a/test/as/factorial_reg.asm b/test/as/factorial.asm
similarity index 96%
rename from test/as/factorial_reg.asm
rename to test/as/factorial.asm
index e3a85e7..98227a6 100644
--- a/test/as/factorial_reg.asm
+++ b/test/as/factorial.asm
@@ -22,7 +22,7 @@
 
 ORIGIN 4x0000
 
-SEGMENT CodeSegment:
+; SEGMENT CodeSegment:                  ; TODO: support segments?
 INIT:
     ; Load constants used throughout the program.
     LDR R1, R0, NEG_ONE
diff --git a/test/as/foo.asm b/test/as/halt.asm
similarity index 100%
rename from test/as/foo.asm
rename to test/as/halt.asm
diff --git a/test/as/tokenizer1.asm b/test/as/tokenizer1.asm
deleted file mode 100644
index 647f5d9..0000000
--- a/test/as/tokenizer1.asm
+++ /dev/null
@@ -1,15 +0,0 @@
-LABEL0
-.MACRO0
-RTI
-
-LABEL1 .MACRO1
-LABEL2 RTI
-
-; comment
-    LABEL3
-    RTI
-    .MACRO2
-
-    LABEL4      ; comment
-    RTI         ; multi-word comment
-    .MACRO3     ; comment
diff --git a/test/as/tokenizer_basic.asm b/test/as/tokenizer_basic.asm
new file mode 100644
index 0000000..c5a628a
--- /dev/null
+++ b/test/as/tokenizer_basic.asm
@@ -0,0 +1,21 @@
+START:                      ; label by itself
+BEGIN:  RET                 ; label w/ opcode, no operands
+
+        ; operand types
+        JMP R7              ; register
+        BR START            ; address (label)
+        BRnz -1             ; address (literal, dec)
+        TRAP 0x25           ; address (literal, hex)
+        NOT R0, R6          ; register & register
+        LEA R0, DATA0       ; register & address (as label)
+        LEA R1, 60          ; register & address (literal, dec)
+        LEA R2, 0x3C        ; register & address (literal, hex)
+        LDW R3, R5, DATA1   ; register & register & address (label)
+        STW R3, R5, 2       ; register & register & address (literal)
+        ADD R0, R1, R2      ; register & register & register
+        ADD R3, R4, -2      ; register & register & immediate (dec)
+        ADD R5, R6, x1E     ; register & register & immediate (hex)
+        ADD R7, R0, START   ; NOT ALLOWED! ADD does not take an address
+
+DATA0:  .FILL 0xBEEF        ; pseudo-op w/ hex operand
+DATA1:  .FILL 1337          ; pseudo-op w/ dec operand

From b54fc9ebb607f00c9fedeb347d47f8327671e66e Mon Sep 17 00:00:00 2001
From: Wes Hampson <WesleyHampson@gmail.com>
Date: Sat, 15 Jun 2019 15:50:52 -0700
Subject: [PATCH 18/18] Correct syntax

---
 test/as/factorial.asm | 14 +++++++-------
 test/as/halt.asm      |  6 +++---
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/test/as/factorial.asm b/test/as/factorial.asm
index 98227a6..b5ab795 100644
--- a/test/as/factorial.asm
+++ b/test/as/factorial.asm
@@ -20,9 +20,9 @@
 ;   * R0 contains a value of 0 upon entry.
 ;===============================================================================
 
-ORIGIN 4x0000
+.ORIGIN 0x0000
 
-; SEGMENT CodeSegment:                  ; TODO: support segments?
+; .SEGMENT CodeSegment:                  ; TODO: support segments?
 INIT:
     ; Load constants used throughout the program.
     LDR R1, R0, NEG_ONE
@@ -68,10 +68,10 @@ HALT:
 
 
 ; Data input/output
-INPUT:      DATA2   5
-RESULT:     DATA2   0
+INPUT:      .FILL   5
+RESULT:     .FILL   0
 
 ; Constants
-POS_ONE:    DATA2   1
-NEG_ONE:    DATA2  -1
-NEG_TWO:    DATA2  -2
+POS_ONE:    .FILL   1
+NEG_ONE:    .FILL  -1
+NEG_TWO:    .FILL  -2
diff --git a/test/as/halt.asm b/test/as/halt.asm
index cf3ede2..c0cb0a4 100644
--- a/test/as/halt.asm
+++ b/test/as/halt.asm
@@ -1,4 +1,4 @@
-ORIGIN 4x3000
+.ORIGIN 0x3000
 
 MAIN:
     AND     R3, R3, R3
@@ -22,5 +22,5 @@ HALT:
 _HALT_LOOP:
     BR _HALT_LOOP
 
-CLOCK_EN:   DATA2   4x8000
-MCR:        DATA2   4xFFFE
+CLOCK_EN:   .FILL   0x8000
+MCR:        .FILL   0xFFFE