--- stack/symbols.c	2003/08/11 14:31:48	1.6
+++ stack/symbols.c	2003/08/18 14:39:16	1.10
@@ -10,22 +10,14 @@
 /* Print a newline to a port */
 extern void nlport(environment *env)
 {
-  switch(check_args(env, port, empty)) {
-  case 1:
-    printerr(env, "Too Few Arguments");
-    return;
-  case 2:
-    printerr(env, "Bad Argument Type");
-    return;
-  default:
-    break;
-  }
+  if(check_args(env, 1, port))
+    return printerr(env);
 
-  if(fprintf(CAR(env->head)->content.p, "\n") < 0){
-    perror("nl");
+  if(fprintf(CAR(env->head)->content.p, "\n") < 0) {
     env->err= 5;
-    return;
+    return printerr(env);
   }
+
   toss(env);
 }
 
@@ -33,16 +25,8 @@
 extern void type(environment *env)
 {
 
-  switch(check_args(env, unknown, empty)) {
-  case 1:
-    printerr(env, "Too Few Arguments");
-    return;
-  case 2:
-    printerr(env, "Bad Argument Type");
-    return;
-  default:
-    break;
-  }
+  if(check_args(env, 1, unknown))
+    return printerr(env);
 
   switch(CAR(env->head)->type){
   case empty:
@@ -82,16 +66,8 @@
 extern void print_(environment *env)
 {
 
-  switch(check_args(env, unknown, empty)) {
-  case 1:
-    printerr(env, "Too Few Arguments");
-    return;
-  case 2:
-    printerr(env, "Bad Argument Type");
-    return;
-  default:
-    break;
-  }
+  if(check_args(env, 1, unknown))
+    return printerr(env);
 
   print_val(env, CAR(env->head), 0, NULL, stdout);
   if(env->err) return;
@@ -111,16 +87,8 @@
 extern void princ_(environment *env)
 {
 
-  switch(check_args(env, unknown, empty)) {
-  case 1:
-    printerr(env, "Too Few Arguments");
-    return;
-  case 2:
-    printerr(env, "Bad Argument Type");
-    return;
-  default:
-    break;
-  }
+  if(check_args(env, 1, unknown))
+    return printerr(env);
 
   print_val(env, CAR(env->head), 1, NULL, stdout);
 }
@@ -137,16 +105,8 @@
 extern void printport_(environment *env)
 {
 
-  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;
-  }
+  if(check_args(env, 2, port, unknown))
+    return printerr(env);
 
   print_val(env, CAR(CDR(env->head)), 0, NULL, CAR(env->head)->content.p);
   if(env->err) return;
@@ -165,16 +125,8 @@
 extern void princport_(environment *env)
 {
 
-  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;
-  }
+  if(check_args(env, 2, port, unknown))
+    return printerr(env);
 
   print_val(env, CAR(CDR(env->head)), 1, NULL, CAR(env->head)->content.p);
   toss(env); if(env->err) return;
@@ -193,16 +145,8 @@
 {
   value *temp= env->head;
 
-  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;
-  }
+  if(check_args(env, 3, unknown, unknown, unknown))
+    return printerr(env);
   
   env->head= CDR(CDR(env->head));
   CDR(CDR(temp))= CDR(env->head);
@@ -214,16 +158,8 @@
 {
   value *temp, *new_head;
 
-  switch(check_args(env, tcons, empty)) {
-  case 1:
-    printerr(env, "Too Few Arguments");
-    return;
-  case 2:
-    printerr(env, "Bad Argument Type");
-    return;
-  default:
-    break;
-  }
+  if(check_args(env, 1, tcons))
+    return printerr(env);
 
   rev(env);
 
@@ -241,9 +177,8 @@
     if (CDR(temp)->type == tcons)
       temp= CDR(temp);
     else {
-      printerr(env, "Bad Argument Type"); /* Improper list */
-      env->err= 2;
-      return;
+      env->err= 2; /* Improper list */
+      return printerr(env); 
     }
   }
 
@@ -258,16 +193,8 @@
 {
   void *left, *right;
 
-  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;
-  }
+  if(check_args(env, 2, unknown, unknown))
+    return printerr(env);
 
   left= CAR(env->head)->content.ptr;
   right= CAR(CDR(env->head))->content.ptr;
@@ -281,16 +208,8 @@
 {
   int val;
 
-  switch(check_args(env, integer, empty)) {
-  case 1:
-    printerr(env, "Too Few Arguments");
-    return;
-  case 2:
-    printerr(env, "Bad Argument Type");
-    return;
-  default:
-    break;
-  }
+  if(check_args(env, 1, integer))
+    return printerr(env);
 
   val= CAR(env->head)->content.i;
   toss(env);
@@ -310,16 +229,8 @@
   symbol *sym;
 
   /* Needs two values on the stack, the top one must be a symbol */
-  switch(check_args(env, symb, unknown, empty)) {
-  case 1:
-    printerr(env, "Too Few Arguments");
-    return;
-  case 2:
-    printerr(env, "Bad Argument Type");
-    return;
-  default:
-    break;
-  }
+  if(check_args(env, 2, symb, unknown))
+    return printerr(env);
 
   /* long names are a pain */
   sym= CAR(env->head)->content.sym;
@@ -341,16 +252,8 @@
 {
   char* sym_id;
 
-  switch(check_args(env, symb, empty)) {
-  case 1:
-    printerr(env, "Too Few Arguments");
-    return;
-  case 2:
-    printerr(env, "Bad Argument Type");
-    return;
-  default:
-    break;
-  }
+  if(check_args(env, 1, symb))
+    return printerr(env);
 
   sym_id= CAR(env->head)->content.sym->id;
   toss(env);
@@ -373,12 +276,7 @@
   char* new_string;
   value *a_val, *b_val;
 
-  if(check_args(env, unknown, unknown, empty)==1) {
-    printerr(env, "Too Few Arguments");
-    return;
-  }
-
-  if(check_args(env, string, string, empty)==0) {
+  if(check_args(env, 2, string, string)==0) {
     a_val= CAR(env->head);
     b_val= CAR(CDR(env->head));
     protect(a_val); protect(b_val);
@@ -396,7 +294,7 @@
     return;
   }
   
-  if(check_args(env, integer, integer, empty)==0) {
+  if(check_args(env, 2, integer, integer)==0) {
     a= CAR(env->head)->content.i;
     toss(env); if(env->err) return;
     b= CAR(env->head)->content.i;
@@ -406,7 +304,7 @@
     return;
   }
 
-  if(check_args(env, tfloat, tfloat, empty)==0) {
+  if(check_args(env, 2, tfloat, tfloat)==0) {
     fa= CAR(env->head)->content.f;
     toss(env); if(env->err) return;
     fb= CAR(env->head)->content.f;
@@ -416,7 +314,7 @@
     return;
   }
 
-  if(check_args(env, tfloat, integer, empty)==0) {
+  if(check_args(env, 2, tfloat, integer)==0) {
     fa= CAR(env->head)->content.f;
     toss(env); if(env->err) return;
     b= CAR(env->head)->content.i;
@@ -426,7 +324,7 @@
     return;
   }
 
-  if(check_args(env, integer, tfloat, empty)==0) {
+  if(check_args(env, 2, integer, tfloat)==0) {
     a= CAR(env->head)->content.i;
     toss(env); if(env->err) return;
     fb= CAR(env->head)->content.f;
@@ -436,8 +334,7 @@
     return;
   }
 
-  printerr(env, "Bad Argument Type");
-  env->err=2;
+  return printerr(env);
 }
 
 /* "-" */
@@ -446,12 +343,7 @@
   int a, b;
   float fa, fb;
 
-  if(check_args(env, unknown, unknown, empty)==1) {
-    printerr(env, "Too Few Arguments");
-    return;
-  }
-
-  if(check_args(env, integer, integer, empty)==0) {
+  if(check_args(env, 2, integer, integer)==0) {
     a= CAR(env->head)->content.i;
     toss(env); if(env->err) return;
     b= CAR(env->head)->content.i;
@@ -461,7 +353,7 @@
     return;
   }
 
-  if(check_args(env, tfloat, tfloat, empty)==0) {
+  if(check_args(env, 2, tfloat, tfloat)==0) {
     fa= CAR(env->head)->content.f;
     toss(env); if(env->err) return;
     fb= CAR(env->head)->content.f;
@@ -471,7 +363,7 @@
     return;
   }
 
-  if(check_args(env, tfloat, integer, empty)==0) {
+  if(check_args(env, 2, tfloat, integer)==0) {
     fa= CAR(env->head)->content.f;
     toss(env); if(env->err) return;
     b= CAR(env->head)->content.i;
@@ -481,7 +373,7 @@
     return;
   }
 
-  if(check_args(env, integer, tfloat, empty)==0) {
+  if(check_args(env, 2, integer, tfloat)==0) {
     a= CAR(env->head)->content.i;
     toss(env); if(env->err) return;
     fb= CAR(env->head)->content.f;
@@ -491,8 +383,7 @@
     return;
   }
 
-  printerr(env, "Bad Argument Type");
-  env->err=2;
+  return printerr(env);
 }
 
 /* ">" */
@@ -501,12 +392,7 @@
   int a, b;
   float fa, fb;
 
-  if(check_args(env, unknown, unknown, empty)==1) {
-    printerr(env, "Too Few Arguments");
-    return;
-  }
-
-  if(check_args(env, integer, integer, empty)==0) {
+  if(check_args(env, 2, integer, integer)==0) {
     a= CAR(env->head)->content.i;
     toss(env); if(env->err) return;
     b= CAR(env->head)->content.i;
@@ -516,7 +402,7 @@
     return;
   }
 
-  if(check_args(env, tfloat, tfloat, empty)==0) {
+  if(check_args(env, 2, tfloat, tfloat)==0) {
     fa= CAR(env->head)->content.f;
     toss(env); if(env->err) return;
     fb= CAR(env->head)->content.f;
@@ -526,7 +412,7 @@
     return;
   }
 
-  if(check_args(env, tfloat, integer, empty)==0) {
+  if(check_args(env, 2, tfloat, integer)==0) {
     fa= CAR(env->head)->content.f;
     toss(env); if(env->err) return;
     b= CAR(env->head)->content.i;
@@ -536,7 +422,7 @@
     return;
   }
 
-  if(check_args(env, integer, tfloat, empty)==0) {
+  if(check_args(env, 2, integer, tfloat)==0) {
     a= CAR(env->head)->content.i;
     toss(env); if(env->err) return;
     fb= CAR(env->head)->content.f;
@@ -546,8 +432,7 @@
     return;
   }
 
-  printerr(env, "Bad Argument Type");
-  env->err= 2;
+  return printerr(env);
 }
 
 /* "<" */
@@ -574,16 +459,8 @@
 /* "dup"; duplicates an item on the stack */
 extern void sx_647570(environment *env)
 {
-  switch(check_args(env, unknown, empty)) {
-  case 1:
-    printerr(env, "Too Few Arguments");
-    return;
-  case 2:
-    printerr(env, "Bad Argument Type");
-    return;
-  default:
-    break;
-  }
+  if(check_args(env, 1, unknown))
+    return printerr(env);
 
   push_val(env, copy_val(env, CAR(env->head)));
 }
@@ -593,16 +470,8 @@
 {
   int truth;
 
-  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;
-  }
+  if(check_args(env, 2, unknown, integer))
+    return printerr(env);
 
   swap(env);
   if(env->err) return;
@@ -623,16 +492,8 @@
 {
   int truth;
 
-  switch(check_args(env, unknown, unknown, integer, empty)) {
-  case 1:
-    printerr(env, "Too Few Arguments");
-    return;
-  case 2:
-    printerr(env, "Bad Argument Type");
-    return;
-  default:
-    break;
-  }
+  if(check_args(env, 3, unknown, unknown, integer))
+    return printerr(env);
 
   rot(env);
   if(env->err) return;
@@ -656,18 +517,8 @@
 extern void sx_656c7365(environment *env)
 {
 
-  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;
-  }
+  if(check_args(env, 5, unknown, symb, unknown, symb, integer))
+    return printerr(env);
 
   /// XXX
 
@@ -675,9 +526,8 @@
      || 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(env, "Bad Argument Type");
     env->err= 2;
-    return;
+    return printerr(env);
   }
 
   swap(env); toss(env); rot(env); toss(env);
@@ -687,24 +537,15 @@
 extern void then(environment *env)
 {
    
-  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;
-  }
+  if(check_args(env, 3, unknown, symb, integer))
+    return printerr(env);
 
   /// XXX
 
   if(CAR(CDR(env->head))->type!=symb
      || strcmp(CAR(CDR(env->head))->content.sym->id, "if")!=0) {
-    printerr(env, "Bad Argument Type");
     env->err= 2;
-    return;
+    return printerr(env);
   }
 
   swap(env); toss(env);
@@ -717,16 +558,8 @@
   int truth;
   value *loop, *test;
 
-  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;
-  }
+  if(check_args(env, 2, unknown, integer))
+    return printerr(env);
 
   loop= CAR(env->head);
   protect(loop);
@@ -743,9 +576,8 @@
     /// XXX
     
     if(CAR(env->head)->type != integer) {
-      printerr(env, "Bad Argument Type");
       env->err= 2;
-      return;
+      return printerr(env);
     }
     
     truth= CAR(env->head)->content.i;
@@ -770,16 +602,8 @@
   value *loop;
   int foo1, foo2;
 
-  switch(check_args(env, unknown, integer, integer, empty)) {
-  case 1:
-    printerr(env, "Too Few Arguments");
-    return;
-  case 2:
-    printerr(env, "Bad Argument Type");
-    return;
-  default:
-    break;
-  }
+  if(check_args(env, 3, unknown, integer, integer))
+    return printerr(env);
 
   loop= CAR(env->head);
   protect(loop);
@@ -816,16 +640,8 @@
   value *loop, *foo;
   value *iterator;
 
-  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;
-  }
+  if(check_args(env, 2, unknown, tcons))
+    return printerr(env);
   
   loop= CAR(env->head);
   protect(loop);
@@ -846,12 +662,13 @@
     if (iterator->type == tcons){
       iterator= CDR(iterator);
     } else {
-      printerr(env, "Bad Argument Type"); /* Improper list */
-      env->err= 2;
+      env->err= 2; /* Improper list */
       break;
     }
   }
   unprotect(loop); unprotect(foo);
+  
+  return printerr(env);
 }
 
 /* "to" */
@@ -860,16 +677,8 @@
   int ending, start, i;
   value *iterator, *temp, *end;
 
-  switch(check_args(env, integer, integer, empty)) {
-  case 1:
-    printerr(env, "Too Few Arguments");
-    return;
-  case 2:
-    printerr(env, "Bad Argument Type");
-    return;
-  default:
-    break;
-  }
+  if(check_args(env, 2, integer, integer))
+    return printerr(env);
 
   end= new_val(env);
 
@@ -926,16 +735,8 @@
 {
   FILE *stream;
 
-  switch(check_args(env, port, empty)) {
-  case 1:
-    printerr(env, "Too Few Arguments");
-    return;
-  case 2:
-    printerr(env, "Bad Argument Type");
-    return;
-  default:
-    break;
-  }
+  if(check_args(env, 1, port))
+    return printerr(env);
 
   stream=CAR(env->head)->content.p;
   readlinestream(env, stream); if(env->err) return;
@@ -955,16 +756,8 @@
 {
   FILE *stream;
 
-  switch(check_args(env, port, empty)) {
-  case 1:
-    printerr(env, "Too Few Arguments");
-    return;
-  case 2:
-    printerr(env, "Bad Argument Type");
-    return;
-  default:
-    break;
-  }
+  if(check_args(env, 1, port))
+    return printerr(env);
 
   stream=CAR(env->head)->content.p;
   readstream(env, stream); if(env->err) return;
@@ -978,16 +771,8 @@
 {
   int freq, dur, period, ticks;
 
-  switch(check_args(env, integer, integer, empty)) {
-  case 1:
-    printerr(env, "Too Few Arguments");
-    return;
-  case 2:
-    printerr(env, "Bad Argument Type");
-    return;
-  default:
-    break;
-  }
+  if(check_args(env, 2, integer, integer))
+    return printerr(env);
 
   dur= CAR(env->head)->content.i;
   toss(env);
@@ -1007,9 +792,8 @@
     usleep(dur);
     return;
   case -1:
-    perror("beep");
     env->err= 5;
-    return;
+    return printerr(env);
   default:
     abort();
   }
@@ -1021,16 +805,8 @@
 {
   int dur;
 
-  switch(check_args(env, integer, empty)) {
-  case 1:
-    printerr(env, "Too Few Arguments");
-    return;
-  case 2:
-    printerr(env, "Bad Argument Type");
-    return;
-  default:
-    break;
-  }
+  if(check_args(env, 1, integer))
+    return printerr(env);
 
   dur= CAR(env->head)->content.i;
   toss(env);
@@ -1038,8 +814,6 @@
   usleep(dur);
 }
 
-/// XXXXXX
-
 
 /* "*" */
 extern void sx_2a(environment *env)
@@ -1047,14 +821,7 @@
   int a, b;
   float fa, fb;
 
-  if(env->head->type==empty || CDR(env->head)->type==empty) {
-    printerr(env, "Too Few Arguments");
-    env->err= 1;
-    return;
-  }
-  
-  if(CAR(env->head)->type==integer
-     && CAR(CDR(env->head))->type==integer) {
+  if(check_args(env, 2, integer, integer)==0) {
     a= CAR(env->head)->content.i;
     toss(env); if(env->err) return;
     b= CAR(env->head)->content.i;
@@ -1064,8 +831,7 @@
     return;
   }
 
-  if(CAR(env->head)->type==tfloat
-     && CAR(CDR(env->head))->type==tfloat) {
+  if(check_args(env, 2, tfloat, tfloat)==0) {
     fa= CAR(env->head)->content.f;
     toss(env); if(env->err) return;
     fb= CAR(env->head)->content.f;
@@ -1075,8 +841,7 @@
     return;
   }
 
-  if(CAR(env->head)->type==tfloat
-     && CAR(CDR(env->head))->type==integer) {
+  if(check_args(env, 2, tfloat, integer)==0) {
     fa= CAR(env->head)->content.f;
     toss(env); if(env->err) return;
     b= CAR(env->head)->content.i;
@@ -1086,8 +851,7 @@
     return;
   }
 
-  if(CAR(env->head)->type==integer
-     && CAR(CDR(env->head))->type==tfloat) {
+  if(check_args(env, 2, integer, tfloat)==0) {
     a= CAR(env->head)->content.i;
     toss(env); if(env->err) return;
     fb= CAR(env->head)->content.f;
@@ -1097,8 +861,7 @@
     return;
   }
 
-  printerr(env, "Bad Argument Type");
-  env->err= 2;
+  return printerr(env);
 }
 
 /* "/" */
@@ -1107,14 +870,7 @@
   int a, b;
   float fa, fb;
 
-  if(env->head->type==empty || CDR(env->head)->type==empty) {
-    printerr(env, "Too Few Arguments");
-    env->err= 1;
-    return;
-  }
-  
-  if(CAR(env->head)->type==integer
-     && CAR(CDR(env->head))->type==integer) {
+  if(check_args(env, 2, integer, integer)==0) {
     a= CAR(env->head)->content.i;
     toss(env); if(env->err) return;
     b= CAR(env->head)->content.i;
@@ -1124,8 +880,7 @@
     return;
   }
 
-  if(CAR(env->head)->type==tfloat
-     && CAR(CDR(env->head))->type==tfloat) {
+  if(check_args(env, 2, tfloat, tfloat)==0) {
     fa= CAR(env->head)->content.f;
     toss(env); if(env->err) return;
     fb= CAR(env->head)->content.f;
@@ -1135,8 +890,7 @@
     return;
   }
 
-  if(CAR(env->head)->type==tfloat
-     && CAR(CDR(env->head))->type==integer) {
+  if(check_args(env, 2, tfloat, integer)==0) {
     fa= CAR(env->head)->content.f;
     toss(env); if(env->err) return;
     b= CAR(env->head)->content.i;
@@ -1146,8 +900,7 @@
     return;
   }
 
-  if(CAR(env->head)->type==integer
-     && CAR(CDR(env->head))->type==tfloat) {
+  if(check_args(env, 2, integer, tfloat)==0) {
     a= CAR(env->head)->content.i;
     toss(env); if(env->err) return;
     fb= CAR(env->head)->content.f;
@@ -1157,8 +910,7 @@
     return;
   }
 
-  printerr(env, "Bad Argument Type");
-  env->err= 2;
+  return printerr(env);
 }
 
 /* "mod" */
@@ -1166,14 +918,7 @@
 {
   int a, b;
 
-  if(env->head->type==empty || CDR(env->head)->type==empty) {
-    printerr(env, "Too Few Arguments");
-    env->err= 1;
-    return;
-  }
-  
-  if(CAR(env->head)->type==integer
-     && CAR(CDR(env->head))->type==integer) {
+  if(check_args(env, 2, integer, integer)==0) {
     a= CAR(env->head)->content.i;
     toss(env); if(env->err) return;
     b= CAR(env->head)->content.i;
@@ -1183,49 +928,31 @@
     return;
   }
 
-  printerr(env, "Bad Argument Type");
-  env->err= 2;
+  return printerr(env);
 }
 
+
 /* "div" */
 extern void sx_646976(environment *env)
 {
   int a, b;
-  
-  if(env->head->type==empty || CDR(env->head)->type==empty) {
-    printerr(env, "Too Few Arguments");
-    env->err= 1;
-    return;
-  }
 
-  if(CAR(env->head)->type==integer
-     && CAR(CDR(env->head))->type==integer) {
-    a= CAR(env->head)->content.i;
-    toss(env); if(env->err) return;
-    b= CAR(env->head)->content.i;
-    toss(env); if(env->err) return;
-    push_int(env, (int)b/a);
-
-    return;
-  }
-
-  printerr(env, "Bad Argument Type");
-  env->err= 2;
+  if(check_args(env, 2, integer, integer))
+    return printerr(env);
+  
+  a= CAR(env->head)->content.i;
+  toss(env); if(env->err) return;
+  b= CAR(env->head)->content.i;
+  toss(env); if(env->err) return;
+  push_int(env, (int)b/a);
 }
 
+
 extern void setcar(environment *env)
 {
-  if(env->head->type==empty || CDR(env->head)->type==empty) {
-    printerr(env, "Too Few Arguments");
-    env->err= 1;
-    return;
-  }
 
-  if(CDR(env->head)->type!=tcons) {
-    printerr(env, "Bad Argument Type");
-    env->err= 2;
-    return;
-  }
+  if(check_args(env, 2, tcons, unknown))
+    return printerr(env);
 
   CAR(CAR(CDR(env->head)))=CAR(env->head);
   toss(env);
@@ -1233,17 +960,9 @@
 
 extern void setcdr(environment *env)
 {
-  if(env->head->type==empty || CDR(env->head)->type==empty) {
-    printerr(env, "Too Few Arguments");
-    env->err= 1;
-    return;
-  }
 
-  if(CDR(env->head)->type!=tcons) {
-    printerr(env, "Bad Argument Type");
-    env->err= 2;
-    return;
-  }
+  if(check_args(env, 2, tcons, unknown))
+    return printerr(env);
 
   CDR(CAR(CDR(env->head)))=CAR(env->head);
   toss(env);
@@ -1251,34 +970,18 @@
 
 extern void car(environment *env)
 {
-  if(env->head->type==empty) {
-    printerr(env, "Too Few Arguments");
-    env->err= 1;
-    return;
-  }
 
-  if(CAR(env->head)->type!=tcons) {
-    printerr(env, "Bad Argument Type");
-    env->err= 2;
-    return;
-  }
+  if(check_args(env, 1, tcons))
+    return printerr(env);
 
   CAR(env->head)=CAR(CAR(env->head));
 }
 
 extern void cdr(environment *env)
 {
-  if(env->head->type==empty) {
-    printerr(env, "Too Few Arguments");
-    env->err= 1;
-    return;
-  }
 
-  if(CAR(env->head)->type!=tcons) {
-    printerr(env, "Bad Argument Type");
-    env->err= 2;
-    return;
-  }
+  if(check_args(env, 1, tcons))
+    return printerr(env);
 
   CAR(env->head)=CDR(CAR(env->head));
 }
@@ -1287,11 +990,8 @@
 {
   value *val;
 
-  if(env->head->type==empty || CDR(env->head)->type==empty) {
-    printerr(env, "Too Few Arguments");
-    env->err= 1;
-    return;
-  }
+  if(check_args(env, 2, unknown, unknown))
+    return printerr(env);
 
   val=new_val(env);
   val->content.c= malloc(sizeof(pair));
@@ -1308,7 +1008,7 @@
   swap(env); if(env->err) return;
   toss(env); if(env->err) return;
   swap(env); if(env->err) return;
-  toss(env); if(env->err) return;
+  toss(env);
 }
 
 
@@ -1319,42 +1019,25 @@
 
   /* 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(env, "Too Few Arguments");
-    env->err= 1;
-    return;
-  }
-
-  if(CAR(env->head)->type!=tcons) {
-    printerr(env, "Bad Argument Type");
-    env->err= 2;
-    return;
-  }
+  if(check_args(env, 2, tcons, unknown))
+    return printerr(env);
 
   key=CAR(CDR(env->head));
   item=CAR(env->head);
 
   while(item->type == tcons){
     if(CAR(item)->type != tcons){
-      printerr(env, "Bad Argument Type");
       env->err= 2;
-      return;
+      return printerr(env);
     }
+
     push_val(env, key);
     push_val(env, CAR(CAR(item)));
-    eqfunc(env); if(env->err) return;
+    eqfunc((void*)env); if(env->err) return;
 
     /* Check the result of 'eqfunc' */
-    if(env->head->type==empty) {
-      printerr(env, "Too Few Arguments");
-      env->err= 1;
-    return;
-    }
-    if(CAR(env->head)->type!=integer) {
-      printerr(env, "Bad Argument Type");
-      env->err= 2;
-      return;
-    }
+    if(check_args(env, 1, integer))
+      return printerr(env);
 
     if(CAR(env->head)->content.i){
       toss(env); if(env->err) return;
@@ -1363,9 +1046,8 @@
     toss(env); if(env->err) return;
 
     if(item->type!=tcons) {
-      printerr(env, "Bad Argument Type");
       env->err= 2;
-      return;
+      return printerr(env);
     }
 
     item=CDR(item);
@@ -1387,7 +1069,7 @@
 /*  1: [ [ 1 . 2 ] [ 3 . 4 ] ]  =>  1: [ 3 . 4 ]  */
 extern void assq(environment *env)
 {
-  assocgen(env, eq);
+  assocgen(env, (void*)eq);
 }
 
 
@@ -1406,26 +1088,15 @@
   value *new_port;
   FILE *stream;
 
-  if(env->head->type == empty || CDR(env->head)->type == empty) {
-    printerr(env, "Too Few Arguments");
-    env->err=1;
-    return;
-  }
-
-  if(CAR(env->head)->type != string
-     || CAR(CDR(env->head))->type != string) {
-    printerr(env, "Bad Argument Type");
-    env->err= 2;
-    return;
-  }
+  if(check_args(env, 2, string, string))
+    return printerr(env);
 
   stream=fopen(CAR(CDR(env->head))->content.ptr,
 	       CAR(env->head)->content.ptr);
 
   if(stream == NULL) {
-    perror("open");
     env->err= 5;
-    return;
+    return printerr(env);
   }
 
   new_port=new_val(env);
@@ -1446,44 +1117,26 @@
 {
   int ret;
 
-  if(env->head->type == empty) {
-    printerr(env, "Too Few Arguments");
-    env->err=1;
-    return;
-  }
-
-  if(CAR(env->head)->type != port) {
-    printerr(env, "Bad Argument Type");
-    env->err= 2;
-    return;
-  }
+  if(check_args(env, 1, port))
+    return printerr(env);
 
   ret= fclose(CAR(env->head)->content.p);
 
   if(ret != 0){
-    perror("close");
     env->err= 5;
-    return;
+    return printerr(env);
   }
 
   toss(env);
 }
 
+
 extern void mangle(environment *env)
 {
   char *new_string;
 
-  if(env->head->type==empty) {
-    printerr(env, "Too Few Arguments");
-    env->err= 1;
-    return;
-  }
-
-  if(CAR(env->head)->type!=string) {
-    printerr(env, "Bad Argument Type");
-    env->err= 2;
-    return;
-  }
+  if(check_args(env, 1, string))
+    return printerr(env);
 
   new_string= mangle_str(CAR(env->head)->content.string);
 
@@ -1503,17 +1156,8 @@
 extern void sx_77616974706964(environment *env)
 {
 
-  if(env->head->type==empty) {
-    printerr(env, "Too Few Arguments");
-    env->err= 1;
-    return;
-  }
-
-  if(CAR(env->head)->type!=integer) {
-    printerr(env, "Bad Argument Type");
-    env->err= 2;
-    return;
-  }
+  if(check_args(env, 1, integer))
+    return printerr(env);
 
   push_int(env, waitpid(CAR(env->head)->content.i, NULL, 0));
   swap(env); toss(env);
@@ -1523,12 +1167,10 @@
 /* Discard the top element of the stack. */
 extern void toss(environment *env)
 {
-  if(env->head->type==empty) {
-    printerr(env, "Too Few Arguments");
-    env->err= 1;
-    return;
-  }
-  
+
+  if(check_args(env, 1, unknown))
+    return printerr(env);
+
   env->head= CDR(env->head); /* Remove the top stack item */
 }
 
@@ -1609,11 +1251,124 @@
 
 extern void copying(environment *env)
 {
-  printf(license_message);
+  puts(license_message);
 }
 
 
 extern void warranty(environment *env)
 {
-  printf(warranty_message);
+  puts(warranty_message);
+}
+
+
+/* random */
+extern void sx_72616e646f6d(environment *env)
+{
+  push_int(env, (int)rand());
+}
+
+
+extern void seed(environment *env)
+{
+  if(check_args(env, 1, integer))
+    return printerr(env);
+
+  srand(CAR(env->head)->content.i);
+  toss(env);
+}
+
+
+extern void ticks(environment *env)
+{
+  int val;
+
+  val= (int)time(NULL);
+  if(val<0) {
+    env->err= 5;
+    return printerr(env);
+  }
+  
+  return push_int(env, val);
+}
+
+
+extern void push(environment *env)
+{
+  symbol *sym;
+  value *oldval;
+  value *newval;
+
+  if(check_args(env, 2, symb, unknown)==0) {
+    sym= CAR(env->head)->content.sym;
+    oldval= sym->val;
+  
+    if(oldval==NULL)
+      oldval= new_val(env);
+
+    sym->val= new_val(env);
+    sym->val->content.c= malloc(sizeof(pair));
+    assert(sym->val->content.c!=NULL);
+    env->gc_count += sizeof(pair);
+    sym->val->type= tcons;
+    CDR(sym->val)= oldval;
+    CAR(sym->val)= CAR(CDR(env->head));
+    env->head= CDR(CDR(env->head));
+
+    return;
+  }
+
+  if(check_args(env, 2, tcons, unknown)==0
+     || check_args(env, 2, empty, unknown)==0) {
+    oldval= CAR(env->head);
+    env->head= CDR(env->head);
+    newval= new_val(env);
+    newval->content.c= malloc(sizeof(pair));
+    assert(newval->content.c!=NULL);
+    env->gc_count += sizeof(pair);
+    newval->type= tcons;
+    CDR(newval)= oldval;
+    CAR(newval)= CAR(env->head);
+    env->head= CDR(env->head);
+    push_val(env, newval);
+    
+    return;
+  }
+
+  return printerr(env);
+}
+
+
+extern void pop(environment *env)
+{
+  symbol *sym;
+  value *val;
+
+  if(check_args(env, 1, symb)==0) {
+    sym= CAR(env->head)->content.sym;
+
+    if(sym->val==NULL) {
+      env->err= 3;
+      return printerr(env);
+    }
+
+    env->head= CDR(env->head);
+    if(sym->val->type==tcons) {
+      push_val(env, CAR(sym->val));
+      sym->val= CDR(sym->val);
+    } else {
+      env->err= 2;
+      return printerr(env);
+    }
+
+    return;
+  }
+
+  if(check_args(env, 1, tcons)==0) {
+    val= CAR(env->head);
+    env->head= CDR(env->head);
+    push_val(env, CAR(val));
+    return;
+  }
+
+  return printerr(env);
 }