mix vm command dispatch refactoring

7 files changed, 1273 insertions, 78 deletions

diff --git a/mixlib/Makefile.am b/mixlib/Makefile.am
index 25269bb..38c475a 100644
--- a/mixlib/Makefile.am
+++ b/mixlib/Makefile.am
@@ -27,5 +27,7 @@ libmix_a_SOURCES = mix.h mix.c \
                    mix_device.h mix_device.c \
                    mix_eval.h mix_eval.c xmix_eval.h mix_eval_scanner.l \
 		   mix_src_file.c mix_src_file.h \
-                   mix_vm_clock.c mix_vm_clock.h
+                   mix_vm_clock.c mix_vm_clock.h \
+		   mix_vm_command.c mix_vm_command.h
+
 
diff --git a/mixlib/mix_types.c b/mixlib/mix_types.c
index 06f926f..4baa4f0 100644
--- a/mixlib/mix_types.c
+++ b/mixlib/mix_types.c
@@ -1,7 +1,7 @@
 /* -*-c-*- ------------------ mix_types.c :
  *  Implementation file for mix_types.h declarations.
  * ------------------------------------------------------------------
- * Copyright (C) 2000 Free Software Foundation, Inc.
+ * Copyright (C) 2000, 2001 Free Software Foundation, Inc.
  *  
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -465,15 +465,15 @@ mix_word_shift_right_circular (mix_word_t A, mix_word_t X, gulong count,
 
 /* Printable representation */
 void 
-mix_word_print (mix_word_t word, const char *message)
+mix_word_print_to_file (mix_word_t word, const char *message, FILE *f)
 {
   guint k;
-  if ( message ) g_print ("%s ", message);
-  g_print ("%s ", mix_word_sign (word) == 0 ? "+" : "-");
+  if ( message ) fprintf (f, "%s ", message);
+  fprintf (f, "%s ", mix_word_sign (word) == 0 ? "+" : "-");
   for ( k = 1; k < 6; ++k ) {
-    g_print ("%02d ", mix_word_get_byte (word,k));
+    fprintf (f, "%02d ", mix_word_get_byte (word,k));
   }
-  g_print ("(%010ld)", mix_word_magnitude (word));
+  fprintf (f, "(%010ld)", mix_word_magnitude (word));
 }
 
 /* Conversions between words and shorts */
diff --git a/mixlib/mix_types.h b/mixlib/mix_types.h
index d706de1..dae6ff8 100644
--- a/mixlib/mix_types.h
+++ b/mixlib/mix_types.h
@@ -2,7 +2,7 @@
  *  This file contains declarations for the basic types used in MIX:
  *   mix_byte_t, mix_char_t, mix_short_t and mix_word_t.
  * ------------------------------------------------------------------
- * Copyright (C) 2000 Free Software Foundation, Inc.
+ * Copyright (C) 2000, 2001 Free Software Foundation, Inc.
  *  
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -24,6 +24,7 @@
 #ifndef MIX_TYPES_H
 #define MIX_TYPES_H
 
+#include <stdio.h>
 #include <glib.h>
 
 /* Initialisation function to be called before using the other
@@ -212,8 +213,11 @@ mix_word_store_field(mix_fspec_t f, mix_word_t from, mix_word_t to);
 
 
 /* Printable representation */
-extern void 
-mix_word_print(mix_word_t word, const char *message);
+#define mix_word_print(word,message) \
+  mix_word_print_to_file (word, message, stdout)
+
+extern void
+mix_word_print_to_file (mix_word_t word, const char *message, FILE *f);
 
 
 /*----------------- mix_short_t ------------------------------------------*/
diff --git a/mixlib/mix_vm_command.c b/mixlib/mix_vm_command.c
new file mode 100644
index 0000000..49f7d1d
--- /dev/null
+++ b/mixlib/mix_vm_command.c
@@ -0,0 +1,1096 @@
+/* -*-c-*- -------------- mix_vm_command.c :
+ * Implementation of the functions declared in mix_vm_command.h
+ * ------------------------------------------------------------------
+ *  Last change: Time-stamp: "01/02/26 03:29:19 jose"
+ * ------------------------------------------------------------------
+ * Copyright (C) 2001 Free Software Foundation, Inc.
+ *  
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *  
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *  
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *  
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include "mix_vm_command.h"
+#include "mix_vm.h"
+#include "mix_vm_dump.h"
+#include "mix_eval.h"
+
+/* hooks */
+typedef struct 
+{
+  mix_vm_cmd_hook_t func;
+  gpointer data;
+} hook_;
+
+typedef struct 
+{
+  mix_vm_cmd_global_hook_t func;
+  gpointer data;
+} global_hook_;
+
+struct mix_vm_cmd_dispatcher_t 
+{
+  mix_vm_t *vm;			/* the virtual machine */
+  FILE *out;			/* message output file */
+  FILE *err;			/* error output file */
+  mix_dump_context_t *dump;	/* dump context for output */
+  mix_eval_t *eval;		/* evaluator for w-expressions */
+  gboolean trace;		/* tracing flag */
+  mix_time_t uptime;		/* total running time */
+  mix_time_t laptime;		/* current program running time */
+  hook_ pre_hooks[MIX_CMD_INVALID]; /* Pre-command hooks */
+  hook_ post_hooks[MIX_CMD_INVALID]; /* Post-command hooks */
+  global_hook_ global_pre;	/* global pre-command hook */
+  global_hook_ global_post;	/* global post-command hook */
+};
+
+/* command handlers */
+typedef int (*Function_)(mix_vm_cmd_dispatcher_t *, const gchar *);
+#define DEC_FUN(name) \
+  static int cmd_##name (mix_vm_cmd_dispatcher_t *dis, const gchar *arg)
+
+DEC_FUN (help_);
+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 (weval_);
+DEC_FUN (w2d_);
+DEC_FUN (tron_);
+DEC_FUN (troff_);
+
+/* internal command info struct */
+typedef struct {
+  const char *name;		/* User printable name of the function. */
+  Function_  func;		/* Function to call to do the job. */
+  const char *doc;		/* Documentation for this function.  */
+  const char *usage;		/* Usage */
+} command_;
+
+/* available commands (in the same order as the type enum) */
+     
+command_ commands_[] = {
+  { "help", cmd_help_, N_("Display this text"), "help [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"},
+  { "weval", cmd_weval_, N_("Evaluate a given W-expression"), "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"},
+  { NULL, NULL, NULL, NULL},
+};
+
+
+/* external interface */
+
+/* conversion from/to commands to strings */
+const gchar *
+mix_vm_command_to_string (mix_vm_command_t cmd)
+{
+  if (cmd < MIX_CMD_INVALID) return commands_[cmd].name;
+  else return NULL;
+}
+
+mix_vm_command_t
+mix_vm_command_from_string (const gchar *name)
+{
+  /* inefficient linear search, i know */
+  gint cmd = 0;
+  while (cmd < MIX_CMD_INVALID && strcmp (name, commands_[cmd].name))
+    ++cmd;
+  return cmd;
+}
+
+/* get help string about a command */
+const gchar *
+mix_vm_command_help (mix_vm_command_t cmd)
+{
+  if (cmd < MIX_CMD_INVALID) return commands_[cmd].doc;
+  else return NULL;
+}
+
+const gchar *
+mix_vm_command_usage (mix_vm_command_t cmd)
+{
+  if (cmd < MIX_CMD_INVALID) return commands_[cmd].usage;
+  else return NULL;
+}
+
+/* create a new command dispatcher */
+mix_vm_cmd_dispatcher_t *
+mix_vm_cmd_dispatcher_new (FILE *out_fd, /* output messages file */
+			   FILE *err_fd /* error messages file */)
+{
+  mix_vm_cmd_dispatcher_t *result = NULL;
+  int k;
+  
+  g_return_val_if_fail (out_fd && err_fd, NULL);
+  
+  result = g_new (mix_vm_cmd_dispatcher_t, 1);
+  result->out = out_fd;
+  result->err = err_fd;
+  result->uptime = result->laptime = 0;
+  result->trace = FALSE;
+  result->eval = mix_eval_new ();
+  result->dump = mix_dump_context_new (out_fd, 
+				       MIX_SHORT_ZERO, MIX_SHORT_ZERO,
+				       MIX_DUMP_ALL);
+  result->vm = mix_vm_new ();
+  result->global_pre.func = result->global_post.func = NULL;
+  result->global_pre.data = result->global_post.data = NULL;
+  for (k =0; k < MIX_CMD_INVALID; ++k)
+    {
+      result->pre_hooks[k].func = result->post_hooks[k].func = NULL;
+      result->pre_hooks[k].data = result->post_hooks[k].data = NULL;
+    }
+      
+  return result;
+}
+
+/* delete (does not close the fds in the constructor) */
+extern void
+mix_vm_cmd_dispatcher_delete (mix_vm_cmd_dispatcher_t *dis)
+{
+  g_return_if_fail (dis != NULL);
+  mix_eval_delete (dis->eval);
+  mix_dump_context_delete (dis->dump);
+  mix_vm_delete (dis->vm);
+  g_free (dis);
+}
+
+/* install hooks */
+void
+mix_vm_cmd_dispatcher_pre_hook (mix_vm_cmd_dispatcher_t *dis,
+				mix_vm_command_t cmd,
+				mix_vm_cmd_hook_t hook, gpointer data)
+{
+  g_return_if_fail (dis != NULL);
+  g_return_if_fail (cmd < MIX_CMD_INVALID);
+  dis->pre_hooks[cmd].func = hook;
+  dis->pre_hooks[cmd].data = data;
+}
+
+void
+mix_vm_cmd_dispatcher_post_hook (mix_vm_cmd_dispatcher_t *dis,
+				 mix_vm_command_t cmd,
+				 mix_vm_cmd_hook_t hook, gpointer data)
+{
+  g_return_if_fail (dis != NULL);
+  g_return_if_fail (cmd < MIX_CMD_INVALID);
+  dis->post_hooks[cmd].func = hook;
+  dis->post_hooks[cmd].data = data;
+}
+
+void
+mix_vm_cmd_dispatcher_global_pre_hook (mix_vm_cmd_dispatcher_t *dis,
+				       mix_vm_cmd_global_hook_t hook,
+				       gpointer data)
+{
+  g_return_if_fail (dis != NULL);
+  dis->global_pre.func = hook;
+  dis->global_pre.data = data;
+}
+
+void
+mix_vm_cmd_dispatcher_global_post_hook (mix_vm_cmd_dispatcher_t *dis,
+					mix_vm_cmd_global_hook_t hook,
+					gpointer data)
+{
+  g_return_if_fail (dis != NULL);
+  dis->global_post.func = hook;
+  dis->global_post.data = data;
+}
+
+/* dispatch a command */
+gboolean /* TRUE if success, FALSE otherwise */
+mix_vm_cmd_dispatcher_dispatch (mix_vm_cmd_dispatcher_t *dis,
+				mix_vm_command_t cmd, const gchar *arg)
+{
+  gboolean result = FALSE;
+  g_return_val_if_fail (dis != NULL, FALSE);
+  
+  if (dis->global_pre.func)
+    (dis->global_pre.func)(dis, cmd, arg, dis->global_pre.data);
+  
+  if (cmd < MIX_CMD_INVALID)
+    {
+      if (dis->pre_hooks[cmd].func)
+	(dis->pre_hooks[cmd].func)(dis, arg, dis->pre_hooks[cmd].data);
+      result = (commands_[cmd].func)(dis, arg);
+      if (dis->post_hooks[cmd].func)
+	(dis->post_hooks[cmd].func)(dis, arg, dis->post_hooks[cmd].data);
+    }
+  else
+    {
+      fprintf (dis->err, "Unknown command. Try: help");
+    }
+
+  if (dis->global_post.func)
+    (dis->global_post.func)(dis, cmd, arg, dis->global_post.data);
+
+  fflush (dis->out);
+  fflush (dis->err);
+  return result;
+}
+
+/* dispatch a command in text format */
+gboolean
+mix_vm_cmd_dispatcher_dispatch_text (mix_vm_cmd_dispatcher_t *dis,
+				     const gchar *text)
+{
+  gchar *cp, *arg = "";
+  int k = 0;
+  gboolean result;
+  
+  g_return_val_if_fail (dis != NULL, FALSE);
+  g_return_val_if_fail (text != NULL, FALSE);
+  
+  cp = g_strdup (text);
+  while (cp[k] && !isspace (cp[k])) ++k;
+  if (cp[k])
+    {
+      cp[k] = '\0'; ++k;
+      while (cp[k] && isspace (cp[k])) ++k;
+      arg = cp + k;
+    }
+
+  result = mix_vm_cmd_dispatcher_dispatch (dis,
+					   mix_vm_command_from_string (cp),
+					   arg);
+  g_free (cp);
+  return result;
+}
+
+/* get the mix vm */
+const mix_vm_t *
+mix_vm_cmd_dispatcher_get_vm (const mix_vm_cmd_dispatcher_t *dis)
+{
+  g_return_val_if_fail (dis != NULL, NULL);
+  return dis->vm;
+}
+
+
+/* trace current instruction */
+static void
+trace_ (mix_vm_cmd_dispatcher_t *dis)
+{
+  enum {BUFFER_LEN = 128};
+  static gchar STRINS[BUFFER_LEN];
+  
+  const mix_src_file_t *file = mix_vm_get_src_file (dis->vm);
+  const gchar *line = "\n";
+  mix_address_t loc = mix_vm_get_prog_count (dis->vm);
+  mix_word_t ins = mix_vm_get_addr_contents (dis->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 (dis->vm);
+      if (b > 0) line = mix_src_file_get_line (file, b);
+    }
+  
+  fprintf (dis->out, "%d: [%s]\t%s", (gint)loc, STRINS, line);
+}
+
+/* run a program tracing executed instructions */
+static int
+run_and_trace_ (mix_vm_cmd_dispatcher_t *dis)
+{
+  int k = MIX_VM_OK;
+  if (!dis->trace)
+    return mix_vm_run (dis->vm);
+  else while (k == MIX_VM_OK)
+    {
+      trace_ (dis);
+      k = mix_vm_exec_next (dis->vm);
+    }
+  return k;
+}
+
+/* print time statistics */
+static void
+print_time_ (mix_vm_cmd_dispatcher_t *dis)
+{
+  mix_time_t lapse = mix_vm_get_uptime(dis->vm) - dis->uptime;
+  dis->uptime += lapse;
+  dis->laptime += lapse;
+  fprintf( dis->out,
+	   _("Elapsed time: %ld /Total program time: %ld (Total uptime: %ld)\n"),
+	 lapse, dis->laptime, dis->uptime);
+}
+
+
+/* commands */
+
+static int
+cmd_help_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg)
+{
+  static const int NO_OF_COLS = 6;
+  
+  int i;
+  int printed = 0;
+     
+  for (i = 0; commands_[i].name; i++)
+    {
+      if (!*arg || (strcmp (arg, commands_[i].name) == 0))
+	{
+	  fprintf (dis->out ,_("%s\t\t%s. Usage: %s\n"), commands_[i].name, 
+		  _(commands_[i].doc), commands_[i].usage);
+	  printed++;
+	}
+    }
+  
+  if (!printed)
+    {
+      fprintf (dis->out,
+	       _("No commands match `%s'.  Possibilities are:\n"), arg);
+     
+      for (i = 0; commands_[i].name; i++)
+	{
+	  if (printed == NO_OF_COLS)
+	    {
+	      printed = 0;
+	      fprintf (dis->out, "\n");
+	    }
+     
+	  fprintf (dis->out, "%s\t", commands_[i].name);
+	  printed++;
+	}
+     
+      if (printed)
+	fprintf (dis->out, "\n");
+    }
+  return TRUE;
+}
+
+static int
+cmd_load_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg)
+{
+  errno = 0;
+  if (arg == NULL || *arg == '\0')
+    {
+      fputs (_("Missing file name\n"), dis->err);
+      return TRUE;
+    }
+  mix_eval_remove_symbols_from_table (dis->eval,
+				      mix_vm_get_symbol_table (dis->vm));
+  if (!mix_vm_load_file (dis->vm, arg) )
+    {
+      fprintf (dis->err, _("Cannot load %s: "), arg);
+      if ( errno == 0 )
+	fputs (_("Wrong file format\n"), dis->err);
+      else
+	perror (NULL);
+      return TRUE + 1;
+    }
+  mix_eval_set_symbols_from_table (dis->eval,
+				   mix_vm_get_symbol_table (dis->vm));
+
+  fprintf (dis->out, _("Program loaded. Start address: %d\n"),
+	   mix_vm_get_prog_count (dis->vm));
+  
+  dis->laptime = 0;
+  return TRUE;
+}
+
+
+static int
+cmd_run_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg)
+{
+  if (arg != NULL && *arg != '\0' && cmd_load_ (dis, arg) != TRUE) 
+      return TRUE;
+  fputs (_("Running ...\n"), dis->out);
+  
+  if (mix_vm_is_halted (dis->vm))
+    {
+      mix_vm_reset_program (dis->vm);
+      dis->laptime = 0;
+    }
+  
+  switch (run_and_trace_ (dis))
+    {
+    case MIX_VM_HALT:
+      fputs (_("... done\n"), dis->out);
+      break;
+    case MIX_VM_BREAK:
+      {
+	gulong line = mix_vm_get_break_lineno (dis->vm);
+	if (line != 0)
+	  fprintf (dis->out,
+		   _("... stopped: breakpoint at line %ld (address %d)\n"), 
+		  line, mix_vm_get_prog_count (dis->vm));
+	else
+	  fprintf (dis->out, _("... stopped: breakpoint at address %d\n"),
+		  mix_vm_get_prog_count (dis->vm));
+      }
+      break;
+    case MIX_VM_ERROR:
+      fputs (_("... error executing loaded file"), dis->err);
+      break;
+    default:
+      g_assert_not_reached ();
+      break;
+    }
+  print_time_ (dis);
+
+  return TRUE;
+}
+
+static int
+cmd_next_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg)
+{
+  int ins_no = 1;
+  int k;
+
+  if ( strlen (arg) != 0 )
+    {
+      int k = 0;
+      while (isdigit (arg[k]))
+	k++;
+      if (arg[k] != '\0')
+	{
+	  fprintf (dis->err, _("Invalid argument: %s\n"), arg);
+	  return cmd_help_ (dis, "next");
+	}
+      ins_no = atoi (arg);
+    }
+
+  if (mix_vm_is_halted (dis->vm))
+    {
+      mix_vm_reset_program (dis->vm);
+      dis->laptime = 0;
+    }
+  
+  while ( ins_no-- > 0 )
+    {
+      if (dis->trace) trace_ (dis);
+      k = mix_vm_exec_next (dis->vm);
+      if (k == MIX_VM_HALT)
+	{
+	  fprintf (dis->err, _("End of program reached at address %d\n"),
+		   mix_vm_get_prog_count (dis->vm));
+	  break;
+	}
+      else if (k == MIX_VM_ERROR)
+	{
+	  fprintf (dis->err, _("Error at address %d\n"),
+		   mix_vm_get_prog_count (dis->vm));
+	  break;
+	}
+    }
+  print_time_ (dis);
+
+  return TRUE;
+}
+
+static int
+cmd_pc_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg)
+{
+  fprintf (dis->out, "Current address: %d\n", mix_vm_get_prog_count (dis->vm));
+  return TRUE;
+}
+
+static int
+cmd_psym_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg)
+{
+  const mix_symbol_table_t *table = mix_eval_symbol_table (dis->eval);
+  if ( table == NULL )
+    fputs (_("Symbol table not available\n"), dis->err);
+  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', dis->out);
+	}
+      else
+	fprintf (dis->out, _("%s: symbol not defined\n"), arg);
+    }
+  else
+    mix_symbol_table_print (table, MIX_SYM_ROWS, stdout, TRUE);
+      
+  return TRUE;
+}
+
+static int
+cmd_preg_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg)
+{
+  mix_dump_context_set_opt (dis->dump, MIX_DUMP_NONE);
+  if ( strlen (arg) == 0 )
+    mix_dump_context_add_opt (dis->dump, MIX_DUMP_rALL);
+  else switch (*arg)
+    {
+    case 'A':
+      mix_dump_context_add_opt (dis->dump, MIX_DUMP_rA);
+      break;
+    case 'X':
+      mix_dump_context_add_opt (dis->dump, MIX_DUMP_rX);
+      break;
+    case 'J':
+      mix_dump_context_add_opt (dis->dump, MIX_DUMP_rJ);
+      break;
+    case 'I':
+      {
+	if ( strlen (arg) == 1 )
+	  mix_dump_context_add_opt (dis->dump, 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 (dis->err, _("Invalid I index: %d"), i);
+		return TRUE;
+	      }
+	    mix_dump_context_add_opt (dis->dump, opt[i]);
+	  }
+      }
+      break;
+    default:
+      fprintf (dis->err, _("Invalid argument: %s\n"), arg);
+      return TRUE;
+    }
+  mix_vm_dump (dis->vm, dis->dump);
+  return TRUE;
+}
+
+static int
+cmd_pflags_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg)
+{
+  mix_dump_context_set_opt (dis->dump, MIX_DUMP_CMP | MIX_DUMP_OVER);
+  mix_vm_dump (dis->vm, dis->dump);
+  return TRUE;
+}
+
+static int
+cmd_pall_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg)
+{
+  mix_dump_context_set_opt (dis->dump, MIX_DUMP_ALL_NOMEM);
+  mix_vm_dump (dis->vm, dis->dump);
+  return TRUE;
+}
+
+static int
+cmd_pmem_ (mix_vm_cmd_dispatcher_t *dis, const gchar *carg)
+{
+  glong begin = MIX_SHORT_ZERO, end = MIX_SHORT_ZERO;
+  int i = 0;
+  gboolean error = FALSE;
+  gchar *arg = NULL;
+  
+  if ( strlen (carg) == 0 )
+    {
+      fputs (_("Missing memory address\n"), dis->err);
+      return TRUE;
+    }
+  arg = g_strdup (carg);
+  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 (dis->err, _("Invalid argument: %s\n"), arg);
+      cmd_help_ (dis, "pmem");
+    }
+  else if ( end < begin || end > MIX_VM_CELL_NO - 1 )
+    {
+      fprintf (dis->err, _("Invalid range: %ld-%ld\n"), begin, end);
+    }
+  else
+    {
+      mix_dump_context_set_opt (dis->dump, MIX_DUMP_CELLS);
+      mix_dump_context_range (dis->dump, mix_short_new (begin),
+			      mix_short_new (end + 1));
+      mix_vm_dump (dis->vm, dis->dump);
+    }
+  g_free (arg);
+  return TRUE;
+}
+
+static int
+cmd_sreg_ (mix_vm_cmd_dispatcher_t *dis, const gchar *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 (dis->vm, mix_word_new (value));
+		break;
+	      case 'X':
+		mix_vm_set_rX (dis->vm, mix_word_new (value));
+		break;
+	      case 'J':
+		if ( value >= 0 )
+		  mix_vm_set_rJ (dis->vm, mix_short_new (value));
+		else
+		  ok = FALSE;
+		break;
+	      case 'I':
+		{
+		  guint k = arg[1] - '0';
+		  if ( k < 7 ) 
+		    mix_vm_set_rI (dis->vm, k, mix_short_new (value));
+		  else
+		    ok = FALSE;
+		}
+		break;
+	      default:
+		ok = FALSE;
+	      }
+	}
+    }
+  if (!ok)
+    {
+      fprintf (dis->err, _("Invalid argument: %s\n"), arg);
+      cmd_help_ (dis, "sreg");
+    }
+    
+  return TRUE;
+}
+
+static int
+cmd_scmp_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg)
+{
+  gboolean ok = (strlen (arg) == 1);
+  if (ok) switch (arg[0])
+    {
+    case 'L':
+      mix_vm_set_cmpflag (dis->vm, mix_LESS);
+      break;
+    case 'E':
+      mix_vm_set_cmpflag (dis->vm, mix_EQ);
+      break;
+    case 'G':
+      mix_vm_set_cmpflag (dis->vm, mix_GREAT);
+      break;
+    default:
+      ok = FALSE;
+    }
+  if (!ok)
+    {
+      fprintf (dis->err, _("Invalid argument: %s\n"), arg);
+      cmd_help_ (dis, "scmp");
+    }
+  
+  return TRUE;
+}
+
+static int
+cmd_sover_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg)
+{
+  gboolean ok = (strlen (arg) == 1);
+  if (ok) switch (arg[0])
+    {
+    case 'T':
+      mix_vm_set_overflow (dis->vm, TRUE);
+      break;
+    case 'F':
+      mix_vm_set_overflow (dis->vm, FALSE);
+      break;
+    default:
+      ok = FALSE;
+    }
+  if (!ok)
+    {
+      fprintf (dis->err, _("Invalid argument: %s\n"), arg);
+      cmd_help_ (dis, "sover");
+    }
+  
+  return TRUE;
+}
+
+static int
+cmd_smem_ (mix_vm_cmd_dispatcher_t *dis, const gchar *carg)
+{
+  gboolean ok = (strlen (carg) > 2 && isdigit (carg[0]));
+  gulong addr;
+  glong value;
+  int k = 0;
+  gchar *arg = NULL;
+  
+  if (ok)
+    {
+      arg = g_strdup (carg);
+      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 (dis->vm, mix_short_new (addr),
+			      mix_word_new (value));
+  else
+    {
+      fprintf (dis->err, _("Invalid argument: %s\n"), arg);
+      cmd_help_ (dis, "smem");
+    }
+  g_free (arg);
+  
+  return TRUE;
+}
+
+static int
+cmd_ssym_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg)
+{
+  if (arg == NULL || strlen(arg) == 0)
+    {
+      fprintf (dis->err, _("Missing arguments\n"));
+      return cmd_help_ (dis, "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_ (dis, w);
+	  if (mix_eval_last_error (dis->eval) == MIX_EVAL_OK)
+	    mix_eval_set_symbol (dis->eval, s, mix_eval_value (dis->eval));
+	}
+      else
+	{
+	  fprintf (dis->err, _("Wrong argument number\n"));
+	  cmd_help_ (dis, "ssym");
+	}
+      g_free (a);
+      return TRUE;
+    }
+}
+
+static int
+cmd_sbp_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg)
+{
+  glong lineno;
+  glong k = 0;
+  while (isdigit (arg[k])) k++;
+  if (arg[k] != '\0')
+    {
+      fprintf (dis->err, _("Invalid argument: %s\n"), arg);
+      return cmd_help_ (dis, "sbp");
+    }
+  lineno = atol (arg);
+  switch (k = mix_vm_set_breakpoint (dis->vm, lineno))
+    {
+    case MIX_VM_BP_INV_LINE:
+      fprintf (dis->err, _("Line number %ld too high\n"), lineno);
+      break;
+    case MIX_VM_BP_ERROR:
+      fputs (_("Could not set breakpoint. Internal error\n"), dis->err);
+      break;
+    case MIX_VM_BP_NDEBUG:
+      fputs (_("Could not set breakpoint. No debug info available\n"),
+	     dis->err);
+      break;
+    default:
+      fprintf (dis->err, _("Breakpoint set at line %ld\n"), k);
+      break;
+    }
+  return TRUE;
+}
+
+static int
+cmd_sbpa_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg)
+{
+  glong address;
+  glong k = 0;
+  while (isdigit (arg[k])) k++;
+  if (arg[k] != '\0')
+    {
+      fprintf (dis->err, _("Invalid argument: %s\n"), arg);
+      return cmd_help_ (dis, "sbpa");
+    }
+  address = atol (arg);
+  switch (mix_vm_set_breakpoint_address (dis->vm, address))
+    {
+    case MIX_VM_BP_INV_ADDRESS:
+      fprintf (dis->err, _("Invalid address %ld\n"), address);
+      break;
+    case MIX_VM_BP_ERROR:
+      fputs (_("Could not set breakpoint. Internal error\n"), dis->err);
+      break;
+    default:
+      fprintf (dis->err, _("Breakpoint set at address %ld\n"), address);
+      break;
+    }
+  return TRUE;
+}
+
+static int
+cmd_cbp_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg)
+{
+  glong lineno;
+  int k = 0;
+  while (isdigit (arg[k])) k++;
+  if (arg[k] != '\0')
+    {
+      fprintf (dis->err, _("Invalid argument: %s\n"), arg);
+      return cmd_help_ (dis, "cbp");
+    }
+  lineno = atol (arg);
+  switch (mix_vm_clear_breakpoint (dis->vm, lineno))
+    {
+    case MIX_VM_BP_INV_LINE:
+      fprintf (dis->err, _("No breakpoint set at line %ld\n"), lineno);
+      break;
+    case MIX_VM_BP_ERROR:
+      fputs (_("Could not set breakpoint. Internal error\n"), dis->err);
+      break;
+    case MIX_VM_BP_NDEBUG:
+      fputs (_("No debug info available\n"), dis->err);
+      break;
+    case MIX_VM_BP_OK:
+      fprintf (dis->err, _("Breakpoint cleared at line %ld\n"), lineno);
+      break;
+    default:
+      g_assert_not_reached ();
+      break;
+    }
+  return TRUE;
+}
+
+static int
+cmd_cbpa_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg)
+{
+  glong address;
+  glong k = 0;
+  while (isdigit (arg[k])) k++;
+  if (arg[k] != '\0')
+    {
+      fprintf (dis->err, _("Invalid argument: %s\n"), arg);
+      return cmd_help_ (dis, "cbpa");
+    }
+  address = atol (arg);
+  switch (mix_vm_clear_breakpoint_address (dis->vm, address))
+    {
+    case MIX_VM_BP_INV_ADDRESS:
+      fprintf (dis->err, _("Invalid address %ld\n"), address);
+      break;
+    case MIX_VM_BP_ERROR:
+      fputs (_("Could not clear breakpoint. Internal error\n"), dis->err);
+      break;
+    default:
+      fprintf (dis->err, _("Breakpoint cleared at address %ld\n"), address);
+      break;
+    }
+  return TRUE;
+}
+
+
+static int
+cmd_cabp_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg)
+{
+  if (strlen (arg) != 0)
+    {
+      fprintf (dis->err, _("Invalid argument: %s\n"), arg);
+      return cmd_help_ (dis, "cabp");
+    }
+  mix_vm_clear_all_breakpoints (dis->vm);
+  return TRUE;
+}
+
+static int
+cmd_weval_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg)
+{
+  if ( strlen (arg) == 0 )
+    return cmd_help_ (dis, "weval");
+
+  if (mix_eval_expression_with_loc (dis->eval, arg,
+				    mix_vm_get_prog_count (dis->vm)) ==
+      MIX_EVAL_OK)
+    {
+      mix_word_print_to_file (mix_eval_value (dis->eval), NULL, dis->out);
+      putc ('\n', dis->out);
+    }
+  else
+    {
+      gint pos = mix_eval_last_error_pos (dis->eval);
+      gint k, len = strlen (arg);
+      g_assert(pos > -1 && pos <= len);
+      for (k = 0; k<pos; ++k) fputc (arg[k], dis->err);
+      fputc ('\n', dis->err);
+      for (k = 0; k<pos; ++k) fputc (' ', dis->err);
+      for (k = pos; k < len; ++k) fputc (arg[k], dis->err);
+      fprintf (dis->err, _("\nEvaluation error: %s\n"),
+	       mix_eval_last_error_string (dis->eval));
+    }
+        
+  return TRUE;
+}
+
+static int
+cmd_w2d_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg)
+{
+  if ( strlen (arg) == 0 )
+    return cmd_help_ (dis, "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 (dis->err, _("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 (dis->err, _("The expression %s does not fit in a word\n"),
+		     arg);
+	  else
+	    {
+	      mix_word_t w = mix_bytes_to_word (bytes, k);
+	      fprintf (dis->out, "%s%ld\n", is_n? "-":"+",
+		       mix_word_magnitude (w));
+	    }
+	}
+      g_free (cp);
+    }
+  
+  return TRUE;
+}
+
+static int
+cmd_tron_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg)
+{
+  dis->trace = TRUE;
+  fprintf (dis->out, _("Instruction tracing has been turned ON.\n"));
+  return TRUE;
+}
+
+static int
+cmd_troff_ (mix_vm_cmd_dispatcher_t *dis, const gchar *arg)
+{
+  dis->trace = FALSE;
+  fprintf (dis->out, _("Instruction tracing has been turned OFF.\n"));
+  return TRUE;
+}
diff --git a/mixlib/mix_vm_command.h b/mixlib/mix_vm_command.h
new file mode 100644
index 0000000..89a2c2b
--- /dev/null
+++ b/mixlib/mix_vm_command.h
@@ -0,0 +1,139 @@
+/* -*-c-*- ---------------- mix_vm_command.h :
+ * declarations for mix_vm_command_t, describing commands issued to a vm
+ * ------------------------------------------------------------------
+ *  Last change: Time-stamp: <01/02/26 02:41:26 jose>
+ * ------------------------------------------------------------------
+ * Copyright (C) 2001 Free Software Foundation, Inc.
+ *  
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *  
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *  
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *  
+ */
+
+
+#ifndef MIX_VM_COMMAND_H
+#define MIX_VM_COMMAND_H
+
+#include <stdio.h>
+#include "mix.h"
+#include "mix_vm.h"
+
+/* mix_vm_cmd_dispatcher encapsulates a virtual machine and helper
+   objects, providing a command driven interface with output to
+   provided files (in the posix sense).
+*/
+typedef struct mix_vm_cmd_dispatcher_t mix_vm_cmd_dispatcher_t;
+
+/* mix_vm_cmd_dispatcher understands the commands of this type */
+typedef enum {
+  MIX_CMD_HELP = 0,		/* echo help message */
+  MIX_CMD_LOAD,			/* load a mix program */
+  MIX_CMD_RUN,			/* run a loaded program */
+  MIX_CMD_NEXT,			/* run next instruction */
+  MIX_CMD_LOC,			/* print location pointer */
+  MIX_CMD_PSYM,			/* print symbol */
+  MIX_CMD_PREG,			/* print registry */
+  MIX_CMD_PFLAGS,		/* print comp and overf flags */
+  MIX_CMD_PALL,			/* print all registers and flags */
+  MIX_CMD_PMEM,			/* print memory cells */
+  MIX_CMD_SREG,			/* set register value */
+  MIX_CMD_SCMP,			/* set comparison flag value */
+  MIX_CMD_SOVER,		/* set overflow toggle value */
+  MIX_CMD_SMEM,			/* set memory cell value */
+  MIX_CMD_SSYM,			/* set symbol value */
+  MIX_CMD_SBP,			/* set breakpoint at lineno */
+  MIX_CMD_CBP,			/* clear breakpoint at lineno */
+  MIX_CMD_SBPA,			/* set breakpoint at address */
+  MIX_CMD_CBPA,			/* clear breakpoint at address */
+  MIX_CMD_CABP,			/* clear all breakpoints */
+  MIX_CMD_WEVAL,		/* evaluate a w-expression */
+  MIX_CMD_W2D,			/* print word in decimal notation */
+  MIX_CMD_TRON,			/* enable instruction traces */
+  MIX_CMD_TROFF,		/* disble instruction traces */
+  MIX_CMD_INVALID,		/* invalid command identifier */
+} mix_vm_command_t;
+
+/* hook functions, to be invoked before and/or after command execution */
+typedef void (*mix_vm_cmd_hook_t)(mix_vm_cmd_dispatcher_t *dis,
+				  const gchar *arg, gpointer data);
+
+/* global hook functions */
+typedef void (*mix_vm_cmd_global_hook_t)(mix_vm_cmd_dispatcher_t *dis,
+					 mix_vm_command_t cmd,
+					 const gchar *arg, gpointer data);
+
+/* conversion from/to commands to strings */
+extern const gchar *
+mix_vm_command_to_string (mix_vm_command_t cmd);
+
+extern mix_vm_command_t
+mix_vm_command_from_string (const gchar *name);
+
+/* get help string about a command */
+extern const gchar *
+mix_vm_command_help (mix_vm_command_t cmd);
+
+extern const gchar *
+mix_vm_command_usage (mix_vm_command_t cmd);
+
+
+/* create a new command dispatcher */
+extern mix_vm_cmd_dispatcher_t *
+mix_vm_cmd_dispatcher_new (FILE *out_fd, /* output messages file */
+			   FILE *err_fd /* error messages file */);
+
+/* delete (does not close the fds in the constructor) */
+extern void
+mix_vm_cmd_dispatcher_delete (mix_vm_cmd_dispatcher_t *dis);
+
+/* dispatch a command */
+extern gboolean /* TRUE if success, FALSE otherwise */
+mix_vm_cmd_dispatcher_dispatch (mix_vm_cmd_dispatcher_t *dis,
+				mix_vm_command_t cmd, const gchar *arg);
+
+/* dispatch a command in text format */
+extern gboolean
+mix_vm_cmd_dispatcher_dispatch_text (mix_vm_cmd_dispatcher_t *dis,
+				     const gchar *text);
+
+/* install hooks */
+extern void
+mix_vm_cmd_dispatcher_pre_hook (mix_vm_cmd_dispatcher_t *dis,
+				mix_vm_command_t cmd,
+				mix_vm_cmd_hook_t hook, gpointer data);
+
+extern void
+mix_vm_cmd_dispatcher_post_hook (mix_vm_cmd_dispatcher_t *dis,
+				 mix_vm_command_t cmd,
+				 mix_vm_cmd_hook_t hook, gpointer data);
+
+extern void
+mix_vm_cmd_dispatcher_global_pre_hook (mix_vm_cmd_dispatcher_t *dis,
+				       mix_vm_cmd_global_hook_t hook,
+				       gpointer data);
+
+extern void
+mix_vm_cmd_dispatcher_global_post_hook (mix_vm_cmd_dispatcher_t *dis,
+					mix_vm_cmd_global_hook_t hook,
+					gpointer data);
+
+
+
+/* get the mix vm */
+extern const mix_vm_t *
+mix_vm_cmd_dispatcher_get_vm (const mix_vm_cmd_dispatcher_t *dis);
+
+
+#endif /* MIX_VM_COMMAND_H */
+
diff --git a/mixlib/mix_vm_dump.c b/mixlib/mix_vm_dump.c
index 2d773fc..91953fd 100644
--- a/mixlib/mix_vm_dump.c
+++ b/mixlib/mix_vm_dump.c
@@ -26,15 +26,12 @@
 
 /* Create/destroy a dump context */
 mix_dump_context_t *
-mix_dump_context_new(gint fd, mix_address_t begin, mix_address_t end,
+mix_dump_context_new(FILE  *fd, mix_address_t begin, mix_address_t end,
 		     guint32 options)
 {
   mix_dump_context_t *result = NULL;
-  GIOChannel *channel = NULL;
   
-  if ( fd == MIX_DUMP_DEF_CHANNEL ) fd = STDIN_FILENO;
-  channel = g_io_channel_unix_new (fd);
-  g_return_val_if_fail (channel != NULL, NULL);
+  g_return_val_if_fail (fd != NULL, NULL);
   
   if ( begin > end ) begin = end;
   if ( end >= MEM_CELLS_NO_ ) end = MEM_CELLS_NO_;
@@ -43,7 +40,7 @@ mix_dump_context_new(gint fd, mix_address_t begin, mix_address_t end,
   result->options = options;
   result->begin = begin;
   result->end = end;
-  result->channel = channel;
+  result->channel = fd;
   
   return result;
 }
@@ -52,20 +49,9 @@ void
 mix_dump_context_delete (mix_dump_context_t *dc)
 {
   g_return_if_fail (dc != NULL);
-  g_io_channel_close (dc->channel);
   g_free (dc);
 }
 
-gboolean /* TRUE if success */
-mix_dump_context_set_channel (mix_dump_context_t *dc, gint fd)
-{
-  g_return_val_if_fail (dc != NULL, FALSE);
-  g_io_channel_close (dc->channel);
-  dc->channel = g_io_channel_unix_new (fd == MIX_DUMP_DEF_CHANNEL? 
-				       STDERR_FILENO : fd);
-  return ( dc->channel != NULL );
-}
-
 /* Use the dump context */
 #define WORD_FMT_   "%s %02d %02d %02d %02d %02d (%010ld)"
 #define SHORT_FMT_  "%s %02d %02d (%04d)"
@@ -80,55 +66,33 @@ mix_dump_context_set_channel (mix_dump_context_t *dc, gint fd)
 #define SHORT_ARGS_(s) SHORT_SIGN_ (s), SHORT_BYTE_ (s,1), SHORT_BYTE_ (s,2), \
 		       SHORT_ABS_ (s)
 
-static gboolean
-write_buffer_ (const gchar *buf, guint len, GIOChannel *io)
-{
-  guint k, err;
-  
-  while ( len > 0 ) {
-    err = g_io_channel_write (io, (gchar *) buf, len, &k);
-    g_return_val_if_fail (err == G_IO_ERROR_NONE || 
-			  err == G_IO_ERROR_AGAIN, FALSE);
-    len -= k;
-  }
-  return TRUE;
-}
-
-
-
 void
 mix_vm_dump (const mix_vm_t *vm, const mix_dump_context_t *dc)
 {
-  static const guint BUF_LEN = 40;
-  gchar buf[BUF_LEN];
   guint j, i;
+  FILE *f;
   
   g_return_if_fail (vm != NULL);
   g_return_if_fail (dc != NULL);
   
-
+  f = dc->channel;
+  
   if ( (dc->options & MIX_DUMP_rA) == MIX_DUMP_rA ) 
     {
       mix_word_t rA = get_rA_ (vm);
-      guint k = g_snprintf (buf, BUF_LEN, "rA: " WORD_FMT_ "\n", 
-			    WORD_ARGS_ (rA));
-      g_return_if_fail (write_buffer_ (buf, k, dc->channel));
+      fprintf (f, "rA: " WORD_FMT_ "\n", WORD_ARGS_ (rA));
     }
 
   if ( (dc->options & MIX_DUMP_rX) == MIX_DUMP_rX ) 
     {
       mix_word_t rX = get_rX_ (vm);
-      guint k = g_snprintf (buf, BUF_LEN, "rX: " WORD_FMT_ "\n", 
-			    WORD_ARGS_ (rX));
-      g_return_if_fail (write_buffer_ (buf, k, dc->channel));
+      fprintf (f, "rX: " WORD_FMT_ "\n", WORD_ARGS_ (rX));
     }
 
   if ( (dc->options & MIX_DUMP_rJ) == MIX_DUMP_rJ ) 
     {
       mix_short_t rJ = get_rJ_ (vm);
-      guint k = g_snprintf (buf, BUF_LEN, "rJ: " SHORT_FMT_ "\n", 
-			    SHORT_ARGS_ (rJ));
-      g_return_if_fail (write_buffer_ (buf, k, dc->channel));
+      fprintf (f, "rJ: " SHORT_FMT_ "\n", SHORT_ARGS_ (rJ));
     }
   
   for (j = 0, i = 0; j < IREG_NO_; ++j) 
@@ -136,28 +100,21 @@ mix_vm_dump (const mix_vm_t *vm, const mix_dump_context_t *dc)
       if ( (dc->options & (MIX_DUMP_rI1<<j)) == (MIX_DUMP_rI1<<j) ) 
 	{
 	  mix_short_t rI = mix_word_to_short_fast (get_rI_ (vm, j+1));
-	  guint k = g_snprintf (buf, BUF_LEN, "rI%d: " SHORT_FMT_ "\t", 
-				j+1, SHORT_ARGS_ (rI));
-	  g_return_if_fail (write_buffer_ (buf, k, dc->channel));
+	  fprintf (f, "rI%d: " SHORT_FMT_ "\t", j+1, SHORT_ARGS_ (rI));
 	  i++;
 	}
-      if ( i%2 == 0 && i != 0 )
-	g_return_if_fail (write_buffer_ ("\n", 1, dc->channel));
+      if ( i%2 == 0 && i != 0 )	fprintf (f, "\n");
     }
 
-  if ( i%2 == 1 )
-    g_return_if_fail (write_buffer_ ("\n", 1, dc->channel));
+  if ( i%2 == 1 ) fprintf (f, "\n");
   
   if ( (dc->options & MIX_DUMP_OVER) == MIX_DUMP_OVER ) 
     {
-      guint k = g_snprintf (buf, BUF_LEN, _("Overflow: %s\n"),
-			    get_over_ (vm)? "T":"F");
-      g_return_if_fail (write_buffer_ (buf, k, dc->channel));
+      fprintf (f, _("Overflow: %s\n"), get_over_ (vm)? "T":"F");
     }
   
   if ( (dc->options & MIX_DUMP_CMP) == MIX_DUMP_CMP ) 
     {
-      guint k;
       const gchar *val = "?";
       switch (get_cmp_ (vm)) 
 	{
@@ -174,8 +131,7 @@ mix_vm_dump (const mix_vm_t *vm, const mix_dump_context_t *dc)
 	  g_assert_not_reached ();
 	  break;
 	}
-      k = g_snprintf (buf, BUF_LEN, _("Cmp: %s\n"), val);
-      g_return_if_fail (write_buffer_ (buf, k, dc->channel));
+      fprintf (f, _("Cmp: %s\n"), val);
     }
   
   if ( (dc->options & MIX_DUMP_CELLS) == MIX_DUMP_CELLS ) 
@@ -183,10 +139,9 @@ mix_vm_dump (const mix_vm_t *vm, const mix_dump_context_t *dc)
       for (j = dc->begin; j < dc->end; ++j) 
 	{
 	  mix_word_t cell = get_cell_ (vm,j);
-	  guint k = g_snprintf (buf, BUF_LEN, "%04d: " WORD_FMT_ "\n", j, 
-				WORD_ARGS_ (cell));
-	  g_return_if_fail (write_buffer_ (buf, k, dc->channel));
+	  fprintf (f, "%04d: " WORD_FMT_ "\n", j, WORD_ARGS_ (cell));
 	}
     }
+  fflush (f);
 }
 
diff --git a/mixlib/mix_vm_dump.h b/mixlib/mix_vm_dump.h
index 265a747..8c5e1bd 100644
--- a/mixlib/mix_vm_dump.h
+++ b/mixlib/mix_vm_dump.h
@@ -2,7 +2,7 @@
  * This file declares types and functions for dumping the contents
  * of a mix virtual machine.
  * ------------------------------------------------------------------
-** Copyright (C) 2000 Free Software Foundation, Inc.
+** Copyright (C) 2000, 2001 Free Software Foundation, Inc.
 **  
 ** This program is free software; you can redistribute it and/or modify
 ** it under the terms of the GNU General Public License as published by
@@ -24,6 +24,7 @@
 #ifndef MIX_VM_DUMP_H
 #define MIX_VM_DUMP_H
 
+#include <stdio.h>
 #include "mix_vm.h"
 
 /* Dump context: a structure defining the properties of dumping */
@@ -36,7 +37,7 @@ struct mix_dump_context_t
   mix_address_t begin;
   mix_address_t end;
   /* IO channel for dumping */
-  GIOChannel *channel;
+  FILE *channel;
 };
 
 /* Flags for activating dumps */
@@ -60,12 +61,12 @@ struct mix_dump_context_t
 #define MIX_DUMP_ALL_NOMEM MIX_DUMP_rALL|MIX_DUMP_OVER|MIX_DUMP_CMP
 
 /* Default output channel (stdout) */
-#define MIX_DUMP_DEF_CHANNEL (-1)
+#define MIX_DUMP_DEF_CHANNEL (stdout)
 
 /* Create/destroy a dump context */
 extern mix_dump_context_t *
-mix_dump_context_new(gint fd, mix_address_t begin, mix_address_t end,
-		     guint32 options);
+mix_dump_context_new (FILE *fd, mix_address_t begin, mix_address_t end,
+		      guint32 options);
 
 extern void
 mix_dump_context_delete(mix_dump_context_t *dc);
@@ -80,8 +81,6 @@ do {						\
   (dc)->end = last;				\
 } while (FALSE)
 
-extern gboolean /* TRUE if success */
-mix_dump_context_set_channel(mix_dump_context_t *dc, gint fd);
 
 /* Use the dump context */
 extern void