--- stack/stack.c	2002/02/08 06:23:19	1.62
+++ stack/stack.c	2002/02/11 22:07:47	1.71
@@ -59,6 +59,7 @@
   hashtbl symbols;		/* Hash table of all variable bindings */
   int err;			/* Error flag */
   int non_eval_flag;
+  char *in_string;		/* Input pending to be read */
 } environment;
 
 /* A type for pointers to external functions */
@@ -70,6 +71,7 @@
 {
   int i;
 
+  env->in_string= NULL;
   env->err= 0;
   env->non_eval_flag= 0;
   for(i= 0; i<HASHTBLSIZE; i++)
@@ -478,8 +480,6 @@
   push_val(&(env->head), val); /* Return its bound value */
 }
 
-void stack_read(environment*, char*);
-
 /* If the top element is a symbol, determine if it's bound to a
    function value, and if it is, toss the symbol and execute the
    function. */
@@ -488,7 +488,6 @@
   funcp in_func;
   value* temp_val;
   stackitem* iterator;
-  char* temp_string;
 
   if(env->head==NULL) {
     printerr("Too Few Arguments");
@@ -496,13 +495,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 +529,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;
@@ -538,22 +539,7 @@
     free_val(temp_val);
     return;
 
-    /* If it's a string */
-  case string:
-    temp_val= env->head->item;
-    env->head->item->refcount++;
-    toss(env);
-    if(env->err) return;
-    temp_string= malloc(strlen((char*)temp_val->content.ptr)+5);
-    strcpy(temp_string, "[ ");
-    strcpy(temp_string+2, (char*)temp_val->content.ptr);
-    free_val(temp_val);
-    strcat(temp_string, " ]");
-    stack_read(env, temp_string);
-    free(temp_string);
-    return eval(env);
-
-  case integer:
+  default:
     return;
   }
 }
@@ -628,85 +614,6 @@
   rev(env);
 }
 
-/* Parse input. */
-void stack_read(environment *env, char *in_line) 
-{
-  char *temp, *rest;
-  int itemp;
-  size_t inlength= strlen(in_line)+1;
-  int convert= 0;
-
-  temp= malloc(inlength);
-  rest= malloc(inlength);
-
-  do {
-    /* If comment */
-    if((convert= sscanf(in_line, "#%[^\n\r]", rest))) {
-      free(temp); free(rest);
-      return;
-    }
-
-    /* If string */
-    if((convert= sscanf(in_line, "\"%[^\"\n\r]\" %[^\n\r]", temp, rest))) {
-      push_cstring(&(env->head), temp);
-      break;
-    }
-    /* If integer */
-    if((convert= sscanf(in_line, "%d %[^\n\r]", &itemp, rest))) {
-      push_int(&(env->head), itemp);
-      break;
-    }
-    /* Escape ';' with '\' */
-    if((convert= sscanf(in_line, "\\%c%[^\n\r]", temp, rest))) {
-      temp[1]= '\0';
-      push_sym(env, temp);
-      break;
-    } 
-    /* If symbol */
-    if((convert= sscanf(in_line, "%[^][ ;\n\r]%[^\n\r]", temp, rest))) {
-	push_sym(env, temp);
-	break;
-    }
-    /* If single char */
-    if((convert= sscanf(in_line, "%c%[^\n\r]", temp, rest))) {
-      if(*temp==';') {
-	if(!env->non_eval_flag) {
-	  eval(env);		/* Evaluate top element */
-	  break;
-	}
-	
-	push_sym(env, ";");
-	break;
-      }
-
-      if(*temp==']') {
-	push_sym(env, "[");
-	pack(env);
-	if(env->non_eval_flag)
-	  env->non_eval_flag--;
-	break;
-      }
-
-      if(*temp=='[') {
-	push_sym(env, "[");
-	env->non_eval_flag++;
-	break;
-      }
-    }
-  } while(0);
-
-  free(temp);
-
-  if(convert<2) {
-    free(rest);
-    return;
-  }
-   
-  stack_read(env, rest);
-  
-  free(rest);
-}
-
 /* Relocate elements of the list on the stack. */
 extern void expand(environment *env)
 {
@@ -894,22 +801,27 @@
   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) {
+    if(myenv.in_string==NULL)
+      printstack(&myenv);
+    read(&myenv);
     if(myenv.err) {
       printf("(error %d) ", myenv.err);
       myenv.err=0;
+    } else if(myenv.head!=NULL
+	      && 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 +1061,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 +1069,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 +1088,158 @@
     }
     
     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!$%*+./:<=>?@^_~-]%[\001-\377]";
+  const char strform[]= "\"%[^\"]\"%[\001-\377]";
+  const char intform[]= "%i%[\001-\377]";
+  const char blankform[]= "%*[ \t]%[\001-\377]";
+  const char ebrackform[]= "%*1[]]%[\001-\377]";
+  const char semicform[]= "%*1[;]%[\001-\377]";
+  const char bbrackform[]= "%*1[[]%[\001-\377]";
+
+  int itemp;
+  static int depth= 0;
+  char *rest, *match;
+  size_t inlength;
+
+  if(env->in_string==NULL) {
+    readline(env); if(env->err) return;
+    
+    env->in_string= malloc(strlen(env->head->item->content.ptr)+1);
+    strcpy(env->in_string, env->head->item->content.ptr);
+    toss(env); if(env->err) return;
+  }
+  
+  inlength= strlen(env->in_string)+1;
+  match= malloc(inlength);
+  rest= malloc(inlength);
+
+  if(sscanf(env->in_string, blankform, rest)) {
+    ; 
+  } else if(sscanf(env->in_string, intform, &itemp, rest) > 0) {
+    push_int(&(env->head), itemp);
+  } else if(sscanf(env->in_string, strform, match, rest) > 0) {
+    push_cstring(&(env->head), match);
+  } else if(sscanf(env->in_string, symbform, match, rest) > 0) {
+    push_sym(env, match);
+  } else if(sscanf(env->in_string, ebrackform, rest) > 0) {
+    push_sym(env, "[");
+    pack(env); if(env->err) return;
+    if(depth!=0) depth--;
+  } else if(sscanf(env->in_string, semicform, rest) > 0) {
+    push_sym(env, ";");
+  } else if(sscanf(env->in_string, bbrackform, rest) > 0) {
+    push_sym(env, "[");
+    depth++;
+  } else {
+    free(rest);
+    rest= NULL;
+  }
+      
+  free(env->in_string);
+  free(match);
+
+  env->in_string= rest;
+
+  if(depth)
+    return read(env);
 }