began support for DAT assembler directive

[dcpu16] / as-dcpu16.c

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sysexits.h>
#include <assert.h>

#include "dcpu16.h"
#include "common.h"

/*
 *  quick and dirty assembler for dcpu16
 *  
 *  Justin Wind <justin.wind@gmail.com>
 *    2012 04 07 - implementation started
 *    2012 04 10 - functional
 *    2012 04 16 - support dat statements
 *
 *  TODO
 *    needs ability to specify location for code or data
 *    short labels not correctly computed
 */

static const char * const src_id_ = "$Id$";

const char const out_filename_default_[] = "a.out";

/* global invocation options */
struct options {
    unsigned int verbose;
    unsigned int dryrun;
} opt_ = {
    .verbose = 0,
    .dryrun = 0,
};

#define DEBUG_PRINTF(...) do { if (opt_.verbose > 2) { printf("DEBUG: "); printf(__VA_ARGS__); } } while (0)
#define DEBUG_PRINTFQ(...) do { if (opt_.verbose > 2) printf(__VA_ARGS__); } while (0)
#define VERBOSE_PRINTF(...) do { if (opt_.verbose) printf(__VA_ARGS__); } while (0)

static
void usage_(char *prog, unsigned int full) {
    FILE *f = full ? stdout : stderr;
    char *x = strrchr(prog, '/');

    if (x && *(x + 1))
        prog = x + 1;

    if (full)
        fprintf(f, "%s -- \n\n",
                prog);

    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-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",
                src_id_);
    }
}


/* instructions have operands */
struct operand_ {
    struct operand_ *next;
    char *operand; /* tokenized operand text */
};

/* keep an array of instructions as we read them in */
struct instruction_ {
    char *label;  /* set if a label points here */
    char *opcode; /* tokenized instruction text */
    struct operand_ *operands;  /* list of operands */
    unsigned int ready : 1; /* bytecode computed? */
    unsigned int length; /* number of words of bytecode */
    DCPU16_WORD instr_words[];
};

/* keep an array of labels, indexed back to their instruction locations */
struct label_ {
    char *label; /* name of label */
    struct instruction_ **instr; /* pointer into array of instructions */
    unsigned int ready : 1; /* do we know where this label is yet? */
    DCPU16_WORD addr;
};


/* locate and return the label entry matching name */
static
struct label_ *label_find_(struct dynamic_array *labels, char *name) {
    size_t x;

    for (x = 0; x < labels->entries; x++) {
        struct label_ *l = (struct label_ *)DYNARRAY_ITEM(*labels, x);
        if (strcmp(l->label, name) == 0)
            return l;
    }
    return NULL;
}


/* if a label has a validly-calculated address, fetch it */
static
int label_addr_(struct dynamic_array *labels, char *name, DCPU16_WORD *addr) {
    struct label_ *l;

    if ( (l = label_find_(labels, name)) == NULL )
        return -1;
    if (! l->ready)
        return -2;
    *addr = l->addr;
    return 0;
}


/* attempt to determine the addresses of all labels */
static
void label_addr_calculate_(struct dynamic_array *instructionps, struct dynamic_array *labels) {
    size_t i;

    /* for each label.. */
    for (i = 0; i < labels->entries; i++) {
        struct label_ *l;
        struct instruction_ **instr;
        unsigned int word_count = 0;

        l = (struct label_ *)DYNARRAY_ITEM(*labels, i);

        /* if it's already calculated, great. */
        if (l->ready)
            continue;

        /*
         *  starting at the instruction for this label,
         *  walk backwards through the list of instructions
         *  until we get to the start or a known prior label address.
         *  update our label with the freshly calculated addr
         */
        for (instr = ((struct label_ *)DYNARRAY_ITEM(*labels, i))->instr;
             instr >= (struct instruction_ **)DYNARRAY_ITEM(*instructionps, 0);
             instr--) {

            if ((*instr)->ready)
                DEBUG_PRINTF("%s: instr not ready\n", __func__);
            word_count += (*instr)->length;

            /* have we come across an instruction which a label points to?
               it should already be calculated, so just add that on and be done */
            if ((*instr)->label
            &&  strcmp((*instr)->label, l->label)) {
                DCPU16_WORD addr;

                if (label_addr_(labels, (*instr)->label, &addr)) {
                    fprintf(stderr, "internal error: incomplete prior address for '%s' while calculating '%s'\n",
                            (*instr)->label,
                            l->label);
                    continue;
                }

                word_count += addr;
                break;
            }
        }
        l->addr = word_count;
        l->ready = 1;
        DEBUG_PRINTF("label '%s' now has addr of 0x%04x\n", l->label, word_count);
    }
}


/* 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;

    fprintf(stderr, "internal error, unknown register character 0x%02x\n", r);
    return -1;
}

/* removes all occurences of chars from buf */
static inline
void buf_strip_chars_(char *buf, char *chars) {
    char *s, *d;

    for (s = d = buf; *s; s++, d++) {
        while (*s && strchr(chars, *s)) {
            s++;
        }
        if (!*s)
            break;
        *d = *s;
    }
    *d = *s;
}


/*  value_bits_
 *  generate the six bits for a given operand string
 *  returns -1 if it could not parse the operand
 *  returns -2 if it could not parse the operand due to an unresolved label
 *  notes: nextword may be overwritten even if it's not used in final instruction
 */
static
int value_bits_(struct dynamic_array *labels, const char *operand_orig, DCPU16_WORD *nextword, unsigned int *nextwordused, unsigned int allow_short_labels) {
    static char *operand = NULL;
    static size_t operand_sz = 0;

    unsigned long l;
    char *o, *ep;

    /*
        Our operand working buffer shouldn't ever need to be too big,
        but DAT might blow that assumption.
    */
    if (operand_sz <= strlen(operand_orig)) {
        void *tmp_ptr;
        size_t new_sz = strlen(operand_orig);

        if (new_sz < 256)
            new_sz = 256;
        new_sz += 256;

        DEBUG_PRINTF("%s: allocating buffer of size %zu\n", __func__, new_sz);
        tmp_ptr = realloc(operand, new_sz);
        if (tmp_ptr == NULL) {
            fprintf(stderr, "%s(%zu):%s\n", "realloc", new_sz, strerror(errno));
            return -1;
        }
        operand = tmp_ptr;
        operand_sz = new_sz;
    }

    o = strcpy(operand, operand_orig);

    DEBUG_PRINTF("%s: operand '%s' ", __func__, operand); /* completed later */

    /* this is a very stupid parser */

    /* first, let's trim all whitespace out of string at once to make parsing easier */
    buf_strip_chars_(operand, " \t\n");

    /* single character might match a register */
    if (strlen(operand) == 1
    &&  strchr("AaBbCcXxYyZzIiJj", *operand)) {
            DEBUG_PRINTFQ("is register %c\n", *operand);
            return register_enumerate_(*operand);
    }

    /* easy matches */
    if (strcasecmp(operand, "POP") == 0) {
        DEBUG_PRINTFQ("is POP\n");
        return 0x18;
    }
    if (strcasecmp(operand, "PUSH") == 0) {
        DEBUG_PRINTFQ("is PUSH\n");
        return 0x19;
    }
    if (strcasecmp(operand, "PEEK") == 0) {
        DEBUG_PRINTFQ("is PEEK\n");
        return 0x1a;
    }
    if (strcasecmp(operand, "SP") == 0) {
        DEBUG_PRINTFQ("is register SP\n");
        return 0x1b;
    }
    if (strcasecmp(operand, "PC") == 0) {
        DEBUG_PRINTFQ("is register PC\n");
        return 0x1c;
    }
    if (strcasecmp(operand, "O") == 0) {
        DEBUG_PRINTFQ("is register O\n");
        return 0x1d;
    }

    /* is the operand [bracketed]? */
    if (operand[0] == '[' && operand[strlen(operand) - 1] == ']') {
        /* eat the brackets */
        operand[strlen(operand) - 1] = '\0';
        operand++;

        /* is it [register]? */
        if (strlen(operand) == 1
        &&  strchr("AaBbCcXxYyZzIiJj", *operand)) {
            DEBUG_PRINTFQ("is dereferenced register %c\n", *operand);
            return 0x08 | register_enumerate_(*operand);
        }

        /* is it [register+something]? */
        if ( (ep = strchr(operand, '+')) ) {
            char *reg;
            char *constant;

            /* eat the plus */
            *ep = '\0';
            ep++;

            /* figure out which one is which */
            if (strlen(ep) == 1
            &&  strchr("AaBbCcXxYyZzIiJj", *ep)) {
                reg = ep;
                constant = operand;
            } else if (strlen(operand) == 1
            &&         strchr("AaBbCcXxYyZzIiJj", *operand) ) {
                reg = operand;
                constant = ep;
            } else {
                DEBUG_PRINTFQ("is unparsable\n");
                fprintf(stderr, "couldn't parse operand '%s'\n", operand_orig);
                return -1;
            }

            /* check if something is understandable as a value */
            errno = 0;
            l = strtoul(constant, &ep, 0);
            if (errno == 0
            &&  (*constant && (*ep == '\0')) ) {
                /* string conversion went without issue */
                /* validate it will fit in a word */
                if (l > 0xffff) {
                    DEBUG_PRINTFQ("is out of range\n");
                    fprintf(stderr, "constant invalid in operand '%s'\n", operand_orig);
                    return -1;
                }

                /* seems fine */
                *nextword = l & 0xffff;
                *nextwordused += 1;
                DEBUG_PRINTFQ("is a dereferenced register (%c) + constant (%hu)\n", *reg, *nextword);
                return 0x10 | register_enumerate_(*reg);
            } else if (errno) {
                DEBUG_PRINTFQ("is out of range\n");
                fprintf(stderr, "trouble with operand '%s': %s\n", operand_orig, strerror(errno));
                return -1;
            }

            /* what? still here? assume it's a label, I guess */
            /* try to populate nextword with label address */
            if (label_addr_(labels, operand, nextword)) {
                DEBUG_PRINTFQ("(deferred label resolution)\n");
                *nextwordused += 1;
                return -2;
            }
            DEBUG_PRINTFQ("is a dereferenced register (%c) + label\n", *reg);
            *nextwordused += 1;
            return 0x10 | register_enumerate_(*reg);
        }

        /* it must just be a dereferenced literal then */

        errno = 0;
        l = strtoul(operand, &ep, 0);
        if (errno == 0
        && (*operand && (*ep == '\0')) ) {
            /* string conversion went without issue */
            /* validate it will fit in a word */
            if (l > 0xffff) {
                DEBUG_PRINTFQ("is out of range\n");
                fprintf(stderr, "constant invalid in operand '%s'\n", operand_orig);
                return -1;
            }

            DEBUG_PRINTFQ("is a dereferenced literal value (%hu)\n", *nextword);
            *nextword = l & 0xffff;
            *nextwordused += 1;
            return 0x1e;
        } else if (errno) {
            DEBUG_PRINTFQ("is out of range\n");
            fprintf(stderr, "trouble with operand '%s': %s\n", operand_orig, strerror(errno));
        }

        /* not a number? try a label */
        if (label_addr_(labels, operand, nextword)) {
            DEBUG_PRINTFQ("(deferred label resolution)\n");
            *nextwordused += 1;
            return -2;
        }
        DEBUG_PRINTFQ("is a dereferenced label\n");
        *nextwordused += 1;
        return 0x1e;
    }

    /* left with a literal or a label, then */

    errno = 0;
    l = strtoul(operand, &ep, 0);
    if (errno == 0
    || (*operand && (*ep == '\0')) ) {
        if (l > 0xffff) {
            DEBUG_PRINTFQ("is out of range\n");
            fprintf(stderr, "constant invalid in operand '%s'\n", operand_orig);
            return -1;
        }

        DEBUG_PRINTFQ("is literal value (%lu)\n", l);
        if (l < 0x20) {
            return l + 0x20;
        }

        *nextword = l & 0xffff;
        *nextwordused += 1;
        return 0x1f;
    }

    /* try to populate nextword with label address */
    if (label_addr_(labels, operand, nextword)) {
        DEBUG_PRINTFQ("(deferred label resolution)\n");
        /* assume non-small literal value */
        *nextwordused += 1;
        return -2;
    }

    DEBUG_PRINTFQ("is label '%s' (0x%02hx)\n", operand, *nextword);
    if (*nextword < 0x20 && allow_short_labels) {
        DEBUG_PRINTF("small value label win\n");
        return (0x20 + *nextword) & 0x3f;
    }

    *nextwordused += 1;
    return 0x1f;
}

/* prints an instruction's assembly */
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;
}

/*  buf_tokenize_
 *  Parses the zero-terminated line of input 'buf' into a newly-allocated struct instruction_.
 *  [label] opcode [operand[,operand[,...]]]
 *  Does not yet validate if labels, opcodes, or operands are valid...
 */
static
int buf_tokenize_(char *buf, struct instruction_ **next_instr) {
    const char const *sep = " \t\n";
    const char const *quot = "'`\"";
    struct instruction_ *instr = NULL;
    struct operand_ *operand_list = NULL;
    char *label = NULL,
         *opcode = NULL,
         *operand = NULL;
    char *x,
         *y,
         *st, *qt;
    size_t instr_words_needed = 1;

    assert(buf != NULL);
    assert(next_instr != NULL);

    *next_instr = NULL;

    /* kill leading whitespace */
    buf += strspn(buf, " \t\n");

    /* kill trailing whitespace */
    for (x = buf + strlen(buf); *x && strchr(sep, *x); x--)
        *x = '\0';

    /* split on first non-quoted ';', ignore following comment */
    x = strqtok_r(buf, ";", '\\', quot, &qt, &st);
    if (x == NULL)
        return 0;
    if (qt) {
        fprintf(stderr, "unmatched %c-quote\n", *qt);
        return -1;
    }

    /* determine if first token is label, opcode, or we just have a blank line to ignore */
    x = strqtok_r(x, sep, '\\', quot, &qt, &st);
    if (x == NULL)
        return 0;
    if (qt) {
        fprintf(stderr, "unmatched %c-quote\n", *qt);
        return -1;
    }

/* I want c-style labels in my asm, but example in spec uses : in prefix rather than postfix */
#ifdef NON_SPEC_LABELS
    /* labels end with :, otherwise its an opcode */
    y = x + strlen(x) - 1;
    if (*y == ':') {
        *y = '\0';
        label = x;
        opcode = strqtok_r(NULL, sep, '\\', quot, &qt, &st);
    } else {
        label = NULL;
        opcode = x;
    }
#else /* NON_SPEC_LABELS */
    /* labels.. begin? with ':' ? okay, I guess. Whatever. */
    /* otherwise, it's an opcode */
    if (*x == ':') {
        label = x + 1;
        opcode = strqtok_r(NULL, sep, '\\', quot, &qt, &st);
    } else {
        label = NULL;
        opcode = x;
    }
#endif /* NON_SPEC_LABELS */

    if (opcode) {
        operand = st;
    }

    /*
        While normal instructions just have comma-separated operands,
        DAT can be followed by comma-separated list of:
            label, to be resolved to address
            value, like 0xffff
            string, "quoted", characters to be rendered into low-byte of words
    */

    if (operand) {
        struct operand_ **o_next = &operand_list;

        for (x = strqtok_r(operand, ",", '\\', quot, &qt, &st);
             x;
             x = strqtok_r(NULL, ",", '\\', quot, &qt, &st) ) {

            /* trim leading whitespace */
            x += strspn(x, " \t\n");
            if (*x == '\0') {
                fprintf(stderr, "encountered empty operand\n");
                return -1;
            }

            /* trim trailing whitespace */
            y = x + strlen(x) - 1;
            while (strchr(" \t\n", *y)) {
                *y = '\0';
                y--;
            }

            /* new operand to append to list */
            *o_next = malloc(sizeof **o_next);
            if (*o_next == NULL) {
                fprintf(stderr, "%s():%s\n", "calloc", strerror(errno));
                return -1;
            }

            /* assume an operand uses one word, unless it's a string */
            instr_words_needed += (*x == '"') ? strlen(x) : 1;

            (*o_next)->operand = strdup(x);
            if ((*o_next)->operand == NULL) {
                fprintf(stderr, "%s():%s\n", "strdup", strerror(errno));
                return -1;
            }
            (*o_next)->next = NULL;
            o_next = &((*o_next)->next);
        }
    }

    DEBUG_PRINTF("allocating instr with room for %zu words\n", instr_words_needed);

    /* extra room for assembled words */
    instr = calloc(1, (instr_words_needed * sizeof *instr->instr_words) + sizeof *instr);
    if (instr == NULL) {
        fprintf(stderr, "%s():%s\n", "calloc", strerror(errno));
        return -1;
    }

    instr->label = label ? strdup(label) : NULL;
    instr->opcode = opcode ? strdup(opcode) : NULL;
    instr->operands = operand_list;

    *next_instr = instr;

    return 0;
}

/* try to generate bytecode for an instruction */
static
int instr_assemble_(struct dynamic_array *labels, 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;

    if (opt_.verbose > 2) {
        printf("%s: assembling %p ", __func__, i);
        instruction_print_(i, 1);
        printf("\n");
    }

    if (i->ready) {
        /* already assembled, nothing to do */
        return 0;
    }

    /* special case DAT */
    if (strncasecmp(i->opcode, "DAT", 3) == 0) {
        DEBUG_PRINTF("processing DAT...\n");

        i->length = 0;

        while (o) {
            size_t j, dat_len;
            char *x;
            unsigned long l;

            DEBUG_PRINTF("DAT operand:'%s' next:%p\n", o->operand, o->next);

            /* is this a string? */
            if ( (x = strchr("\"'`", o->operand[0])) ) {
                dat_len = strlen(o->operand) - 1;
                if (o->operand[dat_len] == *x) {
                    /* it is a string */
                    DEBUG_PRINTF("DAT string operand: %s\n", o->operand);

                    for (j = 0, x = o->operand + 1;
                         j < dat_len - 1;
                          j++, x++) {
                        i->instr_words[i->length] = (DCPU16_WORD)*x;
                        i->length++;
                    }
                }
                o = o->next;
                continue;
            }

            char *ep;
            errno = 0;
            l = strtoul(o->operand, &ep, 0);
            if (errno == 0
            && (*o->operand && (*ep == '\0')) ) {
                /* conversion succeeded */
                if (l > 0xffff) {
                    fprintf(stderr, "value '%lu' out of range\n", l);
                    return -1;
                }
            }

            fprintf(stderr, "FIXME finish implementing DAT\n");
            /* check if it's a parsable number */

            /* otherwise assume it's a label */



            o = o->next;
        }

        return 0;
    }

    /* start with opcode bits */
    bits = opcode_bits_(i->opcode);
    if (bits < 0) {
        fprintf(stderr, "unrecognized instruction '%s%s", i->opcode, i->operands ? " " : "");
        for (o = i->operands; o; o = o->next)
            fprintf(stderr, " %s%s", o->operand, o->next ? "," : "");
        fprintf(stderr, "'\n");
        return -1;
    }
    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");
            exit(EX_SOFTWARE);
        }
    } else {
        if (o == NULL) {
            fprintf(stderr, "'%s' requires more operands\n", i->opcode);
            return -1;
        }
        bits = value_bits_(labels, o->operand, i->instr_words + 1, &nwu, allow_short_labels);
        if (bits == -1) {
            fprintf(stderr, "couldn't assemble instruction\n");
            return -1;
        } else if (bits == -2) {
            DEBUG_PRINTF("%s: assembly deferred: unresolved label\n", __func__);
            /* 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 -1;
    }

    bits = value_bits_(labels, o->operand, i->instr_words + 1 + nwu, &nwu, allow_short_labels);
    if (bits == -1) {
        fprintf(stderr, "couldn't assemble instruction\n");
        return -1;
    } else if (bits == -2) {
        DEBUG_PRINTF("%s: assembly deferred: unresolved label\n", __func__);
        /* 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;

    if (o != NULL) {
        fprintf(stderr, "too many operands\n");
        return -1;
    }

    /* counting labels as words, we now know at least the maximum instruction length */

    i->length = nwu + 1;

    DEBUG_PRINTF("instruction words: [%u]", i->length);
    for (bits = 0; bits <= (int)nwu; bits++)
        DEBUG_PRINTFQ(" %04x", i->instr_words[bits]);

    if (incomplete) {
        DEBUG_PRINTFQ(" (preliminary)");
    } else {
        i->ready = 1;
    }

    DEBUG_PRINTFQ("\n");

    return 0;
}

/*  parse_stream_
 *  read lines from stream f
 *  break each line into parts, populate parts into structures
 */
static
int parse_stream_(FILE *f, const char *src, struct dynamic_array *instructionps, struct dynamic_array *labels, unsigned int allow_short_labels) {
    struct instruction_ *instr, **instr_list_entry;
    unsigned int line = 0;
    int retval = 0;
    char buf[0x4000];

    buf[sizeof buf - 1] = '\0';

    while (fgets(buf, sizeof buf, f)) {
        line++;

        if (buf[sizeof buf - 1] != '\0') {
            fprintf(stderr, "%s:%u:%s", src, line, "input line too long\n");
            retval = -1;
            break;
        }

        if (buf_tokenize_(buf, &instr)) {
            fprintf(stderr, "%s:%u:%s", src, line, "trouble tokenizing input\n");
            retval = -1;
            break;
        }

        if (instr) {
            /* add to list of instructions */
            instr_list_entry = dynarray_add(instructionps, &instr);
            if (instr_list_entry == NULL) {
                fprintf(stderr, "%s:%u:%s", src, line, "could not populate instruction list\n");
                break;
            }

            if (instr->label) {
                struct label_ new_label = {
                    .label = instr->label,
                    .instr = instr_list_entry,
                    .ready = 0,
                    .addr = 0,
                };
                if (label_find_(labels, instr->label)) {
                    fprintf(stderr, "%s:%u:%s", src, line, "duplicate label\n");
                    break;
                }

                if (dynarray_add(labels, &new_label) == NULL) {
                    fprintf(stderr, "%s:%u:%s", src, line, "could not populate label list\n");
                    break;
                }
                label_addr_calculate_(instructionps, labels);
            }

            instr_assemble_(labels, instr, allow_short_labels);
        }
    }
    if (ferror(f)) {
        fprintf(stderr, "%s():%s\n", "fgets", strerror(errno));
        return -1;
    }
    if (! feof(f)) {
        fprintf(stderr, "parsing aborted\n");
        return -1;
    }

    return retval;
}

/*  assemble_check_
 *  make a full pass over instruction list to resolve labels
 */
static
int assemble_check_(struct dynamic_array *instructionps, struct dynamic_array *labels, unsigned int allow_short_labels) {
    int retval = 0;
    size_t x;

    /* fixing short labels .... */
    /* by here we have our list of instructions and their maximum instruction lengths */
    /* and we have a list of addresses, based on those maximum lengths */
    /* So, if doing short labels, all label addresses are now suspect, so recompute them all... */
    /* and reassemble.. */
    /* uh.. what else am I forgetting.. this method won't work for labels approaching the limit */
    /* of short form addresses, when there are more than the difference number of short form labels used previous to those addresses */

    /* try this?  keep another list of locations a label address is used */
    /* as we step forward, and recompute an address, back up to first occurence of address, make sure nothing else has changed */

    DEBUG_PRINTF(" final pass of assembler...\n");
    for (x = 0; x < instructionps->entries; x++) {
        struct instruction_ **instrp = (struct instruction_ **)DYNARRAY_ITEM(*instructionps, x);
        retval |= instr_assemble_(labels, *instrp, allow_short_labels);
        if (retval) {
            fprintf(stderr, "instruction %zu failed to assemble\n", x);
        }
    }

    VERBOSE_PRINTF("%3s %6s %-32s %-4s\n", "", "_addr_", "_label_", "_instruction_");
    for (x = 0; x < labels->entries; x++) {
        struct label_ *l = (struct label_ *)DYNARRAY_ITEM(*labels, x);
        if (! l->ready)
            retval |= -1;
        if (opt_.verbose) {
            printf("%3s0x%04x  %-32s ",
                   l->ready ? "" : "*",
                   l->addr,
                   l->label);
            instruction_print_(*(l->instr), 0);
            printf("\n");
        }
    }

    VERBOSE_PRINTF("\n");

    if (retval)
        fprintf(stderr, "some labels could not be resolved\n");

    return retval;
}

static
int output_(struct dynamic_array *instructionps, const char *filename) {
    FILE *of = NULL;
    struct instruction_ **instrp;
    size_t i, r, total_words = 0;
    size_t x;

    if (! opt_.dryrun) {
        of = fopen(filename, "w");
        if (of == NULL) {
            fprintf(stderr, "%s('%s'):%s\n", "fopen", filename, strerror(errno));
            return -1;
        }
    }

    for (i = 0; i < instructionps->entries; i++) {
        instrp = (struct instruction_ **)DYNARRAY_ITEM(*instructionps, i);

        if (opt_.verbose) {
            int s;
            s = instruction_print_(*instrp, 1);
            printf("%*s;", (44 - s) > 0 ? (44 - s) : 0, "");
            for (x = 0; x < (*instrp)->length; x++) {
                printf(" %04x", (*instrp)->instr_words[x]);
            }
            printf("\n");
        }

        if (of) {
            r = fwrite((*instrp)->instr_words, sizeof(DCPU16_WORD), (*instrp)->length, of);
            if (r < (*instrp)->length) {
                fprintf(stderr, "%s():%s\n", "fwrite", strerror(errno));
                return -1;
            }
        }
        total_words += (*instrp)->length;
    }

    fprintf(stderr, "%s 0x%04zx instructions as 0x%04zx words\n",
            opt_.dryrun ? "assembled" : "wrote",
            i,
            total_words);

    return 0;
}

static struct dynamic_array *instructionps_;
static struct dynamic_array *labels_;

int main(int argc, char *argv[]) {
    const char *out_filename = NULL;
    unsigned int allow_short_labels = 0;
    int c;

    while ( (c = getopt(argc, argv, "dhsvo:")) != EOF ) {
        switch (c) {
            case 'd':
                opt_.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");
                    exit(EX_CANTCREAT);
                }
                out_filename = optarg;
                break;

            case 'v':
                opt_.verbose++;
                break;

            case 'h':
                usage_(argv[0], 1);
                exit(EX_OK);

            default:
                usage_(argv[0], 0);
                exit(EX_USAGE);
        }
    }

    argc -= optind;
    argv += optind;

    if (out_filename == NULL)
        out_filename = out_filename_default_;

    /* init tables */
    instructionps_ = dynarray_new(sizeof (struct instruction_ *), 1024);
    labels_ = dynarray_new(sizeof(struct label_), 256);
    if (instructionps_ == NULL
    ||  labels_ == NULL) {
        fprintf(stderr, "failed to initialize\n");
        exit(EX_OSERR);
    }

    /* if filenames were specified, parse them instead of stdin */
    if (argc) {
        while (argc) {
            char *filename = *argv;
            FILE *f = fopen(filename, "r");

            argc--, argv++;

            if (f == NULL) {
                fprintf(stderr, "%s('%s'):%s\n", "fopen", filename, strerror(errno));
                continue;
            }

            VERBOSE_PRINTF("assembling '%s'...\n", filename);
            parse_stream_(f, filename, instructionps_, labels_, allow_short_labels);

            fclose(f);
        }
    } else {
        VERBOSE_PRINTF("assembling '%s'...\n", "stdin");
        parse_stream_(stdin, "-", instructionps_, labels_, allow_short_labels);
    }

    if (assemble_check_(instructionps_, labels_, allow_short_labels)) {
        fprintf(stderr, "errors prevented assembly\n");
        exit(EX_DATAERR);
    }

    if (output_(instructionps_, out_filename)) {
        fprintf(stderr, "failed to create output\n");
        exit(EX_OSERR);
    }

    exit(EX_OK);
}