mix vm command dispatch refactoring

1 files changed, 70 insertions, 875 deletions

diff --git a/mixutils/mixvm_command.c b/mixutils/mixvm_command.c
index c585363..516bd68 100644
--- a/mixutils/mixvm_command.c
+++ b/mixutils/mixvm_command.c
@@ -24,7 +24,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <ctype.h>
-#include <errno.h>
 #include <readline/readline.h>
 #include <readline/history.h>
 
@@ -32,6 +31,7 @@
 #include <mixlib/mix_vm_dump.h>
 #include <mixlib/mix_eval.h>
 #include <mixlib/mix_src_file.h>
+#include <mixlib/mix_vm_command.h>
 #include "mixvm_command.h"
 
 /* The names of functions that actually do the manipulation. */
@@ -40,31 +40,8 @@ static int cmd_##name (char *arg)
 
 DEC_FUN (help_);
 DEC_FUN (shell_);
-DEC_FUN (load_);
-DEC_FUN (run_);
-DEC_FUN (next_);
-DEC_FUN (pc_);
-DEC_FUN (psym_);
-DEC_FUN (preg_);
-DEC_FUN (pflags_);
-DEC_FUN (pall_);
-DEC_FUN (pmem_);
-DEC_FUN (sreg_);
-DEC_FUN (scmp_);
-DEC_FUN (sover_);
-DEC_FUN (smem_);
-DEC_FUN (ssym_);
-DEC_FUN (sbp_);
-DEC_FUN (sbpa_);
-DEC_FUN (cbp_);
-DEC_FUN (cbpa_);
-DEC_FUN (cabp_);
 DEC_FUN (compile_);
 DEC_FUN (edit_);
-DEC_FUN (weval_);
-DEC_FUN (w2d_);
-DEC_FUN (tron_);
-DEC_FUN (troff_);
 DEC_FUN (quit_);
 
 /* A structure which contains information on the commands this program
@@ -78,47 +55,20 @@ typedef struct {
      
 COMMAND commands[] = {
   { "help", cmd_help_, N_("Display this text"), "help [COMMAND]" },
-  { "?", cmd_help_, N_("Synonym for `help'"), "? [COMMAND]" },
-  { "!", cmd_shell_, N_("Execute shell command"), "! COMMAND" },
-  { "load", cmd_load_, N_("Load a MIX code file"), "load FILENAME" },
-  { "run", cmd_run_, N_("Run loaded or given MIX code file"), 
-    "run [FILENAME]" },
-  { "next", cmd_next_, N_("Execute next instruction(s)"), 
-    "next [NO_OF_INS]"},
-  { "pc", cmd_pc_, N_("Print program counter value"), "pc" },
-  { "psym", cmd_psym_, N_("Print symbol value"), "psym [SYMBOLNAME]" },
-  { "preg", cmd_preg_, N_("Print register value"), 
-    "preg [A | X | J | I[1-6]]" },
-  { "pflags", cmd_pflags_, N_("Print comparison and overflow flags"), 
-    "pflags" },
-  { "pall", cmd_pall_, N_("Print all registers and flags"), "pall" },
-  { "pmem", cmd_pmem_, N_("Print memory contents in address range"), 
-    "pmem FROM[-TO]" },
-  { "sreg", cmd_sreg_, N_("Set register value"), 
-    "preg A | X | J | I[1-6] VALUE" },
-  { "scmp", cmd_scmp_, N_("Set comparison flag value"), "scmp L | E | G" },
-  { "sover", cmd_sover_, N_("Set overflow flag value"), "sover T | F" },
-  { "smem", cmd_smem_, N_("Set memory contents in given address"), 
-    "smem ADDRESS VALUE" },
-  { "ssym", cmd_ssym_, N_("Set a symbol\'s value"), "ssym SYMBOL WEXPR" },
-  { "sbp", cmd_sbp_, N_("Set break point at given line"), "sbp LINENO" },
-  { "cbp", cmd_cbp_, N_("Clear break point at given line"), "cbp LINENO" },
-  { "sbpa", cmd_sbpa_, N_("Set break point at given address"),
-    "sbpa ADDRESS" },
-  { "cbpa", cmd_cbpa_, N_("Clear break point at given address"),
-    "cbpa ADDRESS" },
-  { "cabp", cmd_cabp_, N_("Clear all breakpoints"), "cabp" },
+  { "shell", cmd_shell_, N_("Execute shell command"), "shell COMMAND" },
   { "compile", cmd_compile_, N_("Compile a source file"), "compile FILENAME"},
   { "edit", cmd_edit_, N_("Edit a source file"), "edit FILENAME"},
-  { "weval", cmd_weval_, N_("Evaluate a given W-expres sion"), "weval WEXPR"},
-  { "w2d", cmd_w2d_, N_("Convert a MIX word to its decimal value"),
-    "w2d WORD" },
-  { "tron", cmd_tron_, N_("Turn on instruction tracing."), "tron" },
-  { "troff", cmd_troff_, N_("Turn off instruction tracing."), "troff" },
   { "quit", cmd_quit_, N_("Quit the program"), "quit" },
   { (char *)NULL, (Function *)NULL, (char *)NULL }
 };
 
+#define LOCAL_COMANDS_NO_  ((sizeof (commands) / sizeof (commands[0])) - 1)
+#define MIX_COMMANDS_NO_ MIX_CMD_INVALID+1
+#define ALL_COMMANDS_NO_ LOCAL_COMANDS_NO_+MIX_COMMANDS_NO_
+
+static const char *mix_commands_[ALL_COMMANDS_NO_] = {NULL};
+
+
 
 /* readline functions */
 static char *
@@ -165,14 +115,13 @@ mixvm_cmd_generator_ (char *text, int state)
     }
      
   /* Return the next name which partially matches from the command list. */
-  while ( (name = commands[list_index].name) != NULL)
+  while ((name = mix_commands_[list_index]) != NULL)
     {
       list_index++;
-     
       if (strncmp (name, text, len) == 0)
 	return (g_strdup (name));
     }
-     
+
   /* If no names matched, then return NULL. */
   return ((char *)NULL);
 }
@@ -191,113 +140,31 @@ find_command_ (const char *name)
 }
 
 
-/* the virtual machine and dump context */
-static mix_vm_t *vm_ = NULL;
-static mix_dump_context_t *dc_ = NULL;
-/* the w-expression evaluator */
-static mix_eval_t *eval_ = NULL;
-/* trace status */
-static gboolean is_tracing_ = FALSE;
-/* uptime */
-static mix_time_t uptime_ = 0;
-static mix_time_t prog_time_ = 0;
-/* emacs interface */
-static gboolean emacs_ = FALSE;
+/* mixvm dispatcher */
+static mix_vm_cmd_dispatcher_t *dis_ = NULL;
 
-
-/* auxiliar methods */
 /* emacs interface */
 static void
-emacs_output_ (void);
-
-/* trace current instruction */
-static void
-trace_ (void);
-
-/* run a program tracing executed instructions */
-static int
-run_and_trace_ (void);
-
-/* print time statistics */
-static void
-print_time_ (void);
-
-
-static void
-emacs_output_ (void)
+emacs_output_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg, gpointer data)
 {
   /* pek: probably bad that we snag the src w/every emacs_output_,
      however when multiple files are supported then this will
      have to be done each time (but the info will be snagged
      from elsewhere...) */
-  const mix_src_file_t *src = mix_vm_get_src_file (vm_);
+  const mix_vm_t *vm = mix_vm_cmd_dispatcher_get_vm (dis);
+  const mix_src_file_t *src = mix_vm_get_src_file (vm);
   const gchar *path = mix_src_file_get_path (src);
   
-  mix_address_t loc = mix_vm_get_prog_count (vm_);
-  guint lineno = mix_vm_get_address_lineno (vm_, loc);
+  mix_address_t loc = mix_vm_get_prog_count (vm);
+  guint lineno = mix_vm_get_address_lineno (vm, loc);
 
   printf ("\032\032mixvm:%s%s:%d\n", path, MIX_SRC_DEFEXT, lineno);
   return;
 }
 
-/* trace current instruction */
-static void
-trace_ (void)
-{
-  enum {BUFFER_LEN = 128};
-  static gchar STRINS[BUFFER_LEN];
-  
-  const mix_src_file_t *file = mix_vm_get_src_file (vm_);
-  const gchar *line = "\n";
-  mix_address_t loc = mix_vm_get_prog_count (vm_);
-  mix_word_t ins = mix_vm_get_addr_contents (vm_, loc);
-  mix_ins_t fins;
-  mix_word_to_ins_uncheck (ins, fins);
-  mix_ins_to_string_in_buffer (&fins, STRINS, BUFFER_LEN);
-  
-  if (file != NULL)
-    {
-      gulong b = mix_vm_get_break_lineno (vm_);
-      if (b > 0) line = mix_src_file_get_line (file, b);
-    }
-  
-  printf ("%d: [%s]\t%s", (gint)loc, STRINS, line);
-}
-
-/* run a program tracing executed instructions */
-static int
-run_and_trace_ (void)
-{
-  int k = MIX_VM_OK;
-  if (!is_tracing_)
-    return mix_vm_run (vm_);
-  else while (k == MIX_VM_OK)
-    {
-      trace_ ();
-      k = mix_vm_exec_next (vm_);
-    }
-  return k;
-}
-
-/* print time statistics */
-static void
-print_time_ (void)
-{
-  mix_time_t lapse = mix_vm_get_uptime(vm_) - uptime_;
-  uptime_ += lapse;
-  prog_time_ += lapse;
-  printf(_("Elapsed time: %ld /Total program time: %ld (Total uptime: %ld)\n"),
-	 lapse, prog_time_, uptime_);
-}
-
-
-/* commands */
-
 static int
 cmd_help_ (char *arg)
 {
-  static const int NO_OF_COLS = 6;
-  
   int i;
   int printed = 0;
      
@@ -310,625 +177,36 @@ cmd_help_ (char *arg)
 	  printed++;
 	}
     }
-     
-  if (!printed)
+
+  if (printed > 1) printf ("\n");
+
+  for (i = LOCAL_COMANDS_NO_ + 1 /* skip help cmd */; mix_commands_[i]; i++)
     {
-      printf (_("No commands match `%s'.  Possibilities are:\n"), arg);
-     
-      for (i = 0; commands[i].name; i++)
+      if (!*arg || (strcmp (arg, mix_commands_[i]) == 0))
 	{
-	  if (printed == NO_OF_COLS)
-	    {
-	      printed = 0;
-	      printf ("\n");
-	    }
-     
-	  printf ("%s\t", commands[i].name);
+	  printf (_("%s\t\t%s. Usage: %s\n"), mix_commands_[i], 
+		  mix_vm_command_help (i - LOCAL_COMANDS_NO_),
+		  mix_vm_command_usage (i - LOCAL_COMANDS_NO_));
 	  printed++;
 	}
-     
-      if (printed)
-	printf ("\n");
-    }
-  return TRUE;
-}
-
-static int
-cmd_load_ (char *arg)
-{
-  errno = 0;
-  if (arg == NULL || *arg == '\0')
-    {
-      fputs (_("Missing file name\n"), stderr);
-      return TRUE;
-    }
-  mix_eval_remove_symbols_from_table (eval_,
-				      mix_vm_get_symbol_table (vm_));
-  if (!mix_vm_load_file (vm_, arg) )
-    {
-      fprintf (stderr, _("Cannot load %s: "), arg);
-      if ( errno == 0 )
-	fputs (_("Wrong file format\n"), stderr);
-      else
-	perror (NULL);
-      return TRUE + 1;
-    }
-  mix_eval_set_symbols_from_table (eval_,
-				   mix_vm_get_symbol_table (vm_));
-
-  fprintf (stderr, _("Program loaded. Start address: %d\n"),
-	   mix_vm_get_prog_count (vm_));
-  
-  prog_time_ = 0;
-  
-  if (emacs_)
-    {
-      emacs_output_();
     }
-
-  return TRUE;
-}
-
-
-static int
-cmd_run_ (char *arg)
-{
-  if (arg != NULL && *arg != '\0' && cmd_load_ (arg) != TRUE) 
-      return TRUE;
-  puts (_("Running ..."));
   
-  if (mix_vm_is_halted (vm_))
-    {
-      mix_vm_reset_program (vm_);
-      prog_time_ = 0;
-    }
+  if (!printed) printf ("Command \'%s\' not found\n", arg);
   
-  switch (run_and_trace_ ())
-    {
-    case MIX_VM_HALT:
-      puts (_("... done"));
-      break;
-    case MIX_VM_BREAK:
-      {
-	gulong line = mix_vm_get_break_lineno (vm_);
-	if (line != 0)
-	  printf (_("... stopped: breakpoint at line %ld (address %d)\n"), 
-		  line, mix_vm_get_prog_count (vm_));
-	else
-	  printf (_("... stopped: breakpoint at address %d\n"),
-		  mix_vm_get_prog_count (vm_));
-      }
-      break;
-    case MIX_VM_ERROR:
-      puts (_("... error executing loaded file"));
-      break;
-    default:
-      g_assert_not_reached ();
-      break;
-    }
-  print_time_ ();
-
-  if (emacs_)
-    {
-      emacs_output_();
-    }
-
   return TRUE;
-}
-
-static int
-cmd_next_ (char *arg)
-{
-  int ins_no = 1;
-  int k;
-
-  if ( strlen (arg) != 0 )
-    {
-      int k = 0;
-      while (isdigit (arg[k]))
-	k++;
-      if (arg[k] != '\0')
-	{
-	  fprintf (stderr, _("Invalid argument: %s\n"), arg);
-	  return cmd_help_ ("next");
-	}
-      ins_no = atoi (arg);
-    }
-
-  if (mix_vm_is_halted (vm_))
-    {
-      mix_vm_reset_program (vm_);
-      prog_time_ = 0;
-    }
   
-  while ( ins_no-- > 0 )
-    {
-      if (is_tracing_) trace_ ();
-      k = mix_vm_exec_next (vm_);
-      if (k == MIX_VM_HALT)
-	{
-	  fprintf (stderr, _("End of program reached at address %d\n"),
-		   mix_vm_get_prog_count (vm_));
-	  break;
-	}
-      else if (k == MIX_VM_ERROR)
-	{
-	  fprintf (stderr, _("Error at address %d\n"),
-		   mix_vm_get_prog_count (vm_));
-	  break;
-	}
-    }
-  print_time_ ();
-
-  if (emacs_)
-    {
-      emacs_output_();
-    }
-
-  return TRUE;
 }
 
 static int
 cmd_quit_ (char *arg)
 {
   puts ("Quitting ...");
-  if ( vm_ ) mix_vm_delete (vm_);
-  if ( dc_ ) mix_dump_context_delete (dc_);
+  if ( dis_ ) mix_vm_cmd_dispatcher_delete (dis_);
 
   /* pek: anything needed here to make the marker disappear??? */
   return FALSE;
 }
 
-static int
-cmd_pc_ (char *arg)
-{
-  printf ("Current address: %d\n", mix_vm_get_prog_count (vm_));
-  return TRUE;
-}
-
-static int
-cmd_psym_ (char *arg)
-{
-  const mix_symbol_table_t *table = mix_eval_symbol_table (eval_);
-  if ( table == NULL )
-    fputs (_("Symbol table not available\n"), stderr);
-  else if (arg != NULL && *arg != '\0')
-    {
-      if ( mix_symbol_table_is_defined (table, arg) )
-	{
-	  mix_word_print (mix_symbol_table_value (table, arg), NULL);
-	  putc ('\n', stdout);
-	}
-      else
-	printf (_("%s: symbol not defined\n"), arg);
-    }
-  else
-    mix_symbol_table_print (table, MIX_SYM_ROWS, stdout, TRUE);
-      
-  return TRUE;
-}
-
-static int
-cmd_preg_ (char *arg)
-{
-  mix_dump_context_set_opt (dc_, MIX_DUMP_NONE);
-  if ( strlen (arg) == 0 )
-    mix_dump_context_add_opt (dc_, MIX_DUMP_rALL);
-  else switch (*arg)
-    {
-    case 'A':
-      mix_dump_context_add_opt (dc_, MIX_DUMP_rA);
-      break;
-    case 'X':
-      mix_dump_context_add_opt (dc_, MIX_DUMP_rX);
-      break;
-    case 'J':
-      mix_dump_context_add_opt (dc_, MIX_DUMP_rJ);
-      break;
-    case 'I':
-      {
-	if ( strlen (arg) == 1 )
-	  mix_dump_context_add_opt (dc_, MIX_DUMP_rIa);
-	else
-	  {
-	    static gint32 opt[] = { MIX_DUMP_rI1, MIX_DUMP_rI2,
-				    MIX_DUMP_rI3, MIX_DUMP_rI4,
-				    MIX_DUMP_rI5, MIX_DUMP_rI6 
-	    };
-	    int i = arg[1] - '1';
-	    if ( i < 0 || i > 5 )
-	      {
-		fprintf (stderr, _("Invalid I index: %d"), i);
-		return TRUE;
-	      }
-	    mix_dump_context_add_opt (dc_, opt[i]);
-	  }
-      }
-      break;
-    default:
-      fprintf (stderr, _("Invalid argument: %s\n"), arg);
-      return TRUE;
-    }
-  mix_vm_dump (vm_, dc_);
-  return TRUE;
-}
-
-static int
-cmd_pflags_ (char *arg)
-{
-  mix_dump_context_set_opt (dc_, MIX_DUMP_CMP | MIX_DUMP_OVER);
-  mix_vm_dump (vm_, dc_);
-  return TRUE;
-}
-
-static int
-cmd_pall_ (char *arg)
-{
-  mix_dump_context_set_opt (dc_, MIX_DUMP_ALL_NOMEM);
-  mix_vm_dump (vm_, dc_);
-  return TRUE;
-}
-
-static int
-cmd_pmem_ (char *arg)
-{
-  glong begin = MIX_SHORT_ZERO, end = MIX_SHORT_ZERO;
-  int i = 0;
-  gboolean error = FALSE;
-  
-  if ( strlen (arg) == 0 )
-    {
-      fputs (_("Missing memory address\n"), stderr);
-      return TRUE;
-    }
-  while (isdigit (arg[i]))
-    i++;
-  while (isspace (arg[i]))
-    i++;
-  if (arg[i] == '\0')
-      begin = end = atol (arg);
-  else if (arg[i] == '-')
-    {
-      arg[i++] = '\0';
-      begin = atol (arg);
-      arg = arg + i;
-      i = 0;
-      while (isdigit (arg[i]))
-	i++;
-      while (isspace (arg[i]))
-	i++;
-      if (arg[i] != '\0') 
-	error = TRUE;
-      else 
-	end = atol (arg);
-    }
-  else
-    error = TRUE;
-  
-  if (error)
-    {
-      fprintf (stderr, _("Invalid argument: %s\n"), arg);
-      return cmd_help_("pmem");
-    }
-  if ( end < begin || end > MIX_VM_CELL_NO - 1 )
-    {
-      fprintf (stderr, _("Invalid range: %ld-%ld\n"), begin, end);
-      return TRUE;
-    }
-
-  mix_dump_context_set_opt (dc_, MIX_DUMP_CELLS);
-  mix_dump_context_range (dc_, mix_short_new (begin), mix_short_new (end + 1));
-  mix_vm_dump (vm_, dc_);
-  
-  return TRUE;
-}
-
-static int
-cmd_sreg_ (char *arg)
-{
-  int i = 0;
-  char reg = arg[0];
-  gboolean ok = TRUE;
-  long value;
-  
-  i = (reg == 'I') ? 2 : 1;
-  ok = strlen (arg) > 2 && isspace (arg[i]);
-  if (ok)
-    {
-      while (isspace (arg[i])) i++;
-      ok = isdigit (arg[i]) || arg[i] == '+' || arg[i] == '-';
-      if (ok)
-	{
-	  value = atol (arg + i);
-	  if (arg[i] == '+' || arg[i] == '-') i++;
-	  while (isdigit (arg[i])) i++;
-	  ok = (arg[i] == '\0');
-	  if (ok)
-	    switch (reg)
-	      {
-	      case 'A':
-		mix_vm_set_rA (vm_, mix_word_new (value));
-		break;
-	      case 'X':
-		mix_vm_set_rX (vm_, mix_word_new (value));
-		break;
-	      case 'J':
-		if ( value >= 0 )
-		  mix_vm_set_rJ (vm_, mix_short_new (value));
-		else
-		  ok = FALSE;
-		break;
-	      case 'I':
-		{
-		  guint k = arg[1] - '0';
-		  if ( k < 7 ) 
-		    mix_vm_set_rI (vm_, k, mix_short_new (value));
-		  else
-		    ok = FALSE;
-		}
-		break;
-	      default:
-		ok = FALSE;
-	      }
-	}
-    }
-  if (!ok)
-    {
-      fprintf (stderr, _("Invalid argument: %s\n"), arg);
-      cmd_help_ ("sreg");
-    }
-    
-  return TRUE;
-}
-
-static int
-cmd_scmp_ (char *arg)
-{
-  gboolean ok = (strlen (arg) == 1);
-  if (ok) switch (arg[0])
-    {
-    case 'L':
-      mix_vm_set_cmpflag (vm_, mix_LESS);
-      break;
-    case 'E':
-      mix_vm_set_cmpflag (vm_, mix_EQ);
-      break;
-    case 'G':
-      mix_vm_set_cmpflag (vm_, mix_GREAT);
-      break;
-    default:
-      ok = FALSE;
-    }
-  if (!ok)
-    {
-      fprintf (stderr, _("Invalid argument: %s\n"), arg);
-      cmd_help_ ("scmp");
-    }
-  
-  return TRUE;
-}
-
-static int
-cmd_sover_ (char *arg)
-{
-  gboolean ok = (strlen (arg) == 1);
-  if (ok) switch (arg[0])
-    {
-    case 'T':
-      mix_vm_set_overflow (vm_, TRUE);
-      break;
-    case 'F':
-      mix_vm_set_overflow (vm_, FALSE);
-      break;
-    default:
-      ok = FALSE;
-    }
-  if (!ok)
-    {
-      fprintf (stderr, _("Invalid argument: %s\n"), arg);
-      cmd_help_ ("sover");
-    }
-  
-  return TRUE;
-}
-
-static int
-cmd_smem_ (char *arg)
-{
-  gboolean ok = (strlen (arg) > 2 && isdigit (arg[0]));
-  gulong addr;
-  glong value;
-  int k = 0;
-  
-  if (ok)
-    {
-      while (isdigit (arg[k])) k++;
-      ok = isspace (arg[k]);
-      if (ok)
-	{
-	  arg[k++] = '\0';
-	  addr = atol (arg);
-	  ok = addr < MIX_VM_CELL_NO;
-	}
-      if (ok)
-	{
-	  while (isspace (arg[k])) k++;
-	  value = atol (arg + k);
-	  if ( arg[k] == '+' || arg[k] == '-' ) k++;
-	  while (isdigit (arg[k])) k++;
-	  ok = arg[k] == '\0';
-	}
-    }
-
-  if (ok)
-    mix_vm_set_addr_contents (vm_, mix_short_new (addr), mix_word_new (value));
-  else
-    {
-      fprintf (stderr, "Invalid argument: %s\n", arg);
-      cmd_help_ ("smem");
-    }
-  
-  return TRUE;
-}
-
-static int
-cmd_ssym_ (char *arg)
-{
-  if (arg == NULL || strlen(arg) == 0)
-    {
-      fprintf (stderr, _("Missing arguments\n"));
-      return cmd_help_ ("ssym");
-    }
-  else
-    {
-      gchar *a = g_strdup (arg);
-      gchar *s = strtok (a, " \t");
-      gchar *w = strtok (NULL, " \t");
-      if (w != NULL && strtok (NULL, " \t") == NULL)
-	{
-	  cmd_weval_ (w);
-	  if (mix_eval_last_error (eval_) == MIX_EVAL_OK)
-	    mix_eval_set_symbol (eval_, s, mix_eval_value (eval_));
-	}
-      else
-	{
-	  fprintf (stderr, _("Wrong argument number\n"));
-	  cmd_help_ ("ssym");
-	}
-      g_free (a);
-      return TRUE;
-    }
-}
-
-static int
-cmd_sbp_ (char *arg)
-{
-  glong lineno;
-  glong k = 0;
-  while (isdigit (arg[k])) k++;
-  if (arg[k] != '\0')
-    {
-      fprintf (stderr, _("Invalid argument: %s\n"), arg);
-      return cmd_help_ ("sbp");
-    }
-  lineno = atol (arg);
-  switch (k = mix_vm_set_breakpoint (vm_, lineno))
-    {
-    case MIX_VM_BP_INV_LINE:
-      fprintf (stderr, _("Line number %ld too high\n"), lineno);
-      break;
-    case MIX_VM_BP_ERROR:
-      fputs (_("Could not set breakpoint. Internal error\n"), stderr);
-      break;
-    case MIX_VM_BP_NDEBUG:
-      fputs (_("Could not set breakpoint. No debug info available\n"), stderr);
-      break;
-    default:
-      fprintf (stderr, _("Breakpoint set at line %ld\n"), k);
-      break;
-    }
-  return TRUE;
-}
-
-static int
-cmd_sbpa_ (char *arg)
-{
-  glong address;
-  glong k = 0;
-  while (isdigit (arg[k])) k++;
-  if (arg[k] != '\0')
-    {
-      fprintf (stderr, _("Invalid argument: %s\n"), arg);
-      return cmd_help_ ("sbpa");
-    }
-  address = atol (arg);
-  switch (mix_vm_set_breakpoint_address (vm_, address))
-    {
-    case MIX_VM_BP_INV_ADDRESS:
-      fprintf (stderr, _("Invalid address %ld\n"), address);
-      break;
-    case MIX_VM_BP_ERROR:
-      fputs (_("Could not set breakpoint. Internal error\n"), stderr);
-      break;
-    default:
-      fprintf (stderr, _("Breakpoint set at address %ld\n"), address);
-      break;
-    }
-  return TRUE;
-}
-
-static int
-cmd_cbp_ (char *arg)
-{
-  glong lineno;
-  int k = 0;
-  while (isdigit (arg[k])) k++;
-  if (arg[k] != '\0')
-    {
-      fprintf (stderr, _("Invalid argument: %s\n"), arg);
-      return cmd_help_ ("cbp");
-    }
-  lineno = atol (arg);
-  switch (mix_vm_clear_breakpoint (vm_, lineno))
-    {
-    case MIX_VM_BP_INV_LINE:
-      fprintf (stderr, _("No breakpoint set at line %ld\n"), lineno);
-      break;
-    case MIX_VM_BP_ERROR:
-      fputs (_("Could not set breakpoint. Internal error\n"), stderr);
-      break;
-    case MIX_VM_BP_NDEBUG:
-      fputs (_("No debug info available\n"), stderr);
-      break;
-    case MIX_VM_BP_OK:
-      fprintf (stderr, _("Breakpoint cleared at line %ld\n"), lineno);
-      break;
-    default:
-      g_assert_not_reached ();
-      break;
-    }
-  return TRUE;
-}
-
-static int
-cmd_cbpa_ (char *arg)
-{
-  glong address;
-  glong k = 0;
-  while (isdigit (arg[k])) k++;
-  if (arg[k] != '\0')
-    {
-      fprintf (stderr, _("Invalid argument: %s\n"), arg);
-      return cmd_help_ ("cbpa");
-    }
-  address = atol (arg);
-  switch (mix_vm_clear_breakpoint_address (vm_, address))
-    {
-    case MIX_VM_BP_INV_ADDRESS:
-      fprintf (stderr, _("Invalid address %ld\n"), address);
-      break;
-    case MIX_VM_BP_ERROR:
-      fputs (_("Could not clear breakpoint. Internal error\n"), stderr);
-      break;
-    default:
-      fprintf (stderr, _("Breakpoint cleared at address %ld\n"), address);
-      break;
-    }
-  return TRUE;
-}
-
-
-static int
-cmd_cabp_ (char *arg)
-{
-  if (strlen (arg) != 0)
-    {
-      fprintf (stderr, _("Invalid argument: %s\n"), arg);
-      return cmd_help_ ("cabp");
-    }
-  mix_vm_clear_all_breakpoints (vm_);
-  return TRUE;
-}
 
 static int 
 cmd_shell_ (char *arg)
@@ -957,8 +235,8 @@ static int
 cmd_edit_ (char *arg)
 {
   static const gchar * envars[] = { "MDK_EDITOR", "X_EDITOR", "EDITOR",
-				    "VISUAL" 
-  };
+				    "VISUAL" };
+  
   static const guint s = sizeof (envars) / sizeof (envars[0]);
   static const gchar *editor = NULL;
   
@@ -989,117 +267,38 @@ cmd_edit_ (char *arg)
   return TRUE;
 }
 
-static int
-cmd_weval_ (char *arg)
-{
-  if ( strlen (arg) == 0 )
-    return cmd_help_ ("weval");
-
-  if (mix_eval_expression_with_loc (eval_, arg,
-				    mix_vm_get_prog_count (vm_)) ==
-      MIX_EVAL_OK)
-    {
-      mix_word_print (mix_eval_value (eval_), NULL);
-      putc ('\n', stdout);
-    }
-  else
-    {
-      gint pos = mix_eval_last_error_pos (eval_);
-      gint k, len = strlen (arg);
-      g_assert(pos > -1 && pos <= len);
-      for (k = 0; k<pos; ++k) fputc (arg[k], stderr);
-      fputc ('\n', stderr);
-      for (k = 0; k<pos; ++k) fputc (' ', stderr);
-      for (k = pos; k < len; ++k) fputc (arg[k], stderr);
-      fprintf (stderr, _("\nEvaluation error: %s\n"),
-	       mix_eval_last_error_string (eval_));
-    }
-        
-  return TRUE;
-}
-
-static int
-cmd_w2d_ (char *arg)
-{
-  if ( strlen (arg) == 0 )
-    return cmd_help_ ("w2d");
-  else 
-    {
-      gchar *cp = g_strdup (arg), *a = cp;
-      mix_byte_t bytes[5] = {0, 0, 0, 0, 0};
-      gchar *b;
-      guint k = 0;
-      gboolean is_n = (a[0] == '-'), success = TRUE;
-      if (a[0] == '+' || a[0] == '-') ++a;
-      b = strtok (a, " \t");
-      while (b != NULL && k < 5)
-	{
-	  if (strlen (b) != 2 || !isdigit(b[0]) || !isdigit(b[1]))
-	    {
-	      fprintf (stderr, _("Incorrect byte specification: %s\n"), b);
-	      success = FALSE;
-	      b = NULL;
-	    }
-	  else
-	    {
-	      bytes[k++] = mix_byte_new (atoi (b));
-	      b = strtok (NULL, " \t");
-	    }
-	}
-      if (success) 
-	{
-	  if (strtok (NULL, "\t") != NULL)
-	    fprintf (stderr, _("The expression %s does not fit in a word\n"),
-		     arg);
-	  else
-	    {
-	      mix_word_t w = mix_bytes_to_word (bytes, k);
-	      fprintf (stdout, "%s%ld\n", is_n? "-":"+",
-		       mix_word_magnitude (w));
-	    }
-	}
-      g_free (cp);
-    }
-  
-  return TRUE;
-}
-
-static int
-cmd_tron_ (char *arg)
-{
-  is_tracing_ = TRUE;
-  printf (_("Instruction tracing has been turned ON.\n"));
-  return TRUE;
-}
-
-static int
-cmd_troff_ (char *arg)
-{
-  is_tracing_ = FALSE;
-  printf (_("Instruction tracing has been turned OFF.\n"));
-  return TRUE;
-}
 
 
 /* external interface */
 void
 mixvm_cmd_init (char *arg, gboolean use_emacs)
 {
+  int k;
+  /* get local command names */
+  for (k = 0; k < LOCAL_COMANDS_NO_; ++k)
+    mix_commands_[k] = commands[k].name;
+  /* get external command names */
+  for (k = 0; k < MIX_CMD_INVALID; ++k)
+    mix_commands_[k + LOCAL_COMANDS_NO_] = mix_vm_command_to_string (k);
+  mix_commands_[ALL_COMMANDS_NO_ - 1] = NULL;
   /* Tell the completer that we want a crack first. */
   rl_attempted_completion_function = (CPPFunction *)mixvm_cmd_completion_;
-  /* set the emacs flag */
-  emacs_ = use_emacs;
-  /* initialise the vm */
-  vm_ = mix_vm_new ();
-  dc_ = mix_dump_context_new (MIX_DUMP_DEF_CHANNEL, 
-			      MIX_SHORT_ZERO, MIX_SHORT_ZERO,
-			      MIX_DUMP_ALL);
-  eval_ = mix_eval_new ();
-  
-  if ( vm_ == NULL || dc_ == NULL || eval_ == NULL)
+  /* initialise the dispatcher */
+  dis_ = mix_vm_cmd_dispatcher_new (stdout, stderr);
+
+  if ( dis_ == NULL)
     g_error (_("Failed initialisation (no memory resources)"));
+  
+  /* install post hook for emacs interaction */
+  if (use_emacs)
+    {
+      mix_vm_cmd_dispatcher_post_hook (dis_, MIX_CMD_LOAD, emacs_output_, NULL);
+      mix_vm_cmd_dispatcher_post_hook (dis_, MIX_CMD_RUN, emacs_output_, NULL);
+      mix_vm_cmd_dispatcher_post_hook (dis_, MIX_CMD_NEXT, emacs_output_, NULL);
+    }
+      
   if (arg)
-    cmd_load_ (arg);
+    mix_vm_cmd_dispatcher_dispatch (dis_, MIX_CMD_LOAD, arg);
 }
 
 gboolean
@@ -1107,7 +306,8 @@ mixvm_cmd_exec (char *line)
 {
   int i;
   COMMAND *command;
-  char *word;
+  char *cmd, *arg;
+  mix_vm_command_t mix_cmd;
 
   if (!line) return cmd_quit_(NULL);
   
@@ -1118,7 +318,7 @@ mixvm_cmd_exec (char *line)
   i = 0;
   while (line[i] && isspace (line[i]))
     i++;
-  word = line + i;
+  cmd = line + i;
      
   while (line[i] && !isspace (line[i]))
     i++;
@@ -1126,34 +326,29 @@ mixvm_cmd_exec (char *line)
   if (line[i])
     line[i++] = '\0';
      
-  if (word == NULL || strlen (word) == 0)
+  if (cmd == NULL || strlen (cmd) == 0)
     return TRUE;
   
-  command = find_command_ (word);
-     
-  if (!command)
-    {
-      fprintf (stderr, _("%s: No such command. Try \'help\'\n"), word);
-      return TRUE;
-    }
-     
   /* Get argument to command, if any. */
   while (isspace (line[i]))
     i++;
      
-  word = line + i;
+  arg = line + i;
      
-  /* pek note: as far as I know, only load, run,
-     next, and quit can affect where gud will
-     displays the "marker".  I am toying with the
-     idea of adding some logic before and after
-     the *(command->func) that determines if
-     either the source file or line number have
-     changed.  If another command is added later,
-     then the logic won't have to be inserted... */
+  /* try to find local command */
+  command = find_command_ (cmd);
+  if (command)
+    return ((*(command->func)) (arg));
 
-  /* Call the function. */
-  return ((*(command->func)) (word));
+  /* try to find mix command */
+  mix_cmd = mix_vm_command_from_string (cmd);
+  
+  if (mix_cmd == MIX_CMD_INVALID)
+    fprintf (stderr, _("%s: No such command. Try \'help\'\n"), cmd);
+  else
+    mix_vm_cmd_dispatcher_dispatch (dis_, mix_cmd, arg);
+  
+  return TRUE;
 }