From 3916e67e3326247a5f6f32e7f3b4d147bc2bef4d Mon Sep 17 00:00:00 2001 From: Justin Wind Date: Tue, 10 Apr 2012 13:43:31 -0700 Subject: [PATCH] assembler functional now --- as-dcpu16.c | 742 ++++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 696 insertions(+), 46 deletions(-) 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 #include -/* #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 -- output to [default: %s]\n", + "\t-o -- output to [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); -- 2.43.2