--- stack/stack.c	2002/02/08 06:23:19	1.62
+++ stack/stack.c	2002/02/11 00:54:04	1.69
@@ -496,13 +496,15 @@
     return;
   }
 
+ eval_start:
+
   switch(env->head->item->type) {
     /* if it's a symbol */
   case symb:
     rcl(env);			/* get its contents */
     if(env->err) return;
     if(env->head->item->type!=symb){ /* don't recurse symbols */
-      return eval(env);		/* evaluate the value */
+      goto eval_start;
     }
     return;
 
@@ -528,7 +530,7 @@
 	if(env->err) return;
 	if(iterator->next == NULL){
 	  free_val(temp_val);
-	  return eval(env);
+	  goto eval_start;
 	}
 	eval(env);
 	if(env->err) return;
@@ -551,7 +553,7 @@
     strcat(temp_string, " ]");
     stack_read(env, temp_string);
     free(temp_string);
-    return eval(env);
+    goto eval_start;
 
   case integer:
     return;
@@ -894,22 +896,25 @@
   push_int(&(env->head), env->err);
 }
 
+extern void read(environment*);
+
 int main()
 {
   environment myenv;
-  char in_string[100];
 
   init_env(&myenv);
 
-  printf("okidok\n ");
-
-  while(fgets(in_string, 100, stdin) != NULL) {
-    stack_read(&myenv, in_string);
+  while(1) {
+    fprintf(stderr, "okidok\n ");
+    read(&myenv);
     if(myenv.err) {
       printf("(error %d) ", myenv.err);
       myenv.err=0;
+    } else if(myenv.head->item->type==symb
+	      && ((symbol*)(myenv.head->item->content.ptr))->id[0]==';') {
+      toss(&myenv); 		/* No error check in main */
+      eval(&myenv);
     }
-    printf("okidok\n ");
   }
   quit(&myenv);
   return EXIT_FAILURE;
@@ -1149,6 +1154,7 @@
 extern void sx_7768696c65(environment *env) {
 
   int truth;
+  value *loop, *test;
 
   if((env->head)==NULL || env->head->next==NULL) {
     printerr("Too Few Arguments");
@@ -1156,10 +1162,17 @@
     return;
   }
 
+  loop= env->head->item;
+  loop->refcount++;
+  toss(env); if(env->err) return;
+
+  test= env->head->item;
+  test->refcount++;
+  toss(env); if(env->err) return;
+
   do {
-    swap(env); if(env->err) return;
-    dup(env); if(env->err) return;
-    eval(env); if(env->err) return;
+    push_val(&(env->head), test);
+    eval(env);
     
     if(env->head->item->type != integer) {
       printerr("Bad Argument Type");
@@ -1168,17 +1181,160 @@
     }
     
     truth= env->head->item->content.val;
-    
     toss(env); if(env->err) return;
-    swap(env); if(env->err) return;
     
     if(truth) {
-      dup(env);
+      push_val(&(env->head), loop);
       eval(env);
     } else {
       toss(env);
-      toss(env);
     }
   
   } while(truth);
+
+  free_val(test);
+  free_val(loop);
+}
+
+/* For-loop */
+extern void sx_666f72(environment *env) {
+  
+  value *loop, *foo;
+  stackitem *iterator;
+  
+  if((env->head)==NULL || env->head->next==NULL) {
+    printerr("Too Few Arguments");
+    env->err=1;
+    return;
+  }
+
+  if(env->head->next->item->type != list) {
+    printerr("Bad Argument Type");
+    env->err=2;
+    return;
+  }
+
+  loop= env->head->item;
+  loop->refcount++;
+  toss(env); if(env->err) return;
+
+  foo= env->head->item;
+  foo->refcount++;
+  toss(env); if(env->err) return;
+
+  iterator= foo->content.ptr;
+
+  while(iterator!=NULL) {
+    push_val(&(env->head), iterator->item);
+    push_val(&(env->head), loop);
+    eval(env); if(env->err) return;
+    iterator= iterator->next;
+  }
+
+  free_val(loop);
+  free_val(foo);
+}
+
+/* 'to' */
+extern void to(environment *env) {
+  int i, start, ending;
+  
+  if((env->head)==NULL || env->head->next==NULL) {
+    printerr("Too Few Arguments");
+    env->err=1;
+    return;
+  }
+
+  if(env->head->item->type!=integer 
+     || env->head->next->item->type!=integer) {
+    printerr("Bad Argument Type");
+    env->err=2;
+    return;
+  }
+
+  ending= env->head->item->content.val;
+  toss(env); if(env->err) return;
+  start= env->head->item->content.val;
+  toss(env); if(env->err) return;
+
+  push_sym(env, "[");
+
+  if(ending>=start) {
+    for(i= start; i<=ending; i++)
+      push_int(&(env->head), i);
+  } else {
+    for(i= start; i>=ending; i--)
+      push_int(&(env->head), i);
+  }
+
+  push_sym(env, "[");
+  pack(env); if(env->err) return;
+}
+
+/* Read a string */
+extern void readline(environment *env) {
+  char in_string[101];
+
+  fgets(in_string, 100, stdin);
+  push_cstring(&(env->head), in_string);
+}
+
+/* Read a value and place on stack */
+extern void read(environment *env) {
+  const char symbform[]= "%[a-zA-Z0-9!$%*+./:<=>?@^_~-]%100c";
+  const char strform[]= "\"%[^\"]\"%100c";
+  const char intform[]= "%i%100c";
+  const char blankform[]= "%*[ \t]%100c";
+  const char ebrackform[]= "%*1[]]%100c";
+  const char semicform[]= "%*1[;]%100c";
+  const char bbrackform[]= "%*1[[]%100c";
+
+  int itemp, rerun= 0;
+  static int depth= 0;
+  char *rest, *match;
+  static char *in_string= NULL;
+  size_t inlength;
+
+  if(in_string==NULL) {
+    readline(env); if(env->err) return;
+    
+    in_string= malloc(strlen(env->head->item->content.ptr)+1);
+    strcpy(in_string, env->head->item->content.ptr);
+    toss(env); if(env->err) return;
+  }
+  
+  inlength= strlen(in_string)+1;
+  match= malloc(inlength);
+  rest= malloc(inlength);
+
+  if(sscanf(in_string, blankform, rest)) {
+    rerun= 1;    
+  } else if(sscanf(in_string, intform, &itemp, rest) > 0) {
+    push_int(&(env->head), itemp);
+  } else if(sscanf(in_string, strform, match, rest) > 0) {
+    push_cstring(&(env->head), match);
+  } else if(sscanf(in_string, symbform, match, rest) > 0) {
+    push_sym(env, match);
+  } else if(sscanf(in_string, ebrackform, rest) > 0) {
+    push_sym(env, "[");
+    pack(env); if(env->err) return;
+    if(depth!=0) depth--;
+  } else if(sscanf(in_string, semicform, rest) > 0) {
+    push_sym(env, ";");
+  } else if(sscanf(in_string, bbrackform, rest) > 0) {
+    push_sym(env, "[");
+    depth++;
+  } else {
+    free(rest);
+    rest= NULL;
+    rerun= 1;
+  }
+      
+  free(in_string);
+  free(match);
+
+  in_string= rest;
+
+  if(rerun || depth)
+    return read(env);
 }