![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vocab.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / games / adventure|
Return to vocab.c CVS log | Up to [CSRG BSD Unix] / 43BSD / games / adventure |
1.1 root 1: #
2: /* Re-coding of advent in C: data structure routines */
3:
4: static char sccsid[] = " vocab.c 4.1 82/05/11 ";
5:
6: # include "hdr.h"
7:
8: dstroy(object)
9: int object;
10: { move(object,0);
11: }
12:
13: juggle(object)
14: int object;
15: { register int i,j;
16: i=place[object];
17: j=fixed[object];
18: move(object,i);
19: move(object+100,j);
20: }
21:
22:
23: move(object,where)
24: int object,where;
25: { register int from;
26: if (object<=100)
27: from=place[object];
28: else
29: from=fixed[object-100];
30: if (from>0 && from<=300) carry(object,from);
31: drop(object,where);
32: }
33:
34:
35: put(object,where,pval)
36: int object,where,pval;
37: { move(object,where);
38: return(-1-pval);
39: }
40:
41:
42:
43: carry(object,where)
44: int object,where;
45: { register int temp;
46: if (object<=100)
47: { if (place[object]== -1) return;
48: place[object] = -1;
49: holdng++;
50: }
51: if (atloc[where]==object)
52: { atloc[where]=link[object];
53: return;
54: }
55: for (temp=atloc[where]; link[temp]!=object; temp=link[temp]);
56: link[temp]=link[object];
57: }
58:
59:
60:
61:
62: drop(object,where)
63: int object,where;
64: { if (object>100) fixed[object-100]=where;
65: else
66: { if (place[object]== -1) holdng--;
67: place[object]=where;
68: }
69: if (where<=0) return;
70: link[object]=atloc[where];
71: atloc[where]=object;
72: }
73:
74:
75: vocab(word,type,value) /* look up or store a word */
76: char *word;
77: int type; /* -2 for store, -1 for user word, >=0 for canned lookup*/
78: int value; /* used for storing only */
79: { register int adr;
80: register char *s,*t;
81: int hash, i;
82: struct hashtab *h;
83: for (hash=0,s=word,i=0; i<5 &&*s; i++) /* some kind of hash */
84: hash += *s++; /* add all chars in the word */
85: hash = (hash*3719)&077777; /* pulled that one out of a hat */
86: hash %= HTSIZE; /* put it into range of table */
87:
88: for(adr=hash;; adr++) /* look for entry in table */
89: { if (adr==HTSIZE) adr=0; /* wrap around */
90: h = &voc[adr]; /* point at the entry */
91: switch(type)
92: { case -2: /* fill in entry */
93: if (h->val) /* already got an entry? */
94: goto exitloop2;
95: h->val=value;
96: h->atab=malloc(length(word));
97: for (s=word,t=h->atab; *s;)
98: *t++ = *s++ ^ '=';
99: *t=0^'=';
100: /* encrypt slightly to thwart core reader */
101: /* printf("Stored \"%s\" (%d ch) as entry %d\n", */
102: /* word, length(word), adr); */
103: return(0); /* entry unused */
104: case -1: /* looking up user word */
105: if (h->val==0) return(-1); /* not found */
106: for (s=word, t=h->atab;*t ^ '=';)
107: if ((*s++ ^ '=') != *t++)
108: goto exitloop2;
109: if ((*s ^ '=') != *t && s-word<5) goto exitloop2;
110: /* the word matched o.k. */
111: return(h->val);
112: default: /* looking up known word */
113: if (h->val==0)
114: { printf("Unable to find %s in vocab\n",word);
115: exit(0);
116: }
117: for (s=word, t=h->atab;*t ^ '=';)
118: if ((*s++ ^ '=') != *t++) goto exitloop2;
119: /* the word matched o.k. */
120: if (h->val/1000 != type) continue;
121: return(h->val%1000);
122: }
123:
124: exitloop2: /* hashed entry does not match */
125: if (adr+1==hash || (adr==HTSIZE && hash==0))
126: { printf("Hash table overflow\n");
127: exit(0);
128: }
129: }
130: }
131:
132:
133: copystr(w1,w2) /* copy one string to another */
134: char *w1,*w2;
135: { register char *s,*t;
136: for (s=w1,t=w2; *s;)
137: *t++ = *s++;
138: *t=0;
139: }
140:
141: weq(w1,w2) /* compare words */
142: char *w1,*w2; /* w1 is user, w2 is system */
143: { register char *s,*t;
144: register int i;
145: s=w1;
146: t=w2;
147: for (i=0; i<5; i++) /* compare at most 5 chars */
148: { if (*t==0 && *s==0)
149: return(TRUE);
150: if (*s++ != *t++) return(FALSE);
151: }
152: return(TRUE);
153: }
154:
155:
156: length(str) /* includes 0 at end */
157: char *str;
158: { register char *s;
159: register int n;
160: for (n=0,s=str; *s++;) n++;
161: return(n+1);
162: }
163:
164: prht() /* print hash table */
165: { register int i,j,l;
166: char *c;
167: struct hashtab *h;
168: for (i=0; i<HTSIZE/10+1; i++)
169: { printf("%4d",i*10);
170: for (j=0; j<10; j++)
171: { if (i*10+j>=HTSIZE) break;
172: h= &voc[i*10+j];
173: putchar(' ');
174: if (h->val==0)
175: { printf("-----");
176: continue;
177: }
178: for (l=0, c=h->atab; l<5; l++)
179: if ((*c ^ '=')) putchar(*c++ ^ '=');
180: else putchar(' ');
181: }
182: putchar('\n');
183: }
184: }
185:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.