battlestar/parse.c

   1 /*      $NetBSD: parse.c,v 1.14 2004/01/27 20:30:29 jsm Exp $   */
   2
   3 /*
   4  * Copyright (c) 1983, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the University nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 #ifndef lint
  34 #if 0
  35 static char sccsid[] = "@(#)parse.c     8.2 (Berkeley) 4/28/95";
  36 #else
  37 __RCSID("$NetBSD: parse.c,v 1.14 2004/01/27 20:30:29 jsm Exp $");
  38 #endif
  39 #endif                          /* not lint */
  40
  41 #include "extern.h"
  42
  43 #define HASHSIZE        256
  44 #define HASHMUL         81
  45 #define HASHMASK        (HASHSIZE - 1)
  46
  47 static int hash(const char *);
  48 static void install(struct wlist *);
  49 static struct wlist *lookup(const char *);
  50
  51 static struct wlist *hashtab[HASHSIZE];
  52
  53 void
  54 wordinit()
  55 {
  56         struct wlist *w;
  57
  58         for (w = wlist; w->string; w++)
  59                 install(w);
  60 }
  61
  62 static int
  63 hash(s)
  64         const char   *s;
  65 {
  66         int     hashval = 0;
  67
  68         while (*s) {
  69                 hashval += *s++;
  70                 hashval *= HASHMUL;
  71                 hashval &= HASHMASK;
  72         }
  73         return hashval;
  74 }
  75
  76 static struct wlist *
  77 lookup(s)
  78         const char   *s;
  79 {
  80         struct wlist *wp;
  81
  82         for (wp = hashtab[hash(s)]; wp != NULL; wp = wp->next)
  83                 if (*s == *wp->string && strcmp(s, wp->string) == 0)
  84                         return wp;
  85         return NULL;
  86 }
  87
  88 static void
  89 install(wp)
  90         struct wlist *wp;
  91 {
  92         int     hashval;
  93
  94         if (lookup(wp->string) == NULL) {
  95                 hashval = hash(wp->string);
  96                 wp->next = hashtab[hashval];
  97                 hashtab[hashval] = wp;
  98         } else
  99                 printf("Multiply defined %s.\n", wp->string);
 100 }
 101
 102 void
 103 parse()
 104 {
 105         struct wlist *wp;
 106         int     n;
 107         int     flag;
 108
 109         wordnumber = 0;         /* for cypher */
 110         for (n = 0; n <= wordcount; n++) {
 111                 if ((wp = lookup(words[n])) == NULL) {
 112                         wordvalue[n] = -1;
 113                         wordtype[n] = -1;
 114                 } else {
 115                         wordvalue[n] = wp->value;
 116                         wordtype[n] = wp->article;
 117                 }
 118         }
 119         /* We never use adjectives for anything, so yank them all. */
 120         for (n = 1; n < wordcount; n++)
 121                 if (wordtype[n] == ADJS) {
 122                         int i;
 123                         for (i = n + 1; i < wordcount; i++) {
 124                                 wordtype[i - 1] = wordtype[i];
 125                                 wordvalue[i - 1] = wordvalue[i];
 126                                 strcpy(words[i - 1], words[i]);
 127                         }
 128                         wordcount--;
 129                 }
 130         /* Don't let a comma mean AND if followed by a verb. */
 131         for (n = 0; n < wordcount; n++)
 132                 if (wordvalue[n] == AND && words[n][0] == ','
 133                     && wordtype[n + 1] == VERB) {
 134                         wordvalue[n] = -1;
 135                         wordtype[n] = -1;
 136                 }
 137         /* Trim "AND AND" which can happen naturally at the end of a
 138          * comma-delimited list.
 139          */
 140         for (n = 1; n < wordcount; n++)
 141                 if (wordvalue[n - 1] == AND && wordvalue[n] == AND) {
 142                         int i;
 143                         for (i = n + 1; i < wordcount; i++) {
 144                                 wordtype[i - 1] = wordtype[i];
 145                                 wordvalue[i - 1] = wordvalue[i];
 146                                 strcpy(words[i - 1], words[i]);
 147                         }
 148                         wordcount--;
 149                 }
 150
 151         /* If there is a sequence (NOUN | OBJECT) AND EVERYTHING
 152          * then move all the EVERYTHINGs to the beginning, since that's where
 153          * they're expected.  We can't get rid of the NOUNs and OBJECTs in
 154          * case they aren't in EVERYTHING (i.e. not here or nonexistent).
 155          */
 156         flag = 1;
 157         while (flag) {
 158                 flag = 0;
 159                 for (n = 1; n < wordcount; n++)
 160                         if ((wordtype[n - 1] == NOUNS || wordtype[n - 1] == OBJECT) &&
 161                             wordvalue[n] == AND && wordvalue[n + 1] == EVERYTHING) {
 162                                 char tmpword[WORDLEN];
 163                                 wordvalue[n + 1] = wordvalue[n - 1];
 164                                 wordvalue[n - 1] = EVERYTHING;
 165                                 wordtype[n + 1] = wordtype[n - 1];
 166                                 wordtype[n - 1] = OBJECT;
 167                                 strcpy(tmpword, words[n - 1]);
 168                                 strcpy(words[n - 1], words[n + 1]);
 169                                 strcpy(words[n + 1], tmpword);
 170                                 flag = 1;
 171                 }
 172                 /* And trim EVERYTHING AND EVERYTHING. */
 173                 for (n = 1; n < wordcount; n++)
 174                         if (wordvalue[n - 1] == EVERYTHING &&
 175                             wordvalue[n] == AND && wordvalue[n + 1] == EVERYTHING) {
 176                                 int i;
 177                                 for (i = n + 1; i < wordcount; i++) {
 178                                         wordtype[i - 1] = wordtype[i + 1];
 179                                         wordvalue[i - 1] = wordvalue[i + 1];
 180                                         strcpy(words[i - 1], words[i + 1]);
 181                                 }
 182                                 wordcount--;
 183                                 wordcount--;
 184                                 flag = 1;
 185                         }
 186         }
 187 }