From: Justin Wind <justin.wind@gmail.com>
Date: Tue, 10 Apr 2012 20:43:31 +0000 (-0700)
Subject: assembler functional now
X-Git-Url: https://git.squeep.com/?a=commitdiff_plain;h=3916e67e3326247a5f6f32e7f3b4d147bc2bef4d;p=dcpu16

assembler functional now
---

diff --git a/as-dcpu16.c b/as-dcpu16.c
index 91f63ee..38d77ce 100644
--- a/as-dcpu16.c
+++ b/as-dcpu16.c
@@ -6,14 +6,23 @@
 #include <sysexits.h>
 #include <assert.h>
 
-/* #include dcpu16.h */
-typedef unsigned short DCPU16_WORD;
+#include "as-dcpu16.h"
 
-/* quick and dirty assembler for dcpu16 */
+/*
+ *  quick and dirty assembler for dcpu16
+ *  
+ */
 
 static const char * const src_id_ = "$Id$";
 
 const char const out_filename_default_[] = "a.out";
+unsigned int verbose_ = 0;
+unsigned int dryrun_ = 0;
+
+
+#define DEBUG_NOTIFY(...) do { if (verbose_ > 2) fprintf(stderr, __VA_ARGS__); } while (0)
+#define VERBOSE_NOTIFY(...) do { if (verbose_) printf(__VA_ARGS__); } while (0)
+
 
 static
 void usage_(char *prog, unsigned int full) {
@@ -27,13 +36,16 @@ void usage_(char *prog, unsigned int full) {
         fprintf(f, "%s -- \n\n",
                 prog);
 
-    fprintf(f, "Usage: %s\n",
+    fprintf(f, "Usage: %s [-h] [-v] [-s] [-o file] file [file [...]]\n",
             prog);
 
     if (full) {
         fprintf(f, "\nOptions:\n"
                    "\t-h -- this screen\n"
-                   "\t-o <file> -- output to <file> [default: %s]\n",
+                   "\t-o <file> -- output to <file> [default: %s]\n"
+                   "\t-s -- allow short labels in instruction words\n"
+                   "\t-d -- dry run, print results, do not write to file\n"
+                   "\t-v -- verbose output\n",
                 out_filename_default_);
 
         fprintf(f, "\n%78s\n",
@@ -41,21 +53,408 @@ void usage_(char *prog, unsigned int full) {
     }
 }
 
-struct operand_ {
-    struct operand_ *next;
-    char *operand;
-};
 
-struct instruction_ {
-    struct instruction_ *next;
-    char *label;
-    char *opcode;
-    struct operand_ *operands;
+/* maintain an array of the instructions we have parsed */
+static
+struct instruction_list_ *instr_list_new(void) {
+    size_t init_size = 1024;
+    struct instruction_list_ *il = malloc(IL_SIZE(init_size));
+    if (il == NULL) {
+        fprintf(stderr, "%s():%s\n", "malloc", strerror(errno));
+        return NULL;
+    }
+    il->allocated = init_size;
+    il->entries = 0;
+    return il;
+}
+
+static
+int instr_list_insert(struct instruction_list_ **il, struct instruction_ *i) {
+    /* make room make room */
+    if ((*il)->entries - 1 == (*il)->allocated) {
+        size_t new_allocated = (*il)->allocated + 1024;
+        void *tmp_ptr = realloc(*il, IL_SIZE(new_allocated));
+        if (tmp_ptr == NULL) {
+            fprintf(stderr, "%s():%s\n", "realloc", strerror(errno));
+            return -1;
+        }
+        *il = tmp_ptr;
+        (*il)->allocated = new_allocated;
+    }
+
+    (*il)->instr[(*il)->entries] = i;
+    (*il)->entries += 1;
+    return 0;
+}
+
+/* also maintain a list of the labels we've seen, indexed back to their instructions. */
+/* FIXME: ugh, this could all stand to be rewritten cleaner */
+/* these lists could be rearranged to be a lot easier to wrangle and/or maybe use common interfaces */
+/* they were thrown together on the fly */
+static
+struct label_list_ *label_list_new(void) {
+    size_t init_size = 256;
+    struct label_list_ *ll = malloc(LL_SIZE(init_size));
+    if (ll == NULL) {
+        fprintf(stderr, "%s():%s\n", "malloc", strerror(errno));
+        return NULL;
+    }
+    ll->allocated = init_size;
+    ll->entries = 0;
+    return ll;
+}
+
+/* instr here is index into instruction list */
+static
+int label_list_insert(struct label_list_ **ll, struct instruction_ **instr) {
+    if ((*ll)->entries - 1 == (*ll)->allocated) {
+        size_t new_allocated = (*ll)->allocated + 256;
+        void *tmp_ptr = realloc(*ll,  IL_SIZE(new_allocated));
+        if (tmp_ptr == NULL) {
+            fprintf(stderr, "%s():%s\n", "realloc", strerror(errno));
+            return -1;
+        }
+        *ll = tmp_ptr;
+        (*ll)->allocated = new_allocated;
+    }
+
+    DEBUG_NOTIFY("TRACE: adding label '%s'\n", (*instr)->label);
+
+    (*ll)->label[(*ll)->entries].label = (*instr)->label;
+    (*ll)->label[(*ll)->entries].instr = instr;
+    (*ll)->entries += 1;
+    return 0;
+}
+
+/* locate the index of a labelled instruction within the instruction list */
+static
+struct instruction_ **label_list_find_instr(struct label_list_ *ll, char *label) {
+    size_t x;
+
+    for (x = 0; x < ll->entries; x++) {
+        if (strcmp(ll->label[x].label, label) == 0)
+            return ll->label[x].instr;
+    }
+    return NULL;
+}
+
+/* look up the address of a calculated address */
+static
+int label_list_find_addr(struct label_list_ *ll, char *label, DCPU16_WORD *addr) {
+    size_t x;
+
+    for (x = 0; x < ll->entries; x++) {
+        if (strcmp(ll->label[x].label, label) == 0) {
+            if (ll->label[x].ready == 1) {
+                *addr = ll->label[x].addr;
+                return 0;
+            }
+        }
+    }
+    return -1;
+}
+
+/* attempt to determine the addresses of labels */
+static
+void label_addr_calculate_(struct instruction_list_ *il, struct label_list_ *ll) {
+    size_t i;
+
+    /* walk through labels */
+    for (i = 0; i < ll->entries; i++) {
+        struct instruction_ **instr;
+        unsigned int word_count = 0;
+
+        if (ll->label[i].ready)
+            continue;
+
+        /*
+         *  walk backwards through the list of instructions
+         *  until we get to the start or a known prior label address
+         *  update our label
+         */
+        for (instr = ll->label[i].instr; instr >= il->instr; instr--) {
+
+            word_count += (*instr)->length;
+
+            if ((*instr)->label
+            &&  strcmp((*instr)->label, ll->label[i].label)) {
+                DCPU16_WORD addr;
+
+                if (label_list_find_addr(ll, (*instr)->label, &addr)) {
+                    fprintf(stderr, "internal error: incomplete prior address for '%s' while calculating '%s'\n",
+                            (*instr)->label,
+                            ll->label[i].label);
+                    continue;
+                }
+                word_count += addr;
+                break;
+            }
+        }
+        ll->label[i].addr = word_count;
+        ll->label[i].ready = 1;
+        DEBUG_NOTIFY("label '%s' has addr of 0x%04x\n", ll->label[i].label, word_count);
+    }
+}
+
+static
+void instr_free_(struct instruction_ *i) {
+    if (i->label)
+        free(i->label);
+    if (i->opcode)
+        free(i->opcode);
+    while (i->operands) {
+        struct operand_ *o = i->operands;
+
+        i->operands = o->next;
+        free(o);
+    }
+
+    free(i);
+}
+
+/* generate the nibble for a given basic opcode */
+static
+int opcode_bits_(char *opcode) {
+    static struct {
+        char op[4];
+        char value;
+    } opcodes_lower_nibble[] = {
+        { "JSR", 0x00 },
+        /* { "future nbi instruction", 0x00 }, */
+        { "SET", 0x01 },
+        { "ADD", 0x02 },
+        { "SUB", 0x03 },
+        { "MUL", 0x04 },
+        { "DIV", 0x05 },
+        { "MOD", 0x06 },
+        { "SHL", 0x07 },
+        { "SHR", 0x08 },
+        { "AND", 0x09 },
+        { "BOR", 0x0a },
+        { "XOR", 0x0b },
+        { "IFE", 0x0c },
+        { "IFN", 0x0d },
+        { "IFG", 0x0e },
+        { "IFB", 0x0f },
+        {    "", 0x00 }
+    }, *o;
+
+    for (o = opcodes_lower_nibble; o->op[0]; o++) {
+        if (strcasecmp(o->op, opcode) == 0)
+            break;
+    }
+
+    if (o->op[0] == '\0') {
+        fprintf(stderr, "unknown instruction '%s'\n", opcode);
+        return -1;
+    }
+
+    return o->value;
+}
+
+/* generate the six bits for a given nbi opcode (aka first operand to opcode 0x00) */
+static
+int nbi_opcode_bits_(char *nbi_opcode) {
+    static struct {
+        char op[4];
+        char value;
+    } nbi_opcodes_bits[] = {
+        { "   ", 0x00 }, /* reserved for future */
+        { "JSR", 0x01 },
+        { "", 0x00 }
+    }, *o;
+
+    for (o = nbi_opcodes_bits; o->op[0]; o++) {
+        if (strcasecmp(o->op, nbi_opcode) == 0)
+            break;
+    }
+
+    if (o->op[0] == '\0') {
+        fprintf(stderr, "unknown nbi instruction '%s'\n", o->op);
+        return -1;
+    }
+
+    return o->value;
+}
+
+/* convert register character like 'x' to value like 0x03 */
+static inline
+unsigned int register_enumerate_(char r) {
+    const char regs[] = "AaBbCcXxYyZzIiJj";
+    const char *x = strchr(regs, r);
+
+    if (x)
+        return (x - regs)/2;
 
-    unsigned int length; /* words */
-    DCPU16_WORD instr_words[];
-};
+    fprintf(stderr, "internal error, unknown register character 0x%02x\n", r);
+    return -1;
+}
+
+/* generate the six bits for a given operand */
+/* FIXME: MAEK BETTR */
+/* notes: nextword may be rewritten even if it's not used in final instruction */
+static
+int value_bits_(struct label_list_ *ll, char *operand_orig, DCPU16_WORD *nextword, unsigned int *nextwordused, unsigned int allow_short_labels) {
+    unsigned int retval = -1;
+    unsigned long l;
+    char *operand, *o, *ep;
 
+    operand = o = strdup(operand_orig);
+
+    DEBUG_NOTIFY("TRACE: operand '%s' is ", operand);
+
+    if (strlen(operand) == 1) {
+        if ( (strchr("ABCXYZIJ", *operand))
+        ||   (strchr("abcxyzij", *operand)) ) {
+            DEBUG_NOTIFY("register\n");
+            retval = register_enumerate_(*operand);
+            goto done;
+        }
+    }
+
+    if (operand[0] == '[' && operand[strlen(operand) - 1] == ']') {
+        operand[strlen(operand) - 1] = '\0';
+        operand++;
+        /* trim whitespaces */
+        while (strchr(" \t\n", *operand)) operand++;
+        ep = operand + strlen(operand) - 1;
+
+        if (strlen(operand) == 1) {
+            DEBUG_NOTIFY("dereferenced register\n");
+            retval = 0x08 | register_enumerate_(*operand);
+            goto done;
+        }
+
+        if ( (ep = strchr(operand, '+')) ) {
+            char reg;
+            char *constant;
+
+            while (strchr("+ \t\n", *ep)) {
+                *ep = '\0';
+                ep++;
+            }
+            if (strlen(ep) == 1) {
+                reg = *ep;
+                constant = operand;
+            } else if (strlen(operand) == 1) {
+                reg = *operand;
+                constant = ep;
+            } else {
+                fprintf(stderr, "couldn't parse operand\n");
+                goto done;
+            }
+
+            if ( strchr("ABCXYZIJ", reg)
+            ||   strchr("abcxyzij", reg) ) {
+                l = strtoul(constant, &ep, 0);
+            }
+
+            DEBUG_NOTIFY("dereferenced register+constant\n");
+
+            DEBUG_NOTIFY("\tregister_index:%u %c\n", reg, register_enumerate_(reg));
+            DEBUG_NOTIFY("\tconstant:%lu\n", l);
+
+            *nextword = l & 0xffff;
+            *nextwordused += 1;
+            retval = 0x10 | register_enumerate_(reg);
+            goto done;
+        }
+
+        l = strtoul(operand, &ep, 0);
+        DEBUG_NOTIFY("dereferenced literal value %lu...\n", l);
+        *nextword = l & 0xffff;
+        *nextwordused += 1;
+        retval = 0x1e;
+        goto done;
+    }
+
+    if (strcasecmp(operand, "POP") == 0) {
+        DEBUG_NOTIFY("POP\n");
+        retval = 0x18;
+        goto done;
+    }
+    if (strcasecmp(operand, "PUSH") == 0) {
+        DEBUG_NOTIFY("PUSH\n");
+        retval = 0x19;
+        goto done;
+    }
+    if (strcasecmp(operand, "PEEK") == 0) {
+        DEBUG_NOTIFY("PEEK\n");
+        retval = 0x1a;
+        goto done;
+    }
+    if (strcasecmp(operand, "SP") == 0) {
+        DEBUG_NOTIFY("sp register\n");
+        retval = 0x1b;
+        goto done;
+    }
+    if (strcasecmp(operand, "PC") == 0) {
+        DEBUG_NOTIFY("pc register\n");
+        retval = 0x1c;
+        goto done;
+    }
+    if (strcasecmp(operand, "O") == 0) {
+        DEBUG_NOTIFY("o register\n");
+        retval = 0x1d;
+        goto done;
+    }
+
+    l = strtoul(operand, &ep, 0);
+
+    if (operand && *ep == '\0') {
+        DEBUG_NOTIFY("literal value %lu...\n", l);
+        if (l < 0x20) {
+            retval = l + 0x20;
+            goto done;
+        } else {
+            *nextword = l & 0xffff;
+            *nextwordused += 1;
+            retval = 0x1f;
+            goto done;
+        }
+    }
+
+    /* try to populate nextword with label address */
+    if (label_list_find_addr(ll, operand, nextword)) {
+        DEBUG_NOTIFY("currently-unknown label...\n");
+        /* assume non-small literal value */
+        *nextwordused += 1;
+        goto done;
+    }
+
+    DEBUG_NOTIFY("label '%s' 0x%02hx\n", operand, *nextword);
+    if (*nextword < 0x20 && allow_short_labels) {
+        DEBUG_NOTIFY("small value label win\n");
+        retval = (0x20 + *nextword) & 0x3f;
+        goto done;
+    }
+
+    retval = 0x1f;
+    *nextwordused += 1;
+
+done:
+    free(o);
+    return retval;
+}
+
+static inline
+int instruction_print_(struct instruction_ *i, unsigned int with_label) {
+    struct operand_ *o;
+    int r;
+
+    if (with_label)
+        r = printf("%-16s %3s", i->label ? i->label : "", i->opcode);
+    else
+        r = printf("%3s", i->opcode);
+
+    for (o = i->operands; o; o = o->next)
+        r += printf(" %s%s", o->operand, o->next ? "," : "");
+
+    return r;
+}
+
+/* parse an instruction out of buf, create new instruction struct if seemingly valid */
+/* does not actually check if instruction is valid yet */
 /* buf must be 0-terminated */
 static
 int buf_tokenize_(char *buf, struct instruction_ **next_instr) {
@@ -79,7 +478,15 @@ int buf_tokenize_(char *buf, struct instruction_ **next_instr) {
         *x = '\0';
     /* kill leading whitespace */
     buf += strspn(buf, " \t\n");
-    /* kill trailing newlines */
+    /* kill trailing whitespace */
+    if (*buf) {
+        x = buf + strlen(buf);
+        while (strchr(" \t\n", *x)) {
+            *x = '\0';
+            x--;
+        }
+    }
+
     if ((x = strrchr(buf, '\n')) != NULL)
         *x = '\0';
 
@@ -90,31 +497,68 @@ int buf_tokenize_(char *buf, struct instruction_ **next_instr) {
     if (x == NULL)
         return 0;
 
+#ifdef OTHER_LABELS
     /* labels end with :, otherwise its an opcode */
-    if ((y = strrchr(x, ':')) != NULL) {
+    y = x + strlen(x) - 1;
+    if (*y == ':') {
         *y = '\0';
         label = x;
         opcode = strtok_r(NULL, sep, &st);
+    }
+#else /* OTHER_LABELS */
+    /* labels.. begin? with ':' ? okay, I guess. Whatever. */
+    /* otherwise, it's an opcode */
+    if (*x == ':') {
+        label = x + 1;
+        opcode = strtok_r(NULL, sep, &st);
     } else {
         label = NULL;
         opcode = x;
     }
+#endif /* OTHER_LABELS */
 
     if (opcode) {
         operand = st;
     }
 
-    instr = calloc(1, sizeof *instr);
+    /* extra room for assembled words */
+    instr = calloc(1, 3 + sizeof *instr);
     if (instr == NULL) {
-        fprintf(stderr, "%s():%s\n", "malloc", strerror(errno));
+        fprintf(stderr, "%s():%s\n", "calloc", strerror(errno));
         return -1;
     }
 
-    instr->label = label;
-    instr->opcode = opcode;
+    instr->label = label ? strdup(label) : NULL;
+    instr->opcode = opcode ? strdup(opcode) : NULL;
 
     if (operand) {
-        
+        struct operand_ **o_next = &instr->operands;
+
+        for (x = strtok_r(operand, ",", &st);
+             x;
+             x = strtok_r(NULL, ",", &st) ) {
+            *o_next = malloc(3 + sizeof **o_next); /* FIXME: handle this on the fly later */
+
+            if (*o_next == NULL) {
+                fprintf(stderr, "%s():%s\n", "calloc", strerror(errno));
+                instr_free_(instr);
+                return -1;
+            }
+
+            /* trim */
+            x += strspn(x, " \t\n");
+            if (*x) {
+                y = x + strlen(x) - 1;
+                while (strchr(" \t\n", *y)) {
+                    *y = '\0';
+                    y--;
+                }
+            }
+
+            (*o_next)->operand = strdup(x);
+            (*o_next)->next = NULL;
+            o_next = &((*o_next)->next);
+        }
     }
 
     *next_instr = instr;
@@ -122,10 +566,99 @@ int buf_tokenize_(char *buf, struct instruction_ **next_instr) {
     return 0;
 }
 
+/* try to generate bytecode for an instruction */
+static
+void instr_bytecodify_(struct label_list_ *ll, struct instruction_ *i, unsigned int allow_short_labels) {
+    unsigned int nwu = 0; /* number of words used */
+    unsigned int incomplete = 0;
+    int bits;
+    struct operand_ *o = i->operands;
+
+    DEBUG_NOTIFY("TRACE: codifying %s%s'%s'...", i->label ? i->label : "", i->label ? ":" : "", i->opcode);
+
+    if (i->ready) {
+        /* already codified */
+        return;
+    }
+
+    /* special case DAT */
+    if (strncasecmp(i->opcode, "DAT", 3) == 0) {
+        /* just dump operands into words, I guess */
+        fprintf(stderr, "FIXME unhandled raw data\n");
+        /* count total length of data.. */
+        /* realloc instruction */
+        /* populate words */
+        return;
+    }
+
+    /* start with opcode bits */
+    bits = opcode_bits_(i->opcode);
+    if (bits < 0) {
+        fprintf(stderr, "unrecognized instruction '%s'\n", i->opcode);
+        return;
+    }
+    i->instr_words[0] |= 0x0f & bits;
+
+    /* in rendered bytecode, all instructions have two operands; nbi instructions take 'first operand' bits. */
+    if ((bits & 0x0f) == 0) {
+        bits = nbi_opcode_bits_(i->opcode);
+        if (bits < 0) {
+            fprintf(stderr, "internal error: missing instruction in nbi opcode table\n");
+            return;
+        }
+    } else {
+        if (o == NULL) {
+            fprintf(stderr, "'%s' requires more operands\n", i->opcode);
+            return;
+        }
+        bits = value_bits_(ll, o->operand, i->instr_words + 1, &nwu, allow_short_labels);
+        if (bits < 0) {
+            DEBUG_NOTIFY("TRACE: unresolved label\n");
+            /* keep going, but don't finalize until we can calculate label address */
+            incomplete = 1;
+            bits = 0;
+        }
+        o = o->next;
+    }
+    i->instr_words[0] |= (bits & 0x3f) << 4;
+
+    if (o == NULL) {
+        fprintf(stderr, "'%s' requires more operands\n", i->opcode);
+        return;
+    }
+
+    bits = value_bits_(ll, o->operand, i->instr_words + nwu + 1, &nwu, allow_short_labels);
+    if (bits < 0) {
+        DEBUG_NOTIFY("TRACE: unresolved label\n");
+        /* keep going, but don't finalize until we can calculate label address */
+        incomplete = 1;
+        bits = 0;
+    }
+    o = o->next;
+    i->instr_words[0] |= (bits & 0x3f) << 10;
+
+    /* counting labels as words, we now know the maximum instruction length */
+    /* if label is < 0x20, it can take up less space */
+
+    i->length = nwu + 1;
+
+    DEBUG_NOTIFY("instruction words: [%u]", i->length);
+    for (bits = 0; bits <= (int)nwu; bits++)
+        DEBUG_NOTIFY(" 0x%04x", i->instr_words[bits]);
+
+    if (incomplete) {
+        DEBUG_NOTIFY(" (preliminary)");
+    } else {
+        i->ready = 1;
+    }
+
+    DEBUG_NOTIFY("\n");
+}
+
 /* thish should grow buffer to fit huge linesh, but I jusht don't care right now, hic */
 static
-int parse_stream_(FILE *f) {
-    struct instruction_ *instr;
+int parse_stream_(FILE *f, struct instruction_list_ **il, struct label_list_ **ll, unsigned int allow_short_labels) {
+    struct instruction_ *instr, **instr_list_entry;
     char buf[(1<<14)];
 
     buf[sizeof buf - 1] = '\0';
@@ -142,19 +675,24 @@ int parse_stream_(FILE *f) {
         }
 
         if (instr) {
-            struct operand_ *o;
+            /* add to list of instructions */
+            if (instr_list_insert(il, instr)) {
+                fprintf(stderr, "could not populate instruction list\n");
+            }
+            instr_list_entry = (*il)->instr + (*il)->entries - 1;
+            DEBUG_NOTIFY("TRACE: verify %s == %s\n", (*instr_list_entry)->opcode, instr->opcode);
             if (instr->label) {
-                printf("TRACE: new label '%s'\n", instr->label);
+                if (label_list_find_instr(*ll, instr->label)) {
+                    fprintf(stderr, "duplicate label\n");
+                    break;
+                }
+                if (label_list_insert(ll, instr_list_entry)) {
+                    fprintf(stderr, "could not populate label list\n");
+                }
+                label_addr_calculate_(*il, *ll);
             }
-            printf("TRACE: tokenized opcode:%s operands:",
-                   instr->opcode);
-           for (o = instr->operands; o; o = o->next) {
-               printf("%s%s", o->operand, o->next ? ", " : "");
-           }
-           printf("\n");
-
 
-            /* add to queue of instructions */
+            instr_bytecodify_(*ll, instr, allow_short_labels);
         }
     }
     if (ferror(f)) {
@@ -169,12 +707,100 @@ int parse_stream_(FILE *f) {
     return 0;
 }
 
+static
+int assemble_check_(struct instruction_list_ *il, struct label_list_ *ll, unsigned int allow_short_labels) {
+    int retval = 0;
+    size_t x;
+
+    DEBUG_NOTIFY(" final pass of codifier...\n");
+    for (x = 0; x < il->entries; x++) {
+        instr_bytecodify_(ll, il->instr[x], allow_short_labels);
+    }
+
+    VERBOSE_NOTIFY("%3s %6s %-32s %-4s\n", "", "_addr_", "_label_", "_instruction_");
+    for (x = 0; x < ll->entries; x++) {
+        if (! ll->label[x].ready)
+            retval |= -1;
+        VERBOSE_NOTIFY("%3s0x%04x  %-32s ",
+                       ll->label[x].ready ? "" : "*",
+                       ll->label[x].addr,
+                       ll->label[x].label);
+        if (verbose_) {
+            instruction_print_(*(ll->label[x].instr), 0);
+            printf("\n");
+        }
+    }
+
+    VERBOSE_NOTIFY("\n");
+
+    if (retval)
+        fprintf(stderr, "some labels could not be resolved\n");
+
+    return retval;
+}
+
+static
+int output_(struct instruction_list_ *il, const char *filename) {
+    FILE *of = NULL;
+    struct instruction_ *instr;
+    size_t i, r, total_words = 0;
+    size_t x;
+
+    if (! dryrun_) {
+        of = fopen(filename, "w");
+        if (of == NULL) {
+            fprintf(stderr, "%s('%s'):%s\n", "fopen", filename, strerror(errno));
+            return -1;
+        }
+    }
+
+    for (i = 0; i < il->entries; i++) {
+        instr = il->instr[i];
+
+        if (verbose_) {
+            int s;
+            s = instruction_print_(instr, 1);
+            printf("%*s;", (44 - s) > 0 ? (44 - s) : 0, "");
+            for (x = 0; x < instr->length; x++) {
+                printf(" %04x", instr->instr_words[x]);
+            }
+            printf("\n");
+        }
+
+        if (of) {
+            r = fwrite(instr->instr_words, sizeof(DCPU16_WORD), instr->length, of);
+            if (r < instr->length) {
+                fprintf(stderr, "%s():%s\n", "fwrite", strerror(errno));
+                return -1;
+            }
+        }
+        total_words += instr->length;
+    }
+
+    fprintf(stderr, "wrote 0x%04zx instructions as 0x%04zx words\n",
+            i,
+            total_words);
+    return 0;
+}
+
+static struct instruction_list_ *il_;
+static struct label_list_ *ll_;
+
 int main(int argc, char *argv[]) {
     const char *out_filename = NULL;
+    unsigned int allow_short_labels = 0;
     int c;
 
-    while ( (c = getopt(argc, argv, "ho:")) != EOF ) {
+    while ( (c = getopt(argc, argv, "dhsvo:")) != EOF ) {
         switch (c) {
+            case 'd':
+                dryrun_++;
+                break;
+
+            case 's':
+                allow_short_labels++;
+                break;
+
             case 'o':
                 if (out_filename) {
                     fprintf(stderr, "Sorry, I can only write one file at a time.\n");
@@ -183,6 +809,10 @@ int main(int argc, char *argv[]) {
                 out_filename = optarg;
                 break;
 
+            case 'v':
+                verbose_++;
+                break;
+
             case 'h':
                 usage_(argv[0], 1);
                 exit(EX_OK);
@@ -193,27 +823,47 @@ int main(int argc, char *argv[]) {
         }
     }
 
+    argc -= optind;
+    argv += optind;
+
     if (out_filename == NULL)
         out_filename = out_filename_default_;
 
+    /* init tables */
+    il_ = instr_list_new();
+    ll_ = label_list_new();
+
     /* if filenames were specified, parse them instead of stdin */
-    if (argc - optind) {
-        while (argc - optind) {
-            FILE *f = fopen(argv[argc - optind], "r");
+    if (argc) {
+        while (argc) {
+            char *filename = *argv;
+            FILE *f = fopen(filename, "r");
+
+            argc--, argv++;
+
             if (f == NULL) {
-                fprintf(stderr, "%s('%s'):%s\n", "fopen", argv[argc - optind], strerror(errno));
-                optind++;
+                fprintf(stderr, "%s('%s'):%s\n", "fopen", filename, strerror(errno));
                 continue;
             }
 
-            parse_stream_(f);
+            VERBOSE_NOTIFY("assembling '%s'...\n", filename);
+            parse_stream_(f, &il_, &ll_, allow_short_labels);
 
             fclose(f);
-
-            optind++;
         }
     } else {
-        parse_stream_(stdin);
+        VERBOSE_NOTIFY("assembling '%s'...\n", "stdin");
+        parse_stream_(stdin, &il_, &ll_, allow_short_labels);
+    }
+
+    if (assemble_check_(il_, ll_, allow_short_labels)) {
+        fprintf(stderr, "errors prevented assembly\n");
+        exit(EX_DATAERR);
+    }
+
+    if (output_(il_, out_filename)) {
+        fprintf(stderr, "failed to create output\n");
+        exit(EX_OSERR);
     }
 
     exit(EX_OK);