X-Git-Url: http://git.squeep.com/?p=dcpu16;a=blobdiff_plain;f=as-dcpu16.c;h=4ed6050adf2ea078f219a709cae5ddfda8127c80;hp=0131ba48d2da68ce2de23cbdf979b4858f6f761c;hb=4706199a81dc631b6969927e1a6ad27591852b20;hpb=503abee3b3bf76015786f5a99e31117fbfe2d310

diff --git a/as-dcpu16.c b/as-dcpu16.c
index 0131ba4..4ed6050 100644
--- a/as-dcpu16.c
+++ b/as-dcpu16.c
@@ -7,6 +7,7 @@
 #include <assert.h>
 
 #include "dcpu16.h"
+#include "common.h"
 
 /*
  *  quick and dirty assembler for dcpu16
@@ -14,6 +15,7 @@
  *  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
@@ -92,82 +94,9 @@ struct label_ {
 };
 
 
-/* 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 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);
-    }
-
-    da = calloc(1, sizeof *da);
-    if (da == NULL) {
-        fprintf(stderr, "%s():%s\n", "calloc", strerror(errno));
-        return NULL;
-    }
-
-    da->entry_size = entry_size;
-    da->grow_size = grow_size;
-
-    da->a = malloc(da->entry_size * da->grow_size);
-    if (da->a == NULL) {
-        fprintf(stderr, "%s():%s\n", "malloc", strerror(errno));
-    }
-
-    da->allocated = grow_size;
-
-    DEBUG_PRINTF("allocated new dynarray:%p a:%p entry_size:%zu\n", da, da->a, da->entry_size);
-
-    return da;
-}
-
-/* copy item onto end of array */
-static
-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 NULL;
-        }
-        da->a = tmp_ptr;
-        da->allocated = new_allocated;
-
-        DEBUG_PRINTF("grew dynarray:%p\n", da);
-    }
-
-    dst = DYNARRAY_ITEM(*da, da->entries);
-    memcpy(dst, item, da->entry_size);
-
-    da->entries++;
-
-    DEBUG_PRINTF("added dynarray:%p entry:%zu item:%p\n", da, da->entries, item);
-
-    return dst;
-}
-
-
 /* locate and return the label entry matching name */
 static
-struct label_ *label_find_(struct dynamic_array_ *labels, char *name) {
+struct label_ *label_find_(struct dynamic_array *labels, char *name) {
     size_t x;
 
     for (x = 0; x < labels->entries; x++) {
@@ -181,7 +110,7 @@ struct label_ *label_find_(struct dynamic_array_ *labels, char *name) {
 
 /* if a label has a validly-calculated address, fetch it */
 static
-int label_addr_(struct dynamic_array_ *labels, char *name, DCPU16_WORD *addr) {
+int label_addr_(struct dynamic_array *labels, char *name, DCPU16_WORD *addr) {
     struct label_ *l;
 
     if ( (l = label_find_(labels, name)) == NULL )
@@ -195,7 +124,7 @@ int label_addr_(struct dynamic_array_ *labels, char *name, DCPU16_WORD *addr) {
 
 /* attempt to determine the addresses of all labels */
 static
-void label_addr_calculate_(struct dynamic_array_ *instructionps, struct dynamic_array_ *labels) {
+void label_addr_calculate_(struct dynamic_array *instructionps, struct dynamic_array *labels) {
     size_t i;
 
     /* for each label.. */
@@ -220,6 +149,8 @@ void label_addr_calculate_(struct dynamic_array_ *instructionps, struct dynamic_
              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?
@@ -245,21 +176,6 @@ void label_addr_calculate_(struct dynamic_array_ *instructionps, struct dynamic_
     }
 }
 
-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
@@ -355,6 +271,7 @@ void buf_strip_chars_(char *buf, char *chars) {
     *d = *s;
 }
 
+
 /*  value_bits_
  *  generate the six bits for a given operand string
  *  returns -1 if it could not parse the operand
@@ -362,7 +279,7 @@ void buf_strip_chars_(char *buf, char *chars) {
  *  notes: nextword may be overwritten even if it's not used in final instruction
  */
 static
-int value_bits_(struct dynamic_array_ *labels, char *operand_orig, DCPU16_WORD *nextword, unsigned int *nextwordused, unsigned int allow_short_labels) {
+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;
 
@@ -597,114 +514,145 @@ 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 */
+/*  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;
+         *st, *qt;
+    size_t instr_words_needed = 1;
 
     assert(buf != NULL);
     assert(next_instr != NULL);
 
     *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)
+    /* kill trailing whitespace */
+    for (x = buf + strlen(buf); *x && strchr(sep, *x); x--)
         *x = '\0';
 
-    /* determine if first token is label, opcode, or we just have a blank line to ignore */
-    x = strtok_r(buf, sep, &st);
+    /* 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;
+    }
 
-    /* empty line? nothing to do here. */
+    /* 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;
+    }
 
-#ifdef OTHER_LABELS
+/* 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 = strtok_r(NULL, sep, &st);
+        opcode = strqtok_r(NULL, sep, '\\', quot, &qt, &st);
+    } else {
+        label = NULL;
+        opcode = x;
     }
-#else /* OTHER_LABELS */
+#else /* NON_SPEC_LABELS */
     /* labels.. begin? with ':' ? okay, I guess. Whatever. */
     /* otherwise, it's an opcode */
     if (*x == ':') {
         label = x + 1;
-        opcode = strtok_r(NULL, sep, &st);
+        opcode = strqtok_r(NULL, sep, '\\', quot, &qt, &st);
     } else {
         label = NULL;
         opcode = x;
     }
-#endif /* OTHER_LABELS */
+#endif /* NON_SPEC_LABELS */
 
     if (opcode) {
         operand = st;
     }
 
-    /* extra room for assembled words */
-    instr = calloc(1, 3 + 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;
+    /*
+        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 = &instr->operands;
+        struct operand_ **o_next = &operand_list;
 
-        for (x = strtok_r(operand, ",", &st);
+        for (x = strqtok_r(operand, ",", '\\', quot, &qt, &st);
              x;
-             x = strtok_r(NULL, ",", &st) ) {
-            *o_next = malloc(3 + sizeof **o_next); /* FIXME: handle this on the fly later */
+             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));
-                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--;
-                }
-            }
+            /* 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;
@@ -712,7 +660,7 @@ int buf_tokenize_(char *buf, struct instruction_ **next_instr) {
 
 /* try to generate bytecode for an instruction */
 static
-int instr_assemble_(struct dynamic_array_ *labels, 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;
@@ -731,11 +679,57 @@ int instr_assemble_(struct dynamic_array_ *labels, struct instruction_ *i, unsig
 
     /* 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 */
+        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;
     }
 
@@ -781,7 +775,7 @@ int instr_assemble_(struct dynamic_array_ *labels, struct instruction_ *i, unsig
         return -1;
     }
 
-    bits = value_bits_(labels, o->operand, i->instr_words + nwu + 1, &nwu, allow_short_labels);
+    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;
@@ -823,7 +817,7 @@ int instr_assemble_(struct dynamic_array_ *labels, struct instruction_ *i, unsig
  *  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) {
+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;
@@ -848,7 +842,7 @@ int parse_stream_(FILE *f, const char *src, struct dynamic_array_ *instructionps
 
         if (instr) {
             /* add to list of instructions */
-            instr_list_entry = dynarray_add_(instructionps, &instr);
+            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;
@@ -866,7 +860,7 @@ int parse_stream_(FILE *f, const char *src, struct dynamic_array_ *instructionps
                     break;
                 }
 
-                if (dynarray_add_(labels, &new_label) == NULL) {
+                if (dynarray_add(labels, &new_label) == NULL) {
                     fprintf(stderr, "%s:%u:%s", src, line, "could not populate label list\n");
                     break;
                 }
@@ -892,10 +886,21 @@ int parse_stream_(FILE *f, const char *src, struct dynamic_array_ *instructionps
  *  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 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);
@@ -929,7 +934,7 @@ int assemble_check_(struct dynamic_array_ *instructionps, struct dynamic_array_
 }
 
 static
-int output_(struct dynamic_array_ *instructionps, const char *filename) {
+int output_(struct dynamic_array *instructionps, const char *filename) {
     FILE *of = NULL;
     struct instruction_ **instrp;
     size_t i, r, total_words = 0;
@@ -974,8 +979,8 @@ int output_(struct dynamic_array_ *instructionps, const char *filename) {
     return 0;
 }
 
-static struct dynamic_array_ *instructionps_;
-static struct dynamic_array_ *labels_;
+static struct dynamic_array *instructionps_;
+static struct dynamic_array *labels_;
 
 int main(int argc, char *argv[]) {
     const char *out_filename = NULL;
@@ -1021,8 +1026,8 @@ int main(int argc, char *argv[]) {
         out_filename = out_filename_default_;
 
     /* init tables */
-    instructionps_ = dynarray_new_(sizeof (struct instruction_ *), 1024);
-    labels_ = dynarray_new_(sizeof(struct label_), 256);
+    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");