/[cvs]/stack/stack.c

Diff of /stack/stack.c

Parent Directory | Revision Log | View Patch Patch

-revision 1.67 by masse,
Sat Feb  9 00:57:05 2002 UTC
+revision 1.91 by teddy,
Thu Mar  7 03:28:29 2002 UTC
 Line 1
- /* printf, sscanf, fgets, fprintf */
+ /*
+     stack - an interactive interpreter for a stack-based language
+     Copyright (C) 2002  Mats Alritzson and Teddy Hogeborn
+     This program is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published by
+     the Free Software Foundation; either version 2 of the License, or
+     (at your option) any later version.
+     This program is distributed in the hope that it will be useful,
+     but WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+     GNU General Public License for more details.
+     You should have received a copy of the GNU General Public License
+     along with this program; if not, write to the Free Software
+     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+     Authors: Mats Alritzson <masse@fukt.bth.se>
+              Teddy Hogeborn <teddy@fukt.bth.se>
+ */
+ /* printf, sscanf, fgets, fprintf, fopen, perror */
  #include <stdio.h>
  /* exit, EXIT_SUCCESS, malloc, free */
  #include <stdlib.h>
-Line 8
+Line 30
  #include <dlfcn.h>
  /* strcmp, strcpy, strlen, strcat, strdup */
  #include <string.h>
+ /* getopt, STDIN_FILENO, STDOUT_FILENO, usleep */
+ #include <unistd.h>
+ /* EX_NOINPUT, EX_USAGE */
+ #include <sysexits.h>
+ /* mtrace, muntrace */
+ #include <mcheck.h>
+ /* ioctl */
+ #include <sys/ioctl.h>
+ /* KDMKTONE */
+ #include <linux/kd.h>
- #define HASHTBLSIZE 65536
+ #include "stack.h"
- /* First, define some types. */
- /* A value of some type */
- typedef struct {
-   enum {
-     integer,
-     string,
-     func,                       /* Function pointer */
-     symb,
-     list
-   } type;                       /* Type of stack element */
-   union {
-     void *ptr;                  /* Pointer to the content */
-     int val;                    /* ...or an integer */
-   } content;                    /* Stores a pointer or an integer */
-   int refcount;                 /* Reference counter */
- } value;
- /* A symbol with a name and possible value */
- /* (These do not need reference counters, they are kept unique by
-    hashing.) */
- typedef struct symbol_struct {
-   char *id;                     /* Symbol name */
-   value *val;                   /* The value (if any) bound to it */
-   struct symbol_struct *next;   /* In case of hashing conflicts, a */
- } symbol;                       /* symbol is a kind of stack item. */
- /* A type for a hash table for symbols */
- typedef symbol *hashtbl[HASHTBLSIZE]; /* Hash table declaration */
- /* An item (value) on a stack */
- typedef struct stackitem_struct
- {
-   value *item;                  /* The value on the stack */
-                                 /* (This is never NULL) */
-   struct stackitem_struct *next; /* Next item */
- } stackitem;
- /* An environment; gives access to the stack and a hash table of
-    defined symbols */
- typedef struct {
-   stackitem *head;              /* Head of the stack */
-   hashtbl symbols;              /* Hash table of all variable bindings */
-   int err;                      /* Error flag */
-   int non_eval_flag;
- } environment;
- /* A type for pointers to external functions */
- typedef void (*funcp)(environment *); /* funcp is a pointer to a void
-                                          function (environment *) */
  /* Initialize a newly created environment */
  void init_env(environment *env)
  {
    int i;
-   env->err= 0;
+   env->gc_limit= 20;
-   env->non_eval_flag= 0;
+   env->gc_count= 0;
+   env->gc_ref= NULL;
+   env->gc_protect= NULL;
+   env->head= NULL;
    for(i= 0; i<HASHTBLSIZE; i++)
      env->symbols[i]= NULL;
+   env->err= 0;
+   env->in_string= NULL;
+   env->free_string= NULL;
+   env->inputstream= stdin;
+   env->interactive= 1;
  }
  void printerr(const char* in_string) {
    fprintf(stderr, "Err: %s\n", in_string);
  }
- /* Throw away a value */
- void free_val(value *val){
-   stackitem *item, *temp;
-   val->refcount--;              /* Decrease the reference count */
-   if(val->refcount == 0){
-     switch (val->type){         /* and free the contents if necessary */
-     case string:
-       free(val->content.ptr);
-       break;
-     case list:                  /* lists needs to be freed recursively */
-       item=val->content.ptr;
-       while(item != NULL) {     /* for all stack items */
-         free_val(item->item);   /* free the value */
-         temp=item->next;        /* save next ptr */
-         free(item);             /* free the stackitem */
-         item=temp;              /* go to next stackitem */
-       }
-       free(val);                /* Free the actual list value */
-       break;
-     case integer:
-     case func:
-     case symb:
-       break;
-     }
-   }
- }
  /* Discard the top element of the stack. */
  extern void toss(environment *env)
  {
-Line 115 
 extern void toss(environment *env)
+Line 74 
 extern void toss(environment *env)
    if((env->head)==NULL) {
      printerr("Too Few Arguments");
-     env->err=1;
+     env->err= 1;
      return;
    }
-   free_val(env->head->item);    /* Free the value */
    env->head= env->head->next;   /* Remove the top stack item */
    free(temp);                   /* Free the old top stack item */
+   gc_init(env);
  }
  /* Returns a pointer to a pointer to an element in the hash table. */
-Line 153 
 symbol **hash(hashtbl in_hashtbl, const
+Line 113 
 symbol **hash(hashtbl in_hashtbl, const
    }
  }
- /* Generic push function. */
+ value* new_val(environment *env) {
- void push(stackitem** stack_head, stackitem* in_item)
+   value *nval= malloc(sizeof(value));
+   stackitem *nitem= malloc(sizeof(stackitem));
+   nval->content.ptr= NULL;
+   protect(env, nval);
+   gc_init(env);
+   nitem->item= nval;
+   nitem->next= env->gc_ref;
+   env->gc_ref= nitem;
+   env->gc_count++;
+   unprotect(env);
+   return nval;
+ }
+ void gc_mark(value *val) {
+   stackitem *iterator;
+   if(val==NULL || val->gc_garb==0)
+     return;
+   val->gc_garb= 0;
+   if(val->type==list) {
+     iterator= val->content.ptr;
+     while(iterator!=NULL) {
+       gc_mark(iterator->item);
+       iterator= iterator->next;
+     }
+   }
+ }
+ extern void gc_init(environment *env) {
+   stackitem *new_head= NULL, *titem, *iterator= env->gc_ref;
+   symbol *tsymb;
+   int i;
+   if(env->gc_count < env->gc_limit)
+     return;
+   while(iterator!=NULL) {
+     iterator->item->gc_garb= 1;
+     iterator= iterator->next;
+   }
+   /* Mark */
+   iterator= env->gc_protect;
+   while(iterator!=NULL) {
+     gc_mark(iterator->item);
+     iterator= iterator->next;
+   }
+   iterator= env->head;
+   while(iterator!=NULL) {
+     gc_mark(iterator->item);
+     iterator= iterator->next;
+   }
+   for(i= 0; i<HASHTBLSIZE; i++) {
+     tsymb= env->symbols[i];
+     while(tsymb!=NULL) {
+       gc_mark(tsymb->val);
+       tsymb= tsymb->next;
+     }
+   }
+   env->gc_count= 0;
+   /* Sweep */
+   while(env->gc_ref!=NULL) {
+     if(env->gc_ref->item->gc_garb) {
+       switch(env->gc_ref->item->type) {
+       case string:
+         free(env->gc_ref->item->content.ptr);
+         break;
+       case integer:
+         break;
+       case list:
+         while(env->gc_ref->item->content.ptr!=NULL) {
+           titem= env->gc_ref->item->content.ptr;
+           env->gc_ref->item->content.ptr= titem->next;
+           free(titem);
+         }
+         break;
+       default:
+         break;
+       }
+       free(env->gc_ref->item);
+       titem= env->gc_ref->next;
+       free(env->gc_ref);
+       env->gc_ref= titem;
+     } else {
+       titem= env->gc_ref->next;
+       env->gc_ref->next= new_head;
+       new_head= env->gc_ref;
+       env->gc_ref= titem;
+       env->gc_count++;
+     }
+   }
+   env->gc_limit= env->gc_count*2;
+   env->gc_ref= new_head;
+ }
+ void protect(environment *env, value *val)
  {
-   in_item->next= *stack_head;
+   stackitem *new_item= malloc(sizeof(stackitem));
-   *stack_head= in_item;
+   new_item->item= val;
+   new_item->next= env->gc_protect;
+   env->gc_protect= new_item;
+ }
+ void unprotect(environment *env)
+ {
+   stackitem *temp= env->gc_protect;
+   env->gc_protect= env->gc_protect->next;
+   free(temp);
  }
  /* Push a value onto the stack */
- void push_val(stackitem **stack_head, value *val)
+ void push_val(environment *env, value *val)
  {
    stackitem *new_item= malloc(sizeof(stackitem));
    new_item->item= val;
-   val->refcount++;
+   new_item->next= env->head;
-   push(stack_head, new_item);
+   env->head= new_item;
  }
  /* Push an integer onto the stack. */
- void push_int(stackitem **stack_head, int in_val)
+ void push_int(environment *env, int in_val)
  {
-   value *new_value= malloc(sizeof(value));
+   value *new_value= new_val(env);
-   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(stack_head, new_item);
+   push_val(env, new_value);
  }
  /* Copy a string onto the stack. */
- void push_cstring(stackitem **stack_head, const char *in_string)
+ void push_cstring(environment *env, const char *in_string)
  {
-   value *new_value= malloc(sizeof(value));
+   value *new_value= new_val(env);
-   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(stack_head, new_item);
+   push_val(env, new_value);
  }
  /* Mangle a symbol name to a valid C identifier name */
  char *mangle_str(const char *old_string){
-   char validchars[]
+   char validchars[]= "0123456789abcdef";
-     ="0123456789abcdef";
    char *new_string, *current;
-   new_string=malloc((strlen(old_string)*2)+4);
+   new_string= malloc((strlen(old_string)*2)+4);
    strcpy(new_string, "sx_");    /* Stack eXternal */
-   current=new_string+3;
+   current= new_string+3;
    while(old_string[0] != '\0'){
-     current[0]=validchars[(unsigned char)(old_string[0])/16];
+     current[0]= validchars[(unsigned char)(old_string[0])/16];
-     current[1]=validchars[(unsigned char)(old_string[0])%16];
+     current[1]= validchars[(unsigned char)(old_string[0])%16];
-     current+=2;
+     current+= 2;
      old_string++;
    }
-   current[0]='\0';
+   current[0]= '\0';
    return new_string;            /* The caller must free() it */
  }
  extern void mangle(environment *env){
-   value *new_value;
    char *new_string;
    if((env->head)==NULL) {
      printerr("Too Few Arguments");
-     env->err=1;
+     env->err= 1;
      return;
    }
    if(env->head->item->type!=string) {
      printerr("Bad Argument Type");
-     env->err=2;
+     env->err= 2;
      return;
    }
-Line 239 
 extern void mangle(environment *env){
+Line 309 
 extern void mangle(environment *env){
    toss(env);
    if(env->err) return;
-   new_value= malloc(sizeof(value));
+   push_cstring(env, new_string);
-   new_value->content.ptr= new_string;
-   new_value->type= string;
-   new_value->refcount=1;
-   push_val(&(env->head), new_value);
  }
  /* 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 */
-Line 264 
 void push_sym(environment *env, const ch
+Line 327 
 void push_sym(environment *env, const ch
    const char *dlerr;            /* Dynamic linker error */
    char *mangled;                /* Mangled function name */
-   /* Create a new stack item containing a new value */
+   new_value= new_val(env);
-   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;
-   new_value->refcount= 1;
    /* Look up the symbol name in the hash table */
    new_symbol= hash(env->symbols, in_string);
-Line 294 
 void push_sym(environment *env, const ch
+Line 353 
 void push_sym(environment *env, const ch
      if(handle==NULL)            /* If no handle */
        handle= dlopen(NULL, RTLD_LAZY);
-     funcptr= dlsym(handle, in_string); /* Get function pointer */
+     mangled= mangle_str(in_string); /* mangle the name */
-     dlerr=dlerror();
+     funcptr= dlsym(handle, mangled); /* and try to find it */
+     free(mangled);
+     dlerr= dlerror();
      if(dlerr != NULL) {         /* If no function was found */
-       mangled=mangle_str(in_string);
+       funcptr= dlsym(handle, in_string); /* Get function pointer */
-       funcptr= dlsym(handle, mangled); /* try mangling it */
+       dlerr= dlerror();
-       free(mangled);
-       dlerr=dlerror();
      }
      if(dlerr==NULL) {           /* If a function was found */
-       new_fvalue= malloc(sizeof(value)); /* Create a new value */
+       new_fvalue= new_val(env); /* Create a new value */
-       new_fvalue->type=func;    /* The new value is a function pointer */
+       new_fvalue->type= func;   /* The new value is a function pointer */
-       new_fvalue->content.ptr=funcptr; /* Store function pointer */
+       new_fvalue->content.ptr= funcptr; /* Store function pointer */
        (*new_symbol)->val= new_fvalue; /* Bind the symbol to the new
                                           function value */
-       new_fvalue->refcount= 1;
      }
    }
-   push(&(env->head), new_item);
+   push_val(env, new_value);
  }
  /* Print newline. */
-Line 351 
 extern void type(environment *env){
+Line 409 
 extern void type(environment *env){
  }
  /* Prints the top element of the stack. */
- void print_h(stackitem *stack_head)
+ void print_h(stackitem *stack_head, int noquote)
  {
    switch(stack_head->item->type) {
    case integer:
      printf("%d", stack_head->item->content.val);
      break;
    case string:
-     printf("%s", (char*)stack_head->item->content.ptr);
+     if(noquote)
+       printf("%s", (char*)stack_head->item->content.ptr);
+     else
+       printf("\"%s\"", (char*)stack_head->item->content.ptr);
      break;
    case symb:
      printf("%s", ((symbol *)(stack_head->item->content.ptr))->id);
-Line 371 
 void print_h(stackitem *stack_head)
+Line 432 
 void print_h(stackitem *stack_head)
      stack_head=(stackitem *)(stack_head->item->content.ptr);
      printf("[ ");
      while(stack_head != NULL) {
-       print_h(stack_head);
+       print_h(stack_head, noquote);
        printf(" ");
        stack_head=stack_head->next;
      }
-Line 386 
 extern void print_(environment *env) {
+Line 447 
 extern void print_(environment *env) {
      env->err=1;
      return;
    }
-   print_h(env->head);
+   print_h(env->head, 0);
+   nl();
  }
  /* Prints the top element of the stack and then discards it. */
-Line 397 
 extern void print(environment *env)
+Line 459 
 extern void print(environment *env)
    toss(env);
  }
+ extern void princ_(environment *env) {
+   if(env->head==NULL) {
+     printerr("Too Few Arguments");
+     env->err=1;
+     return;
+   }
+   print_h(env->head, 1);
+ }
+ /* Prints the top element of the stack and then discards it. */
+ extern void princ(environment *env)
+ {
+   princ_(env);
+   if(env->err) return;
+   toss(env);
+ }
  /* Only to be called by function printstack. */
  void print_st(stackitem *stack_head, long counter)
  {
    if(stack_head->next != NULL)
      print_st(stack_head->next, counter+1);
    printf("%ld: ", counter);
-   print_h(stack_head);
+   print_h(stack_head, 0);
    nl();
  }
-Line 411 
 void print_st(stackitem *stack_head, lon
+Line 490 
 void print_st(stackitem *stack_head, lon
  extern void printstack(environment *env)
  {
    if(env->head == NULL) {
+     printf("Stack Empty\n");
      return;
    }
    print_st(env->head, 1);
-   nl();
  }
  /* Swap the two top elements on the stack. */
-Line 473 
 extern void rcl(environment *env)
+Line 552 
 extern void rcl(environment *env)
      env->err=3;
      return;
    }
+   protect(env, val);
    toss(env);            /* toss the symbol */
    if(env->err) return;
-   push_val(&(env->head), val); /* Return its bound value */
+   push_val(env, val); /* Return its bound value */
+   unprotect(env);
  }
- 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. */
-Line 488 
 extern void eval(environment *env)
+Line 567 
 extern void eval(environment *env)
    funcp in_func;
    value* temp_val;
    stackitem* iterator;
-   char* temp_string;
+  eval_start:
    if(env->head==NULL) {
      printerr("Too Few Arguments");
-Line 496 
 extern void eval(environment *env)
+Line 576 
 extern void eval(environment *env)
      return;
    }
-  eval_start:
    switch(env->head->item->type) {
      /* if it's a symbol */
    case symb:
-Line 513 
 extern void eval(environment *env)
+Line 591 
 extern void eval(environment *env)
      in_func= (funcp)(env->head->item->content.ptr);
      toss(env);
      if(env->err) return;
-     return (*in_func)(env);
+     return in_func(env);
      /* If it's a list */
    case list:
      temp_val= env->head->item;
-     env->head->item->refcount++;
+     protect(env, temp_val);
      toss(env);
      if(env->err) return;
      iterator= (stackitem*)temp_val->content.ptr;
+     unprotect(env);
      while(iterator!=NULL) {
-       push_val(&(env->head), iterator->item);
+       push_val(env, iterator->item);
        if(env->head->item->type==symb
          && strcmp(";", ((symbol*)(env->head->item->content.ptr))->id)==0) {
          toss(env);
          if(env->err) return;
          if(iterator->next == NULL){
-           free_val(temp_val);
            goto eval_start;
          }
          eval(env);
-Line 537 
 extern void eval(environment *env)
+Line 618 
 extern void eval(environment *env)
        }
        iterator= iterator->next;
      }
-     free_val(temp_val);
      return;
-     /* If it's a string */
+   default:
-   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);
-     goto eval_start;
-   case integer:
      return;
    }
  }
-Line 566 
 extern void rev(environment *env){
+Line 631 
 extern void rev(environment *env){
    if((env->head)==NULL) {
      printerr("Too Few Arguments");
-     env->err=1;
+     env->err= 1;
      return;
    }
    if(env->head->item->type!=list) {
      printerr("Bad Argument Type");
-     env->err=2;
+     env->err= 2;
      return;
    }
-   old_head=(stackitem *)(env->head->item->content.ptr);
+   old_head= (stackitem *)(env->head->item->content.ptr);
-   new_head=NULL;
+   new_head= NULL;
    while(old_head != NULL){
-     item=old_head;
+     item= old_head;
-     old_head=old_head->next;
+     old_head= old_head->next;
-     item->next=new_head;
+     item->next= new_head;
-     new_head=item;
+     new_head= item;
    }
-   env->head->item->content.ptr=new_head;
+   env->head->item->content.ptr= new_head;
  }
  /* 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 */
-Line 618 
 extern void pack(environment *env)
+Line 682 
 extern void pack(environment *env)
    }
    /* Push list */
-   pack= malloc(sizeof(value));
+   pack= new_val(env);
    pack->type= list;
    pack->content.ptr= temp;
-   pack->refcount= 1;
-   temp= malloc(sizeof(stackitem));
+   push_val(env, pack);
-   temp->item= pack;
-   push(&(env->head), temp);
    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)
  {
-Line 717 
 extern void expand(environment *env)
+Line 698 
 extern void expand(environment *env)
    /* Is top element a list? */
    if(env->head==NULL) {
      printerr("Too Few Arguments");
-     env->err=1;
+     env->err= 1;
      return;
    }
    if(env->head->item->type!=list) {
      printerr("Bad Argument Type");
-     env->err=2;
+     env->err= 2;
      return;
    }
-Line 734 
 extern void expand(environment *env)
+Line 715 
 extern void expand(environment *env)
    /* The first list element is the new stack head */
    new_head= temp= env->head->item->content.ptr;
-   env->head->item->refcount++;
    toss(env);
    /* Find the end of the list */
-Line 755 
 extern void eq(environment *env)
+Line 735 
 extern void eq(environment *env)
    if((env->head)==NULL || env->head->next==NULL) {
      printerr("Too Few Arguments");
-     env->err=1;
+     env->err= 1;
      return;
    }
-Line 765 
 extern void eq(environment *env)
+Line 745 
 extern void eq(environment *env)
    result= (left==right);
    toss(env); toss(env);
-   push_int(&(env->head), result);
+   push_int(env, result);
  }
  /* Negates the top element on the stack. */
-Line 775 
 extern void not(environment *env)
+Line 755 
 extern void not(environment *env)
    if((env->head)==NULL) {
      printerr("Too Few Arguments");
-     env->err=1;
+     env->err= 1;
      return;
    }
    if(env->head->item->type!=integer) {
      printerr("Bad Argument Type");
-     env->err=2;
+     env->err= 2;
      return;
    }
    val= env->head->item->content.val;
    toss(env);
-   push_int(&(env->head), !val);
+   push_int(env, !val);
  }
  /* Compares the two top elements on the stack and return 0 if they're the
-Line 806 
 extern void def(environment *env)
+Line 786 
 extern void def(environment *env)
    /* Needs two values on the stack, the top one must be a symbol */
    if(env->head==NULL || env->head->next==NULL) {
      printerr("Too Few Arguments");
-     env->err=1;
+     env->err= 1;
      return;
    }
    if(env->head->item->type!=symb) {
      printerr("Bad Argument Type");
-     env->err=2;
+     env->err= 2;
      return;
    }
    /* long names are a pain */
-   sym=env->head->item->content.ptr;
+   sym= env->head->item->content.ptr;
-   /* if the symbol was bound to something else, throw it away */
-   if(sym->val != NULL)
-     free_val(sym->val);
    /* Bind the symbol to the value */
    sym->val= env->head->next->item;
-   sym->val->refcount++;         /* Increase the reference counter */
    toss(env); toss(env);
  }
-Line 833 
 extern void def(environment *env)
+Line 808 
 extern void def(environment *env)
  /* Quit stack. */
  extern void quit(environment *env)
  {
+   long i;
+   clear(env);
+   if (env->err) return;
+   for(i= 0; i<HASHTBLSIZE; i++) {
+     while(env->symbols[i]!= NULL) {
+       forget_sym(&(env->symbols[i]));
+     }
+     env->symbols[i]= NULL;
+   }
+   env->gc_limit= 0;
+   gc_init(env);
+   if(env->free_string!=NULL)
+     free(env->free_string);
+   muntrace();
    exit(EXIT_SUCCESS);
  }
-Line 858 
 extern void words(environment *env)
+Line 853 
 extern void words(environment *env)
    }
  }
+ /* Internal forget function */
+ void forget_sym(symbol **hash_entry) {
+   symbol *temp;
+   temp= *hash_entry;
+   *hash_entry= (*hash_entry)->next;
+   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");
-Line 880 
 extern void forget(environment *env)
+Line 885 
 extern void forget(environment *env)
    sym_id= ((symbol*)(stack_head->item->content.ptr))->id;
    toss(env);
-   hash_entry= hash(env->symbols, sym_id);
+   return forget_sym(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);
  }
  /* Returns the current error number to the stack */
  extern void errn(environment *env){
-   push_int(&(env->head), env->err);
+   push_int(env, env->err);
  }
- int main()
+ int main(int argc, char **argv)
  {
    environment myenv;
-   char in_string[100];
+   int c;                        /* getopt option character */
+   mtrace();
    init_env(&myenv);
-   printf("okidok\n ");
+   myenv.interactive = isatty(STDIN_FILENO) && isatty(STDOUT_FILENO);
+   while ((c = getopt (argc, argv, "i")) != -1)
+     switch (c)
+       {
+       case 'i':
+         myenv.interactive = 1;
+         break;
+       case '?':
+         fprintf (stderr,
+                  "Unknown option character `\\x%x'.\n",
+                  optopt);
+         return EX_USAGE;
+       default:
+         abort ();
+       }
+   if (optind < argc) {
+     myenv.interactive = 0;
+     myenv.inputstream= fopen(argv[optind], "r");
+     if(myenv.inputstream== NULL) {
+       perror(argv[0]);
+       exit (EX_NOINPUT);
+     }
+   }
+   if(myenv.interactive) {
+     printf("Stack version $Revision$\n\
+ Copyright (C) 2002  Mats Alritzson and Teddy Hogeborn\n\
+ Stack comes with ABSOLUTELY NO WARRANTY; for details type `warranty;'.\n\
+ This is free software, and you are welcome to redistribute it\n\
+ under certain conditions; type `copying;' for details.\n");
+   }
-   while(fgets(in_string, 100, stdin) != NULL) {
+   while(1) {
-     stack_read(&myenv, in_string);
+     if(myenv.in_string==NULL) {
-     if(myenv.err) {
+       if (myenv.interactive) {
-       printf("(error %d) ", myenv.err);
+         if(myenv.err) {
+           printf("(error %d)\n", myenv.err);
+         }
+         nl();
+         printstack(&myenv);
+         printf("> ");
+       }
        myenv.err=0;
      }
-     printf("okidok\n ");
+     sx_72656164(&myenv);
+     if (myenv.err==4) {
+       return EXIT_SUCCESS;      /* EOF */
+     } 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);
+     }
+     gc_init(&myenv);
    }
    quit(&myenv);
    return EXIT_FAILURE;
  }
- /* + */
+ /* "+" */
  extern void sx_2b(environment *env) {
    int a, b;
    size_t len;
-Line 926 
 extern void sx_2b(environment *env) {
+Line 973 
 extern void sx_2b(environment *env) {
    if((env->head)==NULL || env->head->next==NULL) {
      printerr("Too Few Arguments");
-     env->err=1;
+     env->err= 1;
      return;
    }
-Line 934 
 extern void sx_2b(environment *env) {
+Line 981 
 extern void sx_2b(environment *env) {
       && env->head->next->item->type==string) {
      a_val= env->head->item;
      b_val= env->head->next->item;
-     a_val->refcount++;
+     protect(env, a_val); protect(env, b_val);
-     b_val->refcount++;
      toss(env); if(env->err) return;
      toss(env); if(env->err) return;
      len= strlen(a_val->content.ptr)+strlen(b_val->content.ptr)+1;
      new_string= malloc(len);
      strcpy(new_string, b_val->content.ptr);
      strcat(new_string, a_val->content.ptr);
-     free_val(a_val); free_val(b_val);
+     push_cstring(env, new_string);
-     push_cstring(&(env->head), new_string);
+     unprotect(env); unprotect(env);
      free(new_string);
      return;
    }
-Line 954 
 extern void sx_2b(environment *env) {
+Line 1000 
 extern void sx_2b(environment *env) {
      env->err=2;
      return;
    }
-   a=env->head->item->content.val;
+   a= env->head->item->content.val;
-   toss(env);
+   toss(env); if(env->err) return;
-   if(env->err) return;
-   if(env->head->item->refcount == 1)
+   b= env->head->item->content.val;
-     env->head->item->content.val += a;
+   toss(env); if(env->err) return;
-   else {
+   push_int(env, a+b);
-     b=env->head->item->content.val;
-     toss(env);
-     if(env->err) return;
-     push_int(&(env->head), a+b);
-   }
  }
- /* - */
+ /* "-" */
  extern void sx_2d(environment *env) {
    int a, b;
-Line 983 
 extern void sx_2d(environment *env) {
+Line 1024 
 extern void sx_2d(environment *env) {
      env->err=2;
      return;
    }
    a=env->head->item->content.val;
-   toss(env);
+   toss(env); if(env->err) return;
-   if(env->err) return;
+   b=env->head->item->content.val;
-   if(env->head->item->refcount == 1)
+   toss(env); if(env->err) return;
-     env->head->item->content.val -= a;
+   push_int(env, b-a);
-   else {
-     b=env->head->item->content.val;
-     toss(env);
-     if(env->err) return;
-     push_int(&(env->head), b-a);
-   }
  }
- /* > */
+ /* ">" */
  extern void sx_3e(environment *env) {
    int a, b;
-Line 1012 
 extern void sx_3e(environment *env) {
+Line 1048 
 extern void sx_3e(environment *env) {
      env->err=2;
      return;
    }
    a=env->head->item->content.val;
-   toss(env);
+   toss(env); if(env->err) return;
-   if(env->err) return;
+   b=env->head->item->content.val;
-   if(env->head->item->refcount == 1)
+   toss(env); if(env->err) return;
-     env->head->item->content.val = (env->head->item->content.val > a);
+   push_int(env, b>a);
-   else {
-     b=env->head->item->content.val;
-     toss(env);
-     if(env->err) return;
-     push_int(&(env->head), b>a);
-   }
  }
  /* Return copy of a value */
- value *copy_val(value *old_value){
+ value *copy_val(environment *env, value *old_value){
    stackitem *old_item, *new_item, *prev_item;
-   value *new_value=malloc(sizeof(value));
+   value *new_value= new_val(env);
+   protect(env, old_value);
+   new_value->type= old_value->type;
-   new_value->type=old_value->type;
-   new_value->refcount=0;        /* This is increased if/when this
-                                    value is referenced somewhere, like
-                                    in a stack item or a variable */
    switch(old_value->type){
    case integer:
-     new_value->content.val=old_value->content.val;
+     new_value->content.val= old_value->content.val;
      break;
    case string:
-     (char *)(new_value->content.ptr)
+     (char *)(new_value->content.ptr)=
-       = strdup((char *)(old_value->content.ptr));
+       strdup((char *)(old_value->content.ptr));
      break;
    case func:
    case symb:
-     new_value->content.ptr=old_value->content.ptr;
+     new_value->content.ptr= old_value->content.ptr;
      break;
    case list:
-     new_value->content.ptr=NULL;
+     new_value->content.ptr= NULL;
-     prev_item=NULL;
+     prev_item= NULL;
-     old_item=(stackitem *)(old_value->content.ptr);
+     old_item= (stackitem*)(old_value->content.ptr);
      while(old_item != NULL) {   /* While list is not empty */
        new_item= malloc(sizeof(stackitem));
-       new_item->item=copy_val(old_item->item); /* recurse */
+       new_item->item= copy_val(env, old_item->item); /* recurse */
-       new_item->next=NULL;
+       new_item->next= NULL;
        if(prev_item != NULL)     /* If this wasn't the first item */
-         prev_item->next=new_item; /* point the previous item to the
+         prev_item->next= new_item; /* point the previous item to the
                                       new item */
        else
-         new_value->content.ptr=new_item;
+         new_value->content.ptr= new_item;
-       old_item=old_item->next;
+       old_item= old_item->next;
-       prev_item=new_item;
+       prev_item= new_item;
      }
      break;
    }
+   unprotect(env);
    return new_value;
  }
- /* duplicates an item on the stack */
+ /* "dup"; duplicates an item on the stack */
- extern void dup(environment *env) {
+ extern void sx_647570(environment *env) {
    if((env->head)==NULL) {
      printerr("Too Few Arguments");
-     env->err=1;
+     env->err= 1;
      return;
    }
-   push_val(&(env->head), copy_val(env->head->item));
+   push_val(env, copy_val(env, env->head->item));
  }
  /* "if", If-Then */
-Line 1087 
 extern void sx_6966(environment *env) {
+Line 1120 
 extern void sx_6966(environment *env) {
    if((env->head)==NULL || env->head->next==NULL) {
      printerr("Too Few Arguments");
-     env->err=1;
+     env->err= 1;
      return;
    }
-Line 1147 
 extern void ifelse(environment *env) {
+Line 1180 
 extern void ifelse(environment *env) {
    eval(env);
  }
- /* while */
+ /* "while" */
  extern void sx_7768696c65(environment *env) {
    int truth;
-Line 1160 
 extern void sx_7768696c65(environment *e
+Line 1193 
 extern void sx_7768696c65(environment *e
    }
    loop= env->head->item;
-   loop->refcount++;
+   protect(env, loop);
    toss(env); if(env->err) return;
    test= env->head->item;
-   test->refcount++;
+   protect(env, test);
    toss(env); if(env->err) return;
    do {
-     push_val(&(env->head), test);
+     push_val(env, test);
      eval(env);
      if(env->head->item->type != integer) {
        printerr("Bad Argument Type");
-       env->err=2;
+       env->err= 2;
        return;
      }
-Line 1181 
 extern void sx_7768696c65(environment *e
+Line 1214 
 extern void sx_7768696c65(environment *e
      toss(env); if(env->err) return;
      if(truth) {
-       push_val(&(env->head), loop);
+       push_val(env, loop);
        eval(env);
      } else {
        toss(env);
-Line 1189 
 extern void sx_7768696c65(environment *e
+Line 1222 
 extern void sx_7768696c65(environment *e
    } while(truth);
-   free_val(test);
+   unprotect(env); unprotect(env);
-   free_val(loop);
  }
- /* For-loop */
+ /* "for"; for-loop */
  extern void sx_666f72(environment *env) {
+   value *loop;
+   int foo1, foo2;
+   if(env->head==NULL || env->head->next==NULL
+      || env->head->next->next==NULL) {
+     printerr("Too Few Arguments");
+     env->err= 1;
+     return;
+   }
+   if(env->head->next->item->type!=integer
+      || env->head->next->next->item->type!=integer) {
+     printerr("Bad Argument Type");
+     env->err= 2;
+     return;
+   }
+   loop= env->head->item;
+   protect(env, loop);
+   toss(env); if(env->err) return;
+   foo2= env->head->item->content.val;
+   toss(env); if(env->err) return;
+   foo1= env->head->item->content.val;
+   toss(env); if(env->err) return;
+   if(foo1<=foo2) {
+     while(foo1<=foo2) {
+       push_int(env, foo1);
+       push_val(env, loop);
+       eval(env); if(env->err) return;
+       foo1++;
+     }
+   } else {
+     while(foo1>=foo2) {
+       push_int(env, foo1);
+       push_val(env, loop);
+       eval(env); if(env->err) return;
+       foo1--;
+     }
+   }
+   unprotect(env);
+ }
+ /* Variant of for-loop */
+ extern void foreach(environment *env) {
    value *loop, *foo;
    stackitem *iterator;
    if((env->head)==NULL || env->head->next==NULL) {
      printerr("Too Few Arguments");
-     env->err=1;
+     env->err= 1;
      return;
    }
    if(env->head->next->item->type != list) {
      printerr("Bad Argument Type");
-     env->err=2;
+     env->err= 2;
      return;
    }
    loop= env->head->item;
-   loop->refcount++;
+   protect(env, loop);
    toss(env); if(env->err) return;
    foo= env->head->item;
-   foo->refcount++;
+   protect(env, foo);
    toss(env); if(env->err) return;
    iterator= foo->content.ptr;
    while(iterator!=NULL) {
-     push_val(&(env->head), iterator->item);
+     push_val(env, iterator->item);
-     push_val(&(env->head), loop);
+     push_val(env, loop);
      eval(env); if(env->err) return;
      iterator= iterator->next;
    }
+   unprotect(env); unprotect(env);
-   free_val(loop);
-   free_val(foo);
  }
- /* 'to' */
+ /* "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");
-Line 1254 
 extern void to(environment *env) {
+Line 1334 
 extern void to(environment *env) {
    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->head), i);
+       push_int(env, i);
    } else {
-     for(i= start; i>=ending; i--)
+     for(i= ending; i<=start; i++)
-       push_int(&(env->head), i);
+       push_int(env, i);
+   }
+   temp_val= new_val(env);
+   temp_val->content.ptr= env->head;
+   temp_val->type= list;
+   env->head= temp_head;
+   push_val(env, temp_val);
+ }
+ /* Read a string */
+ extern void readline(environment *env) {
+   char in_string[101];
+   if(fgets(in_string, 100, env->inputstream)==NULL)
+     push_cstring(env, "");
+   else
+     push_cstring(env, in_string);
+ }
+ /* "read"; Read a value and place on stack */
+ extern void sx_72656164(environment *env) {
+   const char symbform[]= "%[a-zA-Z0-9!$%*+./:<=>?@^_~-]%n";
+   const char strform[]= "\"%[^\"]\"%n";
+   const char intform[]= "%i%n";
+   const char blankform[]= "%*[ \t]%n";
+   const char ebrackform[]= "]%n";
+   const char semicform[]= ";%n";
+   const char bbrackform[]= "[%n";
+   int itemp, readlength= -1;
+   static int depth= 0;
+   char *match;
+   size_t inlength;
+   if(env->in_string==NULL) {
+     if(depth > 0 && env->interactive) {
+       printf("]> ");
+     }
+     readline(env); if(env->err) return;
+     if(((char *)(env->head->item->content.ptr))[0]=='\0'){
+       env->err= 4;              /* "" means EOF */
+       return;
+     }
+     env->in_string= malloc(strlen(env->head->item->content.ptr)+1);
+     env->free_string= env->in_string; /* Save the original pointer */
+     strcpy(env->in_string, env->head->item->content.ptr);
+     toss(env); if(env->err) return;
+   }
+   inlength= strlen(env->in_string)+1;
+   match= malloc(inlength);
+   if(sscanf(env->in_string, blankform, &readlength)!=EOF
+      && readlength != -1) {
+     ;
+   } else if(sscanf(env->in_string, intform, &itemp, &readlength) != EOF
+             && readlength != -1) {
+     push_int(env, itemp);
+   } else if(sscanf(env->in_string, strform, match, &readlength) != EOF
+             && readlength != -1) {
+     push_cstring(env, match);
+   } else if(sscanf(env->in_string, symbform, match, &readlength) != EOF
+             && readlength != -1) {
+     push_sym(env, match);
+   } else if(sscanf(env->in_string, ebrackform, &readlength) != EOF
+             && readlength != -1) {
+     pack(env); if(env->err) return;
+     if(depth != 0) depth--;
+   } else if(sscanf(env->in_string, semicform, &readlength) != EOF
+             && readlength != -1) {
+     push_sym(env, ";");
+   } else if(sscanf(env->in_string, bbrackform, &readlength) != EOF
+             && readlength != -1) {
+     push_sym(env, "[");
+     depth++;
+   } else {
+     free(env->free_string);
+     env->in_string = env->free_string = NULL;
+   }
+   if ( env->in_string != NULL) {
+     env->in_string += readlength;
+   }
+   free(match);
+   if(depth)
+     return sx_72656164(env);
+ }
+ extern void beep(environment *env) {
+   int freq, dur, period, ticks;
+   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;
    }
-   push_sym(env, "[");
+   dur=env->head->item->content.val;
-   pack(env); if(env->err) return;
+   toss(env);
+   freq=env->head->item->content.val;
+   toss(env);
+   period=1193180/freq;          /* convert freq from Hz to period
+                                    length */
+   ticks=dur*.001193180;         /* convert duration from µseconds to
+                                    timer ticks */
+ /*    ticks=dur/1000; */
+   /*  if (ioctl(STDOUT_FILENO, KDMKTONE, (125<<16) + 0x637)==0) */
+   switch (ioctl(STDOUT_FILENO, KDMKTONE, (ticks<<16) | period)){
+   case 0:
+     usleep(dur);
+     return;
+   case -1:
+     perror("beep");
+     env->err=5;
+     return;
+   default:
+     abort();
+   }
+ };
+ /* "wait" */
+ extern void sx_77616974(environment *env) {
+   int dur;
+   if((env->head)==NULL) {
+     printerr("Too Few Arguments");
+     env->err=1;
+     return;
+   }
+   if(env->head->item->type!=integer) {
+     printerr("Bad Argument Type");
+     env->err=2;
+     return;
+   }
+   dur=env->head->item->content.val;
+   toss(env);
+   usleep(dur);
+ };
+ extern void copying(environment *env){
+   printf("GNU GENERAL PUBLIC LICENSE\n\
+                        Version 2, June 1991\n\
+ \n\
+  Copyright (C) 1989, 1991 Free Software Foundation, Inc.\n\
+Temple Place, Suite 330, Boston, MA  02111-1307  USA\n\
+  Everyone is permitted to copy and distribute verbatim copies\n\
+  of this license document, but changing it is not allowed.\n\
+ \n\
+                             Preamble\n\
+ \n\
+   The licenses for most software are designed to take away your\n\
+ freedom to share and change it.  By contrast, the GNU General Public\n\
+ License is intended to guarantee your freedom to share and change free\n\
+ software--to make sure the software is free for all its users.  This\n\
+ General Public License applies to most of the Free Software\n\
+ Foundation's software and to any other program whose authors commit to\n\
+ using it.  (Some other Free Software Foundation software is covered by\n\
+ the GNU Library General Public License instead.)  You can apply it to\n\
+ your programs, too.\n\
+ \n\
+   When we speak of free software, we are referring to freedom, not\n\
+ price.  Our General Public Licenses are designed to make sure that you\n\
+ have the freedom to distribute copies of free software (and charge for\n\
+ this service if you wish), that you receive source code or can get it\n\
+ if you want it, that you can change the software or use pieces of it\n\
+ in new free programs; and that you know you can do these things.\n\
+ \n\
+   To protect your rights, we need to make restrictions that forbid\n\
+ anyone to deny you these rights or to ask you to surrender the rights.\n\
+ These restrictions translate to certain responsibilities for you if you\n\
+ distribute copies of the software, or if you modify it.\n\
+ \n\
+   For example, if you distribute copies of such a program, whether\n\
+ gratis or for a fee, you must give the recipients all the rights that\n\
+ you have.  You must make sure that they, too, receive or can get the\n\
+ source code.  And you must show them these terms so they know their\n\
+ rights.\n\
+ \n\
+   We protect your rights with two steps: (1) copyright the software, and\n\
+ (2) offer you this license which gives you legal permission to copy,\n\
+ distribute and/or modify the software.\n\
+ \n\
+   Also, for each author's protection and ours, we want to make certain\n\
+ that everyone understands that there is no warranty for this free\n\
+ software.  If the software is modified by someone else and passed on, we\n\
+ want its recipients to know that what they have is not the original, so\n\
+ that any problems introduced by others will not reflect on the original\n\
+ authors' reputations.\n\
+ \n\
+   Finally, any free program is threatened constantly by software\n\
+ patents.  We wish to avoid the danger that redistributors of a free\n\
+ program will individually obtain patent licenses, in effect making the\n\
+ program proprietary.  To prevent this, we have made it clear that any\n\
+ patent must be licensed for everyone's free use or not licensed at all.\n\
+ \n\
+   The precise terms and conditions for copying, distribution and\n\
+ modification follow.\n\
+ \n\
+                     GNU GENERAL PUBLIC LICENSE\n\
+    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n\
+ \n\
+. This License applies to any program or other work which contains\n\
+ a notice placed by the copyright holder saying it may be distributed\n\
+ under the terms of this General Public License.  The \"Program\", below,\n\
+ refers to any such program or work, and a \"work based on the Program\"\n\
+ means either the Program or any derivative work under copyright law:\n\
+ that is to say, a work containing the Program or a portion of it,\n\
+ either verbatim or with modifications and/or translated into another\n\
+ language.  (Hereinafter, translation is included without limitation in\n\
+ the term \"modification\".)  Each licensee is addressed as \"you\".\n\
+ \n\
+ Activities other than copying, distribution and modification are not\n\
+ covered by this License; they are outside its scope.  The act of\n\
+ running the Program is not restricted, and the output from the Program\n\
+ is covered only if its contents constitute a work based on the\n\
+ Program (independent of having been made by running the Program).\n\
+ Whether that is true depends on what the Program does.\n\
+ \n\
+. You may copy and distribute verbatim copies of the Program's\n\
+ source code as you receive it, in any medium, provided that you\n\
+ conspicuously and appropriately publish on each copy an appropriate\n\
+ copyright notice and disclaimer of warranty; keep intact all the\n\
+ notices that refer to this License and to the absence of any warranty;\n\
+ and give any other recipients of the Program a copy of this License\n\
+ along with the Program.\n\
+ \n\
+ You may charge a fee for the physical act of transferring a copy, and\n\
+ you may at your option offer warranty protection in exchange for a fee.\n\
+ \n\
+. You may modify your copy or copies of the Program or any portion\n\
+ of it, thus forming a work based on the Program, and copy and\n\
+ distribute such modifications or work under the terms of Section 1\n\
+ above, provided that you also meet all of these conditions:\n\
+ \n\
+     a) You must cause the modified files to carry prominent notices\n\
+     stating that you changed the files and the date of any change.\n\
+ \n\
+     b) You must cause any work that you distribute or publish, that in\n\
+     whole or in part contains or is derived from the Program or any\n\
+     part thereof, to be licensed as a whole at no charge to all third\n\
+     parties under the terms of this License.\n\
+ \n\
+     c) If the modified program normally reads commands interactively\n\
+     when run, you must cause it, when started running for such\n\
+     interactive use in the most ordinary way, to print or display an\n\
+     announcement including an appropriate copyright notice and a\n\
+     notice that there is no warranty (or else, saying that you provide\n\
+     a warranty) and that users may redistribute the program under\n\
+     these conditions, and telling the user how to view a copy of this\n\
+     License.  (Exception: if the Program itself is interactive but\n\
+     does not normally print such an announcement, your work based on\n\
+     the Program is not required to print an announcement.)\n\
+ \n\
+ These requirements apply to the modified work as a whole.  If\n\
+ identifiable sections of that work are not derived from the Program,\n\
+ and can be reasonably considered independent and separate works in\n\
+ themselves, then this License, and its terms, do not apply to those\n\
+ sections when you distribute them as separate works.  But when you\n\
+ distribute the same sections as part of a whole which is a work based\n\
+ on the Program, the distribution of the whole must be on the terms of\n\
+ this License, whose permissions for other licensees extend to the\n\
+ entire whole, and thus to each and every part regardless of who wrote it.\n\
+ \n\
+ Thus, it is not the intent of this section to claim rights or contest\n\
+ your rights to work written entirely by you; rather, the intent is to\n\
+ exercise the right to control the distribution of derivative or\n\
+ collective works based on the Program.\n\
+ \n\
+ In addition, mere aggregation of another work not based on the Program\n\
+ with the Program (or with a work based on the Program) on a volume of\n\
+ a storage or distribution medium does not bring the other work under\n\
+ the scope of this License.\n\
+ \n\
+. You may copy and distribute the Program (or a work based on it,\n\
+ under Section 2) in object code or executable form under the terms of\n\
+ Sections 1 and 2 above provided that you also do one of the following:\n\
+ \n\
+     a) Accompany it with the complete corresponding machine-readable\n\
+     source code, which must be distributed under the terms of Sections\n\
+and 2 above on a medium customarily used for software interchange; or,\n\
+ \n\
+     b) Accompany it with a written offer, valid for at least three\n\
+     years, to give any third party, for a charge no more than your\n\
+     cost of physically performing source distribution, a complete\n\
+     machine-readable copy of the corresponding source code, to be\n\
+     distributed under the terms of Sections 1 and 2 above on a medium\n\
+     customarily used for software interchange; or,\n\
+ \n\
+     c) Accompany it with the information you received as to the offer\n\
+     to distribute corresponding source code.  (This alternative is\n\
+     allowed only for noncommercial distribution and only if you\n\
+     received the program in object code or executable form with such\n\
+     an offer, in accord with Subsection b above.)\n\
+ \n\
+ The source code for a work means the preferred form of the work for\n\
+ making modifications to it.  For an executable work, complete source\n\
+ code means all the source code for all modules it contains, plus any\n\
+ associated interface definition files, plus the scripts used to\n\
+ control compilation and installation of the executable.  However, as a\n\
+ special exception, the source code distributed need not include\n\
+ anything that is normally distributed (in either source or binary\n\
+ form) with the major components (compiler, kernel, and so on) of the\n\
+ operating system on which the executable runs, unless that component\n\
+ itself accompanies the executable.\n\
+ \n\
+ If distribution of executable or object code is made by offering\n\
+ access to copy from a designated place, then offering equivalent\n\
+ access to copy the source code from the same place counts as\n\
+ distribution of the source code, even though third parties are not\n\
+ compelled to copy the source along with the object code.\n\
+ \n\
+. You may not copy, modify, sublicense, or distribute the Program\n\
+ except as expressly provided under this License.  Any attempt\n\
+ otherwise to copy, modify, sublicense or distribute the Program is\n\
+ void, and will automatically terminate your rights under this License.\n\
+ However, parties who have received copies, or rights, from you under\n\
+ this License will not have their licenses terminated so long as such\n\
+ parties remain in full compliance.\n\
+ \n\
+. You are not required to accept this License, since you have not\n\
+ signed it.  However, nothing else grants you permission to modify or\n\
+ distribute the Program or its derivative works.  These actions are\n\
+ prohibited by law if you do not accept this License.  Therefore, by\n\
+ modifying or distributing the Program (or any work based on the\n\
+ Program), you indicate your acceptance of this License to do so, and\n\
+ all its terms and conditions for copying, distributing or modifying\n\
+ the Program or works based on it.\n\
+ \n\
+. Each time you redistribute the Program (or any work based on the\n\
+ Program), the recipient automatically receives a license from the\n\
+ original licensor to copy, distribute or modify the Program subject to\n\
+ these terms and conditions.  You may not impose any further\n\
+ restrictions on the recipients' exercise of the rights granted herein.\n\
+ You are not responsible for enforcing compliance by third parties to\n\
+ this License.\n\
+ \n\
+. If, as a consequence of a court judgment or allegation of patent\n\
+ infringement or for any other reason (not limited to patent issues),\n\
+ conditions are imposed on you (whether by court order, agreement or\n\
+ otherwise) that contradict the conditions of this License, they do not\n\
+ excuse you from the conditions of this License.  If you cannot\n\
+ distribute so as to satisfy simultaneously your obligations under this\n\
+ License and any other pertinent obligations, then as a consequence you\n\
+ may not distribute the Program at all.  For example, if a patent\n\
+ license would not permit royalty-free redistribution of the Program by\n\
+ all those who receive copies directly or indirectly through you, then\n\
+ the only way you could satisfy both it and this License would be to\n\
+ refrain entirely from distribution of the Program.\n\
+ \n\
+ If any portion of this section is held invalid or unenforceable under\n\
+ any particular circumstance, the balance of the section is intended to\n\
+ apply and the section as a whole is intended to apply in other\n\
+ circumstances.\n\
+ \n\
+ It is not the purpose of this section to induce you to infringe any\n\
+ patents or other property right claims or to contest validity of any\n\
+ such claims; this section has the sole purpose of protecting the\n\
+ integrity of the free software distribution system, which is\n\
+ implemented by public license practices.  Many people have made\n\
+ generous contributions to the wide range of software distributed\n\
+ through that system in reliance on consistent application of that\n\
+ system; it is up to the author/donor to decide if he or she is willing\n\
+ to distribute software through any other system and a licensee cannot\n\
+ impose that choice.\n\
+ \n\
+ This section is intended to make thoroughly clear what is believed to\n\
+ be a consequence of the rest of this License.\n\
+ \n\
+. If the distribution and/or use of the Program is restricted in\n\
+ certain countries either by patents or by copyrighted interfaces, the\n\
+ original copyright holder who places the Program under this License\n\
+ may add an explicit geographical distribution limitation excluding\n\
+ those countries, so that distribution is permitted only in or among\n\
+ countries not thus excluded.  In such case, this License incorporates\n\
+ the limitation as if written in the body of this License.\n\
+ \n\
+. The Free Software Foundation may publish revised and/or new versions\n\
+ of the General Public License from time to time.  Such new versions will\n\
+ be similar in spirit to the present version, but may differ in detail to\n\
+ address new problems or concerns.\n\
+ \n\
+ Each version is given a distinguishing version number.  If the Program\n\
+ specifies a version number of this License which applies to it and \"any\n\
+ later version\", you have the option of following the terms and conditions\n\
+ either of that version or of any later version published by the Free\n\
+ Software Foundation.  If the Program does not specify a version number of\n\
+ this License, you may choose any version ever published by the Free Software\n\
+ Foundation.\n\
+ \n\
+. If you wish to incorporate parts of the Program into other free\n\
+ programs whose distribution conditions are different, write to the author\n\
+ to ask for permission.  For software which is copyrighted by the Free\n\
+ Software Foundation, write to the Free Software Foundation; we sometimes\n\
+ make exceptions for this.  Our decision will be guided by the two goals\n\
+ of preserving the free status of all derivatives of our free software and\n\
+ of promoting the sharing and reuse of software generally.\n");
+ }
+ extern void warranty(environment *env){
+   printf("                          NO WARRANTY\n\
+ \n\
+. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY\n\
+ FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN\n\
+ OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES\n\
+ PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED\n\
+ OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\n\
+ MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS\n\
+ TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE\n\
+ PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,\n\
+ REPAIR OR CORRECTION.\n\
+ \n\
+. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING\n\
+ WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR\n\
+ REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,\n\
+ INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING\n\
+ OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED\n\
+ TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY\n\
+ YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER\n\
+ PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE\n\
+ POSSIBILITY OF SUCH DAMAGES.\n");
  }

 Legend:



Removed from v.1.67
 


changed lines


 
Added in v.1.91
 Legend:



Removed from v.1.67
 


changed lines


 
Added in v.1.91
-Removed from v.1.67
+Added in v.1.91

root@recompile.se	ViewVC Help
Powered by ViewVC 1.1.26