usr.bin/make/hash_tables.c

   1 /*
   2  * DO NOT EDIT
   3  * $FreeBSD$
   4  * auto-generated from FreeBSD: src/usr.bin/make/parse.c,v 1.114 2008/03/12 14:50:58 obrien Exp
   5  * DO NOT EDIT
   6  */
   7 #include <sys/types.h>
   8
   9 #include "hash_tables.h"
  10
  11 /*
  12  * d=2
  13  * n=40
  14  * m=19
  15  * c=2.09
  16  * maxlen=1
  17  * minklen=2
  18  * maxklen=9
  19  * minchar=97
  20  * maxchar=119
  21  * loop=0
  22  * numiter=1
  23  * seed=
  24  */
  25
  26 static const signed char directive_g[] = {
  27         8, 0, 0, 5, 6, -1, 17, 15, 10, 6,
  28         -1, -1, 10, 0, 0, -1, 18, 2, 3, 0,
  29         7, -1, -1, -1, 0, 14, -1, -1, 11, 16,
  30         -1, -1, 0, -1, 0, 0, 17, 0, -1, 1,
  31 };
  32
  33 static const u_char directive_T0[] = {
  34         26, 14, 19, 35, 10, 34, 18, 27, 1, 17,
  35         22, 37, 12, 12, 36, 21, 0, 6, 1, 25,
  36         9, 4, 19,
  37 };
  38
  39 static const u_char directive_T1[] = {
  40         25, 22, 19, 0, 2, 18, 33, 18, 30, 4,
  41         30, 9, 21, 19, 16, 12, 35, 34, 4, 19,
  42         9, 33, 16,
  43 };
  44
  45
  46 int
  47 directive_hash(const u_char *key, size_t len)
  48 {
  49         unsigned f0, f1;
  50         const u_char *kp = key;
  51
  52         if (len < 2 || len > 9)
  53                 return -1;
  54
  55         for (f0=f1=0; kp < key + len; ++kp) {
  56                 if (*kp < 97 || *kp > 119)
  57                         return -1;
  58                 f0 += directive_T0[-97 + *kp];
  59                 f1 += directive_T1[-97 + *kp];
  60         }
  61
  62         f0 %= 40;
  63         f1 %= 40;
  64
  65         return (directive_g[f0] + directive_g[f1]) % 19;
  66 }
  67 /*
  68  * d=2
  69  * n=74
  70  * m=35
  71  * c=2.09
  72  * maxlen=1
  73  * minklen=4
  74  * maxklen=13
  75  * minchar=46
  76  * maxchar=95
  77  * loop=0
  78  * numiter=4
  79  * seed=
  80  */
  81
  82 static const signed char keyword_g[] = {
  83         12, 18, 7, 25, 30, 5, -1, -1, -1, 7,
  84         -1, 0, 33, 0, 4, -1, -1, 13, 29, 0,
  85         -1, 28, -1, 28, -1, 0, -1, 27, 4, 34,
  86         -1, -1, -1, 30, 13, 10, -1, -1, 0, 10,
  87         24, -1, -1, -1, 0, 6, 0, 0, -1, 23,
  88         -1, -1, -1, 0, -1, 23, -1, -1, 19, 4,
  89         -1, 31, 12, 16, -1, 20, 22, 9, 0, -1,
  90         -1, 9, 4, 0,
  91 };
  92
  93 static const u_char keyword_T0[] = {
  94         34, 28, 50, 61, 14, 57, 48, 60, 20, 67,
  95         60, 63, 0, 24, 28, 2, 49, 64, 18, 23,
  96         36, 33, 40, 14, 38, 42, 71, 49, 2, 53,
  97         53, 37, 7, 29, 24, 21, 12, 50, 59, 10,
  98         43, 23, 0, 44, 47, 6, 46, 22, 48, 64,
  99 };
 100
 101 static const u_char keyword_T1[] = {
 102         18, 67, 39, 60, 7, 70, 2, 26, 31, 18,
 103         73, 47, 61, 17, 38, 50, 22, 52, 13, 55,
 104         56, 32, 63, 4, 64, 55, 49, 21, 47, 67,
 105         33, 66, 60, 73, 30, 68, 69, 32, 72, 4,
 106         28, 49, 51, 15, 66, 68, 43, 67, 46, 56,
 107 };
 108
 109
 110 int
 111 keyword_hash(const u_char *key, size_t len)
 112 {
 113         unsigned f0, f1;
 114         const u_char *kp = key;
 115
 116         if (len < 4 || len > 13)
 117                 return -1;
 118
 119         for (f0=f1=0; *kp; ++kp) {
 120                 if (*kp < 46 || *kp > 95)
 121                         return -1;
 122                 f0 += keyword_T0[-46 + *kp];
 123                 f1 += keyword_T1[-46 + *kp];
 124         }
 125
 126         f0 %= 74;
 127         f1 %= 74;
 128
 129         return (keyword_g[f0] + keyword_g[f1]) % 35;
 130 }