/* $Copyright:	$
 * Copyright (c) 1984, 1985, 1986, 1987, 1988, 1989, 1990 
 * Sequent Computer Systems, Inc.   All rights reserved.
 *  
 * This software is furnished under a license and may be used
 * only in accordance with the terms of that license and with the
 * inclusion of the above copyright notice.   This software may not
 * be provided or otherwise made available to, or used by, any
 * other person.  No title to or ownership of the software is
 * hereby transferred.
 */

/* $Header: vocab.c 2.0 86/01/28 $ */

/*      Re-coding of advent in C: data structure routines               */

static char sccsid[] = "	vocab.c	4.1	82/05/11	";

# include "hdr.h"

dstroy(object)
int object;
{       move(object,0);
}

juggle(object)
int object;
{       register int i,j;
	i=place[object];
	j=fixed[object];
	move(object,i);
	move(object+100,j);
}


move(object,where)
int object,where;
{       register int from;
	if (object<=100)
		from=place[object];
	else
		from=fixed[object-100];
	if (from>0 && from<=300) carry(object,from);
	drop(object,where);
}


put(object,where,pval)
int object,where,pval;
{       move(object,where);
	return(-1-pval);
}



carry(object,where)
int object,where;
{       register int temp;
	if (object<=100)
	{       if (place[object]== -1) return;
		place[object] = -1;
		holdng++;
	}
	if (atloc[where]==object)
	{       atloc[where]=link[object];
		return;
	}
	for (temp=atloc[where]; link[temp]!=object; temp=link[temp]);
	link[temp]=link[object];
}




drop(object,where)
int object,where;
{	if (object>100) fixed[object-100]=where;
	else
	{       if (place[object]== -1) holdng--;
		place[object]=where;
	}
	if (where<=0) return;
	link[object]=atloc[where];
	atloc[where]=object;
}


vocab(word,type,value)                  /* look up or store a word      */
char *word;
int type;       /* -2 for store, -1 for user word, >=0 for canned lookup*/
int value;                              /* used for storing only        */
{       register int adr;
	register char *s,*t;
	int hash, i;
	struct hashtab *h;
	for (hash=0,s=word,i=0; i<5 &&*s; i++)  /* some kind of hash    */
		hash += *s++;           /* add all chars in the word    */
	hash = (hash*3719)&077777;      /* pulled that one out of a hat */
	hash %= HTSIZE;                 /* put it into range of table   */

	for(adr=hash;; adr++)           /* look for entry in table      */
	{       if (adr==HTSIZE) adr=0; /* wrap around                  */
		h = &voc[adr];          /* point at the entry           */
		switch(type)
		{   case -2:            /* fill in entry                */
			if (h->val)     /* already got an entry?        */
				goto exitloop2;
			h->val=value;
			h->atab=malloc(length(word));
			for (s=word,t=h->atab; *s;)
				*t++ = *s++ ^ '=';
			*t=0^'=';
			/* encrypt slightly to thwart core reader       */
		/*      printf("Stored \"%s\" (%d ch) as entry %d\n",   */
		/*              word, length(word), adr);               */
			return(0);      /* entry unused                 */
		    case -1:            /* looking up user word         */
			if (h->val==0) return(-1);   /* not found    */
			for (s=word, t=h->atab;*t ^ '=';)
				if ((*s++ ^ '=') != *t++)
					goto exitloop2;
			if ((*s ^ '=') != *t && s-word<5) goto exitloop2;
			/* the word matched o.k.                        */
			return(h->val);
		    default:            /* looking up known word        */
			if (h->val==0)
			{       printf("Unable to find %s in vocab\n",word);
				exit(0);
			}
			for (s=word, t=h->atab;*t ^ '=';)
				if ((*s++ ^ '=') != *t++) goto exitloop2;
			/* the word matched o.k.                        */
			if (h->val/1000 != type) continue;
			return(h->val%1000);
		}

	    exitloop2:                  /* hashed entry does not match  */
		if (adr+1==hash || (adr==HTSIZE && hash==0))
		{       printf("Hash table overflow\n");
			exit(0);
		}
	}
}


copystr(w1,w2)                          /* copy one string to another   */
char *w1,*w2;
{       register char *s,*t;
	for (s=w1,t=w2; *s;)
		*t++ = *s++;
	*t=0;
}

weq(w1,w2)                              /* compare words                */
char *w1,*w2;                           /* w1 is user, w2 is system     */
{       register char *s,*t;
	register int i;
	s=w1;
	t=w2;
	for (i=0; i<5; i++)             /* compare at most 5 chars      */
	{       if (*t==0 && *s==0)
			return(TRUE);
		if (*s++ != *t++) return(FALSE);
	}
	return(TRUE);
}


length(str)                             /* includes 0 at end            */
char *str;
{       register char *s;
	register int n;
	for (n=0,s=str; *s++;) n++;
	return(n+1);
}

prht()                                  /* print hash table             */
{       register int i,j,l;
	char *c;
	struct hashtab *h;
	for (i=0; i<HTSIZE/10+1; i++)
	{       printf("%4d",i*10);
		for (j=0; j<10; j++)
		{       if (i*10+j>=HTSIZE) break;
			h= &voc[i*10+j];
			putchar(' ');
			if (h->val==0)
			{       printf("-----");
				continue;
			}
			for (l=0, c=h->atab; l<5; l++)
				if ((*c ^ '=')) putchar(*c++ ^ '=');
				else putchar(' ');
		}
		putchar('\n');
	}
}

