--- stack/symbols.c	2003/08/08 14:20:49	1.5
+++ stack/symbols.c	2003/08/11 14:31:48	1.6
@@ -10,16 +10,15 @@
 /* Print a newline to a port */
 extern void nlport(environment *env)
 {
-  if(env->head->type==empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
+  switch(check_args(env, port, empty)) {
+  case 1:
+    printerr(env, "Too Few Arguments");
     return;
-  }
-
-  if(CAR(env->head)->type!=port) {
-    printerr("Bad Argument Type");
-    env->err= 2;
+  case 2:
+    printerr(env, "Bad Argument Type");
     return;
+  default:
+    break;
   }
 
   if(fprintf(CAR(env->head)->content.p, "\n") < 0){
@@ -33,16 +32,25 @@
 /* Gets the type of a value */
 extern void type(environment *env)
 {
-  if(env->head->type==empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
+
+  switch(check_args(env, unknown, empty)) {
+  case 1:
+    printerr(env, "Too Few Arguments");
+    return;
+  case 2:
+    printerr(env, "Bad Argument Type");
     return;
+  default:
+    break;
   }
 
   switch(CAR(env->head)->type){
   case empty:
     push_sym(env, "empty");
     break;
+  case unknown:
+    push_sym(env, "unknown");
+    break;
   case integer:
     push_sym(env, "integer");
     break;
@@ -73,11 +81,18 @@
 /* Print the top element of the stack but don't discard it */
 extern void print_(environment *env)
 {
-  if(env->head->type==empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
+
+  switch(check_args(env, unknown, empty)) {
+  case 1:
+    printerr(env, "Too Few Arguments");
+    return;
+  case 2:
+    printerr(env, "Bad Argument Type");
     return;
+  default:
+    break;
   }
+
   print_val(env, CAR(env->head), 0, NULL, stdout);
   if(env->err) return;
   nl(env);
@@ -95,11 +110,18 @@
    discard it. */
 extern void princ_(environment *env)
 {
-  if(env->head->type==empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
+
+  switch(check_args(env, unknown, empty)) {
+  case 1:
+    printerr(env, "Too Few Arguments");
+    return;
+  case 2:
+    printerr(env, "Bad Argument Type");
     return;
+  default:
+    break;
   }
+
   print_val(env, CAR(env->head), 1, NULL, stdout);
 }
 
@@ -114,16 +136,16 @@
 /* Print a value to a port, but don't discard it */
 extern void printport_(environment *env)
 {
-  if(env->head->type==empty ||  CDR(env->head)->type == empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
-    return;
-  }
 
-  if(CAR(env->head)->type!=port) {
-    printerr("Bad Argument Type");
-    env->err= 2;
+  switch(check_args(env, port, unknown, empty)) {
+  case 1:
+    printerr(env, "Too Few Arguments");
     return;
+  case 2:
+    printerr(env, "Bad Argument Type");
+    return;
+  default:
+    break;
   }
 
   print_val(env, CAR(CDR(env->head)), 0, NULL, CAR(env->head)->content.p);
@@ -142,16 +164,16 @@
 /* Print, without quotes, to a port, a value, but don't discard it. */
 extern void princport_(environment *env)
 {
-  if(env->head->type==empty ||  CDR(env->head)->type == empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
-    return;
-  }
 
-  if(CAR(env->head)->type!=port) {
-    printerr("Bad Argument Type");
-    env->err= 2;
+  switch(check_args(env, port, unknown, empty)) {
+  case 1:
+    printerr(env, "Too Few Arguments");
     return;
+  case 2:
+    printerr(env, "Bad Argument Type");
+    return;
+  default:
+    break;
   }
 
   print_val(env, CAR(CDR(env->head)), 1, NULL, CAR(env->head)->content.p);
@@ -170,12 +192,16 @@
 extern void rot(environment *env)
 {
   value *temp= env->head;
-  
-  if(env->head->type == empty || CDR(env->head)->type == empty
-     || CDR(CDR(env->head))->type == empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
+
+  switch(check_args(env, unknown, unknown, unknown, empty)) {
+  case 1:
+    printerr(env, "Too Few Arguments");
+    return;
+  case 2:
+    printerr(env, "Bad Argument Type");
     return;
+  default:
+    break;
   }
   
   env->head= CDR(CDR(env->head));
@@ -188,17 +214,15 @@
 {
   value *temp, *new_head;
 
-  /* Is top element a list? */
-  if(env->head->type==empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
+  switch(check_args(env, tcons, empty)) {
+  case 1:
+    printerr(env, "Too Few Arguments");
     return;
-  }
-
-  if(CAR(env->head)->type!=tcons) {
-    printerr("Bad Argument Type");
-    env->err= 2;
+  case 2:
+    printerr(env, "Bad Argument Type");
     return;
+  default:
+    break;
   }
 
   rev(env);
@@ -211,12 +235,13 @@
 
   toss(env);
 
+  /// XXX
   /* Find the end of the list */
   while(CDR(temp)->type != empty) {
     if (CDR(temp)->type == tcons)
       temp= CDR(temp);
     else {
-      printerr("Bad Argument Type"); /* Improper list */
+      printerr(env, "Bad Argument Type"); /* Improper list */
       env->err= 2;
       return;
     }
@@ -233,10 +258,15 @@
 {
   void *left, *right;
 
-  if(env->head->type==empty || CDR(env->head)->type==empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
+  switch(check_args(env, unknown, unknown, empty)) {
+  case 1:
+    printerr(env, "Too Few Arguments");
+    return;
+  case 2:
+    printerr(env, "Bad Argument Type");
     return;
+  default:
+    break;
   }
 
   left= CAR(env->head)->content.ptr;
@@ -251,16 +281,15 @@
 {
   int val;
 
-  if(env->head->type==empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
+  switch(check_args(env, integer, empty)) {
+  case 1:
+    printerr(env, "Too Few Arguments");
     return;
-  }
-
-  if(CAR(env->head)->type!=integer) {
-    printerr("Bad Argument Type");
-    env->err= 2;
+  case 2:
+    printerr(env, "Bad Argument Type");
     return;
+  default:
+    break;
   }
 
   val= CAR(env->head)->content.i;
@@ -281,16 +310,15 @@
   symbol *sym;
 
   /* Needs two values on the stack, the top one must be a symbol */
-  if(env->head->type==empty || CDR(env->head)->type==empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
+  switch(check_args(env, symb, unknown, empty)) {
+  case 1:
+    printerr(env, "Too Few Arguments");
     return;
-  }
-
-  if(CAR(env->head)->type!=symb) {
-    printerr("Bad Argument Type");
-    env->err= 2;
+  case 2:
+    printerr(env, "Bad Argument Type");
     return;
+  default:
+    break;
   }
 
   /* long names are a pain */
@@ -313,16 +341,15 @@
 {
   char* sym_id;
 
-  if(env->head->type==empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
+  switch(check_args(env, symb, empty)) {
+  case 1:
+    printerr(env, "Too Few Arguments");
     return;
-  }
-  
-  if(CAR(env->head)->type!=symb) {
-    printerr("Bad Argument Type");
-    env->err= 2;
+  case 2:
+    printerr(env, "Bad Argument Type");
     return;
+  default:
+    break;
   }
 
   sym_id= CAR(env->head)->content.sym->id;
@@ -346,14 +373,12 @@
   char* new_string;
   value *a_val, *b_val;
 
-  if(env->head->type==empty || CDR(env->head)->type==empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
+  if(check_args(env, unknown, unknown, empty)==1) {
+    printerr(env, "Too Few Arguments");
     return;
   }
 
-  if(CAR(env->head)->type==string
-     && CAR(CDR(env->head))->type==string) {
+  if(check_args(env, string, string, empty)==0) {
     a_val= CAR(env->head);
     b_val= CAR(CDR(env->head));
     protect(a_val); protect(b_val);
@@ -371,8 +396,7 @@
     return;
   }
   
-  if(CAR(env->head)->type==integer
-     && CAR(CDR(env->head))->type==integer) {
+  if(check_args(env, integer, integer, empty)==0) {
     a= CAR(env->head)->content.i;
     toss(env); if(env->err) return;
     b= CAR(env->head)->content.i;
@@ -382,8 +406,7 @@
     return;
   }
 
-  if(CAR(env->head)->type==tfloat
-     && CAR(CDR(env->head))->type==tfloat) {
+  if(check_args(env, tfloat, tfloat, empty)==0) {
     fa= CAR(env->head)->content.f;
     toss(env); if(env->err) return;
     fb= CAR(env->head)->content.f;
@@ -393,8 +416,7 @@
     return;
   }
 
-  if(CAR(env->head)->type==tfloat
-     && CAR(CDR(env->head))->type==integer) {
+  if(check_args(env, tfloat, integer, empty)==0) {
     fa= CAR(env->head)->content.f;
     toss(env); if(env->err) return;
     b= CAR(env->head)->content.i;
@@ -404,8 +426,7 @@
     return;
   }
 
-  if(CAR(env->head)->type==integer
-     && CAR(CDR(env->head))->type==tfloat) {
+  if(check_args(env, integer, tfloat, empty)==0) {
     a= CAR(env->head)->content.i;
     toss(env); if(env->err) return;
     fb= CAR(env->head)->content.f;
@@ -415,7 +436,7 @@
     return;
   }
 
-  printerr("Bad Argument Type");
+  printerr(env, "Bad Argument Type");
   env->err=2;
 }
 
@@ -425,14 +446,12 @@
   int a, b;
   float fa, fb;
 
-  if(env->head->type==empty || CDR(env->head)->type==empty) {
-    printerr("Too Few Arguments");
-    env->err=1;
+  if(check_args(env, unknown, unknown, empty)==1) {
+    printerr(env, "Too Few Arguments");
     return;
   }
-  
-  if(CAR(env->head)->type==integer
-     && CAR(CDR(env->head))->type==integer) {
+
+  if(check_args(env, integer, integer, empty)==0) {
     a= CAR(env->head)->content.i;
     toss(env); if(env->err) return;
     b= CAR(env->head)->content.i;
@@ -442,8 +461,7 @@
     return;
   }
 
-  if(CAR(env->head)->type==tfloat
-     && CAR(CDR(env->head))->type==tfloat) {
+  if(check_args(env, tfloat, tfloat, empty)==0) {
     fa= CAR(env->head)->content.f;
     toss(env); if(env->err) return;
     fb= CAR(env->head)->content.f;
@@ -453,8 +471,7 @@
     return;
   }
 
-  if(CAR(env->head)->type==tfloat
-     && CAR(CDR(env->head))->type==integer) {
+  if(check_args(env, tfloat, integer, empty)==0) {
     fa= CAR(env->head)->content.f;
     toss(env); if(env->err) return;
     b= CAR(env->head)->content.i;
@@ -464,8 +481,7 @@
     return;
   }
 
-  if(CAR(env->head)->type==integer
-     && CAR(CDR(env->head))->type==tfloat) {
+  if(check_args(env, integer, tfloat, empty)==0) {
     a= CAR(env->head)->content.i;
     toss(env); if(env->err) return;
     fb= CAR(env->head)->content.f;
@@ -475,7 +491,7 @@
     return;
   }
 
-  printerr("Bad Argument Type");
+  printerr(env, "Bad Argument Type");
   env->err=2;
 }
 
@@ -485,14 +501,12 @@
   int a, b;
   float fa, fb;
 
-  if(env->head->type==empty || CDR(env->head)->type==empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
+  if(check_args(env, unknown, unknown, empty)==1) {
+    printerr(env, "Too Few Arguments");
     return;
   }
-  
-  if(CAR(env->head)->type==integer
-     && CAR(CDR(env->head))->type==integer) {
+
+  if(check_args(env, integer, integer, empty)==0) {
     a= CAR(env->head)->content.i;
     toss(env); if(env->err) return;
     b= CAR(env->head)->content.i;
@@ -502,8 +516,7 @@
     return;
   }
 
-  if(CAR(env->head)->type==tfloat
-     && CAR(CDR(env->head))->type==tfloat) {
+  if(check_args(env, tfloat, tfloat, empty)==0) {
     fa= CAR(env->head)->content.f;
     toss(env); if(env->err) return;
     fb= CAR(env->head)->content.f;
@@ -513,8 +526,7 @@
     return;
   }
 
-  if(CAR(env->head)->type==tfloat
-     && CAR(CDR(env->head))->type==integer) {
+  if(check_args(env, tfloat, integer, empty)==0) {
     fa= CAR(env->head)->content.f;
     toss(env); if(env->err) return;
     b= CAR(env->head)->content.i;
@@ -524,8 +536,7 @@
     return;
   }
 
-  if(CAR(env->head)->type==integer
-     && CAR(CDR(env->head))->type==tfloat) {
+  if(check_args(env, integer, tfloat, empty)==0) {
     a= CAR(env->head)->content.i;
     toss(env); if(env->err) return;
     fb= CAR(env->head)->content.f;
@@ -535,7 +546,7 @@
     return;
   }
 
-  printerr("Bad Argument Type");
+  printerr(env, "Bad Argument Type");
   env->err= 2;
 }
 
@@ -563,11 +574,17 @@
 /* "dup"; duplicates an item on the stack */
 extern void sx_647570(environment *env)
 {
-  if(env->head->type==empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
+  switch(check_args(env, unknown, empty)) {
+  case 1:
+    printerr(env, "Too Few Arguments");
+    return;
+  case 2:
+    printerr(env, "Bad Argument Type");
     return;
+  default:
+    break;
   }
+
   push_val(env, copy_val(env, CAR(env->head)));
 }
 
@@ -576,18 +593,17 @@
 {
   int truth;
 
-  if(env->head->type==empty || CDR(env->head)->type==empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
+  switch(check_args(env, unknown, integer, empty)) {
+  case 1:
+    printerr(env, "Too Few Arguments");
     return;
-  }
-
-  if(CAR(CDR(env->head))->type != integer) {
-    printerr("Bad Argument Type");
-    env->err= 2;
+  case 2:
+    printerr(env, "Bad Argument Type");
     return;
+  default:
+    break;
   }
-  
+
   swap(env);
   if(env->err) return;
   
@@ -607,19 +623,17 @@
 {
   int truth;
 
-  if(env->head->type==empty || CDR(env->head)->type==empty
-     || CDR(CDR(env->head))->type==empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
+  switch(check_args(env, unknown, unknown, integer, empty)) {
+  case 1:
+    printerr(env, "Too Few Arguments");
     return;
-  }
-
-  if(CAR(CDR(CDR(env->head)))->type!=integer) {
-    printerr("Bad Argument Type");
-    env->err= 2;
+  case 2:
+    printerr(env, "Bad Argument Type");
     return;
+  default:
+    break;
   }
-  
+
   rot(env);
   if(env->err) return;
   
@@ -641,19 +655,27 @@
 /* "else" */
 extern void sx_656c7365(environment *env)
 {
-  if(env->head->type==empty || CDR(env->head)->type==empty 
-     || CDR(CDR(env->head))->type==empty || CDR(CDR(CDR(env->head)))->type==empty
-     || CDR(CDR(CDR(CDR(env->head))))->type==empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
+
+  switch(check_args(env, 
+		    unknown, symb, unknown, symb, integer,
+		    empty)) {
+  case 1:
+    printerr(env, "Too Few Arguments");
+    return;
+  case 2:
+    printerr(env, "Bad Argument Type");
     return;
+  default:
+    break;
   }
 
+  /// XXX
+
   if(CAR(CDR(env->head))->type!=symb
      || strcmp(CAR(CDR(env->head))->content.sym->id, "then")!=0
      || CAR(CDR(CDR(CDR(env->head))))->type!=symb
      || strcmp(CAR(CDR(CDR(CDR(env->head))))->content.sym->id, "if")!=0) {
-    printerr("Bad Argument Type");
+    printerr(env, "Bad Argument Type");
     env->err= 2;
     return;
   }
@@ -664,16 +686,23 @@
 
 extern void then(environment *env)
 {
-  if(env->head->type==empty || CDR(env->head)->type==empty
-     || CDR(CDR(env->head))->type==empty) { 
-    printerr("Too Few Arguments");
-    env->err= 1;
+   
+  switch(check_args(env, unknown, symb, integer, empty)) {
+  case 1:
+    printerr(env, "Too Few Arguments");
     return;
+  case 2:
+    printerr(env, "Bad Argument Type");
+    return;
+  default:
+    break;
   }
 
+  /// XXX
+
   if(CAR(CDR(env->head))->type!=symb
      || strcmp(CAR(CDR(env->head))->content.sym->id, "if")!=0) {
-    printerr("Bad Argument Type");
+    printerr(env, "Bad Argument Type");
     env->err= 2;
     return;
   }
@@ -688,10 +717,15 @@
   int truth;
   value *loop, *test;
 
-  if(env->head->type==empty || CDR(env->head)->type==empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
+  switch(check_args(env, unknown, integer, empty)) {
+  case 1:
+    printerr(env, "Too Few Arguments");
+    return;
+  case 2:
+    printerr(env, "Bad Argument Type");
     return;
+  default:
+    break;
   }
 
   loop= CAR(env->head);
@@ -705,9 +739,11 @@
   do {
     push_val(env, test);
     eval(env);
+
+    /// XXX
     
     if(CAR(env->head)->type != integer) {
-      printerr("Bad Argument Type");
+      printerr(env, "Bad Argument Type");
       env->err= 2;
       return;
     }
@@ -734,18 +770,15 @@
   value *loop;
   int foo1, foo2;
 
-  if(env->head->type==empty || CDR(env->head)->type==empty 
-     || CDR(CDR(env->head))->type==empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
+  switch(check_args(env, unknown, integer, integer, empty)) {
+  case 1:
+    printerr(env, "Too Few Arguments");
     return;
-  }
-
-  if(CAR(CDR(env->head))->type!=integer
-     || CAR(CDR(CDR(env->head)))->type!=integer) {
-    printerr("Bad Argument Type");
-    env->err= 2;
+  case 2:
+    printerr(env, "Bad Argument Type");
     return;
+  default:
+    break;
   }
 
   loop= CAR(env->head);
@@ -782,19 +815,18 @@
 {  
   value *loop, *foo;
   value *iterator;
-  
-  if(env->head->type==empty || CDR(env->head)->type==empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
-    return;
-  }
 
-  if(CAR(CDR(env->head))->type!=tcons) {
-    printerr("Bad Argument Type");
-    env->err= 2;
+  switch(check_args(env, unknown, tcons, empty)) {
+  case 1:
+    printerr(env, "Too Few Arguments");
+    return;
+  case 2:
+    printerr(env, "Bad Argument Type");
     return;
+  default:
+    break;
   }
-
+  
   loop= CAR(env->head);
   protect(loop);
   toss(env); if(env->err) return;
@@ -809,10 +841,12 @@
     push_val(env, CAR(iterator));
     push_val(env, loop);
     eval(env); if(env->err) return;
+
+    /// XXX
     if (iterator->type == tcons){
       iterator= CDR(iterator);
     } else {
-      printerr("Bad Argument Type"); /* Improper list */
+      printerr(env, "Bad Argument Type"); /* Improper list */
       env->err= 2;
       break;
     }
@@ -826,21 +860,19 @@
   int ending, start, i;
   value *iterator, *temp, *end;
 
-  end= new_val(env);
-
-  if(env->head->type==empty || CDR(env->head)->type==empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
+  switch(check_args(env, integer, integer, empty)) {
+  case 1:
+    printerr(env, "Too Few Arguments");
     return;
-  }
-
-  if(CAR(env->head)->type!=integer 
-     || CAR(CDR(env->head))->type!=integer) {
-    printerr("Bad Argument Type");
-    env->err= 2;
+  case 2:
+    printerr(env, "Bad Argument Type");
     return;
+  default:
+    break;
   }
 
+  end= new_val(env);
+
   ending= CAR(env->head)->content.i;
   toss(env); if(env->err) return;
   start= CAR(env->head)->content.i;
@@ -894,16 +926,15 @@
 {
   FILE *stream;
 
-  if(env->head->type==empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
+  switch(check_args(env, port, empty)) {
+  case 1:
+    printerr(env, "Too Few Arguments");
     return;
-  }
-
-  if(CAR(env->head)->type!=port) {
-    printerr("Bad Argument Type");
-    env->err= 2;
+  case 2:
+    printerr(env, "Bad Argument Type");
     return;
+  default:
+    break;
   }
 
   stream=CAR(env->head)->content.p;
@@ -924,16 +955,15 @@
 {
   FILE *stream;
 
-  if(env->head->type==empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
+  switch(check_args(env, port, empty)) {
+  case 1:
+    printerr(env, "Too Few Arguments");
     return;
-  }
-
-  if(CAR(env->head)->type!=port) {
-    printerr("Bad Argument Type");
-    env->err= 2;
+  case 2:
+    printerr(env, "Bad Argument Type");
     return;
+  default:
+    break;
   }
 
   stream=CAR(env->head)->content.p;
@@ -948,17 +978,15 @@
 {
   int freq, dur, period, ticks;
 
-  if(env->head->type==empty || CDR(env->head)->type==empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
+  switch(check_args(env, integer, integer, empty)) {
+  case 1:
+    printerr(env, "Too Few Arguments");
     return;
-  }
-
-  if(CAR(env->head)->type!=integer
-     || CAR(CDR(env->head))->type!=integer) {
-    printerr("Bad Argument Type");
-    env->err= 2;
+  case 2:
+    printerr(env, "Bad Argument Type");
     return;
+  default:
+    break;
   }
 
   dur= CAR(env->head)->content.i;
@@ -993,16 +1021,15 @@
 {
   int dur;
 
-  if(env->head->type==empty) {
-    printerr("Too Few Arguments");
-    env->err= 1;
+  switch(check_args(env, integer, empty)) {
+  case 1:
+    printerr(env, "Too Few Arguments");
     return;
-  }
-
-  if(CAR(env->head)->type!=integer) {
-    printerr("Bad Argument Type");
-    env->err= 2;
+  case 2:
+    printerr(env, "Bad Argument Type");
     return;
+  default:
+    break;
   }
 
   dur= CAR(env->head)->content.i;
@@ -1011,6 +1038,9 @@
   usleep(dur);
 }
 
+/// XXXXXX
+
+
 /* "*" */
 extern void sx_2a(environment *env)
 {
@@ -1018,7 +1048,7 @@
   float fa, fb;
 
   if(env->head->type==empty || CDR(env->head)->type==empty) {
-    printerr("Too Few Arguments");
+    printerr(env, "Too Few Arguments");
     env->err= 1;
     return;
   }
@@ -1067,7 +1097,7 @@
     return;
   }
 
-  printerr("Bad Argument Type");
+  printerr(env, "Bad Argument Type");
   env->err= 2;
 }
 
@@ -1078,7 +1108,7 @@
   float fa, fb;
 
   if(env->head->type==empty || CDR(env->head)->type==empty) {
-    printerr("Too Few Arguments");
+    printerr(env, "Too Few Arguments");
     env->err= 1;
     return;
   }
@@ -1127,7 +1157,7 @@
     return;
   }
 
-  printerr("Bad Argument Type");
+  printerr(env, "Bad Argument Type");
   env->err= 2;
 }
 
@@ -1137,7 +1167,7 @@
   int a, b;
 
   if(env->head->type==empty || CDR(env->head)->type==empty) {
-    printerr("Too Few Arguments");
+    printerr(env, "Too Few Arguments");
     env->err= 1;
     return;
   }
@@ -1153,7 +1183,7 @@
     return;
   }
 
-  printerr("Bad Argument Type");
+  printerr(env, "Bad Argument Type");
   env->err= 2;
 }
 
@@ -1163,7 +1193,7 @@
   int a, b;
   
   if(env->head->type==empty || CDR(env->head)->type==empty) {
-    printerr("Too Few Arguments");
+    printerr(env, "Too Few Arguments");
     env->err= 1;
     return;
   }
@@ -1179,20 +1209,20 @@
     return;
   }
 
-  printerr("Bad Argument Type");
+  printerr(env, "Bad Argument Type");
   env->err= 2;
 }
 
 extern void setcar(environment *env)
 {
   if(env->head->type==empty || CDR(env->head)->type==empty) {
-    printerr("Too Few Arguments");
+    printerr(env, "Too Few Arguments");
     env->err= 1;
     return;
   }
 
   if(CDR(env->head)->type!=tcons) {
-    printerr("Bad Argument Type");
+    printerr(env, "Bad Argument Type");
     env->err= 2;
     return;
   }
@@ -1204,13 +1234,13 @@
 extern void setcdr(environment *env)
 {
   if(env->head->type==empty || CDR(env->head)->type==empty) {
-    printerr("Too Few Arguments");
+    printerr(env, "Too Few Arguments");
     env->err= 1;
     return;
   }
 
   if(CDR(env->head)->type!=tcons) {
-    printerr("Bad Argument Type");
+    printerr(env, "Bad Argument Type");
     env->err= 2;
     return;
   }
@@ -1222,13 +1252,13 @@
 extern void car(environment *env)
 {
   if(env->head->type==empty) {
-    printerr("Too Few Arguments");
+    printerr(env, "Too Few Arguments");
     env->err= 1;
     return;
   }
 
   if(CAR(env->head)->type!=tcons) {
-    printerr("Bad Argument Type");
+    printerr(env, "Bad Argument Type");
     env->err= 2;
     return;
   }
@@ -1239,13 +1269,13 @@
 extern void cdr(environment *env)
 {
   if(env->head->type==empty) {
-    printerr("Too Few Arguments");
+    printerr(env, "Too Few Arguments");
     env->err= 1;
     return;
   }
 
   if(CAR(env->head)->type!=tcons) {
-    printerr("Bad Argument Type");
+    printerr(env, "Bad Argument Type");
     env->err= 2;
     return;
   }
@@ -1258,7 +1288,7 @@
   value *val;
 
   if(env->head->type==empty || CDR(env->head)->type==empty) {
-    printerr("Too Few Arguments");
+    printerr(env, "Too Few Arguments");
     env->err= 1;
     return;
   }
@@ -1290,13 +1320,13 @@
   /* Needs two values on the stack, the top one must be an association
      list */
   if(env->head->type==empty || CDR(env->head)->type==empty) {
-    printerr("Too Few Arguments");
+    printerr(env, "Too Few Arguments");
     env->err= 1;
     return;
   }
 
   if(CAR(env->head)->type!=tcons) {
-    printerr("Bad Argument Type");
+    printerr(env, "Bad Argument Type");
     env->err= 2;
     return;
   }
@@ -1306,7 +1336,7 @@
 
   while(item->type == tcons){
     if(CAR(item)->type != tcons){
-      printerr("Bad Argument Type");
+      printerr(env, "Bad Argument Type");
       env->err= 2;
       return;
     }
@@ -1316,12 +1346,12 @@
 
     /* Check the result of 'eqfunc' */
     if(env->head->type==empty) {
-      printerr("Too Few Arguments");
+      printerr(env, "Too Few Arguments");
       env->err= 1;
     return;
     }
     if(CAR(env->head)->type!=integer) {
-      printerr("Bad Argument Type");
+      printerr(env, "Bad Argument Type");
       env->err= 2;
       return;
     }
@@ -1333,7 +1363,7 @@
     toss(env); if(env->err) return;
 
     if(item->type!=tcons) {
-      printerr("Bad Argument Type");
+      printerr(env, "Bad Argument Type");
       env->err= 2;
       return;
     }
@@ -1377,14 +1407,14 @@
   FILE *stream;
 
   if(env->head->type == empty || CDR(env->head)->type == empty) {
-    printerr("Too Few Arguments");
+    printerr(env, "Too Few Arguments");
     env->err=1;
     return;
   }
 
   if(CAR(env->head)->type != string
      || CAR(CDR(env->head))->type != string) {
-    printerr("Bad Argument Type");
+    printerr(env, "Bad Argument Type");
     env->err= 2;
     return;
   }
@@ -1417,13 +1447,13 @@
   int ret;
 
   if(env->head->type == empty) {
-    printerr("Too Few Arguments");
+    printerr(env, "Too Few Arguments");
     env->err=1;
     return;
   }
 
   if(CAR(env->head)->type != port) {
-    printerr("Bad Argument Type");
+    printerr(env, "Bad Argument Type");
     env->err= 2;
     return;
   }
@@ -1444,13 +1474,13 @@
   char *new_string;
 
   if(env->head->type==empty) {
-    printerr("Too Few Arguments");
+    printerr(env, "Too Few Arguments");
     env->err= 1;
     return;
   }
 
   if(CAR(env->head)->type!=string) {
-    printerr("Bad Argument Type");
+    printerr(env, "Bad Argument Type");
     env->err= 2;
     return;
   }
@@ -1474,13 +1504,13 @@
 {
 
   if(env->head->type==empty) {
-    printerr("Too Few Arguments");
+    printerr(env, "Too Few Arguments");
     env->err= 1;
     return;
   }
 
   if(CAR(env->head)->type!=integer) {
-    printerr("Bad Argument Type");
+    printerr(env, "Bad Argument Type");
     env->err= 2;
     return;
   }
@@ -1494,7 +1524,7 @@
 extern void toss(environment *env)
 {
   if(env->head->type==empty) {
-    printerr("Too Few Arguments");
+    printerr(env, "Too Few Arguments");
     env->err= 1;
     return;
   }