X-Git-Url: http://git.squeep.com/?a=blobdiff_plain;f=as-dcpu16.c;h=063741d51a8698330c3a8af13d12c33a03114d11;hb=244481c68cb54e08e38b8b85a4371a2f5dbbef69;hp=38d77ce6c6e497d293834a0bcd8d5687205ead2c;hpb=3916e67e3326247a5f6f32e7f3b4d147bc2bef4d;p=dcpu16 diff --git a/as-dcpu16.c b/as-dcpu16.c index 38d77ce..063741d 100644 --- a/as-dcpu16.c +++ b/as-dcpu16.c @@ -6,23 +6,39 @@ #include #include -#include "as-dcpu16.h" +#include "dcpu16.h" +#include "common.h" /* * quick and dirty assembler for dcpu16 * + * Justin Wind + * 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 + * needs ability to specify label as relative to another label + * 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) { @@ -54,163 +70,116 @@ 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_ { + size_t src_line; + 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 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; -} +struct label_ *label_find_(struct dynamic_array *labels, char *name) { + size_t x; -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; + for (x = 0; x < labels->entries; x++) { + struct label_ *l = (struct label_ *)DYNARRAY_ITEM(*labels, x); + if (strcmp(l->label, name) == 0) + return l; } - - (*il)->instr[(*il)->entries] = i; - (*il)->entries += 1; - return 0; + return NULL; } -/* 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 */ +/* if a label has a validly-calculated address, fetch it */ 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); +int label_addr_(struct dynamic_array *labels, char *name, DCPU16_WORD *addr) { + struct label_ *l; - (*ll)->label[(*ll)->entries].label = (*instr)->label; - (*ll)->label[(*ll)->entries].instr = instr; - (*ll)->entries += 1; + if ( (l = label_find_(labels, name)) == NULL ) + return -1; + if (! l->ready) + return -2; + *addr = l->addr; 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 */ +/* 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++) { + /* idea: label1:label2 - calculated as offset between labels */ + + /* 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--) { + 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, 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); } } -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 @@ -290,153 +259,249 @@ unsigned int register_enumerate_(char 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 */ +/* 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, 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 *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; @@ -453,149 +518,256 @@ int instruction_print_(struct instruction_ *i, unsigned int with_label) { 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 */ +/* tokenize_line_ + * Parses a zero-terminated line of input into a newly-allocated struct instruction_. + * [label] instruction [operand[,operand[,...]]] + * Does no validation of contents of any of these tokens, as of yet. + */ static -int buf_tokenize_(char *buf, struct instruction_ **next_instr) { - const char const *sep = " \t\n"; +int tokenize_line_(char *line, struct instruction_ **next_instr) { + const char const *whitespace = " \t\n"; + const char const *quotes = "\"'`"; struct instruction_ *instr = NULL; - char *label = NULL, - *opcode = NULL, - *operand = NULL; - - char *x, - *y, - *st; + char *x, *st, *qt; + char *label, *opcode; + struct operand_ *operand_list = NULL; + struct operand_ **operand_tail = &operand_list; + size_t instr_words_needed = 0; - assert(buf != NULL); - assert(next_instr != NULL); + assert(line); + assert(next_instr); *next_instr = NULL; - /* kill comments */ - if ((x = strchr(buf, ';')) != NULL) - *x = '\0'; - /* kill leading whitespace */ - buf += strspn(buf, " \t\n"); - /* 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'; + /* strip leading whitespace */ + line += strspn(line, whitespace); + if (*line == '\0') + return 0; - /* determine if first token is label, opcode, or we just have a blank line to ignore */ - x = strtok_r(buf, sep, &st); + /* set first bare ';' to '\0', thus isolating any comments */ + /* here we only care about the side-effect of truncating the first separator character */ + (void)strqtok_r(line, ";", '\\', quotes, &qt, &st); + /* we don't care if there was an unmatched quote at this point, let's see what happens */ + if (*line == '\0') + return 0; - /* empty line? nothing to do here. */ - if (x == NULL) + /* carve off the first token, determine if it is a label */ + x = strqtok_r(line, whitespace, '\\', quotes, &qt, &st); + if (x == NULL || *x == '\0') return 0; + if (qt) { + /* labels could contain an unmatched quote character, I guess? */ + qt = NULL; + } + + /* we have something, try to make sense of what it is */ + +#ifdef NON_SPEC_LABELS + /* I want my labels like 'label:' */ + if ( *(x + strlen(line) - 1) == ':' ) { + *(x + strlen(line) - 1) = '\0'; + DEBUG_PRINTF("label: %s\n", x); -#ifdef OTHER_LABELS - /* labels end with :, otherwise its an opcode */ - y = x + strlen(x) - 1; - if (*y == ':') { - *y = '\0'; label = x; - opcode = strtok_r(NULL, sep, &st); + + opcode = strqtok_r(NULL, whitespace, '\\', quotes, &qt, &st); + } else { + label = NULL; + opcode = x; } -#else /* OTHER_LABELS */ - /* labels.. begin? with ':' ? okay, I guess. Whatever. */ - /* otherwise, it's an opcode */ +#endif /* NON_SPEC_LABELS */ + + /* spec gives example of labels as ':label' */ if (*x == ':') { - label = x + 1; - opcode = strtok_r(NULL, sep, &st); + *x = '\0'; + x++; + label = x; + opcode = strqtok_r(NULL, whitespace, '\\', quotes, &qt, &st); } else { label = NULL; opcode = x; } -#endif /* OTHER_LABELS */ + /* opcodes shouldn't have quotes, so we'll ignore any unmatched quotes again */ - if (opcode) { - operand = st; - } + if (opcode && *opcode) { + /* if we have an opcode, we'll need at least one word to compile instruction */ + instr_words_needed++; - /* extra room for assembled words */ - instr = calloc(1, 3 + sizeof *instr); - if (instr == NULL) { - fprintf(stderr, "%s():%s\n", "calloc", strerror(errno)); - return -1; - } + while ( (x = strqtok_r(NULL, ",", '\\', quotes, &qt, &st)) ) { + struct operand_ *new_operand; + char *y; - instr->label = label ? strdup(label) : NULL; - instr->opcode = opcode ? strdup(opcode) : NULL; + /* trim whitespaces */ + x += strspn(x, whitespace); - if (operand) { - struct operand_ **o_next = &instr->operands; + if (*x) { + for (y = x + strlen(x) - 1; *y; y--) { + if (strchr(whitespace, *y)) { + *y = '\0'; + } + } + } + /* nothing left? */ + if (*x == '\0') { + fprintf(stderr, "null operand encountered\n"); + return -1; + } - 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 */ + DEBUG_PRINTF("tokenized operand '%s'\n", x); - if (*o_next == NULL) { - fprintf(stderr, "%s():%s\n", "calloc", strerror(errno)); - instr_free_(instr); + new_operand = malloc(sizeof *new_operand); + if (new_operand == NULL) { + fprintf(stderr, "%s():%s\n", "malloc", strerror(errno)); return -1; } - /* trim */ - x += strspn(x, " \t\n"); - if (*x) { - y = x + strlen(x) - 1; - while (strchr(" \t\n", *y)) { - *y = '\0'; - y--; - } + new_operand->operand = strdup(x); + if (new_operand->operand == NULL) { + fprintf(stderr, "%s():%s\n", "strdup", strerror(errno)); + return -1; + } + + new_operand->next = NULL; + + if (strchr(quotes, x[0])) { + /* if this is a quoted operand, assuming we are in a DAT statement, it will take up slightly less room than it is long */ + instr_words_needed += strlen(x) - 1; } + instr_words_needed++; + + *operand_tail = new_operand; + operand_tail = &(*operand_tail)->next; + } + } - (*o_next)->operand = strdup(x); - (*o_next)->next = NULL; - o_next = &((*o_next)->next); + DEBUG_PRINTF("allocating new instruction with room for %zu bytes\n", instr_words_needed); + + instr = calloc(1, (instr_words_needed * sizeof *instr->instr_words) + sizeof *instr); + if (instr == NULL) { + fprintf(stderr, "%s():%s\n", "malloc", strerror(errno)); + return -1; + } + + if (label) { + instr->label = strdup(label); + if (instr->label == NULL) { + fprintf(stderr, "%s():%s\n", "malloc", strerror(errno)); + return -1; } + } else { + label = NULL; } + if (opcode) { + instr->opcode = strdup(opcode); + if (instr->opcode == NULL) { + fprintf(stderr, "%s():%s\n", "malloc", strerror(errno)); + return -1; + } + } else { + opcode = NULL; + } + + instr->operands = operand_list; + *next_instr = instr; return 0; } /* try to generate bytecode for an instruction */ +/* returns -1 on unrecoverable error */ 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("(line :%zu)\n", i->src_line); + } if (i->ready) { - /* already codified */ - return; + /* already assembled, nothing to do */ + return 0; } /* 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; - } + DEBUG_PRINTF("processing DAT...\n"); + + i->length = 0; + + for ( /* */ ; o; o = o->next) { + 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] = *x; + i->length++; + } + /* Note that strings in DAT do not include their zero-terminators */ + /* specify as 'DAT "string", 0' */ + } + continue; + } + + /* is this a number? */ + 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; + } + i->instr_words[i->length] = l; + i->length++; + continue; + } + + /* otherwise assume it's a label, even if we don't know what it is */ + if (label_addr_(labels, o->operand, &i->instr_words[i->length])) { + DEBUG_PRINTF("(deferred label resolution)\n"); + incomplete = 1; + } + i->length++; + } + + if (incomplete) { + DEBUG_PRINTF("pending label address\n"); + } else { + i->ready = 1; + } + + return 0; + } /* end of DAT */ /* 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; @@ -603,17 +775,20 @@ void instr_bytecodify_(struct label_list_ *ll, struct instruction_ *i, unsigned 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; @@ -624,12 +799,15 @@ void instr_bytecodify_(struct label_list_ *ll, struct instruction_ *i, unsigned 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 + 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; @@ -637,62 +815,90 @@ void instr_bytecodify_(struct label_list_ *ll, struct instruction_ *i, unsigned 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"); + if (tokenize_line_(buf, &instr)) { + fprintf(stderr, "%s:%u:%s", src, line, "trouble tokenizing input\n"); + retval = -1; break; } if (instr) { + instr->src_line = line; /* 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); + if (instr_assemble_(labels, instr, allow_short_labels)) { + fprintf(stderr, "%s:%u:%s", src, line, "could not assemble instruction\n"); + break; + } } } if (ferror(f)) { @@ -704,34 +910,58 @@ int parse_stream_(FILE *f, struct instruction_list_ **il, struct label_list_ **l 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); + /* 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); + return retval; + } + if (! (*instrp)->ready) { + fprintf(stderr, "instruction not resolvable\n"); + return -1; + } } - 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"); @@ -739,14 +969,17 @@ int assemble_check_(struct instruction_list_ *il, struct label_list_ *ll, unsign return retval; } +/* output_ + * write assembled words to named file + */ 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)); @@ -754,37 +987,39 @@ int output_(struct instruction_list_ *il, const char *filename) { } } - 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; @@ -794,7 +1029,7 @@ int main(int argc, char *argv[]) { while ( (c = getopt(argc, argv, "dhsvo:")) != EOF ) { switch (c) { case 'd': - dryrun_++; + opt_.dryrun++; break; case 's': @@ -810,7 +1045,7 @@ int main(int argc, char *argv[]) { break; case 'v': - verbose_++; + opt_.verbose++; break; case 'h': @@ -830,8 +1065,13 @@ int main(int argc, char *argv[]) { 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) { @@ -846,22 +1086,27 @@ int main(int argc, char *argv[]) { continue; } - VERBOSE_NOTIFY("assembling '%s'...\n", filename); - parse_stream_(f, &il_, &ll_, allow_short_labels); - + VERBOSE_PRINTF("assembling '%s'...\n", filename); + c = parse_stream_(f, filename, instructionps_, labels_, allow_short_labels); fclose(f); + if (c) + break; } } else { - VERBOSE_NOTIFY("assembling '%s'...\n", "stdin"); - parse_stream_(stdin, &il_, &ll_, allow_short_labels); + VERBOSE_PRINTF("assembling '%s'...\n", "stdin"); + c = parse_stream_(stdin, "-", instructionps_, labels_, allow_short_labels); + } + if (c) { + fprintf(stderr, "could not parse input, aborting\n"); + exit(EX_DATAERR); } - 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); }