X-Git-Url: http://git.squeep.com/?p=dcpu16;a=blobdiff_plain;f=vm-dcpu16.c;h=a463f7ac94858856c5a6e6a2697f44b44811f44f;hp=d60c340d2eeaa7a6f4eb4e9630127ae1152bd439;hb=a9cc197dc14d237e6bcea74591b81688de81ad66;hpb=4706199a81dc631b6969927e1a6ad27591852b20

diff --git a/vm-dcpu16.c b/vm-dcpu16.c
index d60c340..a463f7a 100644
--- a/vm-dcpu16.c
+++ b/vm-dcpu16.c
@@ -2,15 +2,25 @@
 #include <stdio.h>
 #include <unistd.h>
 #include <string.h>
+#include <strings.h>
+#include <signal.h>
 #include <errno.h>
 #include <assert.h>
 #include <sysexits.h>
+#include <time.h>
+#include <sys/time.h>
 
 #include <readline/readline.h>
+#ifdef HAVE_LIBVNCSERVER
+#include "rfb/rfb.h"
+#endif /* HAVE_LIBVNCSERVER */
 
 #include "dcpu16.h"
 #include "common.h"
 
+#include "hw_lem1802.h"
+#include "hw_keyboard.h"
+
 /*
  *  shell-like driver for dcpu16 core
  *  provides a basic interface to control a single emulation instance
@@ -18,6 +28,7 @@
  *  Justin Wind <justin.wind@gmail.com>
  *    2012 04 10 - implementation started
  *    2012 04 12 - cleanup, better shell loop
+ *    2012 05 12 - support v1.7 style devices
  *
  *  TODO
  *    handle quotes in shell command parsing
@@ -62,7 +73,7 @@ void usage_(char *prog, unsigned int full) {
     if (full) {
         fprintf(f, "\nOptions:\n"
                 "\t [file] -- ram image to load initially\n"
-                "\t -v -- displays slightly more information\n"
+                "\t -v -- prints slightly more information while operating\n"
                 "\t -h -- this screen\n");
 
         fprintf(f, "\n%78s\n", src_id_);
@@ -137,6 +148,63 @@ int file_load_(struct dcpu16 *vm, char *filename, DCPU16_WORD addr) {
     return 0;
 }
 
+
+#ifdef HAVE_LIBVNCSERVER
+static struct dynamic_array rfbScreens_;
+/* wups, kbdAddEvent isn't null by default, so I guess track things externally */
+struct rfb_instance_ {
+    rfbScreenInfoPtr screen;
+    struct dcpu16_hw *attached_display;
+    struct dcpu16_hw *attached_keyboard;
+};
+
+/* locate or allocate the next display with an un-occupied framebuffer */
+static
+struct rfb_instance_ *rfbScreen_next_available_display_(struct dynamic_array *rfbScreens, int argc, char *argv[]) {
+    size_t i;
+    struct rfb_instance_ new_instance, *s;
+
+    fprintf(stderr, "DEBUG: rfbScreens->entries:%zu\n", rfbScreens->entries);
+
+    for (i = 0; i < rfbScreens->entries; i++) {
+        s = (struct rfb_instance_ *)DYNARRAY_ITEM(*rfbScreens, i);
+        if (s->attached_display == NULL)
+            return s;
+    }
+
+    new_instance.screen = lem1802_rfb_new(argc, argv);
+    new_instance.attached_display = NULL;
+    new_instance.attached_keyboard = NULL;
+    s = dynarray_add(rfbScreens, &new_instance);
+    return s;
+}
+
+/* locate or allocate the next display with an un-occupied keyboard */
+static
+struct rfb_instance_ *rfbScreen_next_available_keyboard_(struct dynamic_array *rfbScreens, int argc, char *argv[]) {
+    size_t i;
+    struct rfb_instance_ new_instance, *s;
+
+    for (i = 0; i < rfbScreens->entries; i++) {
+        s = (struct rfb_instance_ *)DYNARRAY_ITEM(*rfbScreens, i);
+        if (s->attached_keyboard == NULL)
+            return s;
+    }
+
+    new_instance.screen = lem1802_rfb_new(argc, argv);
+    new_instance.attached_display = NULL;
+    new_instance.attached_keyboard = NULL;
+    s = dynarray_add(rfbScreens, &new_instance);
+    return s;
+}
+
+/* begin serving a screen */
+void rfbScreen_start(rfbScreenInfoPtr s) {
+    rfbInitServer(s);
+    rfbRunEventLoop(s, -1, TRUE);
+}
+#endif /* HAVE_LIBVNCSERVER */
+
 /*
     Here follows the various commands the shell can execute.
 
@@ -232,7 +300,7 @@ COMMAND_IMPL(dump) {
             return 0;
         }
     }
-    if (arg_count < 2) addr[0] = vm->pc;
+    if (arg_count < 2) addr[0] = vm->reg[DCPU16_REG_PC];
     if (arg_count < 3) addr[1] = addr[0];
 
     if (addr[1] < addr[0]) {
@@ -263,7 +331,7 @@ COMMAND_IMPL(disassemble) {
             return 0;
         }
     }
-    if (arg_count < 2) addr[0] = vm->pc;
+    if (arg_count < 2) addr[0] = vm->reg[DCPU16_REG_PC];
     if (arg_count < 3) addr[1] = addr[0];
 
     if (addr[1] < addr[0]) {
@@ -295,7 +363,7 @@ COMMAND_IMPL(step) {
         errno = 0;
         count = strtoul(arg_vector[1], &ep, 0);
         if (errno
-        ||  !(*arg_vector[0] && *ep == '\0') ) {
+        ||  !(*arg_vector[1] && *ep == '\0') ) {
             fprintf(stderr, "count '%s' is not a valid number: %s\n", arg_vector[1], strerror(errno));
             return 0;
         }
@@ -307,7 +375,7 @@ COMMAND_IMPL(step) {
     }
 
     while (count--) {
-        dcpu16_disassemble_print(vm, vm->pc);
+        dcpu16_disassemble_print(vm, vm->reg[DCPU16_REG_PC]);
         printf("\n");
         dcpu16_step(vm);
 
@@ -325,34 +393,118 @@ COMMAND_HELP(step) {
 }
 
 
+COMMAND_IMPL(set) {
+    int addr, value;
+    DCPU16_WORD *v;
+
+    (void)arg_count;
+
+    /* check if addr is a register */
+    for (addr = 0; dcpu16_reg_names[addr]; addr++) {
+        if (strcasecmp(arg_vector[1], dcpu16_reg_names[addr]) == 0)
+            break;
+    }
+    if (addr < DCPU16_REG__NUM) {
+        v = vm->reg + addr;
+    } else {
+        addr = str_to_word(arg_vector[1]);
+        if (addr < 0) {
+            fprintf(stderr, "address '%s' is not a valid word: %s\n", arg_vector[1], strerror(errno));
+            return 0;
+        }
+        v = vm->ram + addr;
+    }
+
+    value = str_to_word(arg_vector[2]);
+    if (value < 0) {
+        fprintf(stderr, "address '%s' is not a valid word: %s\n", arg_vector[2], strerror(errno));
+        return 0;
+    }
+
+    *v = value;
+
+    return 0;
+}
+
+COMMAND_HELP(set) {
+    fprintf(f, "\tset addr value\n");
+    if (summary) return;
+
+    fprintf(f, "Sets addr to value.");
+}
+
+#define MICROSECONDS_PER_CYCLE 10
 COMMAND_IMPL(run) {
-    sig_t osig;
+    struct sigaction act;
+    struct timeval run_start_tv, run_stop_tv;
+    long long run_cycle_start;
+    struct timeval start_tv, now_tv, diff_tv;
+    long long cycle_start, cycles_to_wait;
+    struct timespec sleep_time, rem_time;
+    long long run_usec;
+
     (void)arg_count, (void)arg_vector;
 
     running_ = 1;
+    gettimeofday(&run_start_tv, NULL);
+    run_cycle_start = vm->cycle;
+
+    memset(&act, 0, sizeof act);
+    act.sa_handler = sigint_handler_;
+    act.sa_flags = SA_RESETHAND;
 
-    /* install our new interrupt signal handler */
-    if ( (osig = signal(SIGINT, sigint_handler_)) == SIG_ERR ) {
-        fprintf(stderr, "%s():%s\n", "signal", strerror(errno));
+    if (sigaction(SIGINT, &act, NULL)) {
+        fprintf(stderr, "%s():%s\n", "sigaction", strerror(errno));
         return -1;
     }
 
-    while(running_) {
+    while (running_) {
+        gettimeofday(&start_tv, NULL);
+        cycle_start = vm->cycle;
+
         dcpu16_step(vm);
         if (opt_.verbose > 1)
             dcpu16_state_print(vm);
         else if (opt_.verbose) {
-            dcpu16_disassemble_print(vm, vm->pc);
+            dcpu16_disassemble_print(vm, vm->reg[DCPU16_REG_PC]);
             printf("\n");
         }
-    }
 
-    /* restore the old interrupt signal handler */
-    if (signal(SIGINT, osig) == SIG_ERR) {
-        fprintf(stderr, "%s():%s\n", "signal", strerror(errno));
-        return -1;
+        /* how many cycles did this instr use? */
+        cycles_to_wait = vm->cycle - cycle_start;
+
+        if (cycles_to_wait == 0)
+            continue;
+
+        /* each cycle wants 10 microseconds */
+
+        /* how much of that did we spend already */
+        gettimeofday(&now_tv, NULL);
+        timeval_subtract(&diff_tv, &now_tv, &start_tv);
+        /* do we have time to kill? */
+        if (cycles_to_wait * MICROSECONDS_PER_CYCLE > diff_tv.tv_usec) {
+            sleep_time.tv_sec = diff_tv.tv_sec;
+            /* this is not accurate.. */
+            sleep_time.tv_nsec = 250 * ( (cycles_to_wait * MICROSECONDS_PER_CYCLE) - diff_tv.tv_usec);
+
+            /* nanosleep doesn't interfere with libvncserver, unlike usleep */
+            while ( nanosleep(&sleep_time, &rem_time) ) {
+                sleep_time = rem_time;
+                fprintf(stderr, "rem:%ld %ld\n", rem_time.tv_sec, rem_time.tv_nsec);
+            }
+        }
     }
 
+    gettimeofday(&run_stop_tv, NULL);
+    timeval_subtract(&diff_tv, &run_stop_tv, &run_start_tv);
+    run_usec = diff_tv.tv_sec * 1000000;
+    run_usec += diff_tv.tv_usec;
+    fprintf(stderr, "ran %llu cycles in %lds %dus (%lldus)\n",
+            vm->cycle - run_cycle_start,
+            diff_tv.tv_sec,
+            diff_tv.tv_usec,
+            run_usec);
+
     printf("interrupted...\n");
 
     return 0;
@@ -365,6 +517,136 @@ COMMAND_HELP(run) {
                "May be interrupted with SIGINT.\n");
 }
 
+static const char * const display_filename_default_ =
+#ifdef HAVE_LIBPNG
+    "dcpu16-display.png"
+#else /* HAVE_LIBPNG */
+    "dcpu16-display.pnm"
+#endif /* HAVE_LIBPNG */
+;
+COMMAND_IMPL(display) {
+    struct dcpu16_hw *hw;
+    const char *renderer = arg_vector[1];
+    const char *renderer_arg = NULL;
+    void *renderer_data;
+
+    if (arg_count == 3)
+        renderer_arg = arg_vector[2];
+
+    hw = lem1802_new(vm);
+    if (hw == NULL) {
+        fprintf(stderr, "failed to initialize new display\n");
+        return 0;
+    }
+
+    /* handle per-renderer setup of data.. */
+    /* FIXME: these are awkward */
+    if (strcmp(renderer, "pnm") == 0) {
+        if (renderer_arg == NULL)
+            renderer_arg = display_filename_default_;
+        renderer_data = (void *)renderer_arg;
+    }
+
+#ifdef HAVE_LIBPNG
+    if (strcmp(renderer, "png") == 0) {
+        if (renderer_arg == NULL)
+            renderer_arg = display_filename_default_;
+        renderer_data = (void *)renderer_arg;
+    }
+#endif /* HAVE_LIBPNG */
+
+#ifdef HAVE_LIBVNCSERVER
+    if (strcmp(renderer, "vnc") == 0) {
+        int argc = 1;
+        char *argv[] = { "vm-dcpu16", NULL };
+        struct rfb_instance_ *s;
+
+        s = rfbScreen_next_available_display_(&rfbScreens_, argc, argv);
+        if (s == NULL) {
+            fprintf(stderr, "failed to initialize vnc\n");
+            lem1802_del(&hw);
+            return 0;
+        }
+
+        lem1802_vnc_associate(hw, s->screen);
+        s->attached_display = hw;
+        rfbScreen_start(s->screen);
+        renderer_data = s->screen;
+    }
+#endif /* HAVE_LIBVNCSERVER */
+
+    if (lem1802_renderer_set(hw, renderer, renderer_data)) {
+        fprintf(stderr, "failed to set back-end renderer for display\n");
+        lem1802_del(&hw);
+        return 0;
+    }
+
+    if (dcpu16_hw_add(vm, hw)) {
+        fprintf(stderr, "failed to attach new display\n");
+        lem1802_del(&hw);
+        return 0;
+    }
+
+    return 0;
+}
+COMMAND_HELP(display) {
+    char *name, *args;
+    void *iter;
+
+    fprintf(f, "\tdisplay renderer [renderer data]\n");
+    if (summary) return;
+
+    fprintf(f, "Attaches new display unit, using 'renderer' as back-end output.\n"
+            );
+
+    fprintf(f, "Supported renderers:\n");
+    iter = NULL;
+    while ( (lem1802_renderers_iter(&iter, &name, &args)) ) {
+        fprintf(f, "\t%s %s\n", name, args);
+    }
+}
+
+COMMAND_IMPL(keyboard) {
+    struct dcpu16_hw *hw;
+
+    (void)arg_count, (void)arg_vector;
+
+    hw = keyboard_new(vm);
+    if (hw == NULL) {
+        fprintf(stderr, "failed to initialize new keyboard\n");
+        return 0;
+    }
+
+#ifdef HAVE_LIBVNCSERVER
+    struct rfb_instance_ *s;
+    int argc = 1;
+    char *argv[] = { "vm-dcpu16", NULL };
+
+    s = rfbScreen_next_available_keyboard_(&rfbScreens_, argc, argv);
+    if (s == NULL) {
+        fprintf(stderr, "failed to initialize vnc\n");
+        keyboard_del(&hw);
+        return 0;
+    }
+    keyboard_vnc_associate(hw, s->screen);
+    s->attached_keyboard = hw;
+
+    if (dcpu16_hw_add(vm, hw)) {
+        fprintf(stderr, "failed to attach new keyboard\n");
+        keyboard_del(&hw);
+        return 0;
+    }
+#endif /* HAVE_LIBVNCSERVER */
+
+    return 0;
+}
+COMMAND_HELP(keyboard) {
+    fprintf(f, "\tkeyboard\n");
+    if (summary) return;
+
+    fprintf(f, "Attaches new keyboard unit.\n");
+}
+
 /* gather all these together into a searchable table */
 
 /* help command gets some assistance in declarations */
@@ -379,7 +661,10 @@ static struct command_ command_table_[] = {
     COMMAND_ENTRY(disassemble, 0, 2),
     COMMAND_ENTRY(step, 0, 1),
     COMMAND_ENTRY(run, 0, 0),
+    COMMAND_ENTRY(set, 2, 2),
     COMMAND_ENTRY(reset, 0, 0),
+    COMMAND_ENTRY(display, 1, 2),
+    COMMAND_ENTRY(keyboard, 0, 0),
     { NULL, 0, 0, NULL, NULL }
 };
 
@@ -450,6 +735,13 @@ int main(int argc, char **argv) {
         exit(EX_UNAVAILABLE);
     }
 
+#ifdef HAVE_LIBVNCSERVER
+    if (dynarray_init(&rfbScreens_, sizeof(struct rfb_instance_), 4)) {
+        fprintf(stderr, "could not allocate rfb container\n");
+        exit(EX_UNAVAILABLE);
+    }
+#endif /* HAVE_LIBVNCSERVER */
+
     if (argc) {
         if (file_load_(vm, *argv, 0)) {
             fprintf(stderr, "couldn't load '%s'\n", *argv);
@@ -461,13 +753,13 @@ int main(int argc, char **argv) {
     for (line = line_prev = NULL,
          tok_v = tok_v_prev = NULL,
          tok_c = tok_c_prev= 0,
-         snprintf(prompt, sizeof prompt, prompt_fmt, vm->pc),
+         snprintf(prompt, sizeof prompt, prompt_fmt, vm->reg[DCPU16_REG_PC]),
          dcpu16_state_print(vm);
 
          (line = readline(prompt));
 
          printf("\n"),
-         snprintf(prompt, sizeof prompt, prompt_fmt, vm->pc),
+         snprintf(prompt, sizeof prompt, prompt_fmt, vm->reg[DCPU16_REG_PC]),
          dcpu16_state_print(vm)) {
         const char whitespace[] = " \t";
         char *line_start;