ircd/table_gen.c

   1 /*
   2  * IRC - Internet Relay Chat, include/common.c
   3  * Copyright (C) 1998 Andrea Cocito
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 1, or (at your option)
   8  * any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19
  20 /*
  21  * TABLE GENERATOR
  22  * The following part of code is NOT included in the actual server's
  23  * or library source, it's just used to build the above tables
  24  *
  25  * This should rebuild the actual tables and automatically place them
  26  * into this source file, note that this part of code is for developers
  27  * only, it's supposed to work on both signed and unsigned chars but I
  28  * actually tested it only on signed-char architectures, the code and
  29  * macros actually used by the server instead DO work and have been tested
  30  * on platforms where0 char is both signed or unsigned, this is true as long
  31  * as the <limits.h> macros are set properly and without any need to rebuild
  32  * the tables (which as said an admin should NEVER do, tables need to be rebuilt
  33  * only when one wants to really change the results or when one has to
  34  * compile on architectures where a char is NOT eight bits [?!], yes
  35  * it all is supposed to work in that case too... but I can't test it
  36  * because I've not found a machine in the world where this happens).
  37  *
  38  * NEVER -f[un]signed-char on gcc since that does NOT fix the named macros
  39  * and you end up in a non-ANSI environment where CHAR_MIN and CHAR_MAX
  40  * are _not_ the real limits of a default 'char' type. This is true for
  41  * both admins and coders.
  42  *
  43  */
  44 #include "config.h"
  45
  46 #include "ircd_chattr.h"
  47 #include <stdlib.h>
  48 #include <stdio.h>
  49 #include <ctype.h>
  50
  51
  52 static void zeroTables(void);
  53 static void markString(int macro, const char *s);
  54 static void unMarkString(int macro, const char *s);
  55 static void markRange(int macro, char from, char to);
  56 static void moveMacro(int from, int to);
  57 static void setLowHi(const char firstlow, const char lastlow,
  58     const char firsthi);
  59
  60 char NTL_tolower_tab[1 + CHAR_MAX - CHAR_MIN];  /* 256 bytes */
  61 char NTL_toupper_tab[1 + CHAR_MAX - CHAR_MIN];  /* 256 bytes */
  62 int NTL_char_attrib[1 + CHAR_MAX - CHAR_MIN];   /* 256 ints = 0.5 to 2 kilobytes */
  63
  64 /*
  65  * makeTables()
  66  * Where we make the tables, edit ONLY this to change the tables.
  67  */
  68
  69 static void makeTables(void)
  70 {
  71
  72   /* Start from a known status */
  73   zeroTables();
  74
  75   /* Make the very elementary sets */
  76   markRange(NTL_LOWER, 'a', 'z');
  77   markString(NTL_LOWER, "{|}~");
  78
  79   markRange(NTL_UPPER, 'A', 'Z');
  80   markString(NTL_UPPER, "[\\]^");
  81
  82   markRange(NTL_DIGIT, '0', '9');
  83
  84   markRange(NTL_CNTRL, '\000', '\037');
  85
  86   markString(NTL_PUNCT, "!\"#$%&'()*+,-./:;<=>?@_`");
  87
  88   markString(NTL_SPACE, "\011\012\013\014\015\040");
  89
  90   /* Make the derived sets,
  91    * WARNING: The order of these calls is important, some depend on
  92    * the results of the previous ones ! */
  93
  94   moveMacro(NTL_LOWER | NTL_UPPER, NTL_ALPHA);
  95   moveMacro(NTL_ALPHA | NTL_DIGIT, NTL_ALNUM);
  96   moveMacro(NTL_ALNUM | NTL_PUNCT, NTL_GRAPH);
  97
  98   moveMacro(NTL_GRAPH, NTL_PRINT);
  99   markString(NTL_PRINT, " ");
 100
 101   markRange(NTL_IRCCH, '\041', (char) UCHAR_MAX);
 102   unMarkString(NTL_IRCCH, "\054\240");
 103
 104   markRange(NTL_IRCCL, '\300', '\326');
 105   markRange(NTL_IRCCL, '\330', '\336');
 106
 107   moveMacro(NTL_ALNUM, NTL_IRCHN);
 108   markString(NTL_IRCHN, "-_."); /* Some DNS might allow '_' per RFC 1033 ! */
 109
 110   moveMacro(NTL_DIGIT, NTL_IRCIP);
 111   markString(NTL_IRCIP, ".");
 112
 113   moveMacro(NTL_DIGIT, NTL_IRCIP6);
 114   markString(NTL_IRCIP6, ":.ABCDEFabcdef");
 115
 116   moveMacro(NTL_DIGIT | NTL_ALPHA, NTL_IRCNK);
 117   markString(NTL_IRCNK, "-_`");
 118
 119   moveMacro(NTL_ALNUM, NTL_IRCUI);
 120   markRange(NTL_IRCUI, '\xe0', '\xf6');
 121   markRange(NTL_IRCUI, '\xf8', '\xfe');
 122   markRange(NTL_IRCUI, '\xc0', '\xd6');
 123   markRange(NTL_IRCUI, '\xd8', '\xde');
 124   markString(NTL_IRCUI, ".-_^'`~");
 125   markString(NTL_EOL, "\n\r");
 126   markString(NTL_CHPFX, "#&");
 127   markString(NTL_KTIME, " ,-0123456789");
 128
 129   /* And finally let's take care of the toLower/toUpper stuff */
 130
 131   setLowHi('a', 'z', 'A');
 132   setLowHi('\xe0', '\xf6', '\xc0');
 133   setLowHi('\xf8', '\xfe', '\xd8');
 134   setLowHi('{', '~', '[');
 135 }
 136
 137 /*
 138  * main()
 139  * This is the main program to be executed for -DMAKETABLES
 140  */
 141
 142 static void dumphw(int *p, int beg);
 143 static void dumphb(char *p, int beg);
 144
 145 int main(void)
 146 {
 147   int i;
 148
 149   /* Make the tables */
 150   makeTables();
 151
 152   /* Dump them as ANSI C source to be included below */
 153   printf("/*\n * Automatically Generated Tables - DO NOT EDIT\n */\n");
 154   printf("#include <limits.h>\n");
 155
 156   /* NTL_tolower_tab */
 157   printf("const char ToLowerTab_8859_1[] = {\n");
 158   printf("#if (CHAR_MIN<0)\n");
 159   i = (int)((char)SCHAR_MIN);
 160   dumphb(NTL_tolower_tab, i);
 161   printf("                ,\n");
 162   printf("#endif /* (CHAR_MIN<0) */\n");
 163   i = 0;
 164   dumphb(NTL_tolower_tab, i);
 165   printf("#if (!(CHAR_MIN<0))\n");
 166   printf("                ,\n");
 167   i = (int)((char)SCHAR_MIN);
 168   dumphb(NTL_tolower_tab, i);
 169   printf("#endif /* (!(CHAR_MIN<0)) */\n");
 170   printf("  };\n\n");
 171
 172   /* NTL_toupper_tab */
 173   printf("const char ToUpperTab_8859_1[] = {\n");
 174   printf("#if (CHAR_MIN<0)\n");
 175   i = (int)((char)SCHAR_MIN);
 176   dumphb(NTL_toupper_tab, i);
 177   printf("                ,\n");
 178   printf("#endif /* (CHAR_MIN<0) */\n");
 179   i = 0;
 180   dumphb(NTL_toupper_tab, i);
 181   printf("#if (!(CHAR_MIN<0))\n");
 182   printf("                ,\n");
 183   i = (int)((char)SCHAR_MIN);
 184   dumphb(NTL_toupper_tab, i);
 185   printf("#endif /* (!(CHAR_MIN<0)) */\n");
 186   printf("  };\n\n");
 187
 188   /* NTL_char_attrib */
 189   printf("const unsigned int IRCD_CharAttrTab[] = {\n");
 190   printf("#if (CHAR_MIN<0)\n");
 191   i = (int)((char)SCHAR_MIN);
 192   dumphw(NTL_char_attrib, i);
 193   printf("                ,\n");
 194   printf("#endif /* (CHAR_MIN<0) */\n");
 195   i = 0;
 196   dumphw(NTL_char_attrib, i);
 197   printf("#if (!(CHAR_MIN<0))\n");
 198   printf("                ,\n");
 199   i = (int)((char)SCHAR_MIN);
 200   dumphw(NTL_char_attrib, i);
 201   printf("#endif /* (!(CHAR_MIN<0)) */\n");
 202   printf("  };\n\n");
 203
 204   return 0;
 205
 206 }
 207
 208 /* A few utility functions for makeTables() */
 209
 210 static void zeroTables(void)
 211 {
 212   int i;
 213   for (i = CHAR_MIN; i <= CHAR_MAX; i++)
 214   {
 215     NTL_tolower_tab[i - CHAR_MIN] = (char)i;    /* Unchanged */
 216     NTL_toupper_tab[i - CHAR_MIN] = (char)i;    /* Unchanged */
 217     NTL_char_attrib[i - CHAR_MIN] = 0x0000;     /* Nothing */
 218   }
 219 }
 220
 221 static void markString(int macro, const char *s)
 222 {
 223   while (*s)
 224     NTL_char_attrib[*(s++) - CHAR_MIN] |= macro;
 225 }
 226
 227 static void unMarkString(int macro, const char *s)
 228 {
 229   while (*s)
 230     NTL_char_attrib[*(s++) - CHAR_MIN] &= ~macro;
 231 }
 232
 233 static void markRange(int macro, char from, char to)
 234 {
 235   int i;
 236   for (i = CHAR_MIN; i <= CHAR_MAX; i++)
 237     if (((unsigned char)i >= (unsigned char)from)
 238         && ((unsigned char)i <= (unsigned char)to))
 239       NTL_char_attrib[(char)i - CHAR_MIN] |= macro;
 240 }
 241
 242 static void moveMacro(int from, int to)
 243 {
 244   int i;
 245   for (i = CHAR_MIN; i <= CHAR_MAX; i++)
 246     if (NTL_char_attrib[i - CHAR_MIN] & from)
 247       NTL_char_attrib[i - CHAR_MIN] |= to;
 248 }
 249
 250 static void setLowHi(const char firstlow, const char lastlow,
 251     const char firsthi)
 252 {
 253   int i, j;
 254   for (i = CHAR_MIN; i <= CHAR_MAX; i++)
 255     if (((unsigned char)i >= (unsigned char)firstlow)
 256         && ((unsigned char)i <= (unsigned char)lastlow))
 257     {
 258       j = ((int)((char)(i + (int)(firsthi - firstlow))));
 259       NTL_tolower_tab[((char)j) - CHAR_MIN] = (char)i;
 260       NTL_toupper_tab[((char)i) - CHAR_MIN] = (char)j;
 261     }
 262 }
 263
 264 /* These are used in main() to actually dump the tables, each function
 265    dumps half table as hex/char constants... */
 266
 267 #define ROWSIZE 8
 268
 269 static void dumphb(char *tbl, int beg)
 270 {
 271   int i, j, k;
 272   char *p = &tbl[beg - CHAR_MIN];
 273   unsigned char c;
 274   for (i = 0; i <= SCHAR_MAX; i += ROWSIZE)
 275   {
 276     k = i + ROWSIZE - 1;
 277     if (k > SCHAR_MAX)
 278       k = SCHAR_MAX;
 279
 280     c = (unsigned char)(beg + i);
 281     printf("/*");
 282     if ((c > 0) && (c < SCHAR_MAX) && (isprint(c)) && (c != '\\')
 283         && (c != '\''))
 284       printf(" '%c'", c);
 285     else
 286       printf(" x%02x", ((int)c));
 287
 288     c = (unsigned char)(beg + k);
 289     printf("-");
 290     if ((c > 0) && (c < SCHAR_MAX) && (isprint(c)) && (c != '\\')
 291         && (c != '\''))
 292       printf("'%c'", c);
 293     else
 294       printf("x%02x", ((int)c));
 295     printf(" */");
 296
 297     for (j = i; j <= k; j++)
 298     {
 299       c = p[j];
 300       if ((c > 0) && (c < SCHAR_MAX) && (isprint(c)) && (c != '\\')
 301           && (c != '\''))
 302         printf("    '%c'", c);
 303       else
 304         printf(" '\\x%02x'", ((int)c));
 305       if (j < SCHAR_MAX)
 306         printf(",");
 307     }
 308     printf("\n");
 309   }
 310 }
 311
 312 static void dumphw(int *tbl, int beg)
 313 {
 314   int i, j, k;
 315   int *p = &tbl[beg - CHAR_MIN];
 316   unsigned char c;
 317   for (i = 0; i <= SCHAR_MAX; i += ROWSIZE)
 318   {
 319     k = i + ROWSIZE - 1;
 320     if (k > SCHAR_MAX)
 321       k = SCHAR_MAX;
 322
 323     c = (unsigned char)(beg + i);
 324     printf("/*");
 325     if ((c > 0) && (c < SCHAR_MAX) && (isprint(c)) && (c != '\\')
 326         && (c != '\''))
 327       printf(" '%c'", c);
 328     else
 329       printf(" x%02x", ((int)c));
 330
 331     c = (unsigned char)(beg + k);
 332     printf("-");
 333     if ((c > 0) && (c < SCHAR_MAX) && (isprint(c)) && (c != '\\')
 334         && (c != '\''))
 335       printf("'%c'", c);
 336     else
 337       printf("x%02x", ((int)c));
 338     printf(" */");
 339
 340     for (j = i; j <= k; j++)
 341     {
 342       printf(" 0x%04x", p[j] & 0xffffffff);
 343       if (j < SCHAR_MAX)
 344         printf(",");
 345     }
 346     printf("\n");
 347   }
 348 }
 349