gnushogi/makepattern.c

   1 /*
   2  * FILE: makepattern.c
   3  *
   4  * ----------------------------------------------------------------------
   5  * Copyright (c) 1993, 1994, 1995 Matthias Mutz
   6  * Copyright (c) 1999 Michael Vanier and the Free Software Foundation
   7  * Copyright (c) 2008, 2013, 2014 Yann Dirson and the Free Software Foundation
   8  *
   9  * GNU SHOGI is based on GNU CHESS
  10  *
  11  * Copyright (c) 1988, 1989, 1990 John Stanback
  12  * Copyright (c) 1992 Free Software Foundation
  13  *
  14  * This file is part of GNU SHOGI.
  15  *
  16  * GNU Shogi is free software; you can redistribute it and/or modify it
  17  * under the terms of the GNU General Public License as published by the
  18  * Free Software Foundation; either version 3 of the License,
  19  * or (at your option) any later version.
  20  *
  21  * GNU Shogi is distributed in the hope that it will be useful, but WITHOUT
  22  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  23  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  24  * for more details.
  25  *
  26  * You should have received a copy of the GNU General Public License along
  27  * with GNU Shogi; see the file COPYING. If not, see
  28  * <http://www.gnu.org/licenses/>.
  29  * ----------------------------------------------------------------------
  30  *
  31  */
  32
  33 #include "gnushogi.h"
  34 #include "pattern.h"
  35
  36 #define MAX_PATTERN_DATA     5000
  37 #define MAX_OPENING_SEQUENCE 20
  38 #define MAX_PATTERN          200
  39
  40 bool xboard = false;
  41
  42 small_short pattern_data[MAX_PATTERN_DATA];
  43
  44 /* minimal ShowMessage to avoid dependency on extraneous display code */
  45 static void
  46 Dummy_ShowMessage(char *format, ...)
  47 {
  48     va_list ap;
  49     va_start(ap, format);
  50     vprintf(format, ap);
  51     va_end(ap);
  52 }
  53 static struct display dummydsp = {
  54   .ShowMessage = Dummy_ShowMessage,
  55 };
  56 struct display *dsp = &dummydsp;
  57
  58 #define is_digit(c) (((c) >= '0') && ((c) <= '9'))
  59 #define is_alpha(c) ((((c) >= 'a') && ((c) <= 'z')) \
  60     || (((c) >= 'A') && ((c) <= 'Z')))
  61 #define eos(s)      ((*s == '\0') || (*s == '\n'))
  62
  63
  64 /* skip blanks and comments in brackets */
  65
  66 static void
  67 skipbb(char **s)
  68 {
  69     while ((**s == ' ') || (**s == '|') || (**s == '['))
  70     {
  71         if (**s == '[')
  72         {
  73             while (**s != ']')
  74                 (*s)++;
  75         }
  76
  77         (*s)++;
  78     }
  79 }
  80
  81
  82 /* skip unsigned numbers */
  83
  84 static void
  85 skipi(char **s)
  86 {
  87     while (is_digit(**s))
  88         (*s)++;
  89
  90     skipbb(s);
  91 }
  92
  93
  94 static short
  95 ScanPiece(char **s, small_short *side,
  96           small_short *piece, small_short *square)
  97 {
  98     bool isp;
  99     short isw, c, r;
 100
 101     /* determine promotion status */
 102     if (**s == '+')
 103         isp = true, (*s)++;  /* FIXME: split into two lines. */
 104     else
 105         isp = false;
 106
 107     /* determine side and piece */
 108     for (c = 0; c < NO_PIECES; c++)
 109     {
 110         if ((isw = (**s == pxx[c])) || (**s == qxx[c]))
 111         {
 112             *piece = isp ? promoted[c] : unpromoted[c];
 113             *side  = isw;
 114             (*s)++;
 115             break;
 116         }
 117     }
 118
 119     if (c == NO_PIECES)
 120         return 1;
 121
 122     if (**s == '*')
 123     {
 124         /* piece is captured */
 125         (*s)++;
 126         *square = NO_SQUARES + *piece;
 127     }
 128     else
 129     {
 130         /* determine column */
 131         for (c = 0; c < NO_COLS; c++)
 132         {
 133             if (**s == COL_NAME(c))
 134             {
 135                 (*s)++;
 136                 break;
 137             }
 138         }
 139
 140         if (c >= NO_COLS)
 141             return 1;
 142
 143         /* determine row */
 144         for (r = 0; r < NO_ROWS; r++)
 145         {
 146             if (**s == ROW_NAME(r))
 147             {
 148                 (*s)++;
 149                 break;
 150             }
 151         }
 152
 153         if (r >= NO_ROWS)
 154             return 1;
 155
 156         /* determine square */
 157         *square = r * NO_COLS + c;
 158     }
 159
 160     skipbb(s);
 161     return 0;
 162 }
 163
 164
 165 static short
 166 ScanPattern (char *s, short *pindex)
 167 {
 168     small_short side, piece, square;
 169     skipbb(&s); /* skip blanks and comments */
 170
 171     while (is_digit(*s))
 172     {
 173         pattern_data[(*pindex)++] = atoi(s);
 174         skipi(&s);
 175     }
 176
 177     pattern_data[(*pindex)++] = END_OF_LINKS;
 178     skipbb(&s);
 179
 180     while (!eos(s))
 181     {
 182         if (ScanPiece(&s, &side, &piece, &square))
 183         {
 184             return 1;
 185         }
 186         else
 187         {
 188             pattern_data[(*pindex)++] = piece;
 189             pattern_data[(*pindex)++] = (side ? -square : square);
 190         }
 191
 192     }
 193
 194     pattern_data[(*pindex)++] = END_OF_FIELDS;
 195     return 0;
 196 }
 197
 198
 199 void
 200 ReadOpeningSequences (short *pindex, const char* patternfile)
 201 {
 202     FILE *fd;
 203     char s[256];
 204     short max_pattern = 0;
 205     short max_opening_sequence = 0;
 206
 207     fd = fopen (patternfile, "r");
 208
 209     if (fd == NULL) {
 210         sprintf(s, "no pattern file '%s'", patternfile);
 211         dsp->ShowMessage(s);
 212         return;
 213     }
 214
 215     *pindex = 0;
 216
 217     while (fgets (s, 256, fd) != NULL)
 218     {
 219         if (*s == '#')
 220         {
 221             /* comment, skip line */
 222         }
 223         else if (is_alpha(*s))
 224         {
 225             if (max_opening_sequence++ > 0)
 226             {
 227                 pattern_data[(*pindex)++] = END_OF_PATTERNS;
 228             }
 229
 230             pattern_data[(*pindex)++] = ValueOfOpeningName(s);
 231         }
 232         else
 233         {
 234             if (ScanPattern(s, pindex))
 235             {
 236                 dsp->ShowMessage("error in pattern sequence...");
 237                 exit(1);
 238             }
 239             else
 240             {
 241                 max_pattern++;
 242             }
 243         }
 244     }
 245
 246     pattern_data[(*pindex)++] = END_OF_PATTERNS;
 247     pattern_data[(*pindex)++] = END_OF_SEQUENCES;
 248
 249     sprintf(s,
 250             "Pattern: %d bytes for %d sequences with %d patterns.\n",
 251             *pindex, max_opening_sequence, max_pattern);
 252     dsp->ShowMessage(s);
 253
 254     fclose(fd);
 255 }
 256
 257
 258 void
 259 WriteOpeningSequences (short pindex, const char* patternincfile)
 260 {
 261     FILE *fd;
 262     short n = 0;
 263     short max_pattern = 0;
 264     short max_opening_sequence = 0;
 265
 266     fd = fopen (patternincfile, "w");
 267     fprintf(fd, "#define MAX_PATTERN_DATA %d\n\n", pindex);
 268     fprintf(fd, "small_short pattern_data[MAX_PATTERN_DATA] =\n{\n");
 269
 270     do
 271     {
 272         fprintf(fd, "  %d,\n", pattern_data[n++]);
 273
 274         do
 275         {
 276             fprintf(fd, "    ");
 277
 278             /* write links */
 279             while (pattern_data[n] != END_OF_LINKS)
 280             {
 281                 fprintf(fd, "%d, ", pattern_data[n++]);
 282             };
 283
 284             fprintf(fd, "%d, ", pattern_data[n++]);
 285
 286             /* write pattern */
 287             do
 288             {
 289                 fprintf(fd, "%d,", pattern_data[n++]);
 290             }
 291             while (pattern_data[n] != END_OF_FIELDS);
 292
 293             fprintf(fd, "%d,\n", pattern_data[n++]);
 294             max_pattern++;
 295         }
 296         while (pattern_data[n] != END_OF_PATTERNS);
 297
 298         fprintf(fd, "    %d,\n", pattern_data[n++]);
 299         max_opening_sequence++;
 300     }
 301     while (pattern_data[n] != END_OF_SEQUENCES);
 302
 303     fprintf(fd, "  %d\n}; \n", pattern_data[n++]);
 304     fprintf(fd, "\n#define MAX_OPENING_SEQUENCE %d\n", max_opening_sequence);
 305     fprintf(fd, "\n#define MAX_PATTERN %d\n", max_pattern);
 306     fclose(fd);
 307 }
 308
 309