#include <sysexits.h>
#include <assert.h>
-#include "as-dcpu16.h"
+#include "dcpu16.h"
/*
* quick and dirty assembler for dcpu16
*
+ * Justin Wind <justin.wind@gmail.com>
+ * 2012 04 07 - implementation started
+ * 2012 04 10 - functional
+ *
+ * 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";
-unsigned int verbose_ = 0;
-unsigned int dryrun_ = 0;
+/* global invocation options */
+struct options {
+ unsigned int verbose;
+ unsigned int dryrun;
+} opt_ = {
+ .verbose = 0,
+ .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)
-
+#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) {
}
-/* maintain an array of the instructions we have parsed */
+/* 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;
+};
+
+
+/* routines to support generic grow-able arrays */
+
+struct dynamic_array_ {
+ size_t entry_size;
+ size_t grow_size;
+ size_t allocated;
+ size_t entries;
+ void *a;
+};
+
+#define DYNARRAY_ITEM(da, index) ( (char *)(da).a + ( (da).entry_size * index ) )
+
+/* allocate and initialize a new generic dynamic array */
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;
+struct dynamic_array_ *dynarray_new_(size_t entry_size, size_t grow_size) {
+ struct dynamic_array_ *da;
+
+ if (entry_size == 0 || grow_size == 0) {
+ fprintf(stderr, "%s: internal error: sizes cannot be zero\n", __func__);
+ exit(EX_SOFTWARE);
}
- 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;
+ da = calloc(1, sizeof *da);
+ if (da == NULL) {
+ fprintf(stderr, "%s():%s\n", "calloc", strerror(errno));
+ return NULL;
}
- (*il)->instr[(*il)->entries] = i;
- (*il)->entries += 1;
- return 0;
-}
+ da->entry_size = entry_size;
+ da->grow_size = grow_size;
-/* 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) {
+ da->a = malloc(da->entry_size * da->grow_size);
+ if (da->a == NULL) {
fprintf(stderr, "%s():%s\n", "malloc", strerror(errno));
- return NULL;
}
- ll->allocated = init_size;
- ll->entries = 0;
- return ll;
+
+ da->allocated = grow_size;
+
+ DEBUG_PRINTF("allocated new dynarray:%p a:%p entry_size:%zu\n", da, da->a, da->entry_size);
+
+ return da;
}
-/* instr here is index into instruction list */
+/* copy item onto end of array */
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));
+void *dynarray_add_(struct dynamic_array_ *da, void *item) {
+ void *dst;
+
+ /* make room, make room */
+ if (da->entries == da->allocated) {
+ size_t new_allocated = da->allocated + da->grow_size;
+ void *tmp_ptr = realloc(da->a, new_allocated * da->entry_size);
if (tmp_ptr == NULL) {
fprintf(stderr, "%s():%s\n", "realloc", strerror(errno));
- return -1;
+ return NULL;
}
- *ll = tmp_ptr;
- (*ll)->allocated = new_allocated;
+ da->a = tmp_ptr;
+ da->allocated = new_allocated;
+
+ DEBUG_PRINTF("grew dynarray:%p\n", da);
}
- DEBUG_NOTIFY("TRACE: adding label '%s'\n", (*instr)->label);
+ dst = DYNARRAY_ITEM(*da, da->entries);
+ memcpy(dst, item, da->entry_size);
- (*ll)->label[(*ll)->entries].label = (*instr)->label;
- (*ll)->label[(*ll)->entries].instr = instr;
- (*ll)->entries += 1;
- return 0;
+ da->entries++;
+
+ DEBUG_PRINTF("added dynarray:%p entry:%zu item:%p\n", da, da->entries, item);
+
+ return dst;
}
-/* locate the index of a labelled instruction within the instruction list */
+
+/* locate and return the label entry matching name */
static
-struct instruction_ **label_list_find_instr(struct label_list_ *ll, char *label) {
+struct label_ *label_find_(struct dynamic_array_ *labels, char *name) {
size_t x;
- for (x = 0; x < ll->entries; x++) {
- if (strcmp(ll->label[x].label, label) == 0)
- return ll->label[x].instr;
+ 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;
}
-/* look up the address of a calculated address */
+
+/* if a label has a validly-calculated address, fetch it */
static
-int label_list_find_addr(struct label_list_ *ll, char *label, DCPU16_WORD *addr) {
- size_t x;
+int label_addr_(struct dynamic_array_ *labels, char *name, DCPU16_WORD *addr) {
+ struct label_ *l;
- 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;
+ 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 labels */
+
+/* attempt to determine the addresses of all labels */
static
-void label_addr_calculate_(struct instruction_list_ *il, struct label_list_ *ll) {
+void label_addr_calculate_(struct dynamic_array_ *instructionps, struct dynamic_array_ *labels) {
size_t i;
- /* walk through labels */
- for (i = 0; i < ll->entries; i++) {
+ /* for each label.. */
+ for (i = 0; i < labels->entries; i++) {
+ struct label_ *l;
struct instruction_ **instr;
unsigned int word_count = 0;
- if (ll->label[i].ready)
+ 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
+ * until we get to the start or a known prior label address.
+ * update our label with the freshly calculated addr
*/
- for (instr = ll->label[i].instr; instr >= il->instr; instr--) {
+ for (instr = ((struct label_ *)DYNARRAY_ITEM(*labels, i))->instr;
+ instr >= (struct instruction_ **)DYNARRAY_ITEM(*instructionps, 0);
+ instr--) {
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, ll->label[i].label)) {
+ && strcmp((*instr)->label, l->label)) {
DCPU16_WORD addr;
- if (label_list_find_addr(ll, (*instr)->label, &addr)) {
+ if (label_addr_(labels, (*instr)->label, &addr)) {
fprintf(stderr, "internal error: incomplete prior address for '%s' while calculating '%s'\n",
(*instr)->label,
- ll->label[i].label);
+ l->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);
+ l->addr = word_count;
+ l->ready = 1;
+ DEBUG_PRINTF("label '%s' now has addr of 0x%04x\n", l->label, word_count);
}
}
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 */
+/* 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 label_list_ *ll, char *operand_orig, DCPU16_WORD *nextword, unsigned int *nextwordused, unsigned int allow_short_labels) {
- unsigned int retval = -1;
+int value_bits_(struct dynamic_array_ *labels, 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 *operand, *o, *ep;
+ 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;
+ }
- operand = o = strdup(operand_orig);
+ o = strcpy(operand, operand_orig);
- DEBUG_NOTIFY("TRACE: operand '%s' is ", operand);
+ DEBUG_PRINTF("%s: operand '%s' ", __func__, operand); /* completed later */
- if (strlen(operand) == 1) {
- if ( (strchr("ABCXYZIJ", *operand))
- || (strchr("abcxyzij", *operand)) ) {
- DEBUG_NOTIFY("register\n");
- retval = register_enumerate_(*operand);
- goto done;
- }
+ /* 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++;
- /* 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;
+
+ /* 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 *reg;
char *constant;
- while (strchr("+ \t\n", *ep)) {
- *ep = '\0';
- ep++;
- }
- if (strlen(ep) == 1) {
- reg = *ep;
+ /* 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) {
- reg = *operand;
+ } else if (strlen(operand) == 1
+ && strchr("AaBbCcXxYyZzIiJj", *operand) ) {
+ reg = operand;
constant = ep;
} else {
- fprintf(stderr, "couldn't parse operand\n");
- goto done;
+ DEBUG_PRINTFQ("is unparsable\n");
+ fprintf(stderr, "couldn't parse operand '%s'\n", operand_orig);
+ return -1;
}
- if ( strchr("ABCXYZIJ", reg)
- || strchr("abcxyzij", reg) ) {
- l = strtoul(constant, &ep, 0);
+ /* 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;
}
- DEBUG_NOTIFY("dereferenced register+constant\n");
+ /* 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);
+ }
- DEBUG_NOTIFY("\tregister_index:%u %c\n", reg, register_enumerate_(reg));
- DEBUG_NOTIFY("\tconstant:%lu\n", l);
+ /* 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;
- retval = 0x10 | register_enumerate_(reg);
- goto done;
+ return 0x1e;
+ } else if (errno) {
+ DEBUG_PRINTFQ("is out of range\n");
+ fprintf(stderr, "trouble with operand '%s': %s\n", operand_orig, strerror(errno));
}
- l = strtoul(operand, &ep, 0);
- DEBUG_NOTIFY("dereferenced literal value %lu...\n", l);
- *nextword = l & 0xffff;
+ /* 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;
- retval = 0x1e;
- goto done;
+ return 0x1e;
}
- 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;
- }
+ /* 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;
+ }
- if (operand && *ep == '\0') {
- DEBUG_NOTIFY("literal value %lu...\n", l);
+ DEBUG_PRINTFQ("is literal value (%lu)\n", l);
if (l < 0x20) {
- retval = l + 0x20;
- goto done;
- } else {
- *nextword = l & 0xffff;
- *nextwordused += 1;
- retval = 0x1f;
- goto done;
+ return l + 0x20;
}
+
+ *nextword = l & 0xffff;
+ *nextwordused += 1;
+ return 0x1f;
}
/* try to populate nextword with label address */
- if (label_list_find_addr(ll, operand, nextword)) {
- DEBUG_NOTIFY("currently-unknown label...\n");
+ if (label_addr_(labels, operand, nextword)) {
+ DEBUG_PRINTFQ("(deferred label resolution)\n");
/* assume non-small literal value */
*nextwordused += 1;
- goto done;
+ return -2;
}
- DEBUG_NOTIFY("label '%s' 0x%02hx\n", operand, *nextword);
+ DEBUG_PRINTFQ("is 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;
+ DEBUG_PRINTF("small value label win\n");
+ return (0x20 + *nextword) & 0x3f;
}
- retval = 0x1f;
*nextwordused += 1;
-
-done:
- free(o);
- return retval;
+ return 0x1f;
}
+/* prints an instruction's assembly */
static inline
int instruction_print_(struct instruction_ *i, unsigned int with_label) {
struct operand_ *o;
/* try to generate bytecode for an instruction */
static
-void instr_bytecodify_(struct label_list_ *ll, struct instruction_ *i, unsigned int allow_short_labels) {
+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;
- DEBUG_NOTIFY("TRACE: codifying %s%s'%s'...", i->label ? i->label : "", i->label ? ":" : "", i->opcode);
+ if (opt_.verbose > 2) {
+ printf("%s: assembling %p ", __func__, i);
+ instruction_print_(i, 1);
+ printf("\n");
+ }
if (i->ready) {
- /* already codified */
- return;
+ /* already assembled, nothing to do */
+ return 0;
}
/* special case DAT */
/* count total length of data.. */
/* realloc instruction */
/* populate words */
- return;
+ return 0;
}
/* start with opcode bits */
bits = opcode_bits_(i->opcode);
if (bits < 0) {
- fprintf(stderr, "unrecognized instruction '%s'\n", i->opcode);
- return;
+ 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;
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;
+ 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;
+ return -1;
}
- bits = value_bits_(ll, o->operand, i->instr_words + 1, &nwu, allow_short_labels);
- if (bits < 0) {
- DEBUG_NOTIFY("TRACE: unresolved label\n");
+ 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;
if (o == NULL) {
fprintf(stderr, "'%s' requires more operands\n", i->opcode);
- return;
+ return -1;
}
- bits = value_bits_(ll, o->operand, i->instr_words + nwu + 1, &nwu, allow_short_labels);
- if (bits < 0) {
- DEBUG_NOTIFY("TRACE: unresolved label\n");
+ bits = value_bits_(labels, o->operand, i->instr_words + nwu + 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) << 10;
- /* counting labels as words, we now know the maximum instruction length */
- /* if label is < 0x20, it can take up less space */
+ 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_NOTIFY("instruction words: [%u]", i->length);
+ DEBUG_PRINTF("instruction words: [%u]", i->length);
for (bits = 0; bits <= (int)nwu; bits++)
- DEBUG_NOTIFY(" 0x%04x", i->instr_words[bits]);
+ DEBUG_PRINTFQ(" %04x", i->instr_words[bits]);
if (incomplete) {
- DEBUG_NOTIFY(" (preliminary)");
+ DEBUG_PRINTFQ(" (preliminary)");
} else {
i->ready = 1;
}
- DEBUG_NOTIFY("\n");
+ DEBUG_PRINTFQ("\n");
+
+ return 0;
}
-/* thish should grow buffer to fit huge linesh, but I jusht don't care right now, hic */
+/* parse_stream_
+ * read lines from stream f
+ * break each line into parts, populate parts into structures
+ */
static
-int parse_stream_(FILE *f, struct instruction_list_ **il, struct label_list_ **ll, unsigned int allow_short_labels) {
+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;
- char buf[(1<<14)];
+ 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, "input buffer exhausted\n");
+ fprintf(stderr, "%s:%u:%s", src, line, "input line too long\n");
+ retval = -1;
break;
}
if (buf_tokenize_(buf, &instr)) {
- fprintf(stderr, "trouble tokenizing input\n");
+ fprintf(stderr, "%s:%u:%s", src, line, "trouble tokenizing input\n");
+ retval = -1;
break;
}
if (instr) {
/* add to list of instructions */
- if (instr_list_insert(il, instr)) {
- fprintf(stderr, "could not populate instruction list\n");
+ 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;
}
- instr_list_entry = (*il)->instr + (*il)->entries - 1;
- DEBUG_NOTIFY("TRACE: verify %s == %s\n", (*instr_list_entry)->opcode, instr->opcode);
+
if (instr->label) {
- if (label_list_find_instr(*ll, instr->label)) {
- fprintf(stderr, "duplicate label\n");
+ 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 (label_list_insert(ll, instr_list_entry)) {
- fprintf(stderr, "could not populate label list\n");
+
+ if (dynarray_add_(labels, &new_label) == NULL) {
+ fprintf(stderr, "%s:%u:%s", src, line, "could not populate label list\n");
+ break;
}
- label_addr_calculate_(*il, *ll);
+ label_addr_calculate_(instructionps, labels);
}
- instr_bytecodify_(*ll, instr, allow_short_labels);
+ instr_assemble_(labels, instr, allow_short_labels);
}
}
if (ferror(f)) {
return -1;
}
- return 0;
+ return retval;
}
+/* assemble_check_
+ * make a full pass over instruction list to resolve labels
+ */
static
-int assemble_check_(struct instruction_list_ *il, struct label_list_ *ll, unsigned int allow_short_labels) {
+int assemble_check_(struct dynamic_array_ *instructionps, struct dynamic_array_ *labels, 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);
+ 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_NOTIFY("%3s %6s %-32s %-4s\n", "", "_addr_", "_label_", "_instruction_");
- for (x = 0; x < ll->entries; x++) {
- if (! ll->label[x].ready)
+ 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;
- 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);
+ if (opt_.verbose) {
+ printf("%3s0x%04x %-32s ",
+ l->ready ? "" : "*",
+ l->addr,
+ l->label);
+ instruction_print_(*(l->instr), 0);
printf("\n");
}
}
- VERBOSE_NOTIFY("\n");
+ VERBOSE_PRINTF("\n");
if (retval)
fprintf(stderr, "some labels could not be resolved\n");
}
static
-int output_(struct instruction_list_ *il, const char *filename) {
+int output_(struct dynamic_array_ *instructionps, const char *filename) {
FILE *of = NULL;
- struct instruction_ *instr;
+ struct instruction_ **instrp;
size_t i, r, total_words = 0;
size_t x;
- if (! dryrun_) {
+ if (! opt_.dryrun) {
of = fopen(filename, "w");
if (of == NULL) {
fprintf(stderr, "%s('%s'):%s\n", "fopen", filename, strerror(errno));
}
}
- for (i = 0; i < il->entries; i++) {
- instr = il->instr[i];
+ for (i = 0; i < instructionps->entries; i++) {
+ instrp = (struct instruction_ **)DYNARRAY_ITEM(*instructionps, i);
- if (verbose_) {
+ if (opt_.verbose) {
int s;
- s = instruction_print_(instr, 1);
+ s = instruction_print_(*instrp, 1);
printf("%*s;", (44 - s) > 0 ? (44 - s) : 0, "");
- for (x = 0; x < instr->length; x++) {
- printf(" %04x", instr->instr_words[x]);
+ for (x = 0; x < (*instrp)->length; x++) {
+ printf(" %04x", (*instrp)->instr_words[x]);
}
printf("\n");
}
if (of) {
- r = fwrite(instr->instr_words, sizeof(DCPU16_WORD), instr->length, of);
- if (r < instr->length) {
+ 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 += instr->length;
+ total_words += (*instrp)->length;
}
- fprintf(stderr, "wrote 0x%04zx instructions as 0x%04zx words\n",
+ fprintf(stderr, "%s 0x%04zx instructions as 0x%04zx words\n",
+ opt_.dryrun ? "assembled" : "wrote",
i,
total_words);
+
return 0;
}
-static struct instruction_list_ *il_;
-static struct label_list_ *ll_;
+static struct dynamic_array_ *instructionps_;
+static struct dynamic_array_ *labels_;
int main(int argc, char *argv[]) {
const char *out_filename = NULL;
while ( (c = getopt(argc, argv, "dhsvo:")) != EOF ) {
switch (c) {
case 'd':
- dryrun_++;
+ opt_.dryrun++;
break;
case 's':
break;
case 'v':
- verbose_++;
+ opt_.verbose++;
break;
case 'h':
out_filename = out_filename_default_;
/* init tables */
- il_ = instr_list_new();
- ll_ = label_list_new();
+ 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) {
continue;
}
- VERBOSE_NOTIFY("assembling '%s'...\n", filename);
- parse_stream_(f, &il_, &ll_, allow_short_labels);
+ VERBOSE_PRINTF("assembling '%s'...\n", filename);
+ parse_stream_(f, filename, instructionps_, labels_, allow_short_labels);
fclose(f);
}
} else {
- VERBOSE_NOTIFY("assembling '%s'...\n", "stdin");
- parse_stream_(stdin, &il_, &ll_, allow_short_labels);
+ VERBOSE_PRINTF("assembling '%s'...\n", "stdin");
+ parse_stream_(stdin, "-", instructionps_, labels_, allow_short_labels);
}
- if (assemble_check_(il_, ll_, allow_short_labels)) {
+ if (assemble_check_(instructionps_, labels_, allow_short_labels)) {
fprintf(stderr, "errors prevented assembly\n");
exit(EX_DATAERR);
}
- if (output_(il_, out_filename)) {
+ if (output_(instructionps_, out_filename)) {
fprintf(stderr, "failed to create output\n");
exit(EX_OSERR);
}
projects / dcpu16 / blobdiff