--- stack/stack.c	2002/02/12 22:13:12	1.72
+++ stack/stack.c	2002/02/13 19:53:55	1.77
@@ -155,49 +155,39 @@
   }
 }
 
-/* Generic push function. */
-void push(environment *env, stackitem* in_item)
-{
-  in_item->next= env->head;
-  env->head= in_item;
-}
-
 /* Push a value onto the stack */
 void push_val(environment *env, value *val)
 {
   stackitem *new_item= malloc(sizeof(stackitem));
   new_item->item= val;
   val->refcount++;
-  push(env, new_item);
+  new_item->next= env->head;
+  env->head= new_item;
 }
 
 /* Push an integer onto the stack. */
 void push_int(environment *env, int in_val) 
 {
   value *new_value= malloc(sizeof(value));
-  stackitem *new_item= malloc(sizeof(stackitem));
-  new_item->item= new_value;
   
   new_value->content.val= in_val;
   new_value->type= integer;
   new_value->refcount=1;
 
-  push(env, new_item);
+  push_val(env, new_value);
 }
 
 /* Copy a string onto the stack. */
 void push_cstring(environment *env, const char *in_string)
 {
   value *new_value= malloc(sizeof(value));
-  stackitem *new_item= malloc(sizeof(stackitem));
-  new_item->item=new_value;
 
   new_value->content.ptr= malloc(strlen(in_string)+1);
   strcpy(new_value->content.ptr, in_string);
   new_value->type= string;
   new_value->refcount=1;
 
-  push(env, new_item);
+  push_val(env, new_value);
 }
 
 /* Mangle a symbol name to a valid C identifier name */
@@ -252,8 +242,6 @@
 /* Push a symbol onto the stack. */
 void push_sym(environment *env, const char *in_string)
 {
-  stackitem *new_item;		/* The new stack item */
-  /* ...which will contain... */
   value *new_value;		/* A new symbol value */
   /* ...which might point to... */
   symbol **new_symbol;		/* (if needed) A new actual symbol */
@@ -266,10 +254,7 @@
   const char *dlerr;		/* Dynamic linker error */
   char *mangled;		/* Mangled function name */
 
-  /* Create a new stack item containing a new value */
-  new_item= malloc(sizeof(stackitem));
   new_value= malloc(sizeof(value));
-  new_item->item=new_value;
 
   /* The new value is a symbol */
   new_value->type= symb;
@@ -313,7 +298,7 @@
       new_fvalue->refcount= 1;
     }
   }
-  push(env, new_item);
+  push_val(env, new_value);
 }
 
 /* Print newline. */
@@ -546,7 +531,7 @@
 
 /* Reverse (flip) a list */
 extern void rev(environment *env){
-  stackitem *old_head, *new_head, *item;
+  stackitem *item, *temp, *prev= NULL;
 
   if((env->head)==NULL) {
     printerr("Too Few Arguments");
@@ -560,36 +545,36 @@
     return;
   }
 
-  old_head=(stackitem *)(env->head->item->content.ptr);
-  new_head=NULL;
-  while(old_head != NULL){
-    item=old_head;
-    old_head=old_head->next;
-    item->next=new_head;
-    new_head=item;
+  item= (stackitem *)(env->head->item->content.ptr);
+  while(item->next!=NULL){
+    temp= item->next;
+    item->next= prev;
+    prev= item;
+    item= temp;
   }
-  env->head->item->content.ptr=new_head;
+  item->next= prev;
+
+  env->head->item->content.ptr=item;
 }
 
 /* Make a list. */
 extern void pack(environment *env)
 {
-  void* delimiter;
   stackitem *iterator, *temp;
   value *pack;
 
-  delimiter= env->head->item->content.ptr; /* Get delimiter */
-  toss(env);
-
   iterator= env->head;
 
-  if(iterator==NULL || iterator->item->content.ptr==delimiter) {
+  if(iterator==NULL
+     || (iterator->item->type==symb
+     && ((symbol*)(iterator->item->content.ptr))->id[0]=='[')) {
     temp= NULL;
     toss(env);
   } else {
     /* Search for first delimiter */
     while(iterator->next!=NULL
-	  && iterator->next->item->content.ptr!=delimiter)
+	  && (iterator->next->item->type!=symb
+	  || ((symbol*)(iterator->next->item->content.ptr))->id[0]!='['))
       iterator= iterator->next;
     
     /* Extract list */
@@ -607,10 +592,7 @@
   pack->content.ptr= temp;
   pack->refcount= 1;
 
-  temp= malloc(sizeof(stackitem));
-  temp->item= pack;
-
-  push(env, temp);
+  push_val(env, pack);
   rev(env);
 }
 
@@ -735,9 +717,22 @@
   toss(env); toss(env);
 } 
 
+extern void clear(environment *);
+void forget_sym(symbol **);
+
 /* Quit stack. */
 extern void quit(environment *env)
 {
+  long i;
+
+  clear(env);
+  if (env->err) return;
+  for(i= 0; i<HASHTBLSIZE; i++) {
+    if (env->symbols[i]!= NULL) {
+      forget_sym(&(env->symbols[i]));
+      env->symbols[i]= NULL;
+    }
+  }
   exit(EXIT_SUCCESS);
 }
 
@@ -763,12 +758,25 @@
   }
 }
 
+/* Internal forget function */
+void forget_sym(symbol **hash_entry) {
+  symbol *temp;
+
+  temp= *hash_entry;
+  *hash_entry= (*hash_entry)->next;
+  
+  if(temp->val!=NULL) {
+    free_val(temp->val);
+  }
+  free(temp->id);
+  free(temp);
+}
+
 /* Forgets a symbol (remove it from the hash table) */
 extern void forget(environment *env)
 {
   char* sym_id;
   stackitem *stack_head= env->head;
-  symbol **hash_entry, *temp;
 
   if(stack_head==NULL) {
     printerr("Too Few Arguments");
@@ -785,15 +793,7 @@
   sym_id= ((symbol*)(stack_head->item->content.ptr))->id;
   toss(env);
 
-  hash_entry= hash(env->symbols, sym_id);
-  temp= *hash_entry;
-  *hash_entry= (*hash_entry)->next;
-  
-  if(temp->val!=NULL) {
-    free_val(temp->val);
-  }
-  free(temp->id);
-  free(temp);
+  return forget_sym(hash(env->symbols, sym_id));
 }
 
 /* Returns the current error number to the stack */
@@ -1145,6 +1145,8 @@
 /* 'to' */
 extern void to(environment *env) {
   int i, start, ending;
+  stackitem *temp_head;
+  value *temp_val;
   
   if((env->head)==NULL || env->head->next==NULL) {
     printerr("Too Few Arguments");
@@ -1164,18 +1166,23 @@
   start= env->head->item->content.val;
   toss(env); if(env->err) return;
 
-  push_sym(env, "[");
+  temp_head= env->head;
+  env->head= NULL;
 
   if(ending>=start) {
-    for(i= start; i<=ending; i++)
+    for(i= ending; i>=start; i--)
       push_int(env, i);
   } else {
-    for(i= start; i>=ending; i--)
+    for(i= ending; i<=start; i++)
       push_int(env, i);
   }
 
-  push_sym(env, "[");
-  pack(env); if(env->err) return;
+  temp_val= malloc(sizeof(value));
+  temp_val->content.ptr= env->head;
+  temp_val->refcount= 1;
+  temp_val->type= list;
+  env->head= temp_head;
+  push_val(env, temp_val);
 }
 
 /* Read a string */
@@ -1222,7 +1229,6 @@
   } 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) {