parser.l

   1 %a 10000\r
   2 %o 10000\r
   3 %e 2000\r
   4 %k 2500\r
   5 %p 7000\r
   6 %n 1000\r
   7 %{\r
   8 /*\r
   9  * parser.l -- lex parser of algebraic chess moves for XBoard\r
  10  * $Id: parser.l,v 2.1 2003/10/27 19:21:00 mann Exp $\r
  11  *\r
  12  * Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts.\r
  13  * Enhancements Copyright 1992-95 Free Software Foundation, Inc.\r
  14  *\r
  15  * The following terms apply to Digital Equipment Corporation's copyright\r
  16  * interest in XBoard:\r
  17  * ------------------------------------------------------------------------\r
  18  * All Rights Reserved\r
  19  *\r
  20  * Permission to use, copy, modify, and distribute this software and its\r
  21  * documentation for any purpose and without fee is hereby granted,\r
  22  * provided that the above copyright notice appear in all copies and that\r
  23  * both that copyright notice and this permission notice appear in\r
  24  * supporting documentation, and that the name of Digital not be\r
  25  * used in advertising or publicity pertaining to distribution of the\r
  26  * software without specific, written prior permission.\r
  27  *\r
  28  * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING\r
  29  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL\r
  30  * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR\r
  31  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,\r
  32  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,\r
  33  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS\r
  34  * SOFTWARE.\r
  35  * ------------------------------------------------------------------------\r
  36  *\r
  37  * The following terms apply to the enhanced version of XBoard distributed\r
  38  * by the Free Software Foundation:\r
  39  * ------------------------------------------------------------------------\r
  40  * This program is free software; you can redistribute it and/or modify\r
  41  * it under the terms of the GNU General Public License as published by\r
  42  * the Free Software Foundation; either version 2 of the License, or\r
  43  * (at your option) any later version.\r
  44  *\r
  45  * This program is distributed in the hope that it will be useful,\r
  46  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  47  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  48  * GNU General Public License for more details.\r
  49  *\r
  50  * You should have received a copy of the GNU General Public License\r
  51  * along with this program; if not, write to the Free Software\r
  52  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\r
  53  * ------------------------------------------------------------------------\r
  54  */\r
  55 \r
  56 /* This parser handles all forms of promotion.\r
  57  * The parser resolves ambiguous moves by searching and check-testing.\r
  58  * It also parses comments of the form [anything] or (anything).\r
  59  *\r
  60  * [HGM] Parser extensively modified for bigger boards, Shogi-like syntax,\r
  61  * and unknow pieces. All pieces are now mandatory upper case, but can be\r
  62  * any letter A-Z. Files must be lower case (as before), but can run upto 'l'.\r
  63  * Ranks can be 0-9. The parser returns 0 for off-board files and ranks.\r
  64  * For an unknown piece (as mover or promotion piece) it returns\r
  65  * IllegalMove, like it does when the piece doesn't match.\r
  66  * Promotions can now also be appended Shogi-style, a bare '=' or '+',\r
  67  * and this is then returned as promotion character. The piece indicator\r
  68  * can be prefixed by a '+' to indicate it is a promoted piece.\r
  69  */\r
  70 \r
  71 #include "config.h"\r
  72 \r
  73 #define NO_CONSTRAINT   -1\r
  74 #undef YYLMAX\r
  75 #define YYLMAX                  4096\r
  76 #define UNPUT_BUF_SIZE          YYLMAX\r
  77 \r
  78 #ifdef FLEX_SCANNER\r
  79 /* yytext is probably a char*, but could be a char[].  yy_text is set\r
  80    in YY_DECL below, because if yytext is a char*, its value is not\r
  81    constant. */\r
  82 char *yy_text;\r
  83 #else /*!FLEX_SCANNER*/\r
  84 /* yytext is definitely a char[], so yy_text can be set here, statically. */\r
  85 char *yy_text = (char *) yytext;\r
  86 #endif\r
  87 \r
  88 #ifdef FLEX_SCANNER\r
  89 /* This is flex */\r
  90 #undef YY_INPUT\r
  91 #define YY_INPUT(buf, result, max_size) my_yy_input(buf, &result, max_size)\r
  92 #undef YY_DECL\r
  93 #define YY_DECL                     \\r
  94     int _yylex YY_PROTO((void));    \\r
  95     int yylex YY_PROTO((void))      \\r
  96     {                               \\r
  97         int result = _yylex();      \\r
  98         yy_text = (char *) yytext;  \\r
  99         return(result);             \\r
 100     }                               \\r
 101     int _yylex YY_PROTO((void))\r
 102 #else\r
 103 /* This is lex */\r
 104 #undef input\r
 105 #undef output\r
 106 #undef unput\r
 107 #endif\r
 108 \r
 109 /* The includes must be here, below the #undef input */\r
 110 \r
 111 #include <ctype.h>\r
 112 \r
 113 #if STDC_HEADERS\r
 114 # include <stdlib.h>\r
 115 # include <string.h>\r
 116 #else /* not STDC_HEADERS */\r
 117 # if HAVE_STRING_H\r
 118 #  include <string.h>\r
 119 # else /* not HAVE_STRING_H */\r
 120 #  include <strings.h>\r
 121 # endif /* not HAVE_STRING_H */\r
 122 #endif /* not STDC_HEADERS */\r
 123 \r
 124 #if HAVE_UNISTD_H\r
 125 # include <unistd.h>\r
 126 #endif\r
 127 \r
 128 #if defined(_amigados)\r
 129 # include <errno.h>\r
 130 # if HAVE_FCNTL_H\r
 131 #  include <fcntl.h>    /*  isatty() prototype  */\r
 132 # endif /*  HAVE_FCNTL_H        */\r
 133 #endif  /*  defined(_amigados)  */\r
 134 \r
 135 #include "common.h"\r
 136 #include "backend.h"\r
 137 #include "frontend.h"\r
 138 #include "parser.h"\r
 139 #include "moves.h"\r
 140 \r
 141 extern int PosFlags P((int));\r
 142 \r
 143 extern Board    boards[MAX_MOVES];\r
 144 int             yyboardindex;\r
 145 int             yyskipmoves = FALSE;\r
 146 char            currentMoveString[YYLMAX];\r
 147 #ifndef FLEX_SCANNER\r
 148 char            unputBuffer[UNPUT_BUF_SIZE];\r
 149 int             unputCount = 0;\r
 150 #endif\r
 151 \r
 152 #ifdef FLEX_SCANNER\r
 153 void my_yy_input P((char *buf, int *result, int max_size));\r
 154 #else /*!FLEX_SCANNER*/\r
 155 static int input P((void));\r
 156 static void output P((int ch));\r
 157 static void unput P((int ch));\r
 158 int yylook P((void));\r
 159 int yyback P((int *, int));\r
 160 #endif\r
 161 #undef yywrap\r
 162 int yywrap P((void));\r
 163 extern void CopyBoard P((Board to, Board from));\r
 164 \r
 165 %}\r
 166 %%\r
 167 \r
 168 "+"?[A-Z][/]?[a-l][0-9][xX:-]?[a-l][0-9]((=?\(?[A-Z]\)?)|=)? {\r
 169     /*\r
 170      * Fully-qualified algebraic move, possibly with promotion\r
 171      */\r
 172     int skip1 = 0, skip2 = 0, skip3 = 0, promoted = 0;\r
 173     ChessSquare piece;\r
 174     ChessMove result;\r
 175     char c;\r
 176     \r
 177     if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */\r
 178 \r
 179     if (yytext[0] == '+') skip1 = skip3 = promoted = 1; /* [HGM] Shogi promoted */\r
 180 \r
 181     /* remove the / */\r
 182     if (yytext[1+skip1] == '/')  skip1++; \r
 183     \r
 184     /* remove the [xX:-] */\r
 185     if ((yytext[3+skip1] == 'x') || (yytext[3+skip1] == 'X') ||\r
 186         (yytext[3+skip1] == '-') || (yytext[3+skip1] == ':')) skip2 = 1;\r
 187     \r
 188     currentMoveString[0] = yytext[1+skip1];\r
 189     currentMoveString[1] = yytext[2+skip1];\r
 190     currentMoveString[2] = yytext[3+skip1+skip2];\r
 191     currentMoveString[3] = yytext[4+skip1+skip2];\r
 192     currentMoveString[4] = NULLCHAR;\r
 193     \r
 194     if (appData.debugMode) {\r
 195         fprintf(debugFP, "Parser Qa1b2: yyleng=%d\n",\r
 196         yyleng);\r
 197     }\r
 198 \r
 199     if (yyleng-skip1-skip2 > 5) { char c;\r
 200         if (yytext[yyleng-1] == ')') {\r
 201             c = currentMoveString[4] = ToLower(yytext[yyleng-2]);\r
 202         } else {\r
 203             c = currentMoveString[4] = ToLower(yytext[yyleng-1]);\r
 204         }\r
 205         currentMoveString[5] = NULLCHAR;\r
 206         if(c != '=' && c != '+' && CharToPiece(c) == EmptySquare)\r
 207             return IllegalMove; /* [HGM] promotion to invalid piece */\r
 208     }\r
 209 \r
 210     if (appData.debugMode) {\r
 211         fprintf(debugFP, "parser: %s\n", currentMoveString);\r
 212     }\r
 213     /* [HGM] do not allow values beyond board size */\r
 214     if(currentMoveString[1] - ONE >= BOARD_HEIGHT ||\r
 215        currentMoveString[1] - ONE <  0            ||\r
 216        currentMoveString[0] - AAA >= BOARD_RGHT   ||\r
 217        currentMoveString[3] - ONE >= BOARD_HEIGHT ||\r
 218        currentMoveString[3] - ONE <  0            ||\r
 219        currentMoveString[2] - AAA >= BOARD_RGHT   ||\r
 220        currentMoveString[0] - AAA <  BOARD_LEFT   ||\r
 221        currentMoveString[2] - AAA <  BOARD_LEFT     )\r
 222       return 0;\r
 223 \r
 224     piece = boards[yyboardindex]\r
 225       [currentMoveString[1] - ONE][currentMoveString[0] - AAA];\r
 226     if(promoted) piece = (ChessSquare) (DEMOTED piece);\r
 227     c = PieceToChar(piece);\r
 228     if(c == '~') c = PieceToChar((ChessSquare) (DEMOTED piece));\r
 229     if (ToLower(yytext[skip3]) != ToLower(c))\r
 230       return (int) IllegalMove;\r
 231 \r
 232     result = LegalityTest(boards[yyboardindex],\r
 233                           PosFlags(yyboardindex), EP_UNKNOWN,\r
 234                           initialRights, /* [HGM] assume all castlings allowed */\r
 235                           currentMoveString[1] - ONE,\r
 236                           currentMoveString[0] - AAA,\r
 237                           currentMoveString[3] - ONE,\r
 238                           currentMoveString[2] - AAA,\r
 239                           currentMoveString[4]);\r
 240 \r
 241     if (currentMoveString[4] == NULLCHAR &&\r
 242         (result == WhitePromotionKnight || result == BlackPromotionKnight ||\r
 243          result == WhitePromotionQueen  || result == BlackPromotionQueen)) {\r
 244         currentMoveString[4] = PieceToChar(BlackQueen);\r
 245         currentMoveString[5] = NULLCHAR;\r
 246     }\r
 247 \r
 248     return (int) result;\r
 249 }\r
 250 \r
 251 [a-l][0-9][xX:-]?[a-l][0-9]((=?\(?[A-Za-z]\)?)|=)?      {\r
 252     /*\r
 253      * Simple algebraic move, possibly with promotion\r
 254      * [HGM] Engine moves are received in this format, with lower-case promoChar!\r
 255      */\r
 256     int skip = 0;\r
 257     ChessMove result;\r
 258 \r
 259     if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */\r
 260 \r
 261     /* remove the [xX:-] */\r
 262     if ((yytext[2] == 'x') || (yytext[2] == 'X') ||\r
 263         (yytext[2] == '-') || (yytext[2] == ':')) skip = 1;\r
 264 \r
 265     currentMoveString[0] = yytext[0];\r
 266     currentMoveString[1] = yytext[1];\r
 267     currentMoveString[2] = yytext[2+skip];\r
 268     currentMoveString[3] = yytext[3+skip];\r
 269     currentMoveString[4] = NULLCHAR;\r
 270 \r
 271     if (yyleng-skip > 4) { char c;\r
 272         if (yytext[yyleng-1] == ')') {\r
 273             c = currentMoveString[4] = ToLower(yytext[yyleng-2]);\r
 274         } else {\r
 275             c = currentMoveString[4] = ToLower(yytext[yyleng-1]);\r
 276         }\r
 277         currentMoveString[5] = NULLCHAR;\r
 278         if(c != '=' && c != '+' && CharToPiece(c) == EmptySquare)\r
 279             return IllegalMove;\r
 280     }\r
 281 \r
 282     /* [HGM] do not allow values beyond board size */\r
 283     if(currentMoveString[1] - ONE >= BOARD_HEIGHT ||\r
 284        currentMoveString[1] - ONE <  0            ||\r
 285        currentMoveString[0] - AAA >= BOARD_RGHT   ||\r
 286        currentMoveString[3] - ONE >= BOARD_HEIGHT ||\r
 287        currentMoveString[3] - ONE <  0            ||\r
 288        currentMoveString[2] - AAA >= BOARD_RGHT   ||\r
 289        currentMoveString[0] - AAA <  BOARD_LEFT   ||\r
 290        currentMoveString[2] - AAA <  BOARD_LEFT     )\r
 291       return 0;\r
 292 \r
 293     result = LegalityTest(boards[yyboardindex],\r
 294                           PosFlags(yyboardindex), EP_UNKNOWN,\r
 295                           initialRights, /* [HGM] assume all castlings allowed */\r
 296                           currentMoveString[1] - ONE,\r
 297                           currentMoveString[0] - AAA,\r
 298                           currentMoveString[3] - ONE,\r
 299                           currentMoveString[2] - AAA,\r
 300                           currentMoveString[4]);\r
 301 \r
 302     if (currentMoveString[4] == NULLCHAR &&\r
 303         (result == WhitePromotionKnight || result == BlackPromotionKnight ||\r
 304          result == WhitePromotionQueen  || result == BlackPromotionQueen)) {\r
 305         if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier)\r
 306             currentMoveString[4] = PieceToChar(BlackFerz);\r
 307         else\r
 308             currentMoveString[4] = PieceToChar(BlackQueen);\r
 309         currentMoveString[5] = NULLCHAR;\r
 310     }\r
 311 \r
 312     return (int) result;\r
 313 }\r
 314 \r
 315 [a-l][0-9]((=?\(?[A-Z]\)?)|=)?       {\r
 316     /*\r
 317      * Pawn move, possibly with promotion\r
 318      */\r
 319     DisambiguateClosure cl;\r
 320     int skip = 0; char c;\r
 321 \r
 322     if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */\r
 323 \r
 324     /* remove the =() */\r
 325     if (yytext[2] == '=' && yytext[3] != NULLCHAR) skip++;\r
 326     if (yytext[2+skip] == '(') skip++;\r
 327 \r
 328     cl.pieceIn = WhiteOnMove(yyboardindex) ? WhitePawn : BlackPawn;\r
 329     cl.rfIn = -1;\r
 330     cl.ffIn = yytext[0] - AAA;\r
 331     cl.rtIn = yytext[1] - ONE;\r
 332     cl.ftIn = yytext[0] - AAA;\r
 333     c = cl.promoCharIn = yytext[2+skip];\r
 334 \r
 335     /* [HGM] do not allow values beyond board size */\r
 336     if(cl.rtIn >= BOARD_HEIGHT ||\r
 337        cl.rtIn <  0            ||\r
 338        cl.ffIn >= BOARD_RGHT   ||\r
 339        cl.ftIn <  BOARD_LEFT     )\r
 340       return 0;\r
 341 \r
 342     if(c != '=' && c != '+' && c != NULLCHAR && CharToPiece(c) == EmptySquare)\r
 343       return IllegalMove;\r
 344 \r
 345 \r
 346     Disambiguate(boards[yyboardindex],\r
 347                  PosFlags(yyboardindex), EP_UNKNOWN, &cl);\r
 348 \r
 349     currentMoveString[0] = cl.ff + AAA;\r
 350     currentMoveString[1] = cl.rf + ONE;\r
 351     currentMoveString[2] = cl.ft + AAA;\r
 352     currentMoveString[3] = cl.rt + ONE;\r
 353     currentMoveString[4] = cl.promoChar;\r
 354     currentMoveString[5] = NULLCHAR;\r
 355 \r
 356     return (int) cl.kind;\r
 357 }\r
 358 \r
 359 \r
 360 (ab|bc|cd|de|ef|fg|gh|hi|ij|jk|kl|lk|kj|ji|ih|hg|gf|fe|ed|dc|cb|ba|aa|bb|cc|dd|ee|ff|gg|hh|ii|jj|kk|ll|([a-l][xX:-][a-l]))((=?\(?[A-Z]\)?)|ep|"e.p."|=)? {\r
 361     /*\r
 362      * Pawn capture, possibly with promotion, possibly ambiguous\r
 363      */\r
 364     DisambiguateClosure cl;\r
 365     int skip1 = 0, skip2 = 0; char c;\r
 366 \r
 367     if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */\r
 368 \r
 369     /* remove trailing ep or e.p. (nonstandard PGN) */\r
 370     if (yytext[yyleng-1] == 'p') {\r
 371       yyleng -= 2;\r
 372       yytext[yyleng] = NULLCHAR;\r
 373     } else if (yytext[yyleng-1] == '.') {\r
 374       yyleng -= 4;\r
 375       yytext[yyleng] = NULLCHAR;\r
 376     }\r
 377 \r
 378     /* remove the [xX:-] and =() */\r
 379     if ((yytext[1] == 'x') || (yytext[1] == 'X')\r
 380         || (yytext[1] == ':') || (yytext[1] == '-')) skip1 = 1;\r
 381     if (yytext[2+skip1] == '=' && yytext[3+skip1] != NULLCHAR) skip2++;\r
 382     if (yytext[2+skip1+skip2] == '(') skip2++;\r
 383 \r
 384     cl.pieceIn = WhiteOnMove(yyboardindex) ? WhitePawn : BlackPawn;\r
 385     cl.rfIn = -1;\r
 386     cl.ffIn = yytext[0] - AAA;\r
 387     cl.rtIn = -1;\r
 388     cl.ftIn = yytext[1+skip1] - AAA;\r
 389     c = cl.promoCharIn = yytext[2+skip1+skip2];\r
 390 \r
 391     /* [HGM] do not allow values beyond board size */\r
 392     if(cl.ffIn >= BOARD_RGHT  ||\r
 393        cl.ffIn <  BOARD_LEFT  ||\r
 394        cl.ftIn >= BOARD_RGHT  ||\r
 395        cl.ftIn <  BOARD_LEFT     )\r
 396       return 0;\r
 397 \r
 398     if(c != '=' && c != '+' && c != NULLCHAR && CharToPiece(c) == EmptySquare)\r
 399       return IllegalMove;\r
 400 \r
 401     Disambiguate(boards[yyboardindex],\r
 402                  PosFlags(yyboardindex), EP_UNKNOWN, &cl);\r
 403 \r
 404     currentMoveString[0] = cl.ff + AAA;\r
 405     currentMoveString[1] = cl.rf + ONE;\r
 406     currentMoveString[2] = cl.ft + AAA;\r
 407     currentMoveString[3] = cl.rt + ONE;\r
 408     currentMoveString[4] = cl.promoChar;\r
 409     currentMoveString[5] = NULLCHAR;\r
 410 \r
 411     return (int) cl.kind;\r
 412 }\r
 413 \r
 414 [a-l][xX:]?[a-l][0-9]((=?\(?[A-Z]\)?)|ep|"e.p."|=)? {\r
 415     /*\r
 416      * unambiguously abbreviated Pawn capture, possibly with promotion\r
 417      */\r
 418     int skip = 0;\r
 419     ChessMove result; char c;\r
 420 \r
 421     if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */\r
 422 \r
 423     /* remove trailing ep or e.p. (nonstandard PGN) */\r
 424     if (yytext[yyleng-1] == 'p') {\r
 425       yyleng -= 2;\r
 426       yytext[yyleng] = NULLCHAR;\r
 427     } else if (yytext[yyleng-1] == '.') {\r
 428       yyleng -= 4;\r
 429       yytext[yyleng] = NULLCHAR;\r
 430     }\r
 431 \r
 432     /* remove the [xX:-] */\r
 433     if ((yytext[1] == 'x') || (yytext[1] == 'X')\r
 434         || (yytext[1] == ':') || (yytext[1] == '-')) skip = 1;\r
 435 \r
 436     currentMoveString[0] = yytext[0];\r
 437     currentMoveString[2] = yytext[1+skip];\r
 438     currentMoveString[3] = yytext[2+skip];\r
 439 \r
 440     /* [HGM] do not allow values beyond board size */\r
 441     if(currentMoveString[0] - AAA >= BOARD_RGHT   ||\r
 442        currentMoveString[3] - ONE >= BOARD_HEIGHT ||\r
 443        currentMoveString[3] - ONE <  0            ||\r
 444        currentMoveString[2] - AAA >= BOARD_RGHT   ||\r
 445        currentMoveString[0] - AAA <  BOARD_LEFT   ||\r
 446        currentMoveString[2] - AAA <  BOARD_LEFT     )\r
 447       return 0;\r
 448 \r
 449     if (gameInfo.variant == VariantXiangqi && /* [HGM] In Xiangqi rank stays same */\r
 450          currentMoveString[0] != currentMoveString[2] ) {\r
 451         if (yytext[2+skip] == ONE) return (int) ImpossibleMove;\r
 452         currentMoveString[1] = yytext[2+skip];\r
 453     } else \r
 454     if (WhiteOnMove(yyboardindex)) {\r
 455         if (yytext[2+skip] == ONE) return (int) ImpossibleMove;\r
 456         currentMoveString[1] = yytext[2+skip] - 1;\r
 457     } else {\r
 458         currentMoveString[1] = currentMoveString[3] + 1;\r
 459         if (currentMoveString[3] == ONE+BOARD_HEIGHT-1) return (int) ImpossibleMove;\r
 460     }\r
 461     if (yyleng-skip > 3) {\r
 462         if (yytext[yyleng-1] == ')')\r
 463           c = currentMoveString[4] = ToLower(yytext[yyleng-2]);\r
 464         else\r
 465           c = currentMoveString[4] = ToLower(yytext[yyleng-1]);\r
 466         currentMoveString[5] = NULLCHAR;\r
 467         if(c != '=' && c != '+' && CharToPiece(c) == EmptySquare)\r
 468             return IllegalMove;\r
 469     } else {\r
 470         currentMoveString[4] = NULLCHAR;\r
 471     }\r
 472 \r
 473     result = LegalityTest(boards[yyboardindex],\r
 474                           PosFlags(yyboardindex), EP_UNKNOWN,\r
 475                           initialRights, /* [HGM] assume all castlings allowed */\r
 476                           currentMoveString[1] - ONE,\r
 477                           currentMoveString[0] - AAA,\r
 478                           currentMoveString[3] - ONE,\r
 479                           currentMoveString[2] - AAA,\r
 480                           currentMoveString[4]);\r
 481 \r
 482     if (currentMoveString[4] == NULLCHAR &&\r
 483         (result == WhitePromotionQueen  || result == BlackPromotionQueen ||\r
 484          result == WhitePromotionKnight || result == BlackPromotionKnight)) {\r
 485         currentMoveString[4] = PieceToChar(BlackQueen);\r
 486         currentMoveString[5] = NULLCHAR;\r
 487     }\r
 488 \r
 489     if (result != IllegalMove) return (int) result;\r
 490 \r
 491     /* Special case: improperly written en passant capture */\r
 492     if (WhiteOnMove(yyboardindex)) {\r
 493         if (currentMoveString[3] == '5') {\r
 494             currentMoveString[1] = '5';\r
 495             currentMoveString[3] = '6';\r
 496         } else {\r
 497             return (int) IllegalMove;\r
 498         }\r
 499     } else {\r
 500         if (currentMoveString[3] == '4') {\r
 501             currentMoveString[1] = '4';\r
 502             currentMoveString[3] = '3';\r
 503         } else {\r
 504             return (int) IllegalMove;\r
 505         }\r
 506     }\r
 507 \r
 508     result = LegalityTest(boards[yyboardindex],\r
 509                           PosFlags(yyboardindex), EP_UNKNOWN,\r
 510                           initialRights, /* [HGM] assume all castlings allowed */\r
 511                           currentMoveString[1] - ONE,\r
 512                           currentMoveString[0] - AAA,\r
 513                           currentMoveString[3] - ONE,\r
 514                           currentMoveString[2] - AAA,\r
 515                           currentMoveString[4]);\r
 516 \r
 517     if (result == WhiteCapturesEnPassant || result == BlackCapturesEnPassant)\r
 518       return (int) result;\r
 519     else\r
 520       return (int) IllegalMove;\r
 521 }\r
 522 \r
 523 "+"?[A-Z][xX:-]?[a-l][0-9]=?  {\r
 524     /*\r
 525      * piece move, possibly ambiguous\r
 526      */\r
 527     DisambiguateClosure cl;\r
 528     int skip = 0, skip2 = 0, promoted = 0;\r
 529 \r
 530     if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */\r
 531 \r
 532     if(yytext[0] == '+') promoted = skip = skip2 = 1;\r
 533 \r
 534     /* remove the [xX:-] */\r
 535     if ((yytext[1+skip] == 'x') || (yytext[1+skip] == 'X')\r
 536         || (yytext[1+skip] == ':') || (yytext[1+skip] == '-')) skip++;\r
 537 \r
 538     if (WhiteOnMove(yyboardindex)) {\r
 539         cl.pieceIn = CharToPiece(ToUpper(yytext[skip2]));\r
 540     } else {\r
 541         cl.pieceIn = CharToPiece(ToLower(yytext[skip2]));\r
 542     }\r
 543     if(promoted) cl.pieceIn = (ChessSquare) (PROMOTED cl.pieceIn);\r
 544 \r
 545     cl.rfIn = -1;\r
 546     cl.ffIn = -1;\r
 547     cl.rtIn = yytext[2+skip] - ONE;\r
 548     cl.ftIn = yytext[1+skip] - AAA;\r
 549     cl.promoCharIn = NULLCHAR;\r
 550 \r
 551     if(yyleng-skip > 3) /* [HGM] can have Shogi-style promotion */\r
 552         cl.promoCharIn = yytext[yyleng-1];\r
 553 \r
 554     if (appData.debugMode) {\r
 555         fprintf(debugFP, "Parser Qa1: yyleng=%d,  %d(%d,%d)-(%d,%d) = %d (%c)\n",\r
 556         yyleng,\r
 557         cl.pieceIn,cl.ffIn,cl.rfIn,cl.ftIn,cl.rtIn,cl.promoCharIn,cl.promoCharIn?cl.promoCharIn:' ');\r
 558     }\r
 559 \r
 560     /* [HGM] but do not allow values beyond board size */\r
 561     if(cl.rtIn >= BOARD_HEIGHT ||\r
 562        cl.rtIn <  0            ||\r
 563        cl.ftIn >= BOARD_RGHT   ||\r
 564        cl.ftIn <  BOARD_LEFT     )\r
 565       return 0;\r
 566 \r
 567     Disambiguate(boards[yyboardindex],\r
 568                  PosFlags(yyboardindex), EP_UNKNOWN, &cl);\r
 569 \r
 570     currentMoveString[0] = cl.ff + AAA;\r
 571     currentMoveString[1] = cl.rf + ONE;\r
 572     currentMoveString[2] = cl.ft + AAA;\r
 573     currentMoveString[3] = cl.rt + ONE;\r
 574     currentMoveString[4] = cl.promoChar;\r
 575     currentMoveString[5] = NULLCHAR;\r
 576 \r
 577     return (int) cl.kind;\r
 578 }\r
 579 \r
 580 "+"?[A-Z][a-l0-9][xX:-]?[a-l][0-9]=?   {\r
 581     /*\r
 582      * piece move with rank or file disambiguator\r
 583      */\r
 584     DisambiguateClosure cl;\r
 585     int skip = 0, skip2 = 0; int promoted=0;\r
 586 \r
 587     if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */\r
 588 \r
 589     if(yytext[0]=='+') promoted = skip = skip2 = 1;\r
 590 \r
 591     /* remove the [xX:-] */\r
 592     if ((yytext[2+skip] == 'x') || (yytext[2+skip] == 'X')\r
 593         || (yytext[2+skip] == ':') || (yytext[2+skip] == '-')) skip++;\r
 594 \r
 595     if (WhiteOnMove(yyboardindex)) {\r
 596         cl.pieceIn = CharToPiece(ToUpper(yytext[skip2]));\r
 597     } else {\r
 598         cl.pieceIn = CharToPiece(ToLower(yytext[skip2]));\r
 599     }\r
 600     if(promoted) cl.pieceIn = (ChessSquare) (PROMOTED cl.pieceIn);\r
 601 \r
 602     if (isalpha(yytext[1+skip2])) {\r
 603         cl.rfIn = -1;\r
 604         cl.ffIn = yytext[1+skip2] - AAA;\r
 605        \r
 606         if(cl.ffIn >= BOARD_RGHT ||\r
 607            cl.ffIn <  BOARD_LEFT   ) return 0;\r
 608     } else {\r
 609         cl.rfIn = yytext[1+skip2] - ONE;\r
 610         cl.ffIn = -1;\r
 611         if(cl.rfIn >= BOARD_HEIGHT ||\r
 612            cl.rfIn <  0) return 0;\r
 613     }\r
 614     cl.rtIn = yytext[3+skip] - ONE;\r
 615     cl.ftIn = yytext[2+skip] - AAA;\r
 616     cl.promoCharIn = NULLCHAR;\r
 617 \r
 618     if(yyleng-skip > 4) /* [HGM] can have Shogi-style promotion */\r
 619         cl.promoCharIn = yytext[yyleng-1];\r
 620 \r
 621     /* [HGM] do not allow values beyond board size */\r
 622     if(cl.rtIn >= BOARD_HEIGHT ||\r
 623        cl.rtIn <  0            ||\r
 624        cl.ftIn >= BOARD_RGHT   ||\r
 625        cl.ftIn <  BOARD_LEFT     )\r
 626       return 0;\r
 627 \r
 628     Disambiguate(boards[yyboardindex],\r
 629                  PosFlags(yyboardindex), EP_UNKNOWN, &cl);\r
 630 \r
 631     currentMoveString[0] = cl.ff + AAA;\r
 632     currentMoveString[1] = cl.rf + ONE;\r
 633     currentMoveString[2] = cl.ft + AAA;\r
 634     currentMoveString[3] = cl.rt + ONE;\r
 635     currentMoveString[4] = cl.promoChar;\r
 636     currentMoveString[5] = NULLCHAR;\r
 637 \r
 638     return (int) cl.kind;\r
 639 }\r
 640 \r
 641 000|0-0-0|ooo|OOO|o-o-o|O-O-O   {\r
 642     int rf, ff, rt, ft;\r
 643 \r
 644     if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */\r
 645 \r
 646     /* [HGM] all squares referenced to board edges in stead of absolute */\r
 647     if (WhiteOnMove(yyboardindex)) {\r
 648         if (boards[yyboardindex][0][(BOARD_WIDTH-1)>>1] == WhiteKing) {\r
 649             /* ICS wild castling */\r
 650             rf = 0;\r
 651             ff = (BOARD_WIDTH-1)>>1;\r
 652             rt = 0;\r
 653             ft = BOARD_RGHT-3;\r
 654         } else {\r
 655             rf = 0;\r
 656             ff = BOARD_WIDTH>>1;\r
 657             rt = 0;\r
 658             ft = BOARD_LEFT+2;\r
 659         }\r
 660     } else{ \r
 661         if (boards[yyboardindex][BOARD_HEIGHT-1][(BOARD_WIDTH-1)>>1] == BlackKing) {\r
 662             /* ICS wild castling */\r
 663             rf = BOARD_HEIGHT-1;\r
 664             ff = (BOARD_WIDTH-1)>>1;\r
 665             rt = BOARD_HEIGHT-1;\r
 666             ft = BOARD_RGHT-3;\r
 667         } else {\r
 668             rf = BOARD_HEIGHT-1;\r
 669             ff = BOARD_WIDTH>>1;\r
 670             rt = BOARD_HEIGHT-1;\r
 671             ft = BOARD_LEFT+2;\r
 672         }\r
 673     }\r
 674     if(gameInfo.variant == VariantFischeRandom) {\r
 675         if (WhiteOnMove(yyboardindex)) {\r
 676             ff = initialRights[2];\r
 677             ft = initialRights[1];\r
 678         } else {\r
 679             ff = initialRights[5];\r
 680             ft = initialRights[4];\r
 681         }\r
 682         fprintf(debugFP, "Parser FRC long %d %d\n", ff, ft);\r
 683         if(ff < 0 || ft < 0) return 0;\r
 684     }\r
 685     sprintf(currentMoveString, "%c%c%c%c",ff+AAA,rf+ONE,ft+AAA,rt+ONE);\r
 686     if (appData.debugMode) {\r
 687         fprintf(debugFP, "long castling %d %d\n", ff, ft);\r
 688     }\r
 689     return (int) LegalityTest(boards[yyboardindex],\r
 690                               PosFlags(yyboardindex), EP_UNKNOWN,\r
 691                               castlingRights[yyboardindex], /* [HGM] use true castling rights */\r
 692                               rf, ff, rt, ft, NULLCHAR);\r
 693 }\r
 694 \r
 695 00|0-0|oo|OO|o-o|O-O    {\r
 696     int rf, ff, rt, ft;\r
 697 \r
 698     if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */\r
 699 \r
 700     if (WhiteOnMove(yyboardindex)) {\r
 701         if (boards[yyboardindex][0][(BOARD_WIDTH-1)>>1] == WhiteKing) {\r
 702             /* ICS wild castling */\r
 703             rf = 0;\r
 704             ff = (BOARD_WIDTH-1)>>1;\r
 705             rt = 0;\r
 706             ft = BOARD_LEFT+1;\r
 707         } else {\r
 708             rf = 0;\r
 709             ff = BOARD_WIDTH>>1;\r
 710             rt = 0;\r
 711             ft = BOARD_RGHT-2;\r
 712         }\r
 713     } else {\r
 714         if (boards[yyboardindex][BOARD_HEIGHT-1][(BOARD_WIDTH-1)>>1] == BlackKing) {\r
 715             /* ICS wild castling */\r
 716             rf = BOARD_HEIGHT-1;\r
 717             ff = (BOARD_WIDTH-1)>>1;\r
 718             rt = BOARD_HEIGHT-1;\r
 719             ft = BOARD_LEFT+1;\r
 720         } else {\r
 721             rf = BOARD_HEIGHT-1;\r
 722             ff = BOARD_WIDTH>>1;\r
 723             rt = BOARD_HEIGHT-1;\r
 724             ft = BOARD_RGHT-2;\r
 725         }\r
 726     }\r
 727     if(gameInfo.variant == VariantFischeRandom) {\r
 728         if (WhiteOnMove(yyboardindex)) {\r
 729             ff = initialRights[2];\r
 730             ft = initialRights[0];\r
 731         } else {\r
 732             ff = initialRights[5];\r
 733             ft = initialRights[3];\r
 734         }\r
 735     if (appData.debugMode) {\r
 736         fprintf(debugFP, "Parser FRC short %d %d\n", ff, ft);\r
 737     }\r
 738         if(ff < 0 || ft < 0) return 0;\r
 739     }\r
 740     sprintf(currentMoveString, "%c%c%c%c",ff+AAA,rf+ONE,ft+AAA,rt+ONE);\r
 741     if (appData.debugMode) {\r
 742         fprintf(debugFP, "short castling %d %d\n", ff, ft);\r
 743     }\r
 744 \r
 745     return (int) LegalityTest(boards[yyboardindex],\r
 746                               PosFlags(yyboardindex), EP_UNKNOWN,\r
 747                               castlingRights[yyboardindex], /* [HGM] use true castling rights */\r
 748                               rf, ff, rt, ft, NULLCHAR);\r
 749 }\r
 750 \r
 751 [A-Z][@*][a-l][0-9] {\r
 752     /* Bughouse piece drop.  No legality checking for now. */\r
 753     currentMoveString[1] = '@';\r
 754     currentMoveString[2] = yytext[2];\r
 755     currentMoveString[3] = yytext[3];\r
 756     currentMoveString[4] = NULLCHAR;\r
 757 \r
 758     if (appData.debugMode) {\r
 759         fprintf(debugFP, "Drop: %s\n", currentMoveString);\r
 760     }\r
 761     /* [HGM] do not allow values beyond board size */\r
 762     if(currentMoveString[3] - ONE >= BOARD_HEIGHT ||\r
 763        currentMoveString[2] - AAA >= BOARD_WIDTH     )\r
 764       return 0;\r
 765 \r
 766     if (WhiteOnMove(yyboardindex)) {\r
 767         currentMoveString[0] = ToUpper(yytext[0]);\r
 768         return (int) WhiteDrop;\r
 769     } else {\r
 770         currentMoveString[0] = ToLower(yytext[0]);\r
 771         return (int) BlackDrop;\r
 772     }\r
 773 }\r
 774 \r
 775 [Rr]esign(s|ed)?  {\r
 776     if (WhiteOnMove(yyboardindex))\r
 777       return (int) BlackWins;\r
 778     else\r
 779       return (int) WhiteWins;\r
 780 }\r
 781 \r
 782 (([Ww](hite)?)|([Bb](lack)?))" "(([Rr]esign)|([Ff]orfeit))(s|ed)?  {\r
 783     return (int) (ToUpper(yytext[0]) == 'W' ? BlackWins : WhiteWins);\r
 784 }\r
 785 \r
 786 (([Ww](hite)?)|([Bb](lack)?))" "[Dd]isconnect(s|ed)  {\r
 787     return (int) GameUnfinished;\r
 788 }\r
 789 \r
 790 [Ss]talemate  {\r
 791     return (int) GameIsDrawn;\r
 792 }\r
 793 \r
 794 "+-+"  {\r
 795     return (int) GameIsDrawn;\r
 796 }\r
 797 \r
 798 ([Cc]heck)?[Mm]ate {\r
 799     if (WhiteOnMove(yyboardindex))\r
 800       return (int) BlackWins;\r
 801     else\r
 802       return (int) WhiteWins;\r
 803 }\r
 804 \r
 805 "++"  {\r
 806     if (WhiteOnMove(yyboardindex))\r
 807       return (int) BlackWins;\r
 808     else\r
 809       return (int) WhiteWins;\r
 810 }\r
 811 \r
 812 [Dd]raw(n)?(" "by)?(" "[Rr]epetition)|(" "[Aa]gree(d|ment))  {\r
 813     return (int) GameIsDrawn;\r
 814 }\r
 815 \r
 816 [Dd]raw(n)?(" (".*")")?  {\r
 817     return (int) GameIsDrawn;\r
 818 }\r
 819 \r
 820 (([Ww](hite)?)|([Bb](lack)?))" "([Mm]ate(s|ed)?)|([Ww][io]n(s)?.*)  {\r
 821     return (int) (ToUpper(yytext[0]) == 'W' ? WhiteWins : BlackWins);\r
 822 }\r
 823 \r
 824 (([Ww](hite)?)|([Bb](lack)?))" "([Mm]ate(s|ed)?)|([Ll]os[tes]+.*)  {\r
 825     return (int) (ToUpper(yytext[0]) == 'W' ? BlackWins : WhiteWins);\r
 826 }\r
 827 \r
 828 ("{"[^\}\n]*"} ")?(1-0|"1 - 0"|"1/0"|"1 / 0"|"1:0"|"1 : 0")(" (".*")"|" {".*"}")? { \r
 829     return (int) WhiteWins;\r
 830 }\r
 831 \r
 832 ("{"[^\}\n]*"} ")?(0-1|"0 - 1"|"0/1"|"0 / 1"|"0:1"|"0 : 1")(" (".*")"|" {".*"}")? { \r
 833     return (int) BlackWins;\r
 834 }\r
 835 \r
 836 ("{"[^\}\n]*"} ")?("1/2"|"1 / 2")(" "?[-:]" "?("1/2"|"1 / 2"))?(" (".*")"|" {".*"}")? {\r
 837     return (int) GameIsDrawn;\r
 838 }\r
 839 \r
 840 ("{"[^\}\n]*"} ")?"*"(" (".*")"|" {".*"}")? {\r
 841     return (int) GameUnfinished;\r
 842 }\r
 843 \r
 844 [1-9][0-9]*/"."?[ \t\n]*[a-lNnPpRrBQqKACFEWDGHOo]    {\r
 845     /* move numbers */\r
 846     if ((yyleng == 1) && (yytext[0] == '1'))\r
 847       return (int) MoveNumberOne;\r
 848 }\r
 849 \r
 850 \([0-9]+:[0-9][0-9](\.[0-9]+)?\)|\{[0-9]+:[0-9][0-9](\.[0-9]+)?\} {\r
 851     /* elapsed time indication, e.g. (0:12) or {10:21.071} */ \r
 852     return (int) ElapsedTime;\r
 853 }\r
 854 \r
 855 "[--"[^\]]*"--]" {\r
 856     /* position diagram enclosed in [-- --] */\r
 857     return (int) PositionDiagram;\r
 858 }\r
 859 \r
 860 ^"{--------------"\n[^\}]*\n"--------------}"$ {\r
 861     /* position diagram enclosed in {-- --} */\r
 862     return (int) PositionDiagram;\r
 863 }\r
 864 \r
 865 \[[ \t\n]*[A-Za-z0-9][A-Za-z0-9_+#=-]*[ \t\n]*\"[^"]*\"[ \t\n]*\] {\r
 866     return (int) PGNTag;\r
 867 }    \r
 868 \r
 869 [Gg](nu|NU)" "?[Cc](hess|HESS).*[Gg](ame|AME) {\r
 870     return (int) GNUChessGame;\r
 871 }\r
 872 \r
 873 ^[#;%]" "[^ ]*(" game file"|" position file").*$ {\r
 874     return (int) XBoardGame;\r
 875 }\r
 876 \r
 877 \$[0-9]+        {                               /* numeric annotation glyph */\r
 878     return (int) NAG;\r
 879 }\r
 880 \r
 881 \{[^\}]*\}      {                               /* anything in {} */\r
 882     return (int) Comment; \r
 883 }\r
 884 \r
 885 ;.*$ {                                          /* ; to end of line */\r
 886     return (int) Comment;\r
 887 }\r
 888 \r
 889 \[[^\]]*\]      {                               /* anything in [] */\r
 890     return (int) Comment; \r
 891 }\r
 892 \r
 893 \([^()]*(\([^()]*\)[^()]*)+[^()]*\)  {          /* nested () */\r
 894     return (int) Comment; \r
 895 }\r
 896 \r
 897 \([^)][^)]+\)   {                               /* >=2 chars in () */\r
 898     return (int) Comment; \r
 899 }       \r
 900 \r
 901 ^[-a-zA-Z0-9]+:" ".*(\n[ \t]+.*)*  {\r
 902         /* Skip mail headers */\r
 903 }\r
 904 \r
 905 [a-zA-Z0-9'-]+                  {\r
 906         /* Skip random words */\r
 907 }\r
 908 \r
 909 .|\n                            {\r
 910         /* Skip everything else */\r
 911 }\r
 912 \r
 913 %%\r
 914 \r
 915 \r
 916 static char *StringToLex;\r
 917 \r
 918 #ifndef FLEX_SCANNER\r
 919 static FILE *lexFP;\r
 920 \r
 921 static int input()\r
 922 {\r
 923     int ret;\r
 924     \r
 925     if (StringToLex != NULL) {\r
 926         ret = *StringToLex;\r
 927         if (ret == NULLCHAR)\r
 928           ret = EOF;\r
 929         else\r
 930           StringToLex++;\r
 931     } else if (unputCount > 0) {\r
 932         ret = unputBuffer[--unputCount];\r
 933     } else {\r
 934         ret = fgetc(lexFP);\r
 935     }    \r
 936 \r
 937     if (ret == EOF) \r
 938       return 0;\r
 939     else\r
 940       return ret;\r
 941 }\r
 942 \r
 943 /*\r
 944  * Return offset of next pattern within current file\r
 945  */\r
 946 int yyoffset()\r
 947 {\r
 948     int offset = ftell(lexFP) - unputCount;\r
 949 \r
 950     if (offset < 0) {\r
 951         offset = 0;\r
 952     }\r
 953     return(offset);\r
 954 }\r
 955  \r
 956 static void output(ch)\r
 957      int ch;\r
 958 {\r
 959     fprintf(stderr, "PARSER BUG: unmatched character '%c' (0%o)\n",\r
 960             ch, ch);\r
 961 }\r
 962 \r
 963 static void unput(ch)\r
 964      int ch;\r
 965 {\r
 966     if (ch == 0) return;\r
 967     if (StringToLex != NULL) {\r
 968         StringToLex--;\r
 969     } else {\r
 970         if (unputCount >= UNPUT_BUF_SIZE)\r
 971           fprintf(stderr, "PARSER BUG: unput buffer overflow '%c' (0%o)\n",\r
 972                   ch, ch);\r
 973         unputBuffer[unputCount++] = ch;\r
 974     }\r
 975 }\r
 976 \r
 977 /* Get ready to lex from a new file.  Kludge below sticks\r
 978    an artificial newline at the front of the file, which the\r
 979    above grammar ignores, but which makes ^ at start of pattern\r
 980    match at the real start of the file.\r
 981 */\r
 982 void yynewfile(f)\r
 983      FILE *f;\r
 984 {\r
 985     lexFP = f;\r
 986     StringToLex = NULL;\r
 987     unputCount = 0;\r
 988     unput('\n'); /* kludge */\r
 989 }\r
 990 \r
 991 /* Get ready to lex from a string.  ^ at start of pattern WON'T\r
 992    match at the start of the string!\r
 993 */\r
 994 void yynewstr(s)\r
 995      char *s;\r
 996 {\r
 997     lexFP = NULL;\r
 998     StringToLex = s;\r
 999     unputCount = 0;\r
1000 }\r
1001 #endif /*!FLEX_SCANNER*/\r
1002 \r
1003 #ifdef FLEX_SCANNER\r
1004 void my_yy_input(buf, result, max_size)\r
1005      char *buf;\r
1006      int *result;\r
1007      int max_size;\r
1008 {\r
1009     int count;\r
1010 \r
1011     if (StringToLex != NULL) {\r
1012         count = 0;\r
1013         while (*StringToLex != NULLCHAR) {\r
1014             *buf++ = *StringToLex++;\r
1015             count++;\r
1016         }\r
1017         *result = count;\r
1018         return;\r
1019     } else {\r
1020         count = fread(buf, 1, max_size, yyin);\r
1021         if (count == 0) {\r
1022             *result = YY_NULL;\r
1023         } else {\r
1024             *result = count;\r
1025         }\r
1026         return;\r
1027     }    \r
1028 }\r
1029 \r
1030 static YY_BUFFER_STATE my_file_buffer = NULL;\r
1031 \r
1032 /*\r
1033     Return offset of next pattern in the current file.\r
1034 */\r
1035 int yyoffset()\r
1036 {\r
1037     int pos = yy_c_buf_p - yy_current_buffer->yy_ch_buf;\r
1038 \r
1039     return(ftell(yy_current_buffer->yy_input_file) -\r
1040          yy_n_chars + pos);\r
1041 }\r
1042 \r
1043 \r
1044 void yynewstr(s)\r
1045      char *s;\r
1046 {\r
1047     if (my_file_buffer != NULL)\r
1048       yy_delete_buffer(my_file_buffer);\r
1049     StringToLex = s;\r
1050     my_file_buffer = yy_create_buffer(stdin, YY_BUF_SIZE);\r
1051     yy_switch_to_buffer(my_file_buffer);\r
1052 }\r
1053 \r
1054 void yynewfile(f)\r
1055      FILE *f;\r
1056 {\r
1057     if (my_file_buffer != NULL)\r
1058       yy_delete_buffer(my_file_buffer);\r
1059     StringToLex = NULL;\r
1060     my_file_buffer = yy_create_buffer(f, YY_BUF_SIZE);\r
1061     yy_switch_to_buffer(my_file_buffer);\r
1062 }\r
1063 #endif /*FLEX_SCANNER*/\r
1064 \r
1065 int yywrap()\r
1066 {\r
1067     return TRUE;\r
1068 }\r
1069 \r
1070 /* Parse a move from the given string s */\r
1071 /* ^ at start of pattern WON'T work here unless using flex */\r
1072 ChessMove yylexstr(boardIndex, s)\r
1073      int boardIndex;\r
1074      char *s;\r
1075 {\r
1076     ChessMove ret;\r
1077     char *oldStringToLex;\r
1078 #ifdef FLEX_SCANNER\r
1079     YY_BUFFER_STATE buffer, oldBuffer;\r
1080 #endif\r
1081     \r
1082     yyboardindex = boardIndex;\r
1083     oldStringToLex = StringToLex;\r
1084     StringToLex = s;\r
1085 #ifdef FLEX_SCANNER\r
1086     buffer = yy_create_buffer(stdin, YY_BUF_SIZE);\r
1087     oldBuffer = YY_CURRENT_BUFFER;\r
1088     yy_switch_to_buffer(buffer);\r
1089 #endif /*FLEX_SCANNER*/\r
1090 \r
1091     ret = (ChessMove) yylex();\r
1092 \r
1093 #ifdef FLEX_SCANNER\r
1094     if (oldBuffer != NULL) \r
1095       yy_switch_to_buffer(oldBuffer);\r
1096     yy_delete_buffer(buffer);\r
1097 #endif /*FLEX_SCANNER*/\r
1098     StringToLex = oldStringToLex;\r
1099 \r
1100     return ret;\r
1101 }\r