Imported Upstream version 16.1

1 files changed, 421 insertions, 718 deletions

diff --git a/xen.c b/xen.c
index 0f7be8b..1ba78ba 100644
--- a/xen.c
+++ b/xen.c
@@ -1,17 +1,18 @@
 /* xen support procedures */
 
-#include <mus-config.h>
+#include "mus-config.h"
 #include <ctype.h>
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/types.h>
-#if HAVE_STDINT_H
-  #include <stdint.h>
-#endif
 #include <math.h>
-#if HAVE_PTHREAD_H
-  #include <pthread.h>
+#include <time.h>
+
+#ifdef _MSC_VER
+  #include <io.h>
+  #include <process.h>
+  #pragma warning(disable: 4244)
 #endif
 
 #include "xen.h"
@@ -35,48 +36,51 @@ char *xen_strdup(const char *str)
 
 #if HAVE_RUBY
 
+#define HAVE_RB_PROC_NEW 1
+/* As the README says, only versions of ruby 1.8 or later will work */
+
 #if USE_SND
-void snd_rb_raise(XEN type, XEN info); /* XEN_ERROR */
+void snd_rb_raise(Xen type, Xen info); /* XEN_ERROR */
 #endif
 
 #define S_add_help "add_help"
 #define S_get_help "get_help"
 
-XEN rb_documentation(XEN name)
+Xen rb_documentation(Xen name)
 {
-  XEN_ASSERT_TYPE((XEN_STRING_P(name) || XEN_SYMBOL_P(name)), name, XEN_ONLY_ARG, S_get_help, "a char* or symbol");
-  if (XEN_SYMBOL_P(name))
-    return(rb_property(XEN_SYMBOL_TO_STRING(name), XEN_DOCUMENTATION_SYMBOL));
+  Xen_check_type((Xen_is_string(name) || Xen_is_symbol(name)), name, 1, S_get_help, "a char* or symbol");
+  if (Xen_is_symbol(name))
+    return(rb_property(XEN_SYMBOL_TO_STRING(name), Xen_documentation_symbol));
   else
-    return(rb_property(name, XEN_DOCUMENTATION_SYMBOL));
+    return(rb_property(name, Xen_documentation_symbol));
 }
 
 
-XEN rb_set_documentation(XEN name, XEN help)
+Xen rb_set_documentation(Xen name, Xen help)
 {
-  XEN_ASSERT_TYPE((XEN_STRING_P(name) || XEN_SYMBOL_P(name)), name, XEN_ARG_1, S_add_help, "a char* or symbol");
-  XEN_ASSERT_TYPE(XEN_STRING_P(help), help, XEN_ARG_2, S_add_help, "a char*");
-  if (XEN_SYMBOL_P(name))
-    rb_set_property(XEN_SYMBOL_TO_STRING(name), XEN_DOCUMENTATION_SYMBOL, help);
+  Xen_check_type((Xen_is_string(name) || Xen_is_symbol(name)), name, 1, S_add_help, "a char* or symbol");
+  Xen_check_type(Xen_is_string(help), help, 2, S_add_help, "a char*");
+  if (Xen_is_symbol(name))
+    rb_set_property(XEN_SYMBOL_TO_STRING(name), Xen_documentation_symbol, help);
   else
-    rb_set_property(name, XEN_DOCUMENTATION_SYMBOL, help);
+    rb_set_property(name, Xen_documentation_symbol, help);
   return(name);
 }
 
 
-static XEN g_add_help(XEN name, XEN help)
+static Xen g_add_help(Xen name, Xen help)
 {
-#define H_add_help S_add_help"(name, help)  add help to topic or function name (String or Symbol)"
+#define H_add_help S_add_help "(name, help)  add help to topic or function name (String or Symbol)"
   return(rb_set_documentation(name, help));
 }
 
 
-static XEN g_get_help(XEN name)
+static Xen g_get_help(Xen name)
 {
-#define H_get_help S_get_help"([name=:"S_get_help"])  \
+#define H_get_help S_get_help "([name=:" S_get_help "])  \
 return help associated with name (String or Symbol) or false"
-  if (XEN_NOT_BOUND_P(name))
-    return(C_TO_XEN_STRING(H_get_help));
+  if (!Xen_is_bound(name))
+    return(C_string_to_Xen_string(H_get_help));
   else
     return(rb_documentation(name));
 }
@@ -90,88 +94,24 @@ void xen_initialize(void)
 
   ruby_init();
   ruby_init_loadpath();
-  ruby_script("xen");        /* necessary in ruby 1.9 (else segfault in rb_raise) */
+  ruby_script("xen");        /* necessary in ruby 1.9 (else segfault in rb_raise -- is this the rb GC bug (see snd-xen.c)?) */
 
   Init_Hook();
 }
 
 
-off_t xen_to_c_off_t_or_else(XEN obj, off_t fallback)
-{
-  if (XEN_OFF_T_P(obj))
-#if (defined(SIZEOF_OFF_T) && (SIZEOF_OFF_T > 4)) || (defined(_FILE_OFFSET_BITS) && (_FILE_OFFSET_BITS == 64))
-    return(XEN_TO_C_LONG_LONG(obj));
-#else
-    return(XEN_TO_C_INT(obj));
-#endif
-  else
-    if (XEN_NUMBER_P(obj))
-      return((off_t)XEN_TO_C_DOUBLE(obj));
-  return(fallback);
-}
-
-
-off_t xen_to_c_off_t(XEN obj)
-{
-#if (defined(SIZEOF_OFF_T) && (SIZEOF_OFF_T > 4)) || (defined(_FILE_OFFSET_BITS) && (_FILE_OFFSET_BITS == 64))
-  return(XEN_TO_C_LONG_LONG(obj));
-#else
-  return(XEN_TO_C_INT(obj));
-#endif
-}
-
-
-XEN c_to_xen_off_t(off_t val)
-{
-#if (defined(SIZEOF_OFF_T) && (SIZEOF_OFF_T > 4)) || (defined(_FILE_OFFSET_BITS) && (_FILE_OFFSET_BITS == 64))
-    return(C_TO_XEN_LONG_LONG(val));
-#else
-    return(C_TO_XEN_INT(val));
-#endif
-}
-
-
-int64_t xen_to_c_int64_t_or_else(XEN obj, int64_t fallback)
-{
-  if (XEN_INT64_T_P(obj))
-    return(XEN_TO_C_LONG_LONG(obj));
-  else
-    if (XEN_NUMBER_P(obj))
-      return((int64_t)XEN_TO_C_DOUBLE(obj));
-  return(fallback);
-}
-
-
-int64_t xen_to_c_int64_t(XEN obj)
-{
-  return(XEN_TO_C_LONG_LONG(obj));
-}
-
-
-int xen_to_c_int_or_else(XEN obj, int fallback)
-{
-  /* don't want errors about floats with non-zero fractions etc */
-  if (XEN_INTEGER_P(obj))
-    return(XEN_TO_C_INT(obj));
-  else
-    if (XEN_NUMBER_P(obj))
-      return((int)XEN_TO_C_DOUBLE(obj));
-  return(fallback);
-}
-
-
-void xen_gc_mark(XEN val)
+void xen_gc_mark(Xen val)
 {
   rb_gc_mark(val);
 }
 
 
-XEN xen_rb_cdr(XEN val)
+Xen xen_rb_cdr(Xen val)
 {
-  if (XEN_CONS_P(val))
+  if (Xen_is_cons(val))
     {
-      XEN new_list;
-      new_list = XEN_COPY_ARG(val);
+      Xen new_list;
+      new_list = Xen_copy_arg(val);
       rb_ary_delete_at(new_list, 0);
       return(new_list);
     }
@@ -179,25 +119,25 @@ XEN xen_rb_cdr(XEN val)
 }
 
 
-XEN xen_rb_cons(XEN arg1, XEN arg2)
+Xen xen_rb_cons(Xen arg1, Xen arg2)
 {
-  if (XEN_NULL_P(arg2))
+  if (Xen_is_null(arg2))
     return(rb_ary_new3(1, arg1));
-  if (!(XEN_CONS_P(arg2)))
+  if (!(Xen_is_cons(arg2)))
     return(rb_ary_new3(2, arg1, arg2));
   return(rb_ary_unshift(arg2, arg1)); /* arg2 assumed to be array here in Ruby */
 }
 
 
-XEN xen_rb_cons2(XEN arg1, XEN arg2, XEN arg3)
+Xen xen_rb_cons2(Xen arg1, Xen arg2, Xen arg3)
 {
   return(rb_ary_unshift(xen_rb_cons(arg2, arg3), arg1));
 }
 
 
-XEN xen_rb_ary_new_with_initial_element(long num, XEN element)
+Xen xen_rb_ary_new_with_initial_element(long num, Xen element)
 {
-  XEN arr;
+  Xen arr;
   int i;
   arr = rb_ary_new2(num);
   for (i = 0; i < num; i++)
@@ -206,7 +146,7 @@ XEN xen_rb_ary_new_with_initial_element(long num, XEN element)
 }
 
 
-XEN xen_set_assoc(XEN key, XEN val, XEN alist)
+Xen xen_set_assoc(Xen key, Xen val, Xen alist)
 {
   /* assoc key val in alist so later rb_ary_assoc will find val given key in alist */
   /*
@@ -220,11 +160,11 @@ XEN xen_set_assoc(XEN key, XEN val, XEN alist)
       [[key, val]]
     end
   */
-  if (XEN_CONS_P(alist))
+  if (Xen_is_cons(alist))
     {
-      XEN pair;
+      Xen pair;
       pair = rb_ary_assoc(alist, key);
-      if (XEN_CONS_P(pair))
+      if (Xen_is_cons(pair))
 	rb_ary_store(pair, 1, val);
       else rb_ary_push(alist, rb_assoc_new(key, val));
       return(alist);
@@ -233,11 +173,11 @@ XEN xen_set_assoc(XEN key, XEN val, XEN alist)
 }
 
 
-XEN xen_assoc(XEN key, XEN alist) 
+Xen xen_assoc(Xen key, Xen alist) 
 { 
-  if (XEN_CONS_P(alist)) 
+  if (Xen_is_cons(alist)) 
     { 
-      XEN val; 
+      Xen val; 
       val = rb_ary_assoc(alist, key); 
       if (val != Qnil) 
 	return(rb_ary_entry(val, 1)); 
@@ -250,10 +190,11 @@ static char *scheme_to_ruby(const char *name)
 {
   /* replace any non-alphanumeric except "?" with "_". "?" -> "_p". '->" -> "2" drop "!" */
   char *new_name = NULL;
-  int len, i, j;
+  int len;
   len = strlen(name);
   if (len > 0)
     {
+      int i, j;
       new_name = (char *)calloc(len + 3, sizeof(char)); /* +1 for possible _p, +1 for possible $ */
       for (i = 0, j = 0; i < len; i++)
 	{
@@ -285,7 +226,7 @@ static char *scheme_to_ruby(const char *name)
 
 char *xen_scheme_constant_to_ruby(const char *name)
 {
-  /* upcase 1st char */
+  /* upcase first char */
   char *new_name;
   new_name = scheme_to_ruby(name);
   new_name[0] = toupper(new_name[0]);
@@ -296,10 +237,11 @@ char *xen_scheme_constant_to_ruby(const char *name)
 char *xen_scheme_procedure_to_ruby(const char *name)
 {
   char *new_name = NULL;
-  int len, i, j;
-  len = strlen(name);
+  int len;
+  len = name ? strlen(name) : 0;
   if (len > 0)
     {
+      int i, j;
       new_name = (char *)calloc(len + 1, sizeof(char));
       for (i = 0, j = 0; i < len; i++)
 	{
@@ -351,7 +293,7 @@ bool xen_rb_defined_p(const char *name)
     sprintf(buf, "defined? %s", var_name);
   else sprintf(buf, "defined? $%s", var_name);
 
-  if (XEN_EVAL_C_STRING(buf) != Qnil)
+  if (Xen_eval_C_string(buf) != Qnil)
     {
       free(var_name);
       return(true);
@@ -367,10 +309,10 @@ bool xen_rb_defined_p(const char *name)
 }
 
 
-XEN xen_rb_gv_get(const char *name)
+Xen xen_rb_gv_get(const char *name)
 {
   char *temp;
-  XEN val;
+  Xen val;
   temp = xen_scheme_global_variable_to_ruby(name);
   val = rb_gv_get(temp);
   if (temp) free(temp);
@@ -378,10 +320,10 @@ XEN xen_rb_gv_get(const char *name)
 }
 
 
-XEN xen_rb_gv_set(const char *name, XEN new_val)
+Xen xen_rb_gv_set(const char *name, Xen new_val)
 {
   char *temp;
-  XEN val;
+  Xen val;
   temp = xen_scheme_global_variable_to_ruby(name);
   val = rb_gv_set(temp, new_val);
   if (temp) free(temp);
@@ -389,10 +331,10 @@ XEN xen_rb_gv_set(const char *name, XEN new_val)
 }
 
 
-XEN xen_rb_intern(const char *name)
+Xen xen_rb_intern(const char *name)
 {
   char *temp;
-  XEN val;
+  Xen val;
   temp = xen_scheme_constant_to_ruby(name);
   val = rb_intern(temp);
   if (temp) free(temp);
@@ -400,18 +342,18 @@ XEN xen_rb_intern(const char *name)
 }
 
 
-XEN xen_rb_make_keyword(const char *name)
+Xen xen_rb_make_keyword(const char *name)
 {
   char *temp;
-  XEN val;
+  Xen val;
   temp = xen_scheme_procedure_to_ruby(name);
-  val = C_STRING_TO_XEN_SYMBOL(temp);
+  val = C_string_to_Xen_symbol(temp);
   if (temp) free(temp);
   return(val);
 }
 
 
-void xen_rb_define(const char *name, XEN value)
+void xen_rb_define(const char *name, Xen value)
 {
   char *temp;
   temp = xen_scheme_constant_to_ruby(name);
@@ -420,10 +362,10 @@ void xen_rb_define(const char *name, XEN value)
 }
 
 
-XEN xen_rb_define_class(const char *name)
+Xen xen_rb_define_class(const char *name)
 {
   char *temp;
-  XEN val;
+  Xen val;
   temp = xen_scheme_constant_to_ruby(name);
   val = rb_define_class(temp, rb_cObject);
   if (temp) free(temp);
@@ -442,31 +384,27 @@ XEN xen_rb_define_class(const char *name)
 #endif 
  
 
-int xen_rb_list_length(XEN obj) 
+int xen_rb_list_length(Xen obj) 
 { 
-  if (XEN_VECTOR_P(obj)) 
+  if (Xen_is_vector(obj)) 
      return((int)RB_ARRAY_LEN(obj)); 
-  if (obj == XEN_EMPTY_LIST) 
+  if (obj == Xen_empty_list) 
     return(0); 
   return(-1); 
 } 
 
 
-/* XEN_CAR, XEN_CADR..., XEN_LIST_REF, XEN_VECTOR_REF */
-
-XEN xen_rb_list_ref(XEN obj, int index)
+Xen xen_rb_list_ref(Xen obj, int index)
 {
-  if (XEN_VECTOR_P(obj))
+  if (Xen_is_vector(obj))
     return(rb_ary_entry(obj, (long)index));
-  return(XEN_EMPTY_LIST);
+  return(Xen_empty_list);
 }
 
 
-/* XEN_LIST_SET, XEN_VECTOR_SET */
-
-XEN xen_rb_list_set(XEN obj, int index, XEN value)
+Xen xen_rb_list_set(Xen obj, int index, Xen value)
 {
-  if (XEN_VECTOR_P(obj))
+  if (Xen_is_vector(obj))
     rb_ary_store(obj, (long)index, value);
   return(value);
 }
@@ -474,76 +412,47 @@ XEN xen_rb_list_set(XEN obj, int index, XEN value)
 
 char *xen_version(void)
 {
+  /* there is no macro we can depend on for the version number (its name changes unpredictably),
+   *   and ruby/version.h tries to be funny about how unreliable their semi-functional access is.
+   *   Maybe use <ruby/version.h> and ruby_version here (a const char*).
+   * No, even that doesn't work because there's no way to tell whether version.h exists.
+   *   Humph!
+   */
   char *buf;
   buf = (char *)calloc(128, sizeof(char));
-#if HAVE_SNPRINTF
-  snprintf(buf, 128, "Ruby: %s (%s), Xen: %s", 
-#else
-  sprintf(buf, "Ruby: %s (%s), Xen: %s", 
-#endif
-#ifdef MUS_RUBY_VERSION
-	  MUS_RUBY_VERSION,
-	  RUBY_RELEASE_DATE,
-#else
-	  XEN_TO_C_STRING(XEN_EVAL_C_STRING("RUBY_VERSION")),
-	  XEN_TO_C_STRING(XEN_EVAL_C_STRING("RUBY_RELEASE_DATE")),
-#endif
-	  XEN_VERSION);
+  snprintf(buf, 128, "%s", "Ruby");
   return(buf);
 }
 
 
-#if HAVE_READLINE
-  #include <readline/readline.h>
-  #include <readline/history.h>
-#endif
-
-static XEN xen_rb_report_error(XEN nada, XEN err_info)
+static Xen xen_rb_report_error(Xen nada, Xen err_info)
 {
   /* backtrace info: */
   /*    return rb_funcall(err_info, rb_intern("backtrace"), 0); */
   /* which can be an array of strings */
 
-  fprintf(stderr,"error: %s\n", XEN_AS_STRING(err_info));
-  return(XEN_FALSE);
+  fprintf(stderr,"error: %s\n", Xen_object_to_C_string(err_info));
+  return(Xen_false);
 }
 
 
 static char *rb_prompt = NULL;
 
-static XEN xen_rb_rep(XEN ig)
+static Xen xen_rb_rep(Xen ig)
 {
-  XEN val;
+  Xen val;
   char *str;
-#if HAVE_READLINE
-  char *line_read = NULL;
-  line_read = readline(rb_prompt);
-  if ((line_read) && (*line_read))
-    {
-      add_history(line_read);
-      val = xen_rb_eval_string_with_error(line_read);
-      str = XEN_AS_STRING(val);
-      fprintf(stdout, "%s\n", (str) ? str : "nil");
-      free(line_read);
-      line_read = NULL;
-    }
-#else
-  int size = 512;
+  size_t size = 512;
   char **buffer = NULL;
   buffer = (char **)calloc(1, sizeof(char *));
   buffer[0] = (char *)calloc(size, sizeof(char));
-  fprintf(stdout, rb_prompt);
-#if HAVE_GETLINE
-  getline(buffer, &size, stdin);
-#else
+  fprintf(stdout, "%s", rb_prompt);
   fgets(buffer[0], size, stdin);
-#endif
   val = xen_rb_eval_string_with_error(buffer[0]);
-  str = XEN_AS_STRING(val);
+  str = Xen_object_to_C_string(val);
   fprintf(stdout, "%s\n", (str) ? str : "nil");
   free(buffer[0]);
   free(buffer);
-#endif
   return(ig);
 }
 
@@ -555,13 +464,13 @@ void xen_rb_repl_set_prompt(const char *prompt)
 }
 
 
-static XEN xen_rb_rescue(XEN val)
+static Xen xen_rb_rescue(Xen val)
 {
   if (!rb_prompt) rb_prompt = xen_strdup(">");
-  return(rb_rescue(XEN_PROCEDURE_CAST xen_rb_rep,
-		   XEN_FALSE,
-		   XEN_PROCEDURE_CAST xen_rb_report_error,
-		   XEN_FALSE));
+  return(rb_rescue(Xen_procedure_cast xen_rb_rep,
+		   Xen_false,
+		   Xen_procedure_cast xen_rb_report_error,
+		   Xen_false));
 }
 
 
@@ -571,68 +480,68 @@ void xen_repl(int argc, char **argv)
     {
       int status = 0;
       rb_protect(XEN_VALUE_ARG_PROCEDURE_CAST xen_rb_rescue,
-		 XEN_FALSE,
+		 Xen_false,
 		 &status);
       if (status != 0)
 	{
-	  fprintf(stderr, "%s\n", XEN_AS_STRING(rb_gv_get("$!")));
+	  fprintf(stderr, "%s\n", Xen_object_to_C_string(rb_gv_get("$!")));
 	  status = 0;
 	}
     }
 }
 
 
-XEN xen_rb_eval_string_with_error(const char *str)
+Xen xen_rb_eval_string_with_error(const char *str)
 {
   int status = 0;
-  XEN res;
+  Xen res;
   res = rb_eval_string_protect(str, &status);
   if (status != 0)
-    return(XEN_TO_STRING(rb_gv_get("$!")));
+    return(xen_rb_obj_as_string(rb_gv_get("$!")));
   return(res);
 }
 
 
-XEN xen_rb_load_file_with_error(XEN file)
+Xen xen_rb_load_file_with_error(Xen file)
 {
   int status = 0;
   rb_load_protect(file, 0, &status);
   if (status != 0)
-    return(XEN_TO_STRING(rb_gv_get("$!")));
-  return(XEN_TRUE);
+    return(xen_rb_obj_as_string(rb_gv_get("$!")));
+  return(Xen_true);
 }
 
 
-XEN xen_rb_add_to_load_path(char *path) 
+Xen xen_rb_add_to_load_path(char *path) 
 { 
- XEN rpath, load_path; 
+ Xen rpath, load_path; 
  rpath = rb_str_new2(path); 
  load_path = rb_gv_get("$:");
- if (XEN_FALSE_P(rb_ary_includes(load_path, rpath))) 
+ if (Xen_is_false(rb_ary_includes(load_path, rpath))) 
    rb_ary_unshift(load_path, rpath); 
- return(XEN_FALSE); 
+ return(Xen_false); 
 } 
 
 
 static char *lstbuf = NULL;
 
-static char *xen_rb_list_to_s(XEN lst)
+static char *xen_rb_list_to_s(Xen lst)
 {
   int i, len;
   if (lstbuf == NULL) 
     lstbuf = (char *)calloc(512, sizeof(char));
   else lstbuf[0] = '\0';
-  len = XEN_LIST_LENGTH(lst);
+  len = Xen_list_length(lst);
   for (i = 0; i < len; i++)
     {
-      strcat(lstbuf, XEN_AS_STRING(XEN_LIST_REF(lst, i)));
+      strcat(lstbuf, Xen_object_to_C_string(Xen_list_ref(lst, i)));
       strcat(lstbuf, " ");
     }
   return(lstbuf);
 }
 
 
-void xen_rb_raise(XEN type, XEN info)
+void xen_rb_raise(Xen type, Xen info)
 {
   rb_raise(rb_eStandardError, "%s: %s\n", 
 	   rb_id2name(type), 
@@ -640,129 +549,115 @@ void xen_rb_raise(XEN type, XEN info)
 }
 
 
-int xen_rb_required_args(XEN val)
+int xen_rb_required_args(Xen val)
 {
   int args;
-  args = XEN_TO_C_INT(val);
+  args = Xen_integer_to_C_int(val);
   if (args == -1) return(1); 
   if (args < 0) return(abs(args + 1));
   return(args);
 }
 
 
-XEN xen_rb_obj_as_string(XEN obj)
+Xen xen_rb_obj_as_string(Xen obj)
 {
   int status = 0;
-  XEN result;
+  Xen result;
   result = rb_protect(XEN_VALUE_ARG_PROCEDURE_CAST rb_obj_as_string,
 		      obj,
 		      &status);
   if (status != 0)
-    return(C_TO_XEN_STRING("<invalid object>"));
+    return(C_string_to_Xen_string("<invalid object>"));
   return(result);
 }
 
 
 #if HAVE_RB_PROC_NEW
 
-static XEN xen_rb_apply_1(XEN args) 
+static Xen xen_rb_apply_1(Xen args) 
 { 
-  return(rb_apply(XEN_CAR(args), rb_intern("call"), XEN_CADR(args))); 
+  return(rb_apply(Xen_car(args), rb_intern("call"), Xen_cadr(args))); 
 } 
 
 #else
 
-static XEN xen_rb_apply_1(XEN args)
+static Xen xen_rb_apply_1(Xen args)
 {
-  if (XEN_PROCEDURE_P(XEN_CAR(args))) 
-    return(rb_apply(XEN_CAR(args), rb_intern("call"), XEN_CADR(args))); 
-  return(rb_apply(rb_mKernel, XEN_CAR(args), XEN_CADR(args))); 
+  if (Xen_is_procedure(Xen_car(args))) 
+    return(rb_apply(Xen_car(args), rb_intern("call"), Xen_cadr(args))); 
+  return(rb_apply(rb_mKernel, Xen_car(args), Xen_cadr(args))); 
 }
 
 #endif
 
 
-XEN xen_rb_apply(XEN func, XEN args)
+Xen xen_rb_apply(Xen func, Xen args)
 {
-  XEN val;
+  Xen val;
   int status = 0;
   val = rb_protect(XEN_VALUE_ARG_PROCEDURE_CAST xen_rb_apply_1,
-		   XEN_LIST_2(func, args),
+		   Xen_list_2(func, args),
 		   &status);
   if (status != 0)
-    return(XEN_TO_STRING(rb_gv_get("$!")));
+    return(xen_rb_obj_as_string(rb_gv_get("$!")));
   return(val);
 }
 
 
-static XEN xen_rb_funcall_0_inner(XEN args)
+static Xen xen_rb_funcall_0_inner(Xen args)
 {
   return(rb_funcall(args, rb_intern("call"), 0));
 }
 
 
-XEN xen_rb_funcall_0(XEN func)
+Xen xen_rb_funcall_0(Xen func)
 {
-  XEN val;
+  Xen val;
   int status = 0;
   val = rb_protect(XEN_VALUE_ARG_PROCEDURE_CAST xen_rb_funcall_0_inner,
 		   func,
 		   &status);
   if (status != 0)
-    return(XEN_TO_STRING(rb_gv_get("$!")));
+    return(xen_rb_obj_as_string(rb_gv_get("$!")));
   return(val);
 }
 
 
-XEN xen_rb_copy_list(XEN val) 
+Xen xen_rb_copy_list(Xen val) 
 { 
-  if ((val == XEN_EMPTY_LIST) || (!XEN_CONS_P(val)))
-    return XEN_EMPTY_LIST; 
+  if ((val == Xen_empty_list) || (!Xen_is_cons(val)))
+    return Xen_empty_list; 
   return rb_ary_dup(val); 
 } 
 
 
-XEN xen_rb_str_new2(char *arg)
+Xen xen_rb_str_new2(char *arg)
 {
   return(rb_str_new2((arg) ? arg : ""));
 }
 
 
-double xen_rb_to_c_double_or_else(XEN a, double b) 
-{
-  return(XEN_NUMBER_P(a) ? NUM2DBL(a) : b);
-}
-
-
-int xen_rb_to_c_int_or_else(XEN a, int b) 
-{
-  if (XEN_INTEGER_P(a)) return(FIX2INT(a));
-  if (XEN_NUMBER_P(a)) return((int)(NUM2DBL(a)));
-  return(b);
-}
-
-
 /* class Hook */
  
-static XEN xen_rb_cHook;
+static Xen xen_rb_cHook;
 
-static XEN hook_alloc(XEN klass)
+static Xen hook_alloc(Xen klass)
 {
   return(Data_Wrap_Struct(klass, 0, 0, 0));
 }
 
 
-#define XEN_CLASS_HOOK_P(Arg)              rb_obj_is_kind_of(Arg, xen_rb_cHook)
+#define Xen_is_class_hook(Arg)              rb_obj_is_kind_of(Arg, xen_rb_cHook)
 
-bool xen_rb_hook_p(XEN obj)
+bool xen_rb_hook_p(Xen obj)
 {
-  return(XEN_CLASS_HOOK_P(obj));
+  return(Xen_is_class_hook(obj));
 }
 
 
-bool xen_rb_hook_empty_p(XEN obj) 
+bool xen_rb_hook_empty_p(Xen obj) 
 { 
-  if (XEN_CLASS_HOOK_P(obj)) 
+  if (Xen_is_class_hook(obj)) 
     return(RB_ARRAY_LEN(rb_iv_get(obj, "@procs")) == 0); 
   return(true); 
 } 
@@ -774,24 +669,23 @@ bool xen_rb_hook_empty_p(XEN obj)
  * @procs = [["named proc1", proc1], ...]
  */
 
-static XEN xen_rb_hook_initialize(int argc, XEN *argv, XEN hook)
+static Xen xen_rb_hook_initialize(int argc, Xen *argv, Xen hook)
 {
-  XEN name, arity, help;
+  Xen name, arity, help;
   rb_scan_args(argc, argv, "12", &name, &arity, &help);
-  XEN_ASSERT_TYPE(XEN_STRING_P(name) || XEN_SYMBOL_P(name), name, XEN_ARG_1, c__FUNCTION__, "a char* or symbol");
-  if (XEN_SYMBOL_P(name))
+  Xen_check_type(Xen_is_string(name) || Xen_is_symbol(name), name, 1, __func__, "a char* or symbol");
+  if (Xen_is_symbol(name))
     name = XEN_SYMBOL_TO_STRING(name);
   if (arity != Qnil)
     {
-      XEN_ASSERT_TYPE(XEN_INTEGER_P(arity), arity, XEN_ARG_2, c__FUNCTION__, "an integer");
+      Xen_check_type(Xen_is_integer(arity), arity, 2, __func__, "an integer");
     }
   else arity = INT2NUM(0);
   if (help != Qnil)
     {
-      XEN_ASSERT_TYPE(XEN_STRING_P(help), help, XEN_ARG_3, c__FUNCTION__, "a char*");
+      Xen_check_type(Xen_is_string(help), help, 3, __func__, "a char*");
       XEN_SET_OBJECT_HELP(name, help);
     }
-  else help = rb_str_new2("");
   rb_iv_set(hook, "@name", name);
   rb_iv_set(hook, "@arity", arity);
   rb_iv_set(hook, "@procs", rb_ary_new());
@@ -804,12 +698,12 @@ static XEN xen_rb_hook_initialize(int argc, XEN *argv, XEN hook)
  * To create a global hook variables, see xen_rb_create_hook() below.
  */
 
-XEN xen_rb_hook_c_new(char *name, int arity, char *help)
+Xen xen_rb_hook_c_new(char *name, int arity, char *help)
 {
-  XEN args[3];
-  args[0] = C_TO_XEN_STRING(name);
-  args[1] = C_TO_XEN_INT(arity);
-  args[2] = C_TO_XEN_STRING(help);
+  Xen args[3];
+  args[0] = C_string_to_Xen_string(name);
+  args[1] = C_int_to_Xen_integer(arity);
+  args[2] = C_string_to_Xen_string(help);
   return(xen_rb_hook_initialize(3, args, hook_alloc(xen_rb_cHook)));
 }
 
@@ -826,10 +720,10 @@ XEN xen_rb_hook_c_new(char *name, int arity, char *help)
   etc.
 */
 
-#ifdef MUS_RUBY_VERSION
+#ifdef RUBY_VERSION
   #define XEN_RUBY_RELEASE_DATE  RUBY_RELEASE_DATE
 #else
-  #define XEN_RUBY_RELEASE_DATE  XEN_TO_C_STRING(XEN_EVAL_C_STRING("RUBY_RELEASE_DATE"))
+  #define XEN_RUBY_RELEASE_DATE  Xen_string_to_C_string(Xen_eval_C_string("RUBY_RELEASE_DATE"))
 #endif
 
 #define RUBY_NEW_ARITY_DATE   "2004-03-18"
@@ -852,15 +746,15 @@ bool xen_rb_arity_ok(int rargs, int args)
 }
 
  
-static XEN xen_rb_hook_add_hook(int argc, XEN *argv, XEN hook)
+static Xen xen_rb_hook_add_hook(int argc, Xen *argv, Xen hook)
 {
-  XEN name, func;
+  Xen name, func;
   int args;
-  args = XEN_TO_C_INT(rb_iv_get(hook, "@arity"));
+  args = Xen_integer_to_C_int(rb_iv_get(hook, "@arity"));
   rb_scan_args(argc, argv, "1&", &name, &func);
-  XEN_ASSERT_TYPE(XEN_STRING_P(name), name, XEN_ARG_1, c__FUNCTION__, "a char*");
-  XEN_ASSERT_TYPE(XEN_PROCEDURE_P(func) && xen_rb_arity_ok(XEN_TO_C_INT(XEN_ARITY(func)), args),
-		  func, XEN_ARG_2, c__FUNCTION__, "a procedure");
+  Xen_check_type(Xen_is_string(name), name, 1, __func__, "a char*");
+  Xen_check_type(Xen_is_procedure(func) && xen_rb_arity_ok(Xen_integer_to_C_int(Xen_arity(func)), args),
+		  func, 2, __func__, "a procedure");
   rb_ary_push(rb_iv_get(hook, "@procs"), rb_ary_new3(2, name, func));
   return(hook);
 }
@@ -868,50 +762,51 @@ static XEN xen_rb_hook_add_hook(int argc, XEN *argv, XEN hook)
 
 #if HAVE_RB_PROC_NEW
 
-static XEN xen_proc_call(XEN args, XEN id) 
+static Xen xen_proc_call(Xen args, Xen id) 
 { 
-  return(rb_apply(rb_mKernel, (ID)id, XEN_CONS_P(args) ? args : XEN_LIST_1(args))); 
+  return(rb_apply(rb_mKernel, (ID)id, Xen_is_cons(args) ? args : Xen_list_1(args))); 
 } 
 
 #if 0
   VALUE rb_proc_new((VALUE (*)(ANYARGS/* VALUE yieldarg[, VALUE procarg] */), VALUE)); 
 #endif
 
-static XEN xen_rb_proc_new(const char *name, XEN (*func)(), int arity, const char* doc) 
+static Xen xen_rb_proc_new(const char *name, Xen (*func)(), int arity, const char* doc) 
 { 
-  rb_define_module_function(rb_mKernel, name, XEN_PROCEDURE_CAST func, arity); 
+  rb_define_module_function(rb_mKernel, name, Xen_procedure_cast func, arity); 
   if (doc) C_SET_OBJECT_HELP(name, doc); 
-  return(rb_proc_new(XEN_PROCEDURE_CAST xen_proc_call, rb_intern(name))); 
+  return(rb_proc_new(Xen_procedure_cast xen_proc_call, rb_intern(name))); 
 } 
 
 
-static XEN xen_rb_hook_arity(XEN hook); 
+static Xen xen_rb_hook_arity(Xen hook); 
 
-XEN xen_rb_add_hook(XEN hook, VALUE (*func)(), const char *name, const char* doc) 
+Xen xen_rb_add_hook(Xen hook, VALUE (*func)(), const char *name, const char* doc) 
 { 
   /* called from C, not Ruby, to add a function to a Ruby-side hook */ 
   char *temp; 
   temp = xen_scheme_procedure_to_ruby(name); 
-  rb_ary_push(rb_iv_get(hook, "@procs"), rb_ary_new3(2, C_TO_XEN_STRING(temp), xen_rb_proc_new(temp, func, XEN_TO_C_INT(xen_rb_hook_arity(hook)), doc))); 
+  rb_ary_push(rb_iv_get(hook, "@procs"), rb_ary_new3(2, C_string_to_Xen_string(temp), xen_rb_proc_new(temp, func, Xen_integer_to_C_int(xen_rb_hook_arity(hook)), doc))); 
   if (temp) free(temp); 
   return(hook); 
 } 
 
 #else
 
-XEN xen_rb_add_hook(XEN hook, VALUE (*func)(), const char *name, const char* doc) 
+Xen xen_rb_add_hook(Xen hook, VALUE (*func)(), const char *name, const char* doc) 
 {
   /* called from C, not Ruby, to add a function to a Ruby-side hook 
    *   this doesn't work in g++ because it thinks the funcs are invalid:
    *   "error: invalid conversion from 'VALUE (*)(VALUE, VALUE)' to 'VALUE (*)(...)'" (snd-file.c etc)
    */ 
-  XEN var; 
+  Xen var, avar; 
   char *temp; 
   temp = xen_scheme_procedure_to_ruby(name); 
-  rb_define_module_function(rb_mKernel, temp, XEN_PROCEDURE_CAST func, XEN_TO_C_INT_OR_ELSE(rb_iv_get(hook, "@arity"), 0)); 
+  avar = rb_iv_get(hook, "@arity");
+  rb_define_module_function(rb_mKernel, temp, Xen_procedure_cast func, (Xen_is_integer(avar)) ? Xen_integer_to_C_int(avar) : 0); 
   if (doc) C_SET_OBJECT_HELP(temp, doc); 
   var = rb_intern(temp); 
-  rb_ary_push(rb_iv_get(hook, "@procs"), rb_ary_new3(2, C_TO_XEN_STRING(temp), var)); 
+  rb_ary_push(rb_iv_get(hook, "@procs"), rb_ary_new3(2, C_string_to_Xen_string(temp), var)); 
   if (temp) free(temp); 
   return(hook); 
 }
@@ -919,25 +814,25 @@ XEN xen_rb_add_hook(XEN hook, VALUE (*func)(), const char *name, const char* doc
 #endif
 
 
-static XEN xen_rb_hook_remove_hook(XEN hook, XEN name)
+static Xen xen_rb_hook_remove_hook(Xen hook, Xen name)
 {
-  XEN ary;
+  Xen ary;
   ary = rb_iv_get(hook, "@procs");
   return(rb_ary_delete(ary, rb_ary_assoc(ary, name)));
 }
 
 
-XEN xen_rb_hook_reset_hook(XEN hook)
+Xen xen_rb_hook_reset_hook(Xen hook)
 {
-  if (XEN_CLASS_HOOK_P(hook))
+  if (Xen_is_class_hook(hook))
     rb_ary_clear(rb_iv_get(hook, "@procs"));
   return(hook);
 }
 
 
-static XEN xen_rb_hook_names(XEN hook)
+static Xen xen_rb_hook_names(Xen hook)
 {
-  XEN ary, ret = Qnil;
+  Xen ary, ret = Qnil;
   long len;
   ary = rb_iv_get(hook, "@procs");
   len = RB_ARRAY_LEN(ary); 
@@ -946,34 +841,34 @@ static XEN xen_rb_hook_names(XEN hook)
       long i;
       ret = rb_ary_new2(len);
       for (i = 0; i < len; i++)
-	rb_ary_store(ret, i, XEN_VECTOR_REF(XEN_VECTOR_REF(ary, i), 0));
+	rb_ary_store(ret, i, Xen_vector_ref(Xen_vector_ref(ary, i), 0));
     }
   return(ret);
 }
 
 
-XEN xen_rb_hook_to_a(XEN hook)
+Xen xen_rb_hook_to_a(Xen hook)
 {
-  XEN ret = Qnil;
-  if (XEN_CLASS_HOOK_P(hook))
+  Xen ret = Qnil;
+  if (Xen_is_class_hook(hook))
     {
-      XEN ary;
+      Xen ary;
       long len;
       ary = rb_iv_get(hook, "@procs");
-      len = XEN_LIST_LENGTH(ary);
+      len = Xen_list_length(ary);
       if (len > 0)
 	{
 	  long i;
 	  ret = rb_ary_new2(len);
 	  for (i = 0; i < len; i++)
-	    rb_ary_store(ret, i, XEN_VECTOR_REF(XEN_VECTOR_REF(ary, i), 1));
+	    rb_ary_store(ret, i, Xen_vector_ref(Xen_vector_ref(ary, i), 1));
 	}
     }
   return(ret);
 }
 
 
-static XEN xen_rb_hook_run_hook(XEN hook)
+static Xen xen_rb_hook_run_hook(Xen hook)
 {
   if (RB_ARRAY_LEN(rb_iv_get(hook, "@procs"))) 
     rb_ary_each(xen_rb_hook_to_a(hook));
@@ -987,9 +882,9 @@ static XEN xen_rb_hook_run_hook(XEN hook)
  * results.
  */
 
-static XEN xen_rb_hook_call(int argc, XEN *argv, XEN hook)
+static Xen xen_rb_hook_call(int argc, Xen *argv, Xen hook)
 {
-  XEN result = Qnil, rest, procs;
+  Xen result = Qnil, rest, procs;
   rb_scan_args(argc, argv, "*", &rest);
   procs = xen_rb_hook_to_a(hook);
   if (procs != Qnil)
@@ -1002,39 +897,39 @@ static XEN xen_rb_hook_call(int argc, XEN *argv, XEN hook)
 }
 
 
-static XEN xen_rb_hook_is_empty_p(XEN hook)
+static Xen xen_rb_hook_is_empty_p(Xen hook)
 {
-  return(C_TO_XEN_BOOLEAN(RB_ARRAY_LEN(rb_iv_get(hook, "@procs")) == 0)); 
+  return(C_bool_to_Xen_boolean(RB_ARRAY_LEN(rb_iv_get(hook, "@procs")) == 0)); 
 }
 
  
-static XEN xen_rb_hook_length(XEN hook)
+static Xen xen_rb_hook_length(Xen hook)
 {
-  return(C_TO_XEN_INT(RB_ARRAY_LEN(rb_iv_get(hook, "@procs")))); 
+  return(C_int_to_Xen_integer(RB_ARRAY_LEN(rb_iv_get(hook, "@procs")))); 
 }
 
 
-static XEN xen_rb_hook_name(XEN hook)
+static Xen xen_rb_hook_name(Xen hook)
 {
   return(rb_iv_get(hook, "@name"));
 }
 
 
-static XEN xen_rb_hook_describe(XEN hook)
+static Xen xen_rb_hook_describe(Xen hook)
 {
-  return(XEN_OBJECT_HELP(xen_rb_hook_name(hook)));
+  return(Xen_documentation(xen_rb_hook_name(hook)));
 }
 
 
-static XEN xen_rb_hook_arity(XEN hook)
+static Xen xen_rb_hook_arity(Xen hook)
 {
   return(rb_iv_get(hook, "@arity"));
 }
 
 
-static XEN xen_rb_hook_inspect(XEN hook)
+static Xen xen_rb_hook_inspect(Xen hook)
 {
-  XEN str = rb_str_new2("#<Hook name: ");
+  Xen str = rb_str_new2("#<Hook name: ");
   rb_str_append(str, rb_inspect(rb_iv_get(hook, "@name")));
   rb_str_cat2(str, ", arity: ");
   rb_str_append(str, rb_inspect(rb_iv_get(hook, "@arity")));
@@ -1047,19 +942,19 @@ static XEN xen_rb_hook_inspect(XEN hook)
 }    
 
 
-/* bil -- added xen_rb_create_hook for XEN_DEFINE_HOOK in xen.h, 13-Jun-05 --
+/* bil -- added xen_rb_create_hook for Xen_define_hook in xen.h, 13-Jun-05 --
  *   seems to work, but I'm guessing, especially the rb_gv_set line.
  *   I can't use rb_define_variable here, as in the old version, because it takes a pointer
  *   to the new variable, which in this case is a local variable => segfault.
  */
 
-XEN xen_rb_create_hook(char *name, int arity, char *help)
+Xen xen_rb_create_hook(char *name, int arity, char *help)
 {
-  XEN var, hook_name;
+  Xen var, hook_name;
   char *temp;
   var = xen_rb_hook_c_new(temp = xen_scheme_global_variable_to_ruby(name), arity, help);
   hook_name = xen_rb_hook_name(var);
-  rb_gv_set(XEN_TO_C_STRING(hook_name), var);
+  rb_gv_set(Xen_string_to_C_string(hook_name), var);
   if (temp) free(temp);
   return(var);
 }
@@ -1067,10 +962,10 @@ XEN xen_rb_create_hook(char *name, int arity, char *help)
 static int simple_hook_number = 0; 
  
 
-XEN xen_rb_create_simple_hook(int arity) 
+Xen xen_rb_create_simple_hook(int arity) 
 { 
   char *name; 
-  XEN hook; 
+  Xen hook; 
   name = (char *)calloc(20, sizeof(char)); 
   snprintf(name, 20, "simple_%02d_hook", simple_hook_number++); 
   hook = xen_rb_create_hook(name, arity, NULL); 
@@ -1100,9 +995,9 @@ XEN xen_rb_create_simple_hook(int arity)
   #define RB_STR_LEN(str)                RSTRING_LEN(str) 
 #endif 
 
-static XEN xen_rb_make_hook(int argc, XEN *argv, XEN klass)
+static Xen xen_rb_make_hook(int argc, Xen *argv, Xen klass)
 {
-  XEN hook = XEN_FALSE, name;
+  Xen hook = Xen_false, name;
   if (argc > 0 && argc < 4)
     {
       hook = xen_rb_hook_initialize(argc, argv, hook_alloc(xen_rb_cHook));
@@ -1118,24 +1013,24 @@ static XEN xen_rb_make_hook(int argc, XEN *argv, XEN klass)
       argv[0] = argv[3];
       xen_rb_hook_add_hook(1, argv, hook);
     }
-  else XEN_ERROR(XEN_ERROR_TYPE("wrong-number-of-args"),
-		 XEN_LIST_1(C_TO_XEN_STRING("make_hook(name, arity=0, help=\"\", hook_name=\"\", &func)")));
+  else Xen_error(Xen_make_error_type("wrong-number-of-args"),
+		 Xen_list_1(C_string_to_Xen_string("make_hook(name, arity=0, help=\"\", hook_name=\"\", &func)")));
   name = xen_rb_hook_name(hook);
-  if (XEN_TO_C_CHAR(name) != '$') 
+  if (Xen_char_to_C_char(name) != '$') 
     {
       char *temp;
-      temp = xen_scheme_global_variable_to_ruby(XEN_TO_C_STRING(name)); 
-      name = C_TO_XEN_STRING(temp);
+      temp = xen_scheme_global_variable_to_ruby(Xen_string_to_C_string(name)); 
+      name = C_string_to_Xen_string(temp);
       if (temp) free(temp);
     }
-  XEN_ASSERT_TYPE(RB_STR_LEN(name) >= 2, name, XEN_ARG_1, c__FUNCTION__, "a char*, len >= 2"); 
-  return(rb_gv_set(XEN_TO_C_STRING(name), hook)); 
+  Xen_check_type(RB_STR_LEN(name) >= 2, name, 1, __func__, "a char*, len >= 2"); 
+  return(rb_gv_set(Xen_string_to_C_string(name), hook)); 
 }
 
 
-static XEN xen_rb_is_hook_p(XEN klass, XEN obj)
+static Xen xen_rb_is_hook_p(Xen klass, Xen obj)
 {
-  return(C_TO_XEN_BOOLEAN(XEN_CLASS_HOOK_P(obj)));
+  return(C_bool_to_Xen_boolean(Xen_is_class_hook(obj)));
 }
 
 
@@ -1161,55 +1056,55 @@ static XEN xen_rb_is_hook_p(XEN klass, XEN obj)
  */
 
 #if (!HAVE_RB_DEFINE_ALLOC_FUNC)
-static XEN xen_rb_new(int argc, XEN *argv, XEN klass)
+static Xen xen_rb_new(int argc, Xen *argv, Xen klass)
 {
-  XEN hook = hook_alloc(klass);
+  Xen hook = hook_alloc(klass);
   rb_obj_call_init(hook, argc, argv);
   return(hook);
 }
 #endif
 
 
-static XEN rb_object_properties = XEN_FALSE;
+static Xen rb_object_properties = Xen_false;
 
 #define S_property       "property"
 #define S_set_property   "set_property"
 #define S_properties     "properties"
 
 
-XEN rb_property(XEN obj, XEN key)
+Xen rb_property(Xen obj, Xen key)
 {
 #define H_property S_property "(obj, key)  \
 if key exists, return obj's value (maybe nil) associated with key otherwise false"
-  XEN props = XEN_FALSE;
+  Xen props = Xen_false;
   
-  if (XEN_FALSE_P(rb_object_properties))
-    return(XEN_FALSE);
+  if (Xen_is_false(rb_object_properties))
+    return(Xen_false);
 
   props = rb_hash_aref(rb_object_properties, obj);
 
-  if (XEN_FALSE_P(props) || props == Qnil)
-    return(XEN_FALSE);
+  if (Xen_is_false(props) || props == Qnil)
+    return(Xen_false);
   else
     return(rb_hash_aref(props, key));
 }
 
 
-XEN rb_set_property(XEN obj, XEN key, XEN value)
+Xen rb_set_property(Xen obj, Xen key, Xen value)
 {
 #define H_set_property S_set_property "(obj, key, value)  \
 set key-value pair for obj and return value"
-  XEN props = XEN_FALSE;
+  Xen props = Xen_false;
 
-  if (XEN_FALSE_P(rb_object_properties))
+  if (Xen_is_false(rb_object_properties))
     {
       rb_object_properties = rb_hash_new();
-      XEN_PROTECT_FROM_GC(rb_object_properties);
+      Xen_GC_protect(rb_object_properties);
     }
   else
     props = rb_hash_aref(rb_object_properties, obj);
   
-  if (XEN_FALSE_P(props) || props == Qnil)
+  if (Xen_is_false(props) || props == Qnil)
     props = rb_hash_new();
   
   rb_hash_aset(props, key, value);
@@ -1218,37 +1113,37 @@ set key-value pair for obj and return value"
 }
 
 
-XEN rb_properties(void)
+Xen rb_properties(void)
 {
 #define H_properties S_properties "()  return all properties of rb_object_properties (a hash)"
   return(rb_object_properties);
 }
 
 
-static XEN g_gc_off(void) 
+static Xen g_gc_off(void) 
 {
   #define H_gc_off "(" S_gc_off ") turns off garbage collection"
   rb_gc_disable();
-  return(XEN_FALSE);
+  return(Xen_false);
 }
 
 
-static XEN g_gc_on(void) 
+static Xen g_gc_on(void) 
 {
   #define H_gc_on "(" S_gc_on ") turns on garbage collection"
   rb_gc_enable();
-  return(XEN_FALSE);
+  return(Xen_false);
 }
 
 
-XEN_ARGIFY_1(g_get_help_w, g_get_help);
-XEN_NARGIFY_2(g_add_help_w, g_add_help);
-XEN_NARGIFY_3(g_set_property_w, rb_set_property);
-XEN_NARGIFY_2(g_property_w, rb_property);
-XEN_NARGIFY_0(g_properties_w, rb_properties);
+Xen_wrap_1_optional_arg(g_get_help_w, g_get_help);
+Xen_wrap_2_args(g_add_help_w, g_add_help);
+Xen_wrap_3_args(g_set_property_w, rb_set_property);
+Xen_wrap_2_args(g_property_w, rb_property);
+Xen_wrap_no_args(g_properties_w, rb_properties);
 
-XEN_NARGIFY_0(g_gc_off_w, g_gc_off)
-XEN_NARGIFY_0(g_gc_on_w, g_gc_on)
+Xen_wrap_no_args(g_gc_off_w, g_gc_off)
+Xen_wrap_no_args(g_gc_on_w, g_gc_on)
 
 
 static bool hook_inited = false;
@@ -1263,40 +1158,40 @@ void Init_Hook(void)
 #if HAVE_RB_DEFINE_ALLOC_FUNC
   rb_define_alloc_func(xen_rb_cHook, hook_alloc);
 #else
-  rb_define_singleton_method(xen_rb_cHook, "new", XEN_PROCEDURE_CAST xen_rb_new, -1);
+  rb_define_singleton_method(xen_rb_cHook, "new", Xen_procedure_cast xen_rb_new, -1);
 #endif
     
-  rb_define_method(xen_rb_cHook, "initialize", XEN_PROCEDURE_CAST xen_rb_hook_initialize, -1);
-  rb_define_method(xen_rb_cHook, "add_hook!", XEN_PROCEDURE_CAST xen_rb_hook_add_hook, -1);
-  rb_define_method(xen_rb_cHook, "remove_hook!", XEN_PROCEDURE_CAST xen_rb_hook_remove_hook, 1);
-  rb_define_method(xen_rb_cHook, "reset_hook!", XEN_PROCEDURE_CAST xen_rb_hook_reset_hook, 0);
+  rb_define_method(xen_rb_cHook, "initialize", Xen_procedure_cast xen_rb_hook_initialize, -1);
+  rb_define_method(xen_rb_cHook, "add_hook!", Xen_procedure_cast xen_rb_hook_add_hook, -1);
+  rb_define_method(xen_rb_cHook, "remove_hook!", Xen_procedure_cast xen_rb_hook_remove_hook, 1);
+  rb_define_method(xen_rb_cHook, "reset_hook!", Xen_procedure_cast xen_rb_hook_reset_hook, 0);
   rb_define_alias(xen_rb_cHook, "clear", "reset_hook!");
-  rb_define_method(xen_rb_cHook, "to_a", XEN_PROCEDURE_CAST xen_rb_hook_to_a, 0);
-  rb_define_method(xen_rb_cHook, "run_hook", XEN_PROCEDURE_CAST xen_rb_hook_run_hook, 0);
+  rb_define_method(xen_rb_cHook, "to_a", Xen_procedure_cast xen_rb_hook_to_a, 0);
+  rb_define_method(xen_rb_cHook, "run_hook", Xen_procedure_cast xen_rb_hook_run_hook, 0);
   rb_define_alias(xen_rb_cHook, "each", "run_hook");
-  rb_define_method(xen_rb_cHook, "call", XEN_PROCEDURE_CAST xen_rb_hook_call, -1);
-  rb_define_method(xen_rb_cHook, "length", XEN_PROCEDURE_CAST xen_rb_hook_length, 0);
+  rb_define_method(xen_rb_cHook, "call", Xen_procedure_cast xen_rb_hook_call, -1);
+  rb_define_method(xen_rb_cHook, "length", Xen_procedure_cast xen_rb_hook_length, 0);
   rb_define_alias(xen_rb_cHook, "size", "length");
-  rb_define_method(xen_rb_cHook, "empty?", XEN_PROCEDURE_CAST xen_rb_hook_is_empty_p, 0);
-  rb_define_method(xen_rb_cHook, "name", XEN_PROCEDURE_CAST xen_rb_hook_name, 0);
-  rb_define_method(xen_rb_cHook, "arity", XEN_PROCEDURE_CAST xen_rb_hook_arity, 0);
-  rb_define_method(xen_rb_cHook, "describe", XEN_PROCEDURE_CAST xen_rb_hook_describe, 0);
+  rb_define_method(xen_rb_cHook, "empty?", Xen_procedure_cast xen_rb_hook_is_empty_p, 0);
+  rb_define_method(xen_rb_cHook, "name", Xen_procedure_cast xen_rb_hook_name, 0);
+  rb_define_method(xen_rb_cHook, "arity", Xen_procedure_cast xen_rb_hook_arity, 0);
+  rb_define_method(xen_rb_cHook, "describe", Xen_procedure_cast xen_rb_hook_describe, 0);
   rb_define_alias(xen_rb_cHook, "help", "describe");
   rb_define_alias(xen_rb_cHook, "documentation", "describe");
-  rb_define_method(xen_rb_cHook, "inspect", XEN_PROCEDURE_CAST xen_rb_hook_inspect, 0);
+  rb_define_method(xen_rb_cHook, "inspect", Xen_procedure_cast xen_rb_hook_inspect, 0);
   
-  rb_define_global_function("make_hook", XEN_PROCEDURE_CAST xen_rb_make_hook, -1);
-  rb_define_global_function("hook?", XEN_PROCEDURE_CAST xen_rb_is_hook_p, 1);
+  rb_define_global_function("make_hook", Xen_procedure_cast xen_rb_make_hook, -1);
+  rb_define_global_function("hook?", Xen_procedure_cast xen_rb_is_hook_p, 1);
 
-  XEN_DEFINE_PROCEDURE(S_get_help,             g_get_help_w,             0, 1, 0, H_get_help);
-  XEN_DEFINE_PROCEDURE(S_add_help,             g_add_help_w,             2, 0, 0, H_add_help);
+  Xen_define_procedure(S_get_help,             g_get_help_w,             0, 1, 0, H_get_help);
+  Xen_define_procedure(S_add_help,             g_add_help_w,             2, 0, 0, H_add_help);
 
-  XEN_DEFINE_PROCEDURE(S_set_property,         g_set_property_w,         3, 0, 0, H_set_property);
-  XEN_DEFINE_PROCEDURE(S_property,             g_property_w,             2, 0, 0, H_property);
-  XEN_DEFINE_PROCEDURE(S_properties,           g_properties_w,           0, 0, 0, H_properties);
+  Xen_define_procedure(S_set_property,         g_set_property_w,         3, 0, 0, H_set_property);
+  Xen_define_procedure(S_property,             g_property_w,             2, 0, 0, H_property);
+  Xen_define_procedure(S_properties,           g_properties_w,           0, 0, 0, H_properties);
 
-  XEN_DEFINE_PROCEDURE(S_gc_off,               g_gc_off_w,               0, 0, 0, H_gc_off);
-  XEN_DEFINE_PROCEDURE(S_gc_on,                g_gc_on_w,                0, 0, 0, H_gc_on);
+  Xen_define_procedure(S_gc_off,               g_gc_off_w,               0, 0, 0, H_gc_off);
+  Xen_define_procedure(S_gc_on,                g_gc_on_w,                0, 0, 0, H_gc_on);
 }
 
 /* end of class Hook */
@@ -1315,7 +1210,7 @@ char *xen_version(void)
 }
 
 
-void xen_gc_mark(XEN val)
+void xen_gc_mark(Xen val)
 {
   fth_gc_mark(val);
 }
@@ -1341,65 +1236,31 @@ void xen_repl(int argc, char **argv)
 }
 
 
-off_t xen_to_c_off_t_or_else(XEN obj, off_t fallback)
-{
-  if (XEN_NUMBER_P(obj))
-    return(fth_long_long_ref(obj));
-  return(fallback);
-}
-
-
-off_t xen_to_c_off_t(XEN obj)
-{
-  return(fth_long_long_ref(obj));
-}
-
-
-XEN c_to_xen_off_t(off_t obj)
-{
-  return(fth_make_long_long(obj));
-}
-
-
-int64_t xen_to_c_int64_t_or_else(XEN obj, int64_t fallback)
-{
-  if (XEN_NUMBER_P(obj))
-    return(fth_long_long_ref(obj));
-  return(fallback);
-}
-
-
-int64_t xen_to_c_int64_t(XEN obj)
-{
-  return(fth_long_long_ref(obj));
-}
-
-
 static ficlWord *snd_exit_xt; 
 
 static void fth_snd_exit(int n) 
 { 
   if (!snd_exit_xt) 
-    snd_exit_xt = ficlSystemLookup(FTH_FICL_SYSTEM(), "snd-exit"); 
+    snd_exit_xt = ficlSystemLookup(FTH_FICL_SYSTEM(), (char *)"snd-exit"); 
   ficlStackPushInteger(FTH_FICL_STACK(), n); 
   ficlVmExecuteXT(FTH_FICL_VM(), snd_exit_xt); 
   ficlStackDrop(FTH_FICL_STACK(), 1); 
 } 
  
 
-static XEN g_gc_off(void) 
+static Xen g_gc_off(void) 
 {
   #define H_gc_off "(" S_gc_off ") turns off garbage collection"
   fth_gc_on();
-  return(XEN_FALSE);
+  return(Xen_false);
 }
 
 
-static XEN g_gc_on(void) 
+static Xen g_gc_on(void) 
 {
   #define H_gc_on "(" S_gc_on ") turns on garbage collection"
   fth_gc_on();
-  return(XEN_FALSE);
+  return(Xen_false);
 }
 
 
@@ -1408,8 +1269,8 @@ void xen_initialize(void)
   fth_init();
   fth_exit_hook = fth_snd_exit; 
 
-  XEN_DEFINE_PROCEDURE(S_gc_off, g_gc_off, 0, 0, 0, H_gc_off);
-  XEN_DEFINE_PROCEDURE(S_gc_on,  g_gc_on,  0, 0, 0, H_gc_on);
+  Xen_define_procedure(S_gc_off, g_gc_off, 0, 0, 0, H_gc_off);
+  Xen_define_procedure(S_gc_on,  g_gc_on,  0, 0, 0, H_gc_on);
 }
 
 #endif 	/* HAVE_FORTH */
@@ -1419,18 +1280,10 @@ void xen_initialize(void)
 /* ------------------------------ S7 ------------------------------ */
 
 #if HAVE_SCHEME
-
-#if HAVE_LIMITS_H
-  #include <limits.h>
-#else
-  #define INT_MAX 2147483647
-  #define INT_MIN (-INT_MAX - 1)
-#endif
-
 #include "s7.h"
 
 s7_scheme *s7;
-XEN xen_false, xen_true, xen_nil, xen_undefined, xen_zero;
+Xen xen_false, xen_true, xen_nil, xen_undefined, xen_zero;
 
 char *xen_version(void)
 {
@@ -1445,34 +1298,6 @@ char *xen_version(void)
 }
 
 
-int xen_to_c_int(XEN a) /* xen_to_c_int is expected to return an int (not an int64_t) */
-{
-  s7_Int val;
-  val = s7_number_to_integer(a);
-  if (val > INT_MAX)
-    return(INT_MAX);
-  if (val < INT_MIN)
-    return(INT_MIN);
-  return(val);
-}
-
-
-int64_t xen_to_c_int64_t(XEN a)
-{
-  if (XEN_NUMBER_P(a))
-    return(s7_number_to_integer(a));
-  return(0); /* ?? in xm.c, XtSetValues of XmUserData with a pointer falls back on this -- probably can't work */
-}
-
-
-double xen_to_c_double_or_else(XEN a, double b) 
-{
-  if (XEN_NUMBER_P(a))
-    return(s7_number_to_real(a));
-  return(b);
-}
-
-
 static char *xen_s7_repl_prompt = NULL;
 
 void xen_s7_set_repl_prompt(const char *new_prompt)
@@ -1482,6 +1307,11 @@ void xen_s7_set_repl_prompt(const char *new_prompt)
 }
 
 
+#if USE_SND
+char *stdin_check_for_full_expression(const char *newstr);
+void stdin_free_str(void);
+#endif
+
 void xen_repl(int argc, char **argv)
 {
   int size = 512;
@@ -1508,7 +1338,7 @@ void xen_repl(int argc, char **argv)
 	    {
 	      if (buffer[i] == 0)
 		break;
-	      if (!isspace(buffer[i]))
+	      if (!isspace((int)buffer[i]))
 		{
 		  expr_ok = true;
 		  break;
@@ -1516,13 +1346,22 @@ void xen_repl(int argc, char **argv)
 	    }
 	  if (expr_ok)
 	    {
-	      char *temp;
-	      temp = (char *)malloc(len + 128);
-	      sprintf(temp, 
-		      "(write %s)",
-		      buffer);           /* use write, not display so that strings are in double quotes */
-	      XEN_EVAL_C_STRING(temp);
+	      char *str, *temp;
+#if USE_SND
+	      str = stdin_check_for_full_expression(buffer); /* "str" here is actually stdin_str, so we need to clear it explicitly */
+	      if (!str) {expr_ok = false; continue;}
+	      len = strlen(str) + 16;
+	      temp = (char *)malloc(len * sizeof(char));
+	      snprintf(temp, len, "(write %s)", str);  
+	      Xen_eval_C_string(temp);
+	      free(temp);
+	      stdin_free_str();
+#else
+	      temp = (char *)malloc(len + 16);
+	      snprintf(temp, len + 16, "(write %s)", buffer);    /* use write, not display so that strings are in double quotes */
+	      Xen_eval_C_string(temp);
 	      free(temp);
+#endif
 	    }
 	}
     }
@@ -1530,91 +1369,13 @@ void xen_repl(int argc, char **argv)
 }
 
 
-void xen_s7_ignore(s7_function func) /* squelch compiler warnings */
-{
-}
-
-
-XEN xen_define_variable(const char *name, XEN value)
-{
-  XEN_DEFINE(name, value);
-  /* s7_gc_protect(s7, value); */
-  /* XEN_DEFINE places value in the global env, so it is already gc protected */
-  return(C_STRING_TO_XEN_SYMBOL(name));
-}
-
-
-XEN xen_s7_define_hook(const char *name, XEN value)
-{
-  s7_define_constant(s7, name, value);
-  /* s7_gc_protect(s7, value); -- see above */
-  return(value);
-}
-
-
-void xen_gc_mark(XEN val)
+void xen_gc_mark(Xen val)
 {
   s7_mark_object(val);
 }
 
 
-#if !(defined(__GNUC__) && (!(defined(__cplusplus))))
-XEN xen_s7_c_to_xen_string(const char *str)
-{
-  return((str) ? s7_make_string(s7, str) : XEN_FALSE);
-}
-#endif
-
-
-static const char **constant_names = NULL, **constant_helps = NULL;
-static int constant_size = 0, constant_top = -1;
-
-void xen_s7_define_constant(s7_scheme *sc, const char *name, s7_pointer value, const char *help)
-{
-  /* save doc string */
-  constant_top++;
-  if (constant_top >= constant_size)
-    {
-      if (constant_size == 0)
-	{
-	  constant_size = 128;
-	  constant_names = (const char **)calloc(constant_size, sizeof(const char *));
-	  constant_helps = (const char **)calloc(constant_size, sizeof(const char *));
-	}
-      else
-	{
-	  int i;
-	  i = constant_size;
-	  constant_size += 128;
-	  constant_names = (const char **)realloc(constant_names, constant_size * sizeof(const char *));
-	  constant_helps = (const char **)realloc(constant_helps, constant_size * sizeof(const char *));
-	  for (; i < constant_size; i++)
-	    {
-	      constant_names[i] = NULL;
-	      constant_helps[i] = NULL;
-	    }
-	}
-    }
-  constant_names[constant_top] = xen_strdup(name);
-  constant_helps[constant_top] = xen_strdup(help);
-  s7_define_constant(s7, name, value);
-}
-
-
-const char *xen_s7_constant_help(const char *name)
-{
-  int i;
-  if (name)
-    {
-      for (i = 0; i <= constant_top; i++)
-	if (strcmp(name, constant_names[i]) == 0)
-	  return(constant_helps[i]);
-    }
-  return(NULL);
-}
-
-
-XEN xen_set_assoc(s7_scheme *sc, s7_pointer key, s7_pointer val, s7_pointer alist)
+Xen xen_set_assoc(s7_scheme *sc, s7_pointer key, s7_pointer val, s7_pointer alist)
 {
   /* fixup alist, return it (caller has to make sure it is reflected in its object) */
   /*
@@ -1625,7 +1386,7 @@ XEN xen_set_assoc(s7_scheme *sc, s7_pointer key, s7_pointer val, s7_pointer alis
               alist)
 	   (cons (cons key new-val) alist)))
   */
-  XEN old_val;
+  Xen old_val;
   old_val = s7_assoc(sc, key, alist); /* returns #f if nothing found */
   if (old_val == s7_f(sc))
     return(s7_cons(sc, s7_cons(sc, key, val), alist));
@@ -1634,9 +1395,9 @@ XEN xen_set_assoc(s7_scheme *sc, s7_pointer key, s7_pointer val, s7_pointer alis
 }
 
 
-XEN xen_assoc(s7_scheme *sc, XEN key, XEN alist)
+Xen xen_assoc(s7_scheme *sc, Xen key, Xen alist)
 {
-  XEN val;
+  Xen val;
   val = s7_assoc(sc, key, alist);
   if (val != s7_f(sc))
     return(s7_cdr(val));
@@ -1646,29 +1407,26 @@ XEN xen_assoc(s7_scheme *sc, XEN key, XEN alist)
 
 /* add various file functions that everyone else implements */
 
-#if (defined(HAVE_LIBC_H) && (!defined(HAVE_UNISTD_H)))
-  #include <libc.h>
-#else
-  #if (!(defined(_MSC_VER)))
-    #include <unistd.h>
-  #endif
-#endif
-
-#if HAVE_SYS_TIME_H
+#ifndef _MSC_VER
+  #include <unistd.h>
   #include <sys/time.h>
 #endif
 
 #include <sys/stat.h>
+#include <fcntl.h>
 
-#if HAVE_FCNTL_H
-  #include <fcntl.h>
-#endif
 
+static Xen g_getpid(void)
+{
+  #define H_getpid "(getpid) returns the current job's process id"
+  return(C_int_to_Xen_integer((int)getpid()));
+}
 
+
+#if (!WITH_SYSTEM_EXTRAS)
 static bool file_probe(const char *arg)
 {
-  /* from io.c */
-#if HAVE_ACCESS
+#ifndef _MSC_VER
   return(access(arg, F_OK) == 0);
 #else
   int fd;
@@ -1684,106 +1442,100 @@ static bool file_probe(const char *arg)
 }
 
 
-static bool directory_p(const char *filename)
+static Xen g_file_exists_p(Xen name)
 {
-#if HAVE_WINDOZE
-  return(false);
+  #define H_file_exists_p "(file-exists? filename): #t if the file exists"
+  Xen_check_type(Xen_is_string(name), name, 1, "file-exists?", "a string");
+  return(C_bool_to_Xen_boolean(file_probe(Xen_string_to_C_string(name))));
+}
+
 
+static bool is_directory(const char *filename)
+{
+#if (defined(_MSC_VER) || __CYGWIN__)
+  return(false);
 #else
-  /* from snd-file.c */
 #ifdef S_ISDIR
   struct stat statbuf;
-#if HAVE_LSTAT
-  return((lstat(filename, &statbuf) >= 0) &&
+  return((stat(filename, &statbuf) >= 0) &&
 	 (S_ISDIR(statbuf.st_mode)));
   return(false);
-#else
-  return((stat(filename, &statbuf) == 0) && 
-	 (S_ISDIR(statbuf.st_mode)));
-#endif
 #endif
 #endif
 }
 
-
-static XEN g_file_exists_p(XEN name)
-{
-  #define H_file_exists_p "(file-exists? filename): #t if the file exists"
-  XEN_ASSERT_TYPE(XEN_STRING_P(name), name, XEN_ONLY_ARG, "file-exists?", "a string");
-  return(C_TO_XEN_BOOLEAN(file_probe(XEN_TO_C_STRING(name))));
-}
-
-
-static XEN g_getpid(void)
+static Xen g_is_directory(Xen name)
 {
-  #define H_getpid "(getpid) returns the current job's process id"
-  return(C_TO_XEN_INT((int)getpid()));
+  #define H_is_directory "(directory? filename): #t if filename names a directory"
+  Xen_check_type(Xen_is_string(name), name, 1, "directory?", "a string");
+  return(C_bool_to_Xen_boolean(is_directory(Xen_string_to_C_string(name)))); /* snd-file.c l 84 */
 }
 
-
-static XEN g_file_is_directory(XEN name)
+static Xen g_delete_file(Xen name)
 {
-  #define H_file_is_directory "(file-is-directory? filename): #t if filename names a directory"
-  XEN_ASSERT_TYPE(XEN_STRING_P(name), name, XEN_ONLY_ARG, "file-is-directory?", "a string");
-  return(C_TO_XEN_BOOLEAN(directory_p(XEN_TO_C_STRING(name)))); /* snd-file.c l 84 */
+  #define H_delete_file "(delete-file filename): deletes the file"
+  Xen_check_type(Xen_is_string(name), name, 1, "delete-file", "a string");
+  return(C_bool_to_Xen_boolean(unlink(Xen_string_to_C_string(name))));
 }
 
 
-static XEN g_system(XEN command)
+static Xen g_system(Xen command)
 {
   #define H_system "(system command): execute command"
-  XEN_ASSERT_TYPE(XEN_STRING_P(command), command, XEN_ONLY_ARG, "system", "a string");
-  return(C_TO_XEN_INT(system(XEN_TO_C_STRING(command))));
+  Xen_check_type(Xen_is_string(command), command, 1, "system", "a string");
+  return(C_int_to_Xen_integer(system(Xen_string_to_C_string(command))));
 }
 
 
-static XEN g_s7_getenv(XEN var) /* "g_getenv" is in use in glib! */
+static Xen g_s7_getenv(Xen var) /* "g_getenv" is in use in glib! */
 {
   #define H_getenv "(getenv var): return value of environment variable var"
-  XEN_ASSERT_TYPE(XEN_STRING_P(var), var, XEN_ONLY_ARG, "getenv", "a string");
-  return(C_TO_XEN_STRING(getenv(XEN_TO_C_STRING(var))));
+  Xen_check_type(Xen_is_string(var), var, 1, "getenv", "a string");
+  return(C_string_to_Xen_string(getenv(Xen_string_to_C_string(var))));
 }
+#endif
 
 
-static XEN g_delete_file(XEN name)
-{
-  #define H_delete_file "(delete-file filename): deletes the file"
-  XEN_ASSERT_TYPE(XEN_STRING_P(name), name, XEN_ONLY_ARG, "delete-file", "a string");
-  return(C_TO_XEN_BOOLEAN(unlink(XEN_TO_C_STRING(name))));
-}
-
 
 #ifdef _MSC_VER
   #include <direct.h>
 #endif
 
-static XEN g_getcwd(void)
+static Xen g_getcwd(void)
 {
   #define H_getcwd "(getcwd) returns the name of the current working directory"
   char *buf;
-  XEN result = XEN_FALSE;
+  Xen result = Xen_false;
   buf = (char *)calloc(1024, sizeof(char));
 #ifdef _MSC_VER
   if (_getcwd(buf, 1024) != NULL)
 #else
   if (getcwd(buf, 1024) != NULL)
 #endif
-    result = C_TO_XEN_STRING(buf);
+    result = C_string_to_Xen_string(buf);
   free(buf);
   return(result);
 }
 
 
-static XEN g_strftime(XEN format, XEN tm)
+static Xen g_strftime(Xen format, Xen tm)
 {
   #define H_strftime "(strftime format time) returns a string describing the time: (strftime \"%d-%b %H:%M %Z\" (localtime (current-time)))"
   char *buf;
-  XEN result;
-  XEN_ASSERT_TYPE(XEN_STRING_P(format), format, XEN_ARG_1, "strftime", "a string");
+  Xen result;
+  const struct tm *p;
+
+  Xen_check_type(Xen_is_string(format), format, 1, "strftime", "a string");
+  Xen_check_type(Xen_is_wrapped_c_pointer(tm), tm, 2, "strftime", "a localtime struct");
+
+  p = (const struct tm *)Xen_unwrap_C_pointer(tm);
+  Xen_check_type(p != NULL, tm, 2, "strftime", "a localtime struct");
+
   buf = (char *)calloc(1024, sizeof(char));
-  strftime(buf, 1024, XEN_TO_C_STRING(format), (const struct tm *)XEN_UNWRAP_C_POINTER(tm));
-  result = C_TO_XEN_STRING(buf);
+  strftime(buf, 1024, Xen_string_to_C_string(format), p);
+  result = C_string_to_Xen_string(buf);
   free(buf);
+
   return(result);
 }
 
@@ -1791,32 +1543,31 @@ static XEN g_strftime(XEN format, XEN tm)
 /* (format #f ";~A~%" (strftime "%d-%b %H:%M %Z" (localtime (current-time)))) */
 /* these two need to be compatible with g_file_write_date in snd-file.c */
 
-static XEN g_localtime(XEN tm)
+static Xen g_localtime(Xen tm)
 {
   #define H_localtime "(localtime tm) breaks up tm into something suitable for strftime"
   time_t rtime;
-  rtime = (time_t)XEN_TO_C_ULONG(tm);
-  return(XEN_WRAP_C_POINTER(localtime((time_t *)(&rtime))));
+  rtime = (time_t)Xen_ulong_to_C_ulong(tm);
+  return(Xen_wrap_C_pointer(localtime((time_t *)(&rtime))));
 }
 
 
-static XEN g_current_time(void)
+static Xen g_current_time(void)
 {
   time_t curtime;
   #define H_current_time "(current-time) returns the current time (for localtime and strftime)"
   curtime = time(NULL);
-  return(C_TO_XEN_ULONG(curtime));
+  return(C_ulong_to_Xen_ulong(curtime));
 }
 
 
-static XEN g_tmpnam(void)
+static Xen g_tmpnam(void)
 {
-  #define H_tmpnam "(tmpnam) returns a new (hopefully unused) tempporary file name"
+  #define H_tmpnam "(tmpnam) returns a new (hopefully unused) temporary file name"
   #define BUFFER_SIZE 512
   static int file_ctr = 0;
   char *str, *tmpdir = NULL;
-  int len;
-  XEN result;
+  Xen result;
 
   str = (char *)calloc(BUFFER_SIZE, sizeof(char));
   tmpdir = xen_strdup(getenv("TMPDIR"));
@@ -1826,10 +1577,12 @@ static XEN g_tmpnam(void)
     tmpdir = xen_strdup(P_tmpdir); /* /usr/include/stdio.h */
   if (tmpdir)
     {
+      int len;
       len = strlen(tmpdir);
       if (len > 0)
 	{
-	  if (tmpdir[len - 1] == '/') tmpdir[len - 1] = 0;
+	  if (tmpdir[len - 1] == '/') 
+	    tmpdir[len - 1] = 0;
 	}
       else
 	{
@@ -1843,55 +1596,57 @@ static XEN g_tmpnam(void)
 
   snprintf(str, BUFFER_SIZE, "%s/xen_%d_%d", tmpdir, (int)getpid(), file_ctr++);
   if (tmpdir) free(tmpdir);
-  result = C_TO_XEN_STRING(str);
+  result = C_string_to_Xen_string(str);
   free(str);
   return(result);
 }
 
 
-static XEN g_ftell(XEN fd)
+static Xen g_ftell(Xen fd)
 {
-  return(C_TO_XEN_OFF_T(lseek(XEN_TO_C_INT(fd), 0, SEEK_CUR)));
+  return(C_int_to_Xen_integer(lseek(Xen_integer_to_C_int(fd), 0, SEEK_CUR)));
 }
 
 
-static XEN g_gc_off(void) 
+static Xen g_gc_off(void) 
 {
   #define H_gc_off "(" S_gc_off ") turns off garbage collection"
   s7_gc_on(s7, false);
-  return(XEN_FALSE);
+  return(Xen_false);
 }
 
 
-static XEN g_gc_on(void) 
+static Xen g_gc_on(void) 
 {
   #define H_gc_on "(" S_gc_on ") turns on garbage collection"
   s7_gc_on(s7, true);
-  return(XEN_FALSE);
+  return(Xen_false);
 }
 
 
 
-XEN_NARGIFY_0(g_getpid_w, g_getpid)
-XEN_NARGIFY_1(g_file_exists_p_w, g_file_exists_p)
-XEN_NARGIFY_1(g_file_is_directory_w, g_file_is_directory)
-XEN_NARGIFY_1(g_system_w, g_system)
-XEN_NARGIFY_1(g_s7_getenv_w, g_s7_getenv)
-XEN_NARGIFY_1(g_delete_file_w, g_delete_file)
-XEN_NARGIFY_0(g_getcwd_w, g_getcwd)
-XEN_NARGIFY_2(g_strftime_w, g_strftime)
-XEN_NARGIFY_1(g_localtime_w, g_localtime)
-XEN_NARGIFY_0(g_current_time_w, g_current_time)
-XEN_NARGIFY_0(g_tmpnam_w, g_tmpnam)
-XEN_NARGIFY_1(g_ftell_w, g_ftell)
+Xen_wrap_no_args(g_getpid_w, g_getpid)
+#if (!WITH_SYSTEM_EXTRAS)
+  Xen_wrap_1_arg(g_file_exists_p_w, g_file_exists_p)
+  Xen_wrap_1_arg(g_is_directory_w, g_is_directory)
+  Xen_wrap_1_arg(g_delete_file_w, g_delete_file)
+  Xen_wrap_1_arg(g_s7_getenv_w, g_s7_getenv)
+  Xen_wrap_1_arg(g_system_w, g_system)
+#endif
+Xen_wrap_no_args(g_getcwd_w, g_getcwd)
+Xen_wrap_2_args(g_strftime_w, g_strftime)
+Xen_wrap_1_arg(g_localtime_w, g_localtime)
+Xen_wrap_no_args(g_current_time_w, g_current_time)
+Xen_wrap_no_args(g_tmpnam_w, g_tmpnam)
+Xen_wrap_1_arg(g_ftell_w, g_ftell)
 
-XEN_NARGIFY_0(g_gc_off_w, g_gc_off)
-XEN_NARGIFY_0(g_gc_on_w, g_gc_on)
+Xen_wrap_no_args(g_gc_off_w, g_gc_off)
+Xen_wrap_no_args(g_gc_on_w, g_gc_on)
 
 
 s7_scheme *s7_xen_initialize(s7_scheme *sc)
 {
-  xen_s7_repl_prompt = xen_strdup(">");
+  xen_s7_repl_prompt = xen_strdup("> ");
   if (!sc)
     {
       s7 = s7_init();
@@ -1908,57 +1663,45 @@ s7_scheme *s7_xen_initialize(s7_scheme *sc)
   xen_nil = s7_nil(s7);
   xen_undefined = s7_undefined(s7);
   xen_zero = s7_make_integer(s7, 0);
-
-  XEN_DEFINE_PROCEDURE("getpid",              g_getpid_w,             0, 0, 0, H_getpid);
-  XEN_DEFINE_PROCEDURE("file-exists?",        g_file_exists_p_w,      1, 0, 0, H_file_exists_p);
-  XEN_DEFINE_PROCEDURE("directory?",          g_file_is_directory_w,  1, 0, 0, H_file_is_directory);
-  XEN_EVAL_C_STRING("(define file-is-directory? directory?)");    /* backwards compatibility: */
-  XEN_DEFINE_PROCEDURE("system",              g_system_w,             1, 0, 0, H_system);
-  XEN_DEFINE_PROCEDURE("getenv",              g_s7_getenv_w,          1, 0, 0, H_getenv);
-  XEN_DEFINE_PROCEDURE("delete-file",         g_delete_file_w,        1, 0, 0, H_delete_file);
-  XEN_DEFINE_PROCEDURE("getcwd",              g_getcwd_w,             0, 0, 0, H_getcwd);
-  XEN_DEFINE_PROCEDURE("strftime",            g_strftime_w,           2, 0, 0, H_strftime);
-  XEN_DEFINE_PROCEDURE("tmpnam",              g_tmpnam_w,             0, 0, 0, H_tmpnam);
-  XEN_DEFINE_PROCEDURE("localtime",           g_localtime_w,          1, 0, 0, H_localtime);
-  XEN_DEFINE_PROCEDURE("current-time",        g_current_time_w,       0, 0, 0, H_current_time);
-  XEN_DEFINE_PROCEDURE("ftell",               g_ftell_w,              1, 0, 0, "(ftell fd): lseek");
-  XEN_DEFINE_PROCEDURE(S_gc_off,              g_gc_off_w,             0, 0, 0, H_gc_off);
-  XEN_DEFINE_PROCEDURE(S_gc_on,               g_gc_on_w,              0, 0, 0, H_gc_on);
-
-  /* backwards compatibility (guile hook functions) */
-  XEN_EVAL_C_STRING("(define (hook-empty? hook) (null? (hook-functions hook)))");
-  XEN_EVAL_C_STRING("(define (reset-hook! hook) (set! (hook-functions hook) '()))");
-  XEN_EVAL_C_STRING("(define (run-hook . args) (hook-apply (car args) (cdr args)))");
-  XEN_EVAL_C_STRING("(define hook->list hook-functions)");
-  XEN_EVAL_C_STRING("(define* (add-hook! hook func (at-end #f)) \n\
-                       (set! (hook-functions hook) \n\
-                             (if (not at-end) \n\
-                                (cons func (hook-functions hook)) \n\
-                                (append (hook-functions hook) (list func)))))");
-  XEN_EVAL_C_STRING("(define (remove-hook! hook func) \n\
+  s7_gc_protect(s7, xen_zero);
+
+  Xen_define_safe_procedure("getpid",              g_getpid_w,             0, 0, 0, H_getpid);
+#if (!WITH_SYSTEM_EXTRAS)
+  Xen_define_safe_procedure("file-exists?",        g_file_exists_p_w,      1, 0, 0, H_file_exists_p);
+  Xen_define_safe_procedure("directory?",          g_is_directory_w,       1, 0, 0, H_is_directory);
+  Xen_define_safe_procedure("delete-file",         g_delete_file_w,        1, 0, 0, H_delete_file);
+  Xen_define_safe_procedure("getenv",              g_s7_getenv_w,          1, 0, 0, H_getenv);
+  Xen_define_safe_procedure("system",              g_system_w,             1, 0, 0, H_system);
+#endif
+  Xen_define_safe_procedure("getcwd",              g_getcwd_w,             0, 0, 0, H_getcwd);
+  Xen_define_safe_procedure("strftime",            g_strftime_w,           2, 0, 0, H_strftime);
+  Xen_define_safe_procedure("tmpnam",              g_tmpnam_w,             0, 0, 0, H_tmpnam);
+  Xen_define_safe_procedure("localtime",           g_localtime_w,          1, 0, 0, H_localtime);
+  Xen_define_safe_procedure("current-time",        g_current_time_w,       0, 0, 0, H_current_time);
+  Xen_define_safe_procedure("ftell",               g_ftell_w,              1, 0, 0, "(ftell fd): lseek");
+  Xen_define_safe_procedure(S_gc_off,              g_gc_off_w,             0, 0, 0, H_gc_off);
+  Xen_define_safe_procedure(S_gc_on,               g_gc_on_w,              0, 0, 0, H_gc_on);
+
+  Xen_eval_C_string("(define (hook-push hook func) \n\
+                       \"(hook-push hook func) adds func to hook's function list\" \n\
+                       (if (not (member func (hook-functions hook) eq?)) (set! (hook-functions hook) (cons func (hook-functions hook)))))");
+  Xen_eval_C_string("(define (hook-append hook func) \n\
+                       \"(hook-append hook func) adds func to the end of hook's function list\" \n\
+                       (set! (hook-functions hook) (append (hook-functions hook) (list func))))");
+  Xen_eval_C_string("(define (hook-clear hook) (set! (hook-functions hook) ()))");
+  Xen_eval_C_string("(define (hook-remove hook func) \n\
                        (set! (hook-functions hook)\n\
 	                     (let loop ((l (hook-functions hook))\n\
-		                        (result '()))\n\
+		                        (result ()))\n\
 	                       (cond ((null? l) (reverse! result))\n\
 		                     ((eq? func (car l)) (loop (cdr l) result))\n\
 		                     (else (loop (cdr l) (cons (car l) result)))))))");
 
-  /* these three to replace add-hook! and remove-hook! */
-  XEN_EVAL_C_STRING("(define (hook-push hook func) \n\
-                       \"(hook-push hook func) adds func to hook's function list\" \n\
-                       (set! (hook-functions hook) (cons func (hook-functions hook))))");
-  XEN_EVAL_C_STRING("(define (hook-append hook func) \n\
-                       \"(hook-append hook func) adds func to the end of hook's function list\" \n\
-                       (set! (hook-functions hook) (append (hook-functions hook) (list func))))");
-  XEN_EVAL_C_STRING("(define hook-remove remove-hook!)");
-
-
-  XEN_EVAL_C_STRING("(define load-from-path load)");
-  XEN_EVAL_C_STRING("(define (1+ x) \"add 1 to arg\" (+ x 1))");
-  XEN_EVAL_C_STRING("(define (1- x) \"subtract 1 from arg\" (- x 1))");
-  XEN_EVAL_C_STRING("(defmacro while (whether . body) `(do () ((not ,whether)) ,@body))");
-  XEN_EVAL_C_STRING("(define (identity x) \"return arg\" x)");
-  XEN_EVAL_C_STRING("(define (throw . args) (apply error args))");
+  Xen_eval_C_string("(define load-from-path load)");
+  Xen_eval_C_string("(define (1+ x) \"add 1 to arg\" (+ x 1))");
+  Xen_eval_C_string("(define (1- x) \"subtract 1 from arg\" (- x 1))");
+  Xen_eval_C_string("(define-macro (while whether . body) `(do () ((not ,whether)) ,@body))");
+  Xen_eval_C_string("(define (identity x) \"return arg\" x)");
 
   return(s7);
 }
@@ -1979,9 +1722,6 @@ void xen_initialize(void)
 
 char *xen_version(void)
 {
-#if HAVE_XEN_STRDUP
-  return(xen_strdup("no extension language"));
-#else
   char *buf;
   buf = (char *)calloc(64, sizeof(char));
 #if HAVE_SNPRINTF
@@ -1990,7 +1730,6 @@ char *xen_version(void)
   sprintf(buf, "no extension language");
 #endif
   return(buf);
-#endif
 }
 
 
@@ -2004,44 +1743,8 @@ void xen_initialize(void)
 }
 
 
-void xen_gc_mark(XEN val)
-{
-}
-
-
-int xen_to_c_int_or_else(XEN obj, int fallback)
-{
-  return(fallback);
-}
-
-
-off_t xen_to_c_off_t_or_else(XEN obj, off_t fallback)
-{
-  return(0);
-}
-
-
-off_t xen_to_c_off_t(XEN obj)
-{
-  return(0);
-}
-
-
-XEN c_to_xen_off_t(off_t val)
-{
-  return(XEN_ZERO);
-}
-
-
-int64_t xen_to_c_int64_t_or_else(XEN obj, int64_t fallback)
-{
-  return(0);
-}
-
-
-int64_t xen_to_c_int64_t(XEN obj)
+void xen_gc_mark(Xen val)
 {
-  return(0);
 }