Return to parse.c CVS log

Up to [CSRG BSD Unix] / 43BSD / games / battlestar

Annotation of 43BSD/games/battlestar/parse.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Copyright (c) 1983 Regents of the University of California,
                      3:  * All rights reserved.  Redistribution permitted subject to
                      4:  * the terms of the Berkeley Software License Agreement.
                      5:  */
                      6: 
                      7: #ifndef lint
                      8: static char sccsid[] = "@(#)parse.c    1.2 4/24/85";
                      9: #endif
                     10: 
                     11: #include "externs.h"
                     12: 
                     13: wordinit()
                     14: {
                     15:        register struct wlist *w;
                     16: 
                     17:        for (w = wlist; w->string; w++)
                     18:                install(w);
                     19: }
                     20: 
                     21: hash(s)
                     22:        register char *s;
                     23: {
                     24:        register hashval = 0;
                     25: 
                     26:        while (*s) {
                     27:                hashval += *s++;
                     28:                hashval *= HASHMUL;
                     29:                hashval &= HASHMASK;
                     30:        }
                     31:        return hashval;
                     32: }
                     33: 
                     34: struct wlist *
                     35: lookup(s)
                     36:        char *s;
                     37: {
                     38:        register struct wlist *wp;
                     39: 
                     40:        for (wp = hashtab[hash(s)]; wp != NULL; wp = wp->next)
                     41:                if (*s == *wp->string && strcmp(s, wp->string) == 0)
                     42:                        return wp;
                     43:        return NULL;
                     44: }
                     45: 
                     46: install(wp)
                     47:        register struct wlist *wp;
                     48: {
                     49:        int hashval;
                     50: 
                     51:        if (lookup(wp->string) == NULL) {
                     52:                hashval = hash(wp->string);
                     53:                wp->next = hashtab[hashval];
                     54:                hashtab[hashval] = wp;
                     55:        } else
                     56:                printf("Multiply defined %s.\n", wp->string);
                     57: }
                     58: 
                     59: parse()
                     60: {
                     61:        register struct wlist *wp;
                     62:        register n;
                     63: 
                     64:        wordnumber = 0;           /* for cypher */
                     65:        for (n = 0; n <= wordcount; n++) {
                     66:                if ((wp = lookup(words[n])) == NULL) {
                     67:                        wordvalue[n] = -1;
                     68:                        wordtype[n] = -1;
                     69:                } else {
                     70:                        wordvalue[n] = wp -> value;
                     71:                        wordtype[n] = wp -> article;
                     72:                }
                     73:        }
                     74: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.