Imported Upstream version 16.1

1 files changed, 379 insertions, 377 deletions

diff --git a/snd-marks.c b/snd-marks.c
index a2b4b97..75e1eab 100644
--- a/snd-marks.c
+++ b/snd-marks.c
@@ -5,7 +5,7 @@ struct mark {
   char *name;
   int id, sync;
   bool visible;
-  XEN properties;
+  Xen properties;
   int properties_gc_loc;
 };
 
@@ -44,7 +44,7 @@ static mark *make_mark_1(mus_long_t samp, const char *name, int id, int sc)
   mp->id = id;
   set_mark_sync(mp, sc);
   mp->properties_gc_loc = NOT_A_GC_LOC;
-  mp->properties = XEN_FALSE;
+  mp->properties = Xen_false;
   return(mp);
 }
 
@@ -70,7 +70,7 @@ static mark *free_mark(mark *mp)
 	{
 	  snd_unprotect_at(mp->properties_gc_loc);
 	  mp->properties_gc_loc = NOT_A_GC_LOC;
-	  mp->properties = XEN_FALSE;
+	  mp->properties = Xen_false;
 	}
       free(mp);
     }
@@ -120,7 +120,7 @@ static mark *map_over_marks_with_int(chan_info *cp, mark *(*func)(chan_info *ncp
 {
   ed_list *ed;
   ed = cp->edits[cp->edit_ctr];
-  if (ed->marks)
+  if ((ed) && (ed->marks))
     {
       int marks;
       mark **mps;
@@ -206,20 +206,6 @@ mus_long_t mark_id_to_sample(int id)
 }
 
 
-static mark *find_named_mark_1(chan_info *cp, mark *mp, void *uname)
-{
-  char *name = (char *)uname;
-  if ((mp->name) && (mus_strcmp(mp->name, name))) return(mp);
-  else return(NULL);
-}
-
-
-static mark *find_named_mark(chan_info *cp, const char *name)
-{
-  return(map_over_marks(cp, find_named_mark_1, (void *)name, READ_FORWARD));
-}
-
-
 static mark *find_previous_mark_1(chan_info *cp, mark *mp, void *m)
 {
   if (mp->samp < (*((mus_long_t *)m))) 
@@ -263,19 +249,19 @@ void marks_off(chan_info *cp)
 
 static void show_mark(chan_info *cp, mark *mp, bool show);
 
-static XEN draw_mark_hook;
+static Xen draw_mark_hook;
 
 static void draw_mark_1(chan_info *cp, mark *mp, bool show)
 {
   /* fields are samp and name */
-  if (!(cp->graph_time_p)) return;
-  if (XEN_HOOKED(draw_mark_hook))
+  if (!(cp->graph_time_on)) return;
+  if (Xen_hook_has_list(draw_mark_hook))
     {
-      XEN res = XEN_FALSE;
+      Xen res;
       res = run_progn_hook(draw_mark_hook,
-			   XEN_LIST_1(new_xen_mark(mp->id)),
+			   Xen_list_1(new_xen_mark(mp->id)),
 			   S_draw_mark_hook);
-      if (XEN_TRUE_P(res))
+      if (Xen_is_true(res))
 	{
 	  mp->visible = show;
 	  return;
@@ -314,7 +300,7 @@ static mark *hit_mark_1(chan_info *cp, mark *mp, void *m)
   if (mp->samp < ap->losamp) return(NULL);
   if (mp->samp > ap->hisamp) return(md->all_done); /* grf_x clips so we can be confused by off-screen marks */
 
-  mx = grf_x((double)(mp->samp) / (double)SND_SRATE(cp->sound), cp->axis);
+  mx = grf_x((double)(mp->samp) / (double)snd_srate(cp->sound), cp->axis);
   if (mx > (md->x + mark_tag_width(ss))) return(md->all_done); /* past it */
   if (mx < (md->x - mark_tag_width(ss))) return(NULL);         /* before it */
   if (mp->name == NULL)                                    /* check y if unnamed */
@@ -342,7 +328,7 @@ static mark *hit_mark_triangle_1(chan_info *cp, mark *mp, void *m)
   if (mp->samp < ap->losamp) return(NULL);
   if (mp->samp > ap->hisamp) return(md->all_done); /* grf_x clips so we can be confused by off-screen marks */
 
-  mx = grf_x((double)(mp->samp) / (double)SND_SRATE(cp->sound), cp->axis);
+  mx = grf_x((double)(mp->samp) / (double)snd_srate(cp->sound), cp->axis);
   if (mx > (md->x + HIT_SLOP)) return(md->all_done);
   if ((mx + play_arrow_size(ss) + HIT_SLOP) < md->x) return(NULL);
   y = md->y - ap->y_axis_y0 - play_arrow_size(ss);
@@ -379,8 +365,8 @@ mark *hit_mark_triangle(chan_info *cp, int x, int y)
 }
 
 
-static XEN mark_drag_hook;
-static XEN mark_hook; /* add, delete, move */
+static Xen mark_drag_hook;
+static Xen mark_hook; /* add, delete, move */
 
 static bool watching_mouse = false; /* this is tracking axis moves */
 static int last_mouse_x = 0;
@@ -414,7 +400,9 @@ static void start_mark_watching(chan_info *cp, mark *mp)
 
 static void cancel_mark_watch(chan_info *cp)
 {
+#if (!USE_NO_GUI)
   if (watch_mouse_button) TIMEOUT_REMOVE(watch_mouse_button);
+#endif
   watch_mouse_button = 0;
   watching_mouse = false;
   moving_mark = NULL;
@@ -427,8 +415,10 @@ static bool move_mark_1(chan_info *cp, mark *mp, int x)
   int nx;
   mus_long_t samps;
   bool redraw;
+
   ap = cp->axis;
   redraw = (!watching_mouse);
+
   if ((x > ap->x_axis_x1) || (x < ap->x_axis_x0)) 
     {
       if (watching_mouse)
@@ -437,7 +427,7 @@ static bool move_mark_1(chan_info *cp, mark *mp, int x)
 	      ((x > ap->x_axis_x1) && (ap->x1 == ap->xmax)))
 	    return(false);
 	}
-      nx = move_axis(cp, ap, x);
+      nx = move_axis(cp, x);
       if (!watching_mouse) start_mark_watching(cp, mp);
     }
   else 
@@ -450,14 +440,18 @@ static bool move_mark_1(chan_info *cp, mark *mp, int x)
 	  redraw = false;
 	}
     }
-  mp->samp = (mus_long_t)(ungrf_x(ap, nx) * SND_SRATE(cp->sound));
+
+  mp->samp = (mus_long_t)(ungrf_x(ap, nx) * snd_srate(cp->sound));
   if (mp->samp < 0) mp->samp = 0;
-  samps = CURRENT_SAMPLES(cp);
+
+  samps = current_samples(cp);
   if (mp->samp > samps) mp->samp = samps;
-  if (XEN_HOOKED(mark_drag_hook))
-    run_hook(mark_drag_hook,
-	     XEN_LIST_1(new_xen_mark(mp->id)),
-	     S_mark_drag_hook);
+
+  if (Xen_hook_has_list(mark_drag_hook))
+    ss->squelch_mark_drag_info = Xen_is_true(run_progn_hook(mark_drag_hook,
+							   Xen_list_1(new_xen_mark(mp->id)),
+							   S_mark_drag_hook));
+  else ss->squelch_mark_drag_info = false;
   return(redraw);
 }
 
@@ -477,7 +471,8 @@ static void sort_marks(chan_info *cp)
 {
   ed_list *ed;
   ed = cp->edits[cp->edit_ctr];
-  qsort((void *)(ed->marks), ed->mark_ctr + 1, sizeof(mark *), compare_mark_samps);
+  if (ed)
+    qsort((void *)(ed->marks), ed->mark_ctr + 1, sizeof(mark *), compare_mark_samps);
 }
 
 
@@ -486,16 +481,16 @@ typedef enum {MARK_ADD, MARK_DELETE, MARK_MOVE, MARKS_DELETE, MARK_RELEASE} mark
 static void run_mark_hook(chan_info *cp, int id, mark_hook_reason_t reason)
 {
   /* called after the mark list has been made consistent */
-  if (XEN_HOOKED(mark_hook))
+  if (Xen_hook_has_list(mark_hook))
     run_hook(mark_hook,
-	     XEN_LIST_4(new_xen_mark(id),
-			C_INT_TO_XEN_SOUND(cp->sound->index),
-			C_TO_XEN_INT(cp->chan),
-			C_TO_XEN_INT((int)reason)),
+	     Xen_list_4(new_xen_mark(id),
+			C_int_to_Xen_sound(cp->sound->index),
+			C_int_to_Xen_integer(cp->chan),
+			C_int_to_Xen_integer((int)reason)),
 	     S_mark_hook);
 
-  if (XEN_HOOKED(ss->effects_hook))
-    run_hook(ss->effects_hook, XEN_EMPTY_LIST, S_effects_hook);
+  if (Xen_hook_has_list(ss->effects_hook))
+    run_hook(ss->effects_hook, Xen_empty_list, S_effects_hook);
 }
 
 
@@ -567,12 +562,11 @@ bool delete_mark_samp(mus_long_t samp, chan_info *cp)
       ed = cp->edits[cp->edit_ctr];
       if (ed->marks)
 	{
-	  int i;
 	  mark **mps;
 	  mps = ed->marks;
 	  if (mps)
 	    {
-	      int edm;
+	      int i, edm;
 	      edm = ed->mark_ctr;
 	      for (i = 0; i <= edm; i++)
 		{
@@ -656,11 +650,11 @@ static void delete_marks(chan_info *cp)
       ed = cp->edits[cp->edit_ctr];
       if (ed->marks)
 	{
-	  int i;
 	  mark **mps;
 	  mps = ed->marks;
 	  if (mps)
 	    {
+	      int i;
 	      for (i = 0; i < ed->mark_size; i++)
 		{
 		  mark *mp;
@@ -789,7 +783,7 @@ static mark *find_nth_mark(chan_info *cp, int count)
   mark *mp = NULL;
   if ((!cp) || (!cp->edits[cp->edit_ctr]->marks)) return(NULL);
   if (count > 0) c = count; else c = -count;
-  samp = CURSOR(cp);
+  samp = cursor_sample(cp);
   for (i = 0; i < c; i++)
     {
       if (count > 0) mp = find_next_mark(samp, cp);
@@ -812,12 +806,28 @@ bool goto_mark(chan_info *cp, int count)
 }
 
 
+#if 0
+static mark *find_named_mark_1(chan_info *cp, mark *mp, void *uname)
+{
+  char *name = (char *)uname;
+  if ((mp->name) && (mus_strcmp(mp->name, name))) return(mp);
+  else return(NULL);
+}
+
+
+static mark *find_named_mark(chan_info *cp, const char *name)
+{
+  return(map_over_marks(cp, find_named_mark_1, (void *)name, READ_FORWARD));
+}
+
+
 void goto_named_mark(chan_info *cp, const char *name)
 {
   mark *mp;
   mp = find_named_mark(cp, name);
   if (mp) cursor_moveto(cp, mp->samp);
 }
+#endif
 
 
 static mark *active_mark_1(chan_info *cp, mark *mp, void *ignore)
@@ -955,7 +965,7 @@ bool mark_define_region(chan_info *cp, int count)
 	{
 	  mus_long_t beg;
 	  mark *mp;
-	  beg = CURSOR(cp);
+	  beg = cursor_sample(cp);
 	  mp = find_nth_mark(cp, count);
 	  if (mp)
 	    {
@@ -1010,7 +1020,7 @@ void reverse_marks(chan_info *cp, mus_long_t beg, mus_long_t dur) /* beg -1 for
       mps = ed->marks;
       if (beg == -1)
 	{
-	  m = make_mark_1(CURRENT_SAMPLES(cp) - 1, NULL, 0, 0);
+	  m = make_mark_1(current_samples(cp) - 1, NULL, 0, 0);
 	  map_over_marks(cp, reverse_mark_1, (void *)m, READ_FORWARD);
 	  free_mark(m);
 	}
@@ -1315,14 +1325,14 @@ void set_mark_control(chan_info *cp, mark *mp, int key_state)
 	  if ((mark_sd->mark_ctr > 1) &&
 	      (mark_sd->marks[0] != mp))
 	    {
-	      mark *tm;
-	      int loc = 1;
-	      mus_long_t ts;
-	      chan_info *tc;
+	      int loc;
 	      for (loc = 1; loc < mark_sd->mark_ctr; loc++)
 		if (mark_sd->marks[loc] == mp) break;
 	      if (loc < mark_sd->mark_ctr)
 		{
+		  chan_info *tc;
+		  mus_long_t ts;
+		  mark *tm;
 		  tm = mark_sd->marks[0];
 		  ts = mark_sd->initial_samples[0];
 		  tc = mark_sd->chans[0];
@@ -1423,7 +1433,7 @@ static void erase_and_draw_grf_points(mark_context *ms, chan_info *cp, int nj)
   ax = draw_cp->ax;
 
 #if USE_GTK
-  ss->cr = MAKE_CAIRO(ax->wn);
+  ss->cr = make_cairo(ax->wn);
 #endif
 
   undraw_gc = erase_GC(draw_cp);
@@ -1446,7 +1456,7 @@ static void erase_and_draw_grf_points(mark_context *ms, chan_info *cp, int nj)
   ax->gc = draw_gc;
 
 #if USE_GTK
-  FREE_CAIRO(ss->cr);
+  free_cairo(ss->cr);
   ss->cr = NULL;
 #endif
 }
@@ -1470,7 +1480,7 @@ static void erase_and_draw_both_grf_points(mark_context *ms, chan_info *cp, int
   ax = draw_cp->ax;
 
 #if USE_GTK
-  ss->cr = MAKE_CAIRO(ax->wn);
+  ss->cr = make_cairo(ax->wn);
 #endif
 
   undraw_gc = erase_GC(draw_cp);
@@ -1497,7 +1507,7 @@ static void erase_and_draw_both_grf_points(mark_context *ms, chan_info *cp, int
   ax->gc = draw_gc;
 
 #if USE_GTK
-  FREE_CAIRO(ss->cr);
+  free_cairo(ss->cr);
   ss->cr = NULL;
 #endif
 }
@@ -1534,7 +1544,7 @@ static bool move_syncd_mark(chan_info *cp, mark *m, int x)
 		    erase_mark(ncp, mp);
 		  mp->samp += diff;
 		  if (mp->samp < 0) mp->samp = 0;
-		  samps = CURRENT_SAMPLES(ncp);
+		  samps = current_samples(ncp);
 		  if (mp->samp > samps) mp->samp = samps;
 		  if (mark_control_clicked)
 		    make_mark_graph(ncp, mark_sd->initial_samples[i], mp->samp, i);
@@ -1624,7 +1634,7 @@ void finish_moving_mark(chan_info *cp, mark *m) /* button release called from sn
   if ((m->sync != 0) && (mark_sd))
     {
       int i;
-      if (XEN_HOOKED(mark_hook))
+      if (Xen_hook_has_list(mark_hook))
 	for (i = 0; i < mark_sd->mark_ctr; i++)
 	  run_mark_hook(mark_sd->chans[i], mark_sd->marks[i]->id, MARK_RELEASE);
       if (mark_control_clicked)
@@ -1670,7 +1680,7 @@ void play_syncd_mark(chan_info *cp, mark *m)
   sd = gather_syncd_marks(m->sync);
   if ((sd) && (sd->mark_ctr > 0))
     play_channels(sd->chans, sd->mark_ctr, sd->initial_samples, NULL, IN_BACKGROUND, 
-		  C_TO_XEN_INT(AT_CURRENT_EDIT_POSITION), false, "play sync'd mark", 0);
+		  C_int_to_Xen_integer(AT_CURRENT_EDIT_POSITION), false, "play sync'd mark", 0);
   if (sd) free_syncdata(sd);
 }
 
@@ -1682,15 +1692,15 @@ static void make_mark_graph(chan_info *cp, mus_long_t initial_sample, mus_long_t
   int j = 0;
   mus_long_t i, k, samps;
   axis_info *ap;
-  double samples_per_pixel, samp, x, incr;  
+  double samples_per_pixel, x;  
   int pixels;
   snd_fd *sf = NULL;
   int x_start, x_end;
-  double start_time = 0.0, cur_srate = 1.0;
+  double start_time = 0.0, cur_srate;
 
   sp = cp->sound;
   ap = cp->axis;
-  cur_srate = (double)SND_SRATE(sp);
+  cur_srate = (double)snd_srate(sp);
   ap->losamp = (mus_long_t)(ap->x0 * cur_srate);
   if (ap->losamp < 0) ap->losamp = 0;
   if (ap->x0 != ((double)(ap->losamp) / cur_srate)) ap->losamp++;
@@ -1711,6 +1721,7 @@ static void make_mark_graph(chan_info *cp, mus_long_t initial_sample, mus_long_t
   if ((samples_per_pixel < 5.0) && 
       (samps < POINT_BUFFER_SIZE))
     {
+      double incr;
       sf = init_sample_read(ap->losamp, cp, READ_FORWARD);
       if (sf == NULL) return;
       incr = (double)1.0 / cur_srate;
@@ -1728,6 +1739,7 @@ static void make_mark_graph(chan_info *cp, mus_long_t initial_sample, mus_long_t
 	{
 	  for (j = 0, i = ap->losamp, x = start_time; i <= ap->hisamp; i++, j++, x += incr)
 	    {
+	      double samp;
 	      if ((i < initial_sample) || (i >= current_sample)) 
 		samp = read_sample(sf);
 	      else samp = 0.0;
@@ -1738,7 +1750,7 @@ static void make_mark_graph(chan_info *cp, mus_long_t initial_sample, mus_long_t
     }
   else
     {
-      mus_float_t ymin, ymax, msamp;
+      mus_float_t ymin, ymax;
       int xi;
       double xf;
       if (peak_env_usable(cp, samples_per_pixel, ap->hisamp, false, cp->edit_ctr, (samps > PEAK_ENV_CUTOFF)))
@@ -1750,7 +1762,7 @@ static void make_mark_graph(chan_info *cp, mus_long_t initial_sample, mus_long_t
 	   * this is confusing code!
 	   */
 	  double step, xk, xki;
-	  mus_long_t ii, kk;
+	  mus_long_t ii;
 	  peak_env_info *ep;
 	  ep = cp->edits[cp->edit_ctr]->peak_env;
 	  step = samples_per_pixel / (mus_float_t)(ep->samps_per_bin);
@@ -1764,6 +1776,7 @@ static void make_mark_graph(chan_info *cp, mus_long_t initial_sample, mus_long_t
 	  xki = (double)(ap->losamp);
 	  while (i <= ap->hisamp)
 	    {
+	      mus_long_t kk;
 	      k = (mus_long_t)xf;
 	      kk = (mus_long_t)(xf + step);
 	      if (((current_sample >= initial_sample) && 
@@ -1813,6 +1826,7 @@ static void make_mark_graph(chan_info *cp, mus_long_t initial_sample, mus_long_t
 	}
       else
 	{
+	  mus_float_t msamp;
 	  sf = init_sample_read(ap->losamp, cp, READ_FORWARD);
 	  if (sf == NULL) return;
 	  j = 0;      /* graph point counter */
@@ -1823,7 +1837,7 @@ static void make_mark_graph(chan_info *cp, mus_long_t initial_sample, mus_long_t
 	  ymax = MAX_INIT;
 	  if (current_sample < initial_sample) 
 	    {
-	      for (i = ap->losamp, xf = 0.0; i <= ap->hisamp; i++)
+	      for (i = ap->losamp; i <= ap->hisamp; i++)
 		{
 		  if (i == current_sample) 
 		    for (k = current_sample; k < initial_sample; k++) 
@@ -1882,7 +1896,7 @@ static void make_mark_graph(chan_info *cp, mus_long_t initial_sample, mus_long_t
 
 static void show_mark(chan_info *cp, mark *mp, bool show)
 {
-  int len, top, cx, y0, y1;
+  int top, cx, y0, y1;
   axis_info *ap;
   graphics_context *ax;
 
@@ -1897,15 +1911,16 @@ static void show_mark(chan_info *cp, mark *mp, bool show)
   y1 = top;
   y0 = ap->y_axis_y0;
   if (mp->name) top += 10;
-  cx = grf_x((double)(mp->samp) / (double)SND_SRATE(cp->sound), ap);
+  cx = grf_x((double)(mp->samp) / (double)snd_srate(cp->sound), ap);
 
   ax = mark_tag_context(cp);
 #if USE_GTK
-  ss->cr = MAKE_CAIRO(ax->wn);
+  ss->cr = make_cairo(ax->wn);
 #endif
 
   if (mp->name)
     {
+      int len;
 #if USE_MOTIF
       ax->current_font = ss->peaks_fontstruct->fid;
       XSetFont(ax->dp, ax->gc, ss->peaks_fontstruct->fid);
@@ -1921,7 +1936,7 @@ static void show_mark(chan_info *cp, mark *mp, bool show)
 		 2 * mark_tag_width(ss), mark_tag_height(ss));
   draw_line(ax, cx, top + 4, cx, y0);
 
-  if (mp->samp != CURSOR(cp))
+  if (mp->samp != cursor_sample(cp))
     fill_polygon(ax, 4,
 		 cx, y0,
 		 cx + play_arrow_size(ss), y0 + play_arrow_size(ss),
@@ -1929,7 +1944,7 @@ static void show_mark(chan_info *cp, mark *mp, bool show)
 		 cx, y0);
   mp->visible = show;
 #if USE_GTK
-  FREE_CAIRO(ss->cr);
+  free_cairo(ss->cr);
   ss->cr = NULL;
   copy_context(cp);
 #endif
@@ -1949,53 +1964,53 @@ typedef struct {
 } xen_mark;
 
 
-#define XEN_TO_XEN_MARK(arg) ((xen_mark *)XEN_OBJECT_REF(arg))
+#define Xen_to_xen_mark(arg) ((xen_mark *)Xen_object_ref(arg))
 
-int xen_mark_to_int(XEN n)
+int xen_mark_to_int(Xen n)
 {
   xen_mark *mx;
-  mx = XEN_TO_XEN_MARK(n);
+  mx = Xen_to_xen_mark(n);
   return(mx->n);
 }
 
 
-static XEN_OBJECT_TYPE xen_mark_tag;
+static Xen_object_type_t xen_mark_tag;
 
-bool xen_mark_p(XEN obj) 
+bool xen_is_mark(Xen obj) 
 {
-  return(XEN_OBJECT_TYPE_P(obj, xen_mark_tag));
+  return(Xen_c_object_is_type(obj, xen_mark_tag));
 }
 
 
 static void xen_mark_free(xen_mark *v) {if (v) free(v);}
 
-XEN_MAKE_OBJECT_FREE_PROCEDURE(xen_mark, free_xen_mark, xen_mark_free)
+Xen_wrap_free(xen_mark, free_xen_mark, xen_mark_free)
 
 
 static char *xen_mark_to_string(xen_mark *v)
 {
-  #define XEN_MARK_PRINT_BUFFER_SIZE 64
+  #define MARK_PRINT_BUFFER_SIZE 64
   char *buf;
   if (v == NULL) return(NULL);
-  buf = (char *)calloc(XEN_MARK_PRINT_BUFFER_SIZE, sizeof(char));
-  snprintf(buf, XEN_MARK_PRINT_BUFFER_SIZE, "#<mark %d>", v->n);
+  buf = (char *)calloc(MARK_PRINT_BUFFER_SIZE, sizeof(char));
+  snprintf(buf, MARK_PRINT_BUFFER_SIZE, "#<mark %d>", v->n);
   return(buf);
 }
 
-XEN_MAKE_OBJECT_PRINT_PROCEDURE(xen_mark, print_xen_mark, xen_mark_to_string)
+Xen_wrap_print(xen_mark, print_xen_mark, xen_mark_to_string)
 
 
 #if HAVE_FORTH || HAVE_RUBY
-static XEN g_xen_mark_to_string(XEN obj)
+static Xen g_xen_mark_to_string(Xen obj)
 {
   char *vstr;
-  XEN result;
+  Xen result;
   #define S_xen_mark_to_string "mark->string"
 
-  XEN_ASSERT_TYPE(XEN_MARK_P(obj), obj, XEN_ONLY_ARG, S_xen_mark_to_string, "a mark");
+  Xen_check_type(xen_is_mark(obj), obj, 1, S_xen_mark_to_string, "a mark");
 
-  vstr = xen_mark_to_string(XEN_TO_XEN_MARK(obj));
-  result = C_TO_XEN_STRING(vstr);
+  vstr = xen_mark_to_string(Xen_to_xen_mark(obj));
+  result = C_string_to_Xen_string(vstr);
   free(vstr);
   return(result);
 }
@@ -2009,10 +2024,10 @@ static bool xen_mark_equalp(xen_mark *v1, xen_mark *v2)
 	 (v1->n == v2->n));
 }
 
-static XEN equalp_xen_mark(XEN obj1, XEN obj2)
+static Xen equalp_xen_mark(Xen obj1, Xen obj2)
 {
-  if ((!(XEN_MARK_P(obj1))) || (!(XEN_MARK_P(obj2)))) return(XEN_FALSE);
-  return(C_TO_XEN_BOOLEAN(xen_mark_equalp(XEN_TO_XEN_MARK(obj1), XEN_TO_XEN_MARK(obj2))));
+  if ((!(xen_is_mark(obj1))) || (!(xen_is_mark(obj2)))) return(Xen_false);
+  return(C_bool_to_Xen_boolean(xen_mark_equalp(Xen_to_xen_mark(obj1), Xen_to_xen_mark(obj2))));
 }
 #endif
 
@@ -2026,14 +2041,14 @@ static xen_mark *xen_mark_make(int n)
 }
 
 
-XEN new_xen_mark(int n)
+Xen new_xen_mark(int n)
 {
   xen_mark *mx;
   if (n < 0)
-    return(XEN_FALSE);
+    return(Xen_false);
 
   mx = xen_mark_make(n);
-  XEN_MAKE_AND_RETURN_OBJECT(xen_mark_tag, mx, 0, free_xen_mark);
+  return(Xen_make_object(xen_mark_tag, mx, 0, free_xen_mark));
 }
 
 
@@ -2045,16 +2060,23 @@ static bool s7_xen_mark_equalp(void *obj1, void *obj2)
 }
 
 
-static XEN s7_xen_mark_copy(s7_scheme *sc, s7_pointer obj)
+static Xen s7_xen_mark_copy(s7_scheme *sc, s7_pointer args)
 {
+  s7_pointer obj;
   int id;
-  mark *m, *new_m;
-  chan_info *cps[1];
+  mark *m;
+  chan_info *cps[1] = {NULL};
+  obj = s7_car(args);
   id = xen_mark_to_int(obj);
   m = find_mark_from_id(id, cps, AT_CURRENT_EDIT_POSITION);
-  new_m = add_mark(m->samp, m->name, cps[0]);
-  new_m->sync = m->sync;
-  return(new_xen_mark(new_m->id));
+  if (m)
+    {
+      mark *new_m;
+      new_m = add_mark(m->samp, m->name, cps[0]);
+      new_m->sync = m->sync;
+      return(new_xen_mark(new_m->id));
+    }
+  return(obj);
 }
 #endif
 
@@ -2062,12 +2084,12 @@ static XEN s7_xen_mark_copy(s7_scheme *sc, s7_pointer obj)
 static void init_xen_mark(void)
 {
 #if HAVE_SCHEME
-  xen_mark_tag = XEN_MAKE_OBJECT_TYPE("<mark>", print_xen_mark, free_xen_mark, s7_xen_mark_equalp, NULL, NULL, NULL, NULL, s7_xen_mark_copy, NULL);
+  xen_mark_tag = s7_new_type_x(s7, "<mark>", print_xen_mark, free_xen_mark, s7_xen_mark_equalp, NULL, NULL, NULL, NULL, s7_xen_mark_copy, NULL, NULL);
 #else
 #if HAVE_RUBY
-  xen_mark_tag = XEN_MAKE_OBJECT_TYPE("XenMark", sizeof(xen_mark));
+  xen_mark_tag = Xen_make_object_type("XenMark", sizeof(xen_mark));
 #else
-  xen_mark_tag = XEN_MAKE_OBJECT_TYPE("Mark", sizeof(xen_mark));
+  xen_mark_tag = Xen_make_object_type("Mark", sizeof(xen_mark));
 #endif
 #endif
 
@@ -2079,86 +2101,86 @@ static void init_xen_mark(void)
 #endif
 
 #if HAVE_RUBY
-  rb_define_method(xen_mark_tag, "to_s",     XEN_PROCEDURE_CAST print_xen_mark, 0);
-  rb_define_method(xen_mark_tag, "eql?",     XEN_PROCEDURE_CAST equalp_xen_mark, 1);
-  rb_define_method(xen_mark_tag, "==",       XEN_PROCEDURE_CAST equalp_xen_mark, 1);
-  rb_define_method(xen_mark_tag, "to_str",   XEN_PROCEDURE_CAST g_xen_mark_to_string, 0);
+  rb_define_method(xen_mark_tag, "to_s",     Xen_procedure_cast print_xen_mark, 0);
+  rb_define_method(xen_mark_tag, "eql?",     Xen_procedure_cast equalp_xen_mark, 1);
+  rb_define_method(xen_mark_tag, "==",       Xen_procedure_cast equalp_xen_mark, 1);
+  rb_define_method(xen_mark_tag, "to_str",   Xen_procedure_cast g_xen_mark_to_string, 0);
 #endif
 }
 /* -------------------------------------------------------------------------------- */
 
 
-static XEN g_integer_to_mark(XEN n)
+static Xen g_integer_to_mark(Xen n)
 {
   #define H_integer_to_mark "(" S_integer_to_mark " n) returns a mark object corresponding to the given integer"
-  XEN_ASSERT_TYPE(XEN_INTEGER_P(n), n, XEN_ONLY_ARG, S_integer_to_mark, "an integer");
-  return(new_xen_mark(XEN_TO_C_INT(n)));
+  Xen_check_type(Xen_is_integer(n), n, 1, S_integer_to_mark, "an integer");
+  return(new_xen_mark(Xen_integer_to_C_int(n)));
 }
 
 
-static XEN g_mark_to_integer(XEN n)
+static Xen g_mark_to_integer(Xen n)
 {
   #define H_mark_to_integer "(" S_mark_to_integer " id) returns the integer corresponding to the given mark object"
-  XEN_ASSERT_TYPE(XEN_MARK_P(n), n, XEN_ONLY_ARG, S_mark_to_integer, "a mark");
-  return(C_TO_XEN_INT(xen_mark_to_int(n)));
+  Xen_check_type(xen_is_mark(n), n, 1, S_mark_to_integer, "a mark");
+  return(C_int_to_Xen_integer(xen_mark_to_int(n)));
 }
 
 
-static XEN snd_no_such_mark_error(const char *caller, XEN id)
+static Xen snd_no_such_mark_error(const char *caller, Xen id)
 {
-  XEN_ERROR(XEN_ERROR_TYPE("no-such-mark"),
-	    XEN_LIST_3(C_TO_XEN_STRING("~A: no such mark ~A"),
-		       C_TO_XEN_STRING(caller),
+  Xen_error(Xen_make_error_type("no-such-mark"),
+	    Xen_list_3(C_string_to_Xen_string("~A: no such mark ~A"),
+		       C_string_to_Xen_string(caller),
 		       id));
-  return(XEN_FALSE);
+  return(Xen_false);
 }
 
 
 typedef enum {MARK_SAMPLE, MARK_NAME, MARK_SYNC, MARK_HOME} mark_field_t;
 
-static XEN mark_get(XEN n, mark_field_t fld, XEN pos_n, const char *caller)
+static Xen mark_get(Xen n, mark_field_t fld, Xen pos_n, const char *caller)
 {
   int pos;
   chan_info *ncp[1];
   mark *m = NULL;
 
-  pos = XEN_TO_C_INT_OR_ELSE(pos_n, AT_CURRENT_EDIT_POSITION);
+  pos = (Xen_is_integer(pos_n)) ? Xen_integer_to_C_int(pos_n) : AT_CURRENT_EDIT_POSITION;
 
-  m = find_mark_from_id(XEN_MARK_TO_C_INT(n), ncp, pos);
+  m = find_mark_from_id(Xen_mark_to_C_int(n), ncp, pos);
   if (m == NULL) 
     return(snd_no_such_mark_error(caller, n));
 
   switch (fld)
     {
     case MARK_SAMPLE: 
-      return(C_TO_XEN_INT64_T(m->samp)); 
+      return(C_llong_to_Xen_llong(m->samp)); 
       break;
 
     case MARK_SYNC:   
-      return(C_TO_XEN_INT(m->sync)); 
+      return(C_int_to_Xen_integer(m->sync)); 
       break;
 
     case MARK_NAME:   
       if (m->name) 
-	return(C_TO_XEN_STRING(m->name)); 
-      else return(C_TO_XEN_STRING("")); 
+	return(C_string_to_Xen_string(m->name)); 
+      else return(C_string_to_Xen_string("")); 
       break;
 
     case MARK_HOME:   
-      return(XEN_LIST_2(C_INT_TO_XEN_SOUND((ncp[0]->sound)->index),
-			C_TO_XEN_INT(ncp[0]->chan))); 
+      return(Xen_list_2(C_int_to_Xen_sound((ncp[0]->sound)->index),
+			C_int_to_Xen_integer(ncp[0]->chan))); 
       break;
     }
-  return(XEN_FALSE);
+  return(Xen_false);
 }
 
 
-static XEN mark_set(XEN mark_n, XEN val, mark_field_t fld, const char *caller)
+static Xen mark_set(Xen mark_n, Xen val, mark_field_t fld, const char *caller)
 {
   chan_info *cp[1];
   mark *m;
 
-  m = find_mark_from_id(XEN_MARK_TO_C_INT(mark_n), cp, AT_CURRENT_EDIT_POSITION);
+  m = find_mark_from_id(Xen_mark_to_C_int(mark_n), cp, AT_CURRENT_EDIT_POSITION);
   if (m == NULL) 
     return(snd_no_such_mark_error(caller, mark_n));
 
@@ -2166,24 +2188,24 @@ static XEN mark_set(XEN mark_n, XEN val, mark_field_t fld, const char *caller)
     {
     case MARK_SAMPLE: 
       m->samp = mus_oclamp(0, 
-			   XEN_TO_C_INT64_T_OR_ELSE(val, 0),
-			   CURRENT_SAMPLES(cp[0]));
+			   (Xen_is_llong(val)) ? Xen_llong_to_C_llong(val) : 0,
+			   current_samples(cp[0]));
       sort_marks(cp[0]); /* update and re-sort current mark list */
       run_mark_hook(cp[0], m->id, MARK_MOVE);
       update_graph(cp[0]);
       break;
 
     case MARK_SYNC: 
-      if (XEN_INTEGER_P(val))
-	set_mark_sync(m, XEN_TO_C_INT(val));
-      else set_mark_sync(m, (int)XEN_TO_C_BOOLEAN(val));
+      if (Xen_is_integer(val))
+	set_mark_sync(m, Xen_integer_to_C_int(val));
+      else set_mark_sync(m, (int)Xen_boolean_to_C_bool(val));
       break;
 
     case MARK_NAME:
       if (m->name) free(m->name);
-      if (XEN_FALSE_P(val))
+      if (Xen_is_false(val))
 	m->name = NULL;
-      else m->name = mus_strdup(XEN_TO_C_STRING(val));
+      else m->name = mus_strdup(Xen_string_to_C_string(val));
       update_graph(cp[0]);
       break;
 
@@ -2194,77 +2216,77 @@ static XEN mark_set(XEN mark_n, XEN val, mark_field_t fld, const char *caller)
 }
 
 
-static XEN g_mark_p(XEN id_n)
+static Xen g_is_mark(Xen id_n)
 {
-  #define H_mark_p "(" S_mark_p " id): " PROC_TRUE " if mark is active"
-  if (XEN_MARK_P(id_n))
-    return(C_TO_XEN_BOOLEAN(find_mark_from_id(XEN_MARK_TO_C_INT(id_n), NULL, AT_CURRENT_EDIT_POSITION)));
-  return(XEN_FALSE);
+  #define H_is_mark "(" S_is_mark " id): " PROC_TRUE " if mark is active"
+  if (xen_is_mark(id_n))
+    return(C_bool_to_Xen_boolean(find_mark_from_id(Xen_mark_to_C_int(id_n), NULL, AT_CURRENT_EDIT_POSITION)));
+  return(Xen_false);
 }
 
 
-static XEN g_mark_sample(XEN mark_n, XEN pos_n) 
+static Xen g_mark_sample(Xen mark_n, Xen pos_n) 
 {
   #define H_mark_sample "(" S_mark_sample " id :optional pos): mark's location (sample number) at edit history pos"
-  XEN_ASSERT_TYPE(XEN_MARK_P(mark_n), mark_n, XEN_ARG_1, S_mark_sample, "a mark");
-  XEN_ASSERT_TYPE(XEN_INTEGER_IF_BOUND_P(pos_n), pos_n, XEN_ARG_2, S_mark_sample, "an integer");
+  Xen_check_type(xen_is_mark(mark_n), mark_n, 1, S_mark_sample, "a mark");
+  Xen_check_type(Xen_is_integer_or_unbound(pos_n), pos_n, 2, S_mark_sample, "an integer");
   return(mark_get(mark_n, MARK_SAMPLE, pos_n, S_mark_sample));
 }
 
-static XEN g_set_mark_sample(XEN mark_n, XEN samp_n) 
+static Xen g_set_mark_sample(Xen mark_n, Xen samp_n) 
 {
-  XEN_ASSERT_TYPE(XEN_MARK_P(mark_n), mark_n, XEN_ARG_1, S_setB S_mark_sample, "a mark");
-  XEN_ASSERT_TYPE(XEN_INT64_T_P(samp_n) || XEN_NOT_BOUND_P(samp_n), samp_n, XEN_ARG_2, S_setB S_mark_sample, "an integer");
-  return(mark_set(mark_n, samp_n, MARK_SAMPLE, S_setB S_mark_sample));
+  Xen_check_type(xen_is_mark(mark_n), mark_n, 1, S_set S_mark_sample, "a mark");
+  Xen_check_type(Xen_is_llong(samp_n) || !Xen_is_bound(samp_n), samp_n, 2, S_set S_mark_sample, "an integer");
+  return(mark_set(mark_n, samp_n, MARK_SAMPLE, S_set S_mark_sample));
 }
 
 
-XEN g_mark_sync(XEN mark_n)
+Xen g_mark_sync(Xen mark_n)
 {
   #define H_mark_sync "(" S_mark_sync " id): mark's sync value (default: 0)"
-  XEN_ASSERT_TYPE(XEN_MARK_P(mark_n), mark_n, XEN_ONLY_ARG, S_mark_sync, "a mark");
-  return(mark_get(mark_n, MARK_SYNC, XEN_UNDEFINED, S_mark_sync));
+  Xen_check_type(xen_is_mark(mark_n), mark_n, 1, S_mark_sync, "a mark");
+  return(mark_get(mark_n, MARK_SYNC, Xen_undefined, S_mark_sync));
 }
 
-XEN g_set_mark_sync(XEN mark_n, XEN sync_n)
+Xen g_set_mark_sync(Xen mark_n, Xen sync_n)
 {
-  XEN_ASSERT_TYPE(XEN_MARK_P(mark_n), mark_n, XEN_ARG_1, S_setB S_mark_sync, "a mark");
-  XEN_ASSERT_TYPE(XEN_INTEGER_OR_BOOLEAN_P(sync_n), sync_n, XEN_ARG_2, S_setB S_mark_sync, "an integer");
-  return(mark_set(mark_n, sync_n, MARK_SYNC, S_setB S_mark_sync));
+  Xen_check_type(xen_is_mark(mark_n), mark_n, 1, S_set S_mark_sync, "a mark");
+  Xen_check_type(Xen_is_integer_or_boolean(sync_n), sync_n, 2, S_set S_mark_sync, "an integer");
+  return(mark_set(mark_n, sync_n, MARK_SYNC, S_set S_mark_sync));
 }
 
 
-static XEN g_mark_name(XEN mark_n) 
+static Xen g_mark_name(Xen mark_n) 
 {
   #define H_mark_name "(" S_mark_name " id): mark's name"
-  XEN_ASSERT_TYPE(XEN_MARK_P(mark_n), mark_n, XEN_ONLY_ARG, S_mark_name, "a mark");
-  return(mark_get(mark_n, MARK_NAME, XEN_UNDEFINED, S_mark_name));
+  Xen_check_type(xen_is_mark(mark_n), mark_n, 1, S_mark_name, "a mark");
+  return(mark_get(mark_n, MARK_NAME, Xen_undefined, S_mark_name));
 }
 
-static XEN g_set_mark_name(XEN mark_n, XEN name) 
+static Xen g_set_mark_name(Xen mark_n, Xen name) 
 {
-  XEN_ASSERT_TYPE(XEN_MARK_P(mark_n), mark_n, XEN_ARG_1, S_setB S_mark_name, "a mark");
-  XEN_ASSERT_TYPE(XEN_STRING_P(name) || XEN_FALSE_P(name), name, XEN_ARG_2, S_setB S_mark_name, "a string");
-  return(mark_set(mark_n, name, MARK_NAME, S_setB S_mark_name));
+  Xen_check_type(xen_is_mark(mark_n), mark_n, 1, S_set S_mark_name, "a mark");
+  Xen_check_type(Xen_is_string(name) || Xen_is_false(name), name, 2, S_set S_mark_name, "a string");
+  return(mark_set(mark_n, name, MARK_NAME, S_set S_mark_name));
 }
 
 
-static XEN g_mark_sync_max(void) 
+static Xen g_mark_sync_max(void) 
 {
   #define H_mark_sync_max "(" S_mark_sync_max "): max mark sync value seen so far"
-  return(C_TO_XEN_INT(mark_sync_max()));
+  return(C_int_to_Xen_integer(mark_sync_max()));
 }
 
 
-static XEN g_mark_home(XEN mark_n)
+static Xen g_mark_home(Xen mark_n)
 {
   #define H_mark_home "(" S_mark_home " id): the sound (index) and channel that hold mark id"
-  XEN_ASSERT_TYPE(XEN_MARK_P(mark_n), mark_n, XEN_ONLY_ARG, S_mark_home, "a mark");
-  return(mark_get(mark_n, MARK_HOME, XEN_UNDEFINED, S_mark_home));
+  Xen_check_type(xen_is_mark(mark_n), mark_n, 1, S_mark_home, "a mark");
+  return(mark_get(mark_n, MARK_HOME, Xen_undefined, S_mark_home));
 }
 
 
-static XEN g_find_mark(XEN samp_n, XEN snd, XEN chn_n, XEN edpos) 
+static Xen g_find_mark(Xen samp_n, Xen snd, Xen chn_n, Xen edpos) 
 {
   #define H_find_mark "(" S_find_mark " samp-or-name :optional snd chn edpos): \
 find the mark in snd's channel chn at samp (if a number) or with the given name (if a string); return the mark or " PROC_FALSE " if no mark found."
@@ -2273,11 +2295,11 @@ find the mark in snd's channel chn at samp (if a number) or with the given name
   int pos;
   chan_info *cp = NULL;
 
-  XEN_ASSERT_TYPE((XEN_NUMBER_P(samp_n) || XEN_STRING_P(samp_n) || (XEN_FALSE_P(samp_n))), samp_n, XEN_ARG_1, S_find_mark, "a number or string or " PROC_FALSE);
-  ASSERT_CHANNEL(S_find_mark, snd, chn_n, 2); 
+  Xen_check_type((Xen_is_llong(samp_n) || Xen_is_string(samp_n) || (Xen_is_false(samp_n))), samp_n, 1, S_find_mark, "an integer or string or " PROC_FALSE);
+  Snd_assert_channel(S_find_mark, snd, chn_n, 2); 
 
   cp = get_cp(snd, chn_n, S_find_mark);
-  if (!cp) return(XEN_FALSE);
+  if (!cp) return(Xen_false);
   pos = to_c_edit_position(cp, edpos, S_find_mark, 4);
 
   mps = cp->edits[pos]->marks;
@@ -2286,9 +2308,13 @@ find the mark in snd's channel chn at samp (if a number) or with the given name
       int i;
       mus_long_t samp = 0;
       const char *name = NULL;
-      if (XEN_STRING_P(samp_n))
-	name = XEN_TO_C_STRING(samp_n);
-      else samp = XEN_TO_C_INT64_T_OR_ELSE(samp_n, 0);
+      if (Xen_is_string(samp_n))
+	name = Xen_string_to_C_string(samp_n);
+      else 
+	{
+	  if (Xen_is_llong(samp_n))
+	    samp = Xen_llong_to_C_llong(samp_n);
+	}
       if (name)
 	{
 	  for (i = 0; i <= cp->edits[pos]->mark_ctr; i++) 
@@ -2304,41 +2330,41 @@ find the mark in snd's channel chn at samp (if a number) or with the given name
 	      return(new_xen_mark(mps[i]->id));
 	}
     }
-  return(XEN_FALSE);
+  return(Xen_false);
 }
 
 
-static XEN g_add_mark_1(XEN samp_n, XEN snd, XEN chn_n, XEN name, XEN sync, bool check_sample) 
+static Xen g_add_mark_1(Xen samp_n, Xen snd, Xen chn_n, Xen name, Xen sync, bool check_sample, const char *caller) 
 {
   #define H_add_mark "(" S_add_mark " samp :optional snd chn name (sync 0)): add a mark at sample samp returning the mark."
   mark *m = NULL;
   chan_info *cp;
-  mus_long_t loc;
+  mus_long_t loc = 0;
   int msync = 0;
   const char *mname = NULL;
 
-  XEN_ASSERT_TYPE(XEN_INT64_T_P(samp_n) || XEN_NOT_BOUND_P(samp_n), samp_n, XEN_ARG_1, S_add_mark, "an integer");
-  XEN_ASSERT_TYPE(XEN_STRING_IF_BOUND_P(name) || XEN_FALSE_P(name), name, XEN_ARG_4, S_add_mark, "a string");
-  XEN_ASSERT_TYPE(XEN_INTEGER_IF_BOUND_P(sync), sync, XEN_ARG_5, S_add_mark, "an integer");
-  ASSERT_CHANNEL(S_add_mark, snd, chn_n, 2);
+  Xen_check_type(Xen_is_llong(samp_n) || !Xen_is_bound(samp_n), samp_n, 1, caller, "an integer");
+  Xen_check_type(Xen_is_string_or_unbound(name) || Xen_is_false(name), name, 4, caller, "a string");
+  Xen_check_type(Xen_is_integer_or_unbound(sync), sync, 5, caller, "an integer");
+  Snd_assert_channel(caller, snd, chn_n, 2);
 
-  cp = get_cp(snd, chn_n, S_add_mark);
-  if (!cp) return(XEN_FALSE);
+  cp = get_cp(snd, chn_n, caller);
+  if (!cp) return(Xen_false);
 
-  loc = XEN_TO_C_INT64_T_OR_ELSE(samp_n, 0);
+  if (Xen_is_llong(samp_n)) loc = Xen_llong_to_C_llong(samp_n);
 
   if ((!check_sample) &&
-      (loc >= CURRENT_SAMPLES(cp)))
-    return(XEN_FALSE);
+      (loc >= current_samples(cp)))
+    return(Xen_false);
 
   if ((loc < 0) || 
-      (loc >= CURRENT_SAMPLES(cp)))
-    XEN_ERROR(NO_SUCH_SAMPLE,
-	      XEN_LIST_2(C_TO_XEN_STRING(S_add_mark ": no such sample, ~A"),
+      (loc >= current_samples(cp)))
+    Xen_error(NO_SUCH_SAMPLE,
+	      Xen_list_2(C_string_to_Xen_string(S_add_mark ": no such sample, ~A"), 
 			 samp_n));
 
-  if (XEN_STRING_P(name)) mname = XEN_TO_C_STRING(name);
-  if (XEN_INTEGER_P(sync)) msync = XEN_TO_C_INT(sync);
+  if (Xen_is_string(name)) mname = Xen_string_to_C_string(name);
+  if (Xen_is_integer(sync)) msync = Xen_integer_to_C_int(sync);
 
   m = add_mark(loc, mname, cp);
   if (m)
@@ -2347,31 +2373,34 @@ static XEN g_add_mark_1(XEN samp_n, XEN snd, XEN chn_n, XEN name, XEN sync, bool
       update_graph(cp);
       return(new_xen_mark(m->id));
     }
-  return(XEN_FALSE);
+  return(Xen_false);
 }
 
 
-static XEN g_add_mark(XEN samp_n, XEN snd, XEN chn_n, XEN name, XEN sync)
+static Xen g_add_mark(Xen samp_n, Xen snd, Xen chn_n, Xen name, Xen sync)
 {
-  return(g_add_mark_1(samp_n, snd, chn_n, name, sync, true));
+  return(g_add_mark_1(samp_n, snd, chn_n, name, sync, true, S_add_mark));
 }
 
 
-static XEN g_add_mark_unchecked(XEN samp_n, XEN snd, XEN chn_n, XEN name, XEN sync)
+static Xen g_add_mark_unchecked(Xen samp_n, Xen snd, Xen chn_n, Xen name, Xen sync)
 {
-  return(g_add_mark_1(samp_n, snd, chn_n, name, sync, false));
+  #define H_add_mark_unchecked "(add-mark! samp :optional snd chn name (sync 0)): add a mark at sample samp returning the mark.\
+Unlike add-mark, add-mark! does not check for an invalid sample number."
+
+  return(g_add_mark_1(samp_n, snd, chn_n, name, sync, false, S_add_mark "!"));
 }
 
 
-static XEN g_delete_mark(XEN id_n) 
+static Xen g_delete_mark(Xen id_n) 
 {
   #define H_delete_mark "(" S_delete_mark " id): delete mark id"
   chan_info *cp[1];
   mark *m;
   int id;
 
-  XEN_ASSERT_TYPE(XEN_MARK_P(id_n), id_n, XEN_ONLY_ARG, S_delete_mark, "a mark");
-  id = XEN_MARK_TO_C_INT(id_n);
+  Xen_check_type(xen_is_mark(id_n), id_n, 1, S_delete_mark, "a mark");
+  id = Xen_mark_to_C_int(id_n);
 
   m = find_mark_from_id(id, cp, AT_CURRENT_EDIT_POSITION);
   if (m == NULL) 
@@ -2385,23 +2414,23 @@ static XEN g_delete_mark(XEN id_n)
 }
 
 
-static XEN g_delete_marks(XEN snd, XEN chn_n) 
+static Xen g_delete_marks(Xen snd, Xen chn_n) 
 {
   #define H_delete_marks "(" S_delete_marks " :optional snd chn): delete all marks in snd's channel chn"
   chan_info *cp;
-  ASSERT_CHANNEL(S_delete_marks, snd, chn_n, 1);
+  Snd_assert_channel(S_delete_marks, snd, chn_n, 1);
   cp = get_cp(snd, chn_n, S_delete_marks);
-  if (!cp) return(XEN_FALSE);
+  if (!cp) return(Xen_false);
   delete_marks(cp);
-  return(XEN_FALSE);
+  return(Xen_false);
 }
 
 
-static XEN int_array_to_mark_list(int *arr, int i, int len)
+static Xen int_array_to_mark_list(int *arr, int i, int len)
 {
   if (i < len)
-    return(XEN_CONS(new_xen_mark(arr[i]), int_array_to_mark_list(arr, i + 1, len)));
-  return(XEN_CONS(new_xen_mark(arr[i]), XEN_EMPTY_LIST));
+    return(Xen_cons(new_xen_mark(arr[i]), int_array_to_mark_list(arr, i + 1, len)));
+  return(Xen_cons(new_xen_mark(arr[i]), Xen_empty_list));
 }
 
 
@@ -2420,17 +2449,17 @@ static int *syncd_marks(int sync)
 }
 
 
-static XEN g_syncd_marks(XEN sync)
+static Xen g_syncd_marks(Xen sync)
 {
   #define H_syncd_marks "(" S_syncd_marks " sync): list of marks that share a given sync value (" S_mark_sync ")"
   int *ids;
-  XEN res;
+  Xen res;
 
-  XEN_ASSERT_TYPE(XEN_INTEGER_P(sync), sync, XEN_ONLY_ARG, S_syncd_marks, "an integer");
-  ids = syncd_marks(XEN_TO_C_INT(sync));
+  Xen_check_type(Xen_is_integer(sync), sync, 1, S_syncd_marks, "an integer");
+  ids = syncd_marks(Xen_integer_to_C_int(sync));
 
-  if (ids == NULL) return(XEN_EMPTY_LIST);
-  if (ids[0] == 0) {free(ids); return(XEN_EMPTY_LIST);}
+  if (ids == NULL) return(Xen_empty_list);
+  if (ids[0] == 0) {free(ids); return(Xen_empty_list);}
 
   res = int_array_to_mark_list(ids, 1, ids[0]);
 
@@ -2439,31 +2468,31 @@ static XEN g_syncd_marks(XEN sync)
 }
 
 
-static XEN g_mark_tag_width(void) {return(C_TO_XEN_INT(mark_tag_width(ss)));}
+static Xen g_mark_tag_width(void) {return(C_int_to_Xen_integer(mark_tag_width(ss)));}
 
-static XEN g_set_mark_tag_width(XEN val) 
+static Xen g_set_mark_tag_width(Xen val) 
 {
   #define H_mark_tag_width "(" S_mark_tag_width "): width (pixels) of mark tags (10)"
   int width;
-  XEN_ASSERT_TYPE(XEN_INTEGER_P(val), val, XEN_ONLY_ARG, S_setB S_mark_tag_width, "an integer"); 
-  width = mus_iclamp(0, XEN_TO_C_INT(val), LOTSA_PIXELS);
+  Xen_check_type(Xen_is_integer(val), val, 1, S_set S_mark_tag_width, "an integer"); 
+  width = mus_iclamp(0, Xen_integer_to_C_int(val), LOTSA_PIXELS);
   set_mark_tag_width(width);
   for_each_normal_chan(update_graph);
-  return(C_TO_XEN_INT(mark_tag_width(ss)));
+  return(C_int_to_Xen_integer(mark_tag_width(ss)));
 }
 
 
-static XEN g_mark_tag_height(void) {return(C_TO_XEN_INT(mark_tag_height(ss)));}
+static Xen g_mark_tag_height(void) {return(C_int_to_Xen_integer(mark_tag_height(ss)));}
 
-static XEN g_set_mark_tag_height(XEN val) 
+static Xen g_set_mark_tag_height(Xen val) 
 {
   #define H_mark_tag_height "(" S_mark_tag_height "): height (pixels) of mark tags (4)"
   int height;
-  XEN_ASSERT_TYPE(XEN_INTEGER_P(val), val, XEN_ONLY_ARG, S_setB S_mark_tag_height, "an integer"); 
-  height = mus_iclamp(0, XEN_TO_C_INT(val), LOTSA_PIXELS);
+  Xen_check_type(Xen_is_integer(val), val, 1, S_set S_mark_tag_height, "an integer"); 
+  height = mus_iclamp(0, Xen_integer_to_C_int(val), LOTSA_PIXELS);
   set_mark_tag_height(height);
   for_each_normal_chan(update_graph);
-  return(C_TO_XEN_INT(mark_tag_height(ss)));
+  return(C_int_to_Xen_integer(mark_tag_height(ss)));
 }
 
 
@@ -2491,43 +2520,43 @@ static int *channel_marks(chan_info *cp, int pos)
 }
 
 
-static XEN g_marks(XEN snd, XEN chn_n, XEN pos_n) 
+static Xen g_marks(Xen snd, Xen chn_n, Xen pos_n) 
 {
   #define H_marks "(" S_marks " :optional snd chn edpos): list of marks in snd/chn at edit history position pos. \
 mark list is: channel given: (id id ...), snd given: ((id id) (id id ...)), neither given: (((id ...) ...) ...)."
 
   chan_info *cp;
   snd_info *sp;
-  XEN res1 = XEN_EMPTY_LIST;
+  Xen res1 = Xen_empty_list;
 
-  ASSERT_CHANNEL(S_marks, snd, chn_n, 0);
+  Snd_assert_channel(S_marks, snd, chn_n, 0);
 
-  if (XEN_INTEGER_P(snd) || XEN_SOUND_P(snd))
+  if (Xen_is_integer(snd) || xen_is_sound(snd))
       {
-	int i, pos;
 	int *ids;
-	XEN res;
-	if (XEN_INTEGER_P(chn_n))
+	if (Xen_is_integer(chn_n))
 	  {
+	    int pos;
+	    Xen res;
 	    cp = get_cp(snd, chn_n, S_marks);
-	    if (!cp) return(XEN_FALSE);
-	    if (XEN_INTEGER_P(pos_n)) 
+	    if (!cp) return(Xen_false);
+	    if (Xen_is_integer(pos_n)) 
 	      {
-		pos = XEN_TO_C_INT(pos_n);
+		pos = Xen_integer_to_C_int(pos_n);
 		if (pos == AT_CURRENT_EDIT_POSITION)
 		  pos = cp->edit_ctr;
 		if ((pos < 0) || (pos >= cp->edit_size) || (cp->edits[pos] == NULL))
-		  XEN_ERROR(NO_SUCH_EDIT,
-			    XEN_LIST_2(C_TO_XEN_STRING(S_marks ": no such edit, ~A"),
+		  Xen_error(NO_SUCH_EDIT,
+			    Xen_list_2(C_string_to_Xen_string(S_marks ": no such edit, ~A"),
 				       pos_n));
 	      }
 	    else pos = cp->edit_ctr;
 	    ids = channel_marks(cp, pos);
-	    if (ids == NULL) return(XEN_EMPTY_LIST);
+	    if (ids == NULL) return(Xen_empty_list);
 	    if (ids[0] == 0) 
 	      {
 		free(ids); 
-		return(XEN_EMPTY_LIST);
+		return(Xen_empty_list);
 	      }
 	    res = int_array_to_mark_list(ids, 1, ids[0]);
 	    free(ids);
@@ -2535,6 +2564,7 @@ mark list is: channel given: (id id ...), snd given: ((id id) (id id ...)), neit
 	  }
 	else
 	  {
+	    int i;
 	    sp = get_sp(snd);
 	    if (sp == NULL) 
 	      return(snd_no_such_sound_error(S_marks, snd));
@@ -2543,8 +2573,8 @@ mark list is: channel given: (id id ...), snd given: ((id id) (id id ...)), neit
 		cp = sp->chans[i];
 		ids = channel_marks(cp, cp->edit_ctr);
 		if ((ids == NULL) || (ids[0] == 0))
-		  res1 = XEN_CONS(XEN_EMPTY_LIST, res1);
-		else res1 = XEN_CONS(int_array_to_mark_list(ids, 1, ids[0]), 
+		  res1 = Xen_cons(Xen_empty_list, res1);
+		else res1 = Xen_cons(int_array_to_mark_list(ids, 1, ids[0]), 
 				     res1);
 		if (ids) free(ids);
 	      }
@@ -2558,7 +2588,7 @@ mark list is: channel given: (id id ...), snd given: ((id id) (id id ...)), neit
 	{
 	  sp = ss->sounds[j];
 	  if ((sp) && (sp->inuse == SOUND_NORMAL))
-	    res1 = XEN_CONS(g_marks(C_TO_XEN_INT(j), XEN_UNDEFINED, XEN_UNDEFINED), 
+	    res1 = Xen_cons(g_marks(C_int_to_Xen_integer(j), Xen_undefined, Xen_undefined), 
 			    res1);
 	}
     }
@@ -2597,7 +2627,7 @@ static char *mark_sync_name(int cur_sync)
 {
   char *result;
   result = (char *)calloc(SYNC_NAME_SIZE, sizeof(char));
-  mus_snprintf(result, SYNC_NAME_SIZE, "%s%d", SYNC_BASE, cur_sync);
+  snprintf(result, SYNC_NAME_SIZE, "%s%d", SYNC_BASE, cur_sync);
   return(result);
 }
 
@@ -2667,20 +2697,20 @@ static mark *save_mark(chan_info *cp, mark *m, void *info)
 
 #if HAVE_SCHEME
   if (m->name)
-    fprintf(sv->fd, "(add-mark! " MUS_LD " sfile %d \"%s\" %s)\n", m->samp, cp->chan, m->name, mapped_sync);
-  else fprintf(sv->fd, "(add-mark! " MUS_LD " sfile %d #f %s)\n", m->samp, cp->chan, mapped_sync);
+    fprintf(sv->fd, "(add-mark! %lld sfile %d \"%s\" %s)\n", m->samp, cp->chan, m->name, mapped_sync);
+  else fprintf(sv->fd, "(add-mark! %lld sfile %d #f %s)\n", m->samp, cp->chan, mapped_sync);
 #endif
 
 #if HAVE_RUBY
   if (m->name)
-    fprintf(sv->fd, "add_mark!(" MUS_LD ", sfile, %d, \"%s\", %s)\n", m->samp, cp->chan, m->name, mapped_sync);
-  else fprintf(sv->fd, "add_mark!(" MUS_LD ", sfile, %d, false, %s)\n", m->samp, cp->chan, mapped_sync);
+    fprintf(sv->fd, "add_mark!(%lld, sfile, %d, \"%s\", %s)\n", m->samp, cp->chan, m->name, mapped_sync);
+  else fprintf(sv->fd, "add_mark!(%lld, sfile, %d, false, %s)\n", m->samp, cp->chan, mapped_sync);
 #endif
 
 #if HAVE_FORTH
   if (m->name)
-    fprintf(sv->fd, MUS_LD " sfile %d \"%s\" %s add-mark! drop\n", m->samp, cp->chan, m->name, mapped_sync);
-  else fprintf(sv->fd, MUS_LD " sfile %d #f %s add-mark! drop\n", m->samp, cp->chan, mapped_sync);
+    fprintf(sv->fd, "%lld sfile %d \"%s\" %s add-mark! drop\n", m->samp, cp->chan, m->name, mapped_sync);
+  else fprintf(sv->fd, "%lld sfile %d #f %s add-mark! drop\n", m->samp, cp->chan, mapped_sync);
 #endif
 
   free(mapped_sync);
@@ -2731,16 +2761,16 @@ void save_mark_list(FILE *fd, chan_info *cp, bool all_chans)
 }  
 
 
-static XEN g_save_marks(XEN snd, XEN filename)
+static Xen g_save_marks(Xen snd, Xen filename)
 {
   #define H_save_marks "(" S_save_marks " :optional snd (filename \"<snd-file-name>.marks\")): save snd's marks in filename. \
-The saved file is " XEN_LANGUAGE_NAME " code, so to restore the marks, load that file."
+The saved file is " Xen_language " code, so to restore the marks, load that file."
 
   snd_info *sp;
-  XEN res = XEN_FALSE;
+  Xen res = Xen_false;
 
-  ASSERT_SOUND(S_save_marks, snd, 1);
-  XEN_ASSERT_TYPE(XEN_STRING_IF_BOUND_P(filename), filename, XEN_ARG_2, S_save_marks, "a string");  
+  Snd_assert_sound(S_save_marks, snd, 1);
+  Xen_check_type(Xen_is_string_or_unbound(filename), filename, 2, S_save_marks, "a string");  
 
   sp = get_sp(snd);
   if (sp == NULL) 
@@ -2749,15 +2779,15 @@ The saved file is " XEN_LANGUAGE_NAME " code, so to restore the marks, load that
   if (map_over_sound_chans(sp, find_any_marks)) /* are there any marks? */
     {
       char *newname = NULL;
-      int i, len;
       FILE *fd;
-      if (XEN_STRING_P(filename))
-	newname = mus_strdup(XEN_TO_C_STRING(filename));
+      if (Xen_is_string(filename))
+	newname = mus_strdup(Xen_string_to_C_string(filename));
       else
 	{
+	  int i, len;
 	  len = strlen(sp->filename);
 	  newname = (char *)calloc(len + 7, sizeof(char));
-	  strcpy(newname, sp->filename);
+	  strcopy(newname, sp->filename, len + 7);
 	  for (i = len - 1; i > 0; i--) 
 	    if (newname[i] == '.') 
 	      break;
@@ -2768,13 +2798,13 @@ The saved file is " XEN_LANGUAGE_NAME " code, so to restore the marks, load that
       fd = FOPEN(newname, "w");
       if (fd == NULL)
 	{
-	  XEN lname;
-	  lname = C_TO_XEN_STRING(newname);
+	  Xen lname;
+	  lname = C_string_to_Xen_string(newname);
 	  free(newname);
-	  XEN_ERROR(CANNOT_SAVE,
-		    XEN_LIST_3(C_TO_XEN_STRING(S_save_marks ": can't save ~S, ~A"),
+	  Xen_error(CANNOT_SAVE,
+		    Xen_list_3(C_string_to_Xen_string(S_save_marks ": can't save ~S, ~A"),
 			       lname,
-			       C_TO_XEN_STRING(snd_open_strerror())));
+			       C_string_to_Xen_string(snd_open_strerror())));
 	}
       else
 	{
@@ -2785,7 +2815,7 @@ The saved file is " XEN_LANGUAGE_NAME " code, so to restore the marks, load that
 	  save_mark_list(fd, sp->chans[0], true); /* true -> save all chans, matching cross-channel syncs */
 	  close_save_sound_block(fd, false);      /* close the let form */
 	  snd_fclose(fd, newname);
-	  res = C_TO_XEN_STRING(newname);
+	  res = C_string_to_Xen_string(newname);
 	}
       free(newname);
     }
@@ -2793,117 +2823,93 @@ The saved file is " XEN_LANGUAGE_NAME " code, so to restore the marks, load that
 }
 
 
-static XEN g_mark_properties(XEN n)
+static Xen g_mark_properties(Xen n)
 {
   mark *m;
-  #define H_mark_properties "(" S_mark_properties " id):  A property list associated with the given mark. \
-The accessor mark-property is provided in mark." XEN_FILE_EXTENSION "."
+  #define H_mark_properties "(" S_mark_properties " id):  A property list associated with the given mark."
 
-  XEN_ASSERT_TYPE(XEN_MARK_P(n), n, XEN_ARG_1, S_mark_properties, "a mark");
+  Xen_check_type(xen_is_mark(n), n, 1, S_mark_properties, "a mark");
 
-  m = find_mark_from_id(XEN_MARK_TO_C_INT(n), NULL, AT_CURRENT_EDIT_POSITION);
+  m = find_mark_from_id(Xen_mark_to_C_int(n), NULL, AT_CURRENT_EDIT_POSITION);
   if (m == NULL)
     return(snd_no_such_mark_error(S_mark_properties, n));
 
-  if (!(XEN_VECTOR_P(m->properties)))
+  if (!(Xen_is_vector(m->properties)))
     {
-      m->properties = XEN_MAKE_VECTOR(1, XEN_EMPTY_LIST);
+      m->properties = Xen_make_vector(1, Xen_empty_list);
       m->properties_gc_loc = snd_protect(m->properties);
     }
-  return(XEN_VECTOR_REF(m->properties, 0));
+  return(Xen_vector_ref(m->properties, 0));
 }
 
 
-static XEN g_set_mark_properties(XEN n, XEN val)
+static Xen g_set_mark_properties(Xen n, Xen val)
 {
   mark *m;
-  XEN_ASSERT_TYPE(XEN_MARK_P(n), n, XEN_ARG_1, S_mark_properties, "a mark");
+  Xen_check_type(xen_is_mark(n), n, 1, S_mark_properties, "a mark");
 
-  m = find_mark_from_id(XEN_MARK_TO_C_INT(n), NULL, AT_CURRENT_EDIT_POSITION);
+  m = find_mark_from_id(Xen_mark_to_C_int(n), NULL, AT_CURRENT_EDIT_POSITION);
   if (m == NULL)
-    return(snd_no_such_mark_error(S_setB S_mark_properties, n));
+    return(snd_no_such_mark_error(S_set S_mark_properties, n));
 
-  if (!(XEN_VECTOR_P(m->properties)))
+  if (!(Xen_is_vector(m->properties)))
     {
-      m->properties = XEN_MAKE_VECTOR(1, XEN_EMPTY_LIST);
+      m->properties = Xen_make_vector(1, Xen_empty_list);
       m->properties_gc_loc = snd_protect(m->properties);
     }
 
-  XEN_VECTOR_SET(m->properties, 0, val);
-  return(XEN_VECTOR_REF(m->properties, 0));
+  Xen_vector_set(m->properties, 0, val);
+  return(Xen_vector_ref(m->properties, 0));
 }
 
 
-static XEN g_mark_property(XEN key, XEN id) 
+static Xen g_mark_property(Xen key, Xen id) 
 {
-  #define H_mark_property "(" S_mark_property " key id) returns the value associated with 'key' in the given mark's property list, or #f"
-  return(XEN_ASSOC_REF(key, g_mark_properties(id)));
+  #define H_mark_property "(" S_mark_property " key id) returns the value associated with 'key' in the given mark's property list, or " PROC_FALSE "."
+  Xen_check_type(xen_is_mark(id), id, 2, S_mark_property, "a mark");
+  return(Xen_assoc_ref(key, g_mark_properties(id)));
 }
 
-static XEN g_set_mark_property(XEN key, XEN id, XEN val) 
+static Xen g_set_mark_property(Xen key, Xen id, Xen val) 
 {
-  g_set_mark_properties(id, XEN_ASSOC_SET(key, val, g_mark_properties(id)));
+  Xen_check_type(xen_is_mark(id), id, 2, S_mark_property, "a mark");
+  g_set_mark_properties(id, Xen_assoc_set(key, val, g_mark_properties(id)));
   return(val);
 }
 
 
 
-#ifdef XEN_ARGIFY_1
-XEN_ARGIFY_2(g_mark_sample_w, g_mark_sample)
-XEN_NARGIFY_2(g_set_mark_sample_w, g_set_mark_sample)
-XEN_NARGIFY_1(g_mark_sync_w, g_mark_sync)
-XEN_NARGIFY_2(g_set_mark_sync_w, g_set_mark_sync)
-XEN_NARGIFY_1(g_mark_name_w, g_mark_name)
-XEN_NARGIFY_2(g_set_mark_name_w, g_set_mark_name)
-XEN_NARGIFY_0(g_mark_sync_max_w, g_mark_sync_max)
-XEN_NARGIFY_1(g_mark_home_w, g_mark_home)
-XEN_ARGIFY_3(g_marks_w, g_marks)
-XEN_ARGIFY_5(g_add_mark_w, g_add_mark)
-XEN_ARGIFY_5(g_add_mark_unchecked_w, g_add_mark_unchecked)
-XEN_NARGIFY_1(g_delete_mark_w, g_delete_mark)
-XEN_ARGIFY_2(g_delete_marks_w, g_delete_marks)
-XEN_NARGIFY_1(g_syncd_marks_w, g_syncd_marks)
-XEN_NARGIFY_0(g_mark_tag_width_w, g_mark_tag_width)
-XEN_NARGIFY_1(g_set_mark_tag_width_w, g_set_mark_tag_width)
-XEN_NARGIFY_0(g_mark_tag_height_w, g_mark_tag_height)
-XEN_NARGIFY_1(g_set_mark_tag_height_w, g_set_mark_tag_height)
-XEN_ARGIFY_4(g_find_mark_w, g_find_mark)
-XEN_ARGIFY_2(g_save_marks_w, g_save_marks)
-XEN_NARGIFY_1(g_mark_p_w, g_mark_p)
-XEN_NARGIFY_1(g_integer_to_mark_w, g_integer_to_mark)
-XEN_NARGIFY_1(g_mark_to_integer_w, g_mark_to_integer)
-XEN_NARGIFY_1(g_mark_properties_w, g_mark_properties)
-XEN_NARGIFY_2(g_set_mark_properties_w, g_set_mark_properties)
-XEN_NARGIFY_2(g_mark_property_w, g_mark_property)
-XEN_NARGIFY_3(g_set_mark_property_w, g_set_mark_property)
-#else
-#define g_mark_sample_w g_mark_sample
-#define g_set_mark_sample_w g_set_mark_sample
-#define g_mark_sync_w g_mark_sync
-#define g_set_mark_sync_w g_set_mark_sync
-#define g_mark_name_w g_mark_name
-#define g_set_mark_name_w g_set_mark_name
-#define g_mark_sync_max_w g_mark_sync_max
-#define g_mark_home_w g_mark_home
-#define g_marks_w g_marks
-#define g_add_mark_w g_add_mark
-#define g_add_mark_unchecked_w g_add_mark_unchecked
-#define g_delete_mark_w g_delete_mark
-#define g_delete_marks_w g_delete_marks
-#define g_syncd_marks_w g_syncd_marks
-#define g_mark_tag_width_w g_mark_tag_width
-#define g_set_mark_tag_width_w g_set_mark_tag_width
-#define g_mark_tag_height_w g_mark_tag_height
-#define g_set_mark_tag_height_w g_set_mark_tag_height
-#define g_find_mark_w g_find_mark
-#define g_save_marks_w g_save_marks
-#define g_mark_p_w g_mark_p
-#define g_integer_to_mark_w g_integer_to_mark
-#define g_mark_to_integer_w g_mark_to_integer
-#define g_mark_properties_w g_mark_properties
-#define g_set_mark_properties_w g_set_mark_properties
-#define g_mark_property_w g_mark_property
-#define g_set_mark_property_w g_set_mark_property
+Xen_wrap_2_optional_args(g_mark_sample_w, g_mark_sample)
+Xen_wrap_2_args(g_set_mark_sample_w, g_set_mark_sample)
+Xen_wrap_1_arg(g_mark_sync_w, g_mark_sync)
+Xen_wrap_2_args(g_set_mark_sync_w, g_set_mark_sync)
+Xen_wrap_1_arg(g_mark_name_w, g_mark_name)
+Xen_wrap_2_args(g_set_mark_name_w, g_set_mark_name)
+Xen_wrap_no_args(g_mark_sync_max_w, g_mark_sync_max)
+Xen_wrap_1_arg(g_mark_home_w, g_mark_home)
+Xen_wrap_3_optional_args(g_marks_w, g_marks)
+Xen_wrap_5_optional_args(g_add_mark_w, g_add_mark)
+Xen_wrap_5_optional_args(g_add_mark_unchecked_w, g_add_mark_unchecked)
+Xen_wrap_1_arg(g_delete_mark_w, g_delete_mark)
+Xen_wrap_2_optional_args(g_delete_marks_w, g_delete_marks)
+Xen_wrap_1_arg(g_syncd_marks_w, g_syncd_marks)
+Xen_wrap_no_args(g_mark_tag_width_w, g_mark_tag_width)
+Xen_wrap_1_arg(g_set_mark_tag_width_w, g_set_mark_tag_width)
+Xen_wrap_no_args(g_mark_tag_height_w, g_mark_tag_height)
+Xen_wrap_1_arg(g_set_mark_tag_height_w, g_set_mark_tag_height)
+Xen_wrap_4_optional_args(g_find_mark_w, g_find_mark)
+Xen_wrap_2_optional_args(g_save_marks_w, g_save_marks)
+Xen_wrap_1_arg(g_is_mark_w, g_is_mark)
+Xen_wrap_1_arg(g_integer_to_mark_w, g_integer_to_mark)
+Xen_wrap_1_arg(g_mark_to_integer_w, g_mark_to_integer)
+Xen_wrap_1_arg(g_mark_properties_w, g_mark_properties)
+Xen_wrap_2_args(g_set_mark_properties_w, g_set_mark_properties)
+Xen_wrap_2_args(g_mark_property_w, g_mark_property)
+Xen_wrap_3_args(g_set_mark_property_w, g_set_mark_property)
+
+#if HAVE_SCHEME
+static s7_pointer acc_mark_tag_height(s7_scheme *sc, s7_pointer args) {return(g_set_mark_tag_height(s7_cadr(args)));}
+static s7_pointer acc_mark_tag_width(s7_scheme *sc, s7_pointer args) {return(g_set_mark_tag_width(s7_cadr(args)));}
 #endif
 
 void g_init_marks(void)
@@ -2914,47 +2920,43 @@ void g_init_marks(void)
 
   init_xen_mark();
 
-  mark_drag_hook = XEN_DEFINE_HOOK(S_mark_drag_hook, 1, H_mark_drag_hook); /* arg = id */
-  mark_hook = XEN_DEFINE_HOOK(S_mark_hook, 4, H_mark_hook);                /* args = id snd chn reason */
-
-  XEN_DEFINE_PROCEDURE_WITH_SETTER(S_mark_sample, g_mark_sample_w, H_mark_sample,
-				   S_setB S_mark_sample, g_set_mark_sample_w, 1, 1, 2, 0);
-
-  XEN_DEFINE_PROCEDURE_WITH_SETTER(S_mark_sync, g_mark_sync_w, H_mark_sync,
-				   S_setB S_mark_sync, g_set_mark_sync_w, 1, 0, 2, 0);
-
-  XEN_DEFINE_PROCEDURE_WITH_SETTER(S_mark_name, g_mark_name_w, H_mark_name,
-				   S_setB S_mark_name, g_set_mark_name_w, 1, 0, 2, 0);
-
-  XEN_DEFINE_PROCEDURE(S_mark_sync_max,   g_mark_sync_max_w,   0, 0, 0, H_mark_sync_max);
-  XEN_DEFINE_PROCEDURE(S_mark_home,       g_mark_home_w,       1, 0, 0, H_mark_home); 
-  XEN_DEFINE_PROCEDURE(S_marks,           g_marks_w,           0, 3, 0, H_marks);
-  XEN_DEFINE_PROCEDURE(S_add_mark,        g_add_mark_w,        0, 5, 0, H_add_mark);
-  XEN_DEFINE_PROCEDURE(S_add_mark "!",    g_add_mark_unchecked_w, 0, 5, 0, H_add_mark);
-  XEN_DEFINE_PROCEDURE(S_delete_mark,     g_delete_mark_w,     1, 0, 0, H_delete_mark);
-  XEN_DEFINE_PROCEDURE(S_delete_marks,    g_delete_marks_w,    0, 2, 0, H_delete_marks);
-  XEN_DEFINE_PROCEDURE(S_syncd_marks,     g_syncd_marks_w,     1, 0, 0, H_syncd_marks);
-  XEN_DEFINE_PROCEDURE(S_find_mark,       g_find_mark_w,       1, 3, 0, H_find_mark);
-  XEN_DEFINE_PROCEDURE(S_save_marks,      g_save_marks_w,      0, 2, 0, H_save_marks);
-  XEN_DEFINE_PROCEDURE(S_mark_p,          g_mark_p_w,          1, 0, 0, H_mark_p);
-  XEN_DEFINE_PROCEDURE(S_integer_to_mark, g_integer_to_mark_w, 1, 0, 0, H_integer_to_mark);
-  XEN_DEFINE_PROCEDURE(S_mark_to_integer, g_mark_to_integer_w, 1, 0, 0, H_mark_to_integer);
-
-  XEN_DEFINE_PROCEDURE_WITH_SETTER(S_mark_tag_width, g_mark_tag_width_w, H_mark_tag_width,
-				   S_setB S_mark_tag_width, g_set_mark_tag_width_w, 0, 0, 1, 0);
-
-  XEN_DEFINE_PROCEDURE_WITH_SETTER(S_mark_tag_height, g_mark_tag_height_w, H_mark_tag_height,
-				   S_setB S_mark_tag_height, g_set_mark_tag_height_w, 0, 0, 1, 0);
-
-  XEN_DEFINE_PROCEDURE_WITH_SETTER(S_mark_properties, g_mark_properties_w, H_mark_properties, 
-				   S_setB S_mark_properties, g_set_mark_properties_w, 1, 0, 2, 0);
+  mark_drag_hook = Xen_define_hook(S_mark_drag_hook, "(make-hook 'id)", 1, H_mark_drag_hook);
+  mark_hook = Xen_define_hook(S_mark_hook, "(make-hook 'id 'snd 'chn 'reason)", 4, H_mark_hook); 
+
+  Xen_define_dilambda(S_mark_sample, g_mark_sample_w, H_mark_sample, S_set S_mark_sample, g_set_mark_sample_w, 1, 1, 2, 0);
+  Xen_define_dilambda(S_mark_sync, g_mark_sync_w, H_mark_sync, S_set S_mark_sync, g_set_mark_sync_w, 1, 0, 2, 0);
+  Xen_define_dilambda(S_mark_name, g_mark_name_w, H_mark_name, S_set S_mark_name, g_set_mark_name_w, 1, 0, 2, 0);
+
+  Xen_define_safe_procedure(S_mark_sync_max,   g_mark_sync_max_w,   0, 0, 0, H_mark_sync_max);
+  Xen_define_safe_procedure(S_mark_home,       g_mark_home_w,       1, 0, 0, H_mark_home); 
+  Xen_define_safe_procedure(S_marks,           g_marks_w,           0, 3, 0, H_marks);
+  Xen_define_safe_procedure(S_add_mark,        g_add_mark_w,        0, 5, 0, H_add_mark);
+  Xen_define_safe_procedure(S_add_mark "!",    g_add_mark_unchecked_w, 0, 5, 0, H_add_mark_unchecked);
+  Xen_define_safe_procedure(S_delete_mark,     g_delete_mark_w,     1, 0, 0, H_delete_mark);
+  Xen_define_safe_procedure(S_delete_marks,    g_delete_marks_w,    0, 2, 0, H_delete_marks);
+  Xen_define_safe_procedure(S_syncd_marks,     g_syncd_marks_w,     1, 0, 0, H_syncd_marks);
+  Xen_define_safe_procedure(S_find_mark,       g_find_mark_w,       1, 3, 0, H_find_mark);
+  Xen_define_safe_procedure(S_save_marks,      g_save_marks_w,      0, 2, 0, H_save_marks);
+  Xen_define_safe_procedure(S_is_mark,         g_is_mark_w,          1, 0, 0, H_is_mark);
+  Xen_define_safe_procedure(S_integer_to_mark, g_integer_to_mark_w, 1, 0, 0, H_integer_to_mark);
+  Xen_define_safe_procedure(S_mark_to_integer, g_mark_to_integer_w, 1, 0, 0, H_mark_to_integer);
+
+  Xen_define_dilambda(S_mark_tag_width, g_mark_tag_width_w, H_mark_tag_width, S_set S_mark_tag_width, g_set_mark_tag_width_w, 0, 0, 1, 0);
+  Xen_define_dilambda(S_mark_tag_height, g_mark_tag_height_w, H_mark_tag_height, S_set S_mark_tag_height, g_set_mark_tag_height_w, 0, 0, 1, 0);
+  Xen_define_dilambda(S_mark_properties, g_mark_properties_w, H_mark_properties, S_set S_mark_properties, g_set_mark_properties_w, 1, 0, 2, 0);
+  Xen_define_dilambda(S_mark_property, g_mark_property_w, H_mark_property, S_set S_mark_property, g_set_mark_property_w, 2, 0, 3, 0);
+
+  #define H_draw_mark_hook S_draw_mark_hook " (id): called before a mark is drawn. \
+If the hook returns " PROC_TRUE ", the mark is not drawn."
 
-  XEN_DEFINE_PROCEDURE_WITH_SETTER(S_mark_property, g_mark_property_w, H_mark_property, 
-				   S_setB S_mark_property, g_set_mark_property_w, 2, 0, 3, 0);
+  draw_mark_hook = Xen_define_hook(S_draw_mark_hook, "(make-hook 'id)", 1, H_draw_mark_hook);
 
-  #define H_draw_mark_hook S_draw_mark_hook " (mark-id): called before a mark is drawn (in XOR mode). \
-If the hook returns " PROC_TRUE ", the mark is not drawn."
+#if HAVE_SCHEME
+  s7_symbol_set_access(s7, ss->mark_tag_height_symbol, s7_make_function(s7, "[acc-" S_mark_tag_height "]", acc_mark_tag_height, 2, 0, false, "accessor"));
+  s7_symbol_set_access(s7, ss->mark_tag_width_symbol, s7_make_function(s7, "[acc-" S_mark_tag_width "]", acc_mark_tag_width, 2, 0, false, "accessor"));
 
-  draw_mark_hook = XEN_DEFINE_HOOK(S_draw_mark_hook, 1, H_draw_mark_hook);  /* arg = mark-id */
+  s7_symbol_set_documentation(s7, ss->mark_tag_height_symbol, "*mark-tag-height*: height (pixels) of mark tags (4)");
+  s7_symbol_set_documentation(s7, ss->mark_tag_width_symbol, "*mark-tag-width*: width (pixels) of mark tags (10)");
+#endif
 }