9 * parser.l -- lex parser of algebraic chess moves for XBoard
11 * Copyright 1991 by Digital Equipment Corporation, Maynard,
14 * Enhancements Copyright 1992-2001, 2002, 2003, 2004, 2005,
15 * 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
17 * The following terms apply to Digital Equipment Corporation's copyright
19 * ------------------------------------------------------------------------
22 * Permission to use, copy, modify, and distribute this software and its
23 * documentation for any purpose and without fee is hereby granted,
24 * provided that the above copyright notice appear in all copies and that
25 * both that copyright notice and this permission notice appear in
26 * supporting documentation, and that the name of Digital not be
27 * used in advertising or publicity pertaining to distribution of the
28 * software without specific, written prior permission.
30 * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
31 * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
32 * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
33 * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
34 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
35 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
37 * ------------------------------------------------------------------------
39 * The following terms apply to the enhanced version of XBoard
40 * distributed by the Free Software Foundation:
41 * ------------------------------------------------------------------------
43 * GNU XBoard is free software: you can redistribute it and/or modify
44 * it under the terms of the GNU General Public License as published by
45 * the Free Software Foundation, either version 3 of the License, or (at
46 * your option) any later version.
48 * GNU XBoard is distributed in the hope that it will be useful, but
49 * WITHOUT ANY WARRANTY; without even the implied warranty of
50 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
51 * General Public License for more details.
53 * You should have received a copy of the GNU General Public License
54 * along with this program. If not, see http://www.gnu.org/licenses/.
56 *------------------------------------------------------------------------
57 ** See the file ChangeLog for a revision history. */
59 /* This parser handles all forms of promotion.
60 * The parser resolves ambiguous moves by searching and check-testing.
61 * It also parses comments of the form [anything] or (anything).
63 * [HGM] Parser extensively modified for bigger boards, Shogi-like syntax,
64 * and unknow pieces. All pieces are now mandatory upper case, but can be
65 * any letter A-Z. Files must be lower case (as before), but can run upto 'l'.
66 * Ranks can be 0-9. The parser returns 0 for off-board files and ranks.
67 * For an unknown piece (as mover or promotion piece) it returns
68 * IllegalMove, like it does when the piece doesn't match.
69 * Promotions can now also be appended Shogi-style, a bare '=' or '^',
70 * and this is then returned as promotion character. The piece indicator
71 * can be prefixed by a '+' to indicate it is a promoted piece.
76 #define NO_CONSTRAINT -1
79 #define UNPUT_BUF_SIZE YYLMAX
82 /* yytext is probably a char*, but could be a char[]. yy_text is set
83 in YY_DECL below, because if yytext is a char*, its value is not
86 #else /*!FLEX_SCANNER*/
87 /* yytext is definitely a char[], so yy_text can be set here, statically. */
88 char *yy_text = (char *) yytext;
93 /* [AP] use prototypes in function declarations */
97 #define YY_PROTO(proto) proto
99 #define YY_PROTO(proto) ()
101 /* end of [AP] fix */
104 #define YY_INPUT(buf, result, max_size) my_yy_input(buf, &result, max_size)
107 int _yylex YY_PROTO((void)); \
108 int yylex YY_PROTO((void)) \
110 int result = _yylex(); \
111 yy_text = (char *) yytext; \
114 int _yylex YY_PROTO((void))
122 /* The includes must be here, below the #undef input */
129 #else /* not STDC_HEADERS */
132 # else /* not HAVE_STRING_H */
133 # include <strings.h>
134 # endif /* not HAVE_STRING_H */
135 #endif /* not STDC_HEADERS */
141 #if defined(_amigados)
144 # include <fcntl.h> /* isatty() prototype */
145 # endif /* HAVE_FCNTL_H */
146 #endif /* defined(_amigados) */
150 #include "frontend.h"
154 extern int PosFlags P((int));
156 extern Board boards[MAX_MOVES];
158 int yyskipmoves = FALSE;
159 char currentMoveString[YYLMAX];
161 char unputBuffer[UNPUT_BUF_SIZE];
166 void my_yy_input P((char *buf, int *result, int max_size));
167 #else /*!FLEX_SCANNER*/
168 static int input P((void));
169 static void output P((int ch));
170 static void unput P((int ch));
171 int yylook P((void));
172 int yyback P((int *, int));
175 int yywrap P((void));
176 extern void CopyBoard P((Board to, Board from));
181 "+"?[A-Z][/]?[a-l][0-9][xX:-]?[a-l][0-9]((=?\(?[A-Z]\)?)|[=^])? {
183 * Fully-qualified algebraic move, possibly with promotion
185 int skip1 = 0, skip2 = 0, skip3 = 0, promoted = 0;
190 if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */
192 if (yytext[0] == '+') skip1 = skip3 = promoted = 1; /* [HGM] Shogi promoted */
195 if (yytext[1+skip1] == '/') skip1++;
197 /* remove the [xX:-] */
198 if ((yytext[3+skip1] == 'x') || (yytext[3+skip1] == 'X') ||
199 (yytext[3+skip1] == '-') || (yytext[3+skip1] == ':')) skip2 = 1;
201 currentMoveString[0] = yytext[1+skip1];
202 currentMoveString[1] = yytext[2+skip1];
203 currentMoveString[2] = yytext[3+skip1+skip2];
204 currentMoveString[3] = yytext[4+skip1+skip2];
205 currentMoveString[4] = NULLCHAR;
207 if (appData.debugMode) {
208 fprintf(debugFP, "Parser Qa1b2: yyleng=%d\n",
212 if (yyleng-skip1-skip2 > 5) { char c;
213 if (yytext[yyleng-1] == ')') {
214 c = currentMoveString[4] = ToLower(yytext[yyleng-2]);
216 c = currentMoveString[4] = ToLower(yytext[yyleng-1]);
218 currentMoveString[5] = NULLCHAR;
221 if (appData.debugMode) {
222 fprintf(debugFP, "parser: %s\n", currentMoveString);
224 /* [HGM] do not allow values beyond board size */
225 if(currentMoveString[1] - ONE >= BOARD_HEIGHT ||
226 currentMoveString[1] - ONE < 0 ||
227 currentMoveString[0] - AAA >= BOARD_RGHT ||
228 currentMoveString[3] - ONE >= BOARD_HEIGHT ||
229 currentMoveString[3] - ONE < 0 ||
230 currentMoveString[2] - AAA >= BOARD_RGHT ||
231 currentMoveString[0] - AAA < BOARD_LEFT ||
232 currentMoveString[2] - AAA < BOARD_LEFT )
233 return ImpossibleMove;
235 piece = boards[yyboardindex]
236 [currentMoveString[1] - ONE][currentMoveString[0] - AAA];
237 if(PieceToChar(piece) == '+' && appData.icsActive) promoted = 1, yytext[skip3] = PieceToChar(DEMOTED piece); // trust ICS
238 if(promoted) piece = (ChessSquare) (DEMOTED piece);
239 c = PieceToChar(piece);
240 if(c == '~') c = PieceToChar((ChessSquare) (DEMOTED piece));
241 if (ToLower(yytext[skip3]) != ToLower(c))
242 return (int) IllegalMove;
244 result = LegalityTest(boards[yyboardindex],
245 PosFlags(yyboardindex)&~F_MANDATORY_CAPTURE, // [HGM] losers: might think we can e.p.!
246 currentMoveString[1] - ONE,
247 currentMoveString[0] - AAA,
248 currentMoveString[3] - ONE,
249 currentMoveString[2] - AAA,
250 currentMoveString[4]);
252 if (currentMoveString[4] == NULLCHAR) {
253 if(result == WhitePromotion || result == BlackPromotion) {
254 if(gameInfo.variant == VariantCourier || gameInfo.variant == VariantShatranj)
255 currentMoveString[4] = PieceToChar(BlackFerz);
256 else if(gameInfo.variant == VariantGreat)
257 currentMoveString[4] = PieceToChar(BlackMan);
258 else if(gameInfo.variant == VariantShogi)
259 currentMoveString[4] = '^';
261 currentMoveString[4] = PieceToChar(BlackQueen);
262 } else if(result == WhiteNonPromotion || result == BlackNonPromotion)
263 currentMoveString[4] = '=';
264 currentMoveString[5] = NULLCHAR;
270 [a-l][0-9][xX:-]?[a-l][0-9]((=?\(?[A-Za-z]\)?)|[=^])? {
272 * Simple algebraic move, possibly with promotion
273 * [HGM] Engine moves are received in this format, with lower-case promoChar!
278 if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */
280 /* remove the [xX:-] */
281 if ((yytext[2] == 'x') || (yytext[2] == 'X') ||
282 (yytext[2] == '-') || (yytext[2] == ':')) skip = 1;
284 currentMoveString[0] = yytext[0];
285 currentMoveString[1] = yytext[1];
286 currentMoveString[2] = yytext[2+skip];
287 currentMoveString[3] = yytext[3+skip];
288 currentMoveString[4] = NULLCHAR;
290 if (yyleng-skip > 4) { char c;
291 if (yytext[yyleng-1] == ')') {
292 c = currentMoveString[4] = ToLower(yytext[yyleng-2]);
294 c = currentMoveString[4] = ToLower(yytext[yyleng-1]);
296 currentMoveString[5] = NULLCHAR;
299 /* [HGM] do not allow values beyond board size */
300 if(currentMoveString[1] - ONE >= BOARD_HEIGHT ||
301 currentMoveString[1] - ONE < 0 ||
302 currentMoveString[0] - AAA >= BOARD_RGHT ||
303 currentMoveString[3] - ONE >= BOARD_HEIGHT ||
304 currentMoveString[3] - ONE < 0 ||
305 currentMoveString[2] - AAA >= BOARD_RGHT ||
306 currentMoveString[0] - AAA < BOARD_LEFT ||
307 currentMoveString[2] - AAA < BOARD_LEFT )
308 return ImpossibleMove;
310 result = LegalityTest(boards[yyboardindex],
311 PosFlags(yyboardindex)&~F_MANDATORY_CAPTURE, // [HGM] losers: might think we can e.p.!
312 currentMoveString[1] - ONE,
313 currentMoveString[0] - AAA,
314 currentMoveString[3] - ONE,
315 currentMoveString[2] - AAA,
316 currentMoveString[4]);
318 if (currentMoveString[4] == NULLCHAR) {
319 if(result == WhitePromotion || result == BlackPromotion) {
320 if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier || gameInfo.variant == VariantMakruk)
321 currentMoveString[4] = PieceToChar(BlackFerz);
322 else if(gameInfo.variant == VariantGreat)
323 currentMoveString[4] = PieceToChar(BlackMan);
324 else if(gameInfo.variant == VariantShogi)
325 currentMoveString[4] = '^'; // Queen might not be defined in mini variants!
327 currentMoveString[4] = PieceToChar(BlackQueen);
328 } else if(result == WhiteNonPromotion || result == BlackNonPromotion)
329 currentMoveString[4] = '=';
330 currentMoveString[5] = NULLCHAR;
331 } else if(appData.testLegality && // strip off unnecessary and false promo characters
332 !(result == WhitePromotion || result == BlackPromotion ||
333 result == WhiteNonPromotion || result == BlackNonPromotion)) currentMoveString[4] = NULLCHAR;
338 [A-L][0-9][xX:-]?[A-L][0-9] {
340 * Simple algebraic move, in capitals
341 * [HGM] Some Xiangqi engines use this format ('ICCS notation'). So no promotions!
346 if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */
348 /* remove the [xX:-] */
349 if ((yytext[2] == 'x') || (yytext[2] == 'X') ||
350 (yytext[2] == '-') || (yytext[2] == ':')) skip = 1;
352 currentMoveString[0] = yytext[0]+32;
353 currentMoveString[1] = yytext[1];
354 currentMoveString[2] = yytext[2+skip]+32;
355 currentMoveString[3] = yytext[3+skip];
356 currentMoveString[4] = NULLCHAR;
358 /* [HGM] do not allow values beyond board size */
359 if(currentMoveString[1] - ONE >= BOARD_HEIGHT ||
360 currentMoveString[1] - ONE < 0 ||
361 currentMoveString[0] - AAA >= BOARD_RGHT ||
362 currentMoveString[3] - ONE >= BOARD_HEIGHT ||
363 currentMoveString[3] - ONE < 0 ||
364 currentMoveString[2] - AAA >= BOARD_RGHT ||
365 currentMoveString[0] - AAA < BOARD_LEFT ||
366 currentMoveString[2] - AAA < BOARD_LEFT )
367 return ImpossibleMove;
369 result = LegalityTest(boards[yyboardindex],
370 PosFlags(yyboardindex)&~F_MANDATORY_CAPTURE, // [HGM] losers: might think we can e.p.!
371 currentMoveString[1] - ONE,
372 currentMoveString[0] - AAA,
373 currentMoveString[3] - ONE,
374 currentMoveString[2] - AAA,
375 currentMoveString[4]);
380 [a-l][0-9]((=?\(?[A-Za-z]\)?)|[=^])? {
382 * Pawn move, possibly with promotion
384 DisambiguateClosure cl;
385 int skip = 0; char c;
387 if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */
390 if (yytext[2] == '=' && yytext[3] != NULLCHAR) skip++;
391 if (yytext[2+skip] == '(') skip++;
393 cl.pieceIn = WhiteOnMove(yyboardindex) ? WhitePawn : BlackPawn;
395 cl.ffIn = yytext[0] - AAA;
396 cl.rtIn = yytext[1] - ONE;
397 cl.ftIn = yytext[0] - AAA;
398 c = cl.promoCharIn = ToLower(yytext[2+skip]);
400 /* [HGM] do not allow values beyond board size */
401 if(cl.rtIn >= BOARD_HEIGHT ||
403 cl.ffIn >= BOARD_RGHT ||
404 cl.ftIn < BOARD_LEFT )
405 return ImpossibleMove;
407 Disambiguate(boards[yyboardindex], PosFlags(yyboardindex), &cl);
409 currentMoveString[0] = cl.ff + AAA;
410 currentMoveString[1] = cl.rf + ONE;
411 currentMoveString[2] = cl.ft + AAA;
412 currentMoveString[3] = cl.rt + ONE;
413 currentMoveString[4] = cl.promoChar;
414 currentMoveString[5] = NULLCHAR;
416 return (int) cl.kind;
420 (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."|=)? {
422 * Pawn capture, possibly with promotion, possibly ambiguous
424 DisambiguateClosure cl;
425 int skip1 = 0, skip2 = 0; char c;
427 if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */
429 /* remove trailing ep or e.p. (nonstandard PGN) */
430 if (yytext[yyleng-1] == 'p') {
432 yytext[yyleng] = NULLCHAR;
433 } else if (yytext[yyleng-1] == '.') {
435 yytext[yyleng] = NULLCHAR;
438 /* remove the [xX:-] and =() */
439 if ((yytext[1] == 'x') || (yytext[1] == 'X')
440 || (yytext[1] == ':') || (yytext[1] == '-')) skip1 = 1;
441 if (yytext[2+skip1] == '=' && yytext[3+skip1] != NULLCHAR) skip2++;
442 if (yytext[2+skip1+skip2] == '(') skip2++;
444 cl.pieceIn = WhiteOnMove(yyboardindex) ? WhitePawn : BlackPawn;
446 cl.ffIn = yytext[0] - AAA;
448 cl.ftIn = yytext[1+skip1] - AAA;
449 c = cl.promoCharIn = yytext[2+skip1+skip2];
451 /* [HGM] do not allow values beyond board size */
452 if(cl.ffIn >= BOARD_RGHT ||
453 cl.ffIn < BOARD_LEFT ||
454 cl.ftIn >= BOARD_RGHT ||
455 cl.ftIn < BOARD_LEFT )
456 return ImpossibleMove;
458 Disambiguate(boards[yyboardindex], PosFlags(yyboardindex), &cl);
460 currentMoveString[0] = cl.ff + AAA;
461 currentMoveString[1] = cl.rf + ONE;
462 currentMoveString[2] = cl.ft + AAA;
463 currentMoveString[3] = cl.rt + ONE;
464 currentMoveString[4] = cl.promoChar;
465 currentMoveString[5] = NULLCHAR;
467 return (int) cl.kind;
470 [a-l][xX:]?[a-l][0-9]((=?\(?[A-Z]\)?)|ep|"e.p."|[=^])? {
472 * unambiguously abbreviated Pawn capture, possibly with promotion
475 ChessMove result; char c;
477 if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */
479 /* remove trailing ep or e.p. (nonstandard PGN) */
480 if (yytext[yyleng-1] == 'p') {
482 yytext[yyleng] = NULLCHAR;
483 } else if (yytext[yyleng-1] == '.') {
485 yytext[yyleng] = NULLCHAR;
488 /* remove the [xX:-] */
489 if ((yytext[1] == 'x') || (yytext[1] == 'X')
490 || (yytext[1] == ':') || (yytext[1] == '-')) skip = 1;
492 currentMoveString[0] = yytext[0];
493 currentMoveString[2] = yytext[1+skip];
494 currentMoveString[3] = yytext[2+skip];
496 /* [HGM] do not allow values beyond board size */
497 if(currentMoveString[0] - AAA >= BOARD_RGHT ||
498 currentMoveString[3] - ONE >= BOARD_HEIGHT ||
499 currentMoveString[3] - ONE < 0 ||
500 currentMoveString[2] - AAA >= BOARD_RGHT ||
501 currentMoveString[0] - AAA < BOARD_LEFT ||
502 currentMoveString[2] - AAA < BOARD_LEFT )
503 return ImpossibleMove;
505 if (gameInfo.variant == VariantXiangqi && /* [HGM] In Xiangqi rank stays same */
506 currentMoveString[0] != currentMoveString[2] ) {
507 currentMoveString[1] = yytext[2+skip];
509 if (WhiteOnMove(yyboardindex)) {
510 if (yytext[2+skip] == ONE) return (int) ImpossibleMove;
511 currentMoveString[1] = yytext[2+skip] - 1;
512 if(boards[yyboardindex][currentMoveString[1]-ONE][currentMoveString[0]-AAA] != WhitePawn)
513 return ImpossibleMove;
515 currentMoveString[1] = currentMoveString[3] + 1;
516 if (currentMoveString[3] == ONE+BOARD_HEIGHT-1) return (int) ImpossibleMove;
517 if(boards[yyboardindex][currentMoveString[1]-ONE][currentMoveString[0]-AAA] != BlackPawn)
518 return ImpossibleMove;
520 if (yyleng-skip > 3) {
521 if (yytext[yyleng-1] == ')')
522 c = currentMoveString[4] = ToLower(yytext[yyleng-2]);
524 c = currentMoveString[4] = ToLower(yytext[yyleng-1]);
525 currentMoveString[5] = NULLCHAR;
526 if(c != '=' && c != '^' && CharToPiece(c) == EmptySquare)
527 return ImpossibleMove;
529 currentMoveString[4] = NULLCHAR;
532 result = LegalityTest(boards[yyboardindex],
533 PosFlags(yyboardindex)&~F_MANDATORY_CAPTURE, // [HGM] losers: might think we can e.p.!
534 currentMoveString[1] - ONE,
535 currentMoveString[0] - AAA,
536 currentMoveString[3] - ONE,
537 currentMoveString[2] - AAA,
538 currentMoveString[4]);
540 if (currentMoveString[4] == NULLCHAR) {
541 if(result == WhitePromotion || result == BlackPromotion) {
542 currentMoveString[4] = PieceToChar(BlackQueen);
543 // [HGM] shatranj: take care of variants without Queen
544 if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier || gameInfo.variant == VariantMakruk)
545 currentMoveString[4] = PieceToChar(BlackFerz);
546 if(gameInfo.variant == VariantGreat)
547 currentMoveString[4] = PieceToChar(BlackMan);
548 if(gameInfo.variant == VariantShogi)
549 currentMoveString[4] = '^';
550 } else if(result == WhiteNonPromotion || result == BlackNonPromotion)
551 currentMoveString[4] = '=';
552 currentMoveString[5] = NULLCHAR;
555 if (result != IllegalMove) return (int) result;
557 /* Special case: improperly written en passant capture */
558 if (WhiteOnMove(yyboardindex)) {
559 if (currentMoveString[3] == '5') {
560 currentMoveString[1] = '5';
561 currentMoveString[3] = '6';
563 return (int) IllegalMove;
566 if (currentMoveString[3] == '4') {
567 currentMoveString[1] = '4';
568 currentMoveString[3] = '3';
570 return (int) IllegalMove;
574 result = LegalityTest(boards[yyboardindex],
575 PosFlags(yyboardindex)&~F_MANDATORY_CAPTURE, // [HGM] losers: might think we can e.p.!
576 currentMoveString[1] - ONE,
577 currentMoveString[0] - AAA,
578 currentMoveString[3] - ONE,
579 currentMoveString[2] - AAA,
580 currentMoveString[4]);
582 if (result == WhiteCapturesEnPassant || result == BlackCapturesEnPassant)
585 return (int) IllegalMove;
588 "+"?[A-Z][xX:-]?[a-l][0-9]((=?\(?[A-Z]\)?)|[=^])? {
590 * piece move, possibly ambiguous
592 DisambiguateClosure cl;
593 int skip = 0, skip2 = 0, promoted = 0;
595 if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */
597 if(yytext[0] == '+') promoted = skip = skip2 = 1;
599 /* remove the [xX:-] */
600 if ((yytext[1+skip] == 'x') || (yytext[1+skip] == 'X')
601 || (yytext[1+skip] == ':') || (yytext[1+skip] == '-')) skip++;
603 if (WhiteOnMove(yyboardindex)) {
604 cl.pieceIn = CharToPiece(ToUpper(yytext[skip2]));
606 cl.pieceIn = CharToPiece(ToLower(yytext[skip2]));
608 if(promoted) cl.pieceIn = (ChessSquare) (PROMOTED cl.pieceIn);
612 cl.rtIn = yytext[2+skip] - ONE;
613 cl.ftIn = yytext[1+skip] - AAA;
614 cl.promoCharIn = NULLCHAR;
616 if(yyleng-skip > 3) /* [HGM] can have Shogi-style promotion */
617 cl.promoCharIn = yytext[yyleng-1-(yytext[yyleng-1]==')')];
619 if (appData.debugMode) {
620 fprintf(debugFP, "Parser Qa1: yyleng=%d, %d(%d,%d)-(%d,%d) = %d (%c)\n",
622 cl.pieceIn,cl.ffIn,cl.rfIn,cl.ftIn,cl.rtIn,cl.promoCharIn,cl.promoCharIn?cl.promoCharIn:' ');
625 /* [HGM] but do not allow values beyond board size */
626 if(cl.rtIn >= BOARD_HEIGHT ||
628 cl.ftIn >= BOARD_RGHT ||
629 cl.ftIn < BOARD_LEFT )
630 return ImpossibleMove;
632 Disambiguate(boards[yyboardindex], PosFlags(yyboardindex), &cl);
634 currentMoveString[0] = cl.ff + AAA;
635 currentMoveString[1] = cl.rf + ONE;
636 currentMoveString[2] = cl.ft + AAA;
637 currentMoveString[3] = cl.rt + ONE;
638 currentMoveString[4] = cl.promoChar;
639 currentMoveString[5] = NULLCHAR;
641 return (int) cl.kind;
644 "+"?[A-Z][a-l0-9][xX:-]?[a-l][0-9]((=?\(?[A-Z]\)?)|[=^])? {
646 * piece move with rank or file disambiguator
648 DisambiguateClosure cl;
649 int skip = 0, skip2 = 0; int promoted=0;
651 if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */
653 if(yytext[0]=='+') promoted = skip = skip2 = 1;
655 /* remove the [xX:-] */
656 if ((yytext[2+skip] == 'x') || (yytext[2+skip] == 'X')
657 || (yytext[2+skip] == ':') || (yytext[2+skip] == '-')) skip++;
659 if (WhiteOnMove(yyboardindex)) {
660 cl.pieceIn = CharToPiece(ToUpper(yytext[skip2]));
662 cl.pieceIn = CharToPiece(ToLower(yytext[skip2]));
664 if(promoted) cl.pieceIn = (ChessSquare) (PROMOTED cl.pieceIn);
666 if (isalpha(yytext[1+skip2])) {
668 cl.ffIn = yytext[1+skip2] - AAA;
670 if(cl.ffIn >= BOARD_RGHT ||
671 cl.ffIn < BOARD_LEFT ) return 0;
673 cl.rfIn = yytext[1+skip2] - ONE;
675 if(cl.rfIn >= BOARD_HEIGHT ||
676 cl.rfIn < 0) return 0;
678 cl.rtIn = yytext[3+skip] - ONE;
679 cl.ftIn = yytext[2+skip] - AAA;
680 cl.promoCharIn = NULLCHAR;
682 if(yyleng-skip > 4) /* [HGM] can have Shogi-style promotion */
683 cl.promoCharIn = yytext[yyleng-1-(yytext[yyleng-1]==')')];
685 /* [HGM] do not allow values beyond board size */
686 if(cl.rtIn >= BOARD_HEIGHT ||
688 cl.ftIn >= BOARD_RGHT ||
689 cl.ftIn < BOARD_LEFT )
690 return ImpossibleMove;
692 Disambiguate(boards[yyboardindex], PosFlags(yyboardindex), &cl);
694 currentMoveString[0] = cl.ff + AAA;
695 currentMoveString[1] = cl.rf + ONE;
696 currentMoveString[2] = cl.ft + AAA;
697 currentMoveString[3] = cl.rt + ONE;
698 currentMoveString[4] = cl.promoChar;
699 currentMoveString[5] = NULLCHAR;
701 return (int) cl.kind;
704 000|0-0-0|ooo|OOO|o-o-o|O-O-O {
707 if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */
709 /* [HGM] all squares referenced to board edges in stead of absolute */
710 if (WhiteOnMove(yyboardindex)) {
711 if (boards[yyboardindex][0][(BOARD_WIDTH-1)>>1] == WhiteKing) {
712 /* ICS wild castling */
714 ff = (BOARD_WIDTH-1)>>1;
724 if (boards[yyboardindex][BOARD_HEIGHT-1][(BOARD_WIDTH-1)>>1] == BlackKing) {
725 /* ICS wild castling */
727 ff = (BOARD_WIDTH-1)>>1;
737 if(PosFlags(0) & F_FRC_TYPE_CASTLING) {
739 if (WhiteOnMove(yyboardindex)) {
740 ff = initialRights[2];
741 ft = initialRights[1];
743 ff = initialRights[5];
744 ft = initialRights[4];
746 if (appData.debugMode)
748 fprintf(debugFP, "Parser FRC long %d %d\n", ff, ft);
750 if(ff < 0 || ft < 0) return 0;
752 sprintf(currentMoveString, "%c%c%c%c",ff+AAA,rf+ONE,ft+AAA,rt+ONE);
753 if (appData.debugMode) {
754 fprintf(debugFP, "long castling %d %d\n", ff, ft);
756 return (int) LegalityTest(boards[yyboardindex],
757 PosFlags(yyboardindex)&~F_MANDATORY_CAPTURE, // [HGM] losers: e.p.!
758 rf, ff, rt, ft, NULLCHAR);
761 00|0-0|oo|OO|o-o|O-O {
764 if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */
766 if (WhiteOnMove(yyboardindex)) {
767 if (boards[yyboardindex][0][(BOARD_WIDTH-1)>>1] == WhiteKing) {
768 /* ICS wild castling */
770 ff = (BOARD_WIDTH-1)>>1;
780 if (boards[yyboardindex][BOARD_HEIGHT-1][(BOARD_WIDTH-1)>>1] == BlackKing) {
781 /* ICS wild castling */
783 ff = (BOARD_WIDTH-1)>>1;
793 if(PosFlags(0) & F_FRC_TYPE_CASTLING) {
794 if (WhiteOnMove(yyboardindex)) {
795 ff = initialRights[2];
796 ft = initialRights[0];
798 ff = initialRights[5];
799 ft = initialRights[3];
801 if (appData.debugMode) {
802 fprintf(debugFP, "Parser FRC short %d %d\n", ff, ft);
804 if(ff < 0 || ft < 0) return 0;
806 sprintf(currentMoveString, "%c%c%c%c",ff+AAA,rf+ONE,ft+AAA,rt+ONE);
807 if (appData.debugMode) {
808 fprintf(debugFP, "short castling %d %d\n", ff, ft);
811 return (int) LegalityTest(boards[yyboardindex],
812 PosFlags(yyboardindex)&~F_MANDATORY_CAPTURE, // [HGM] losers: e.p.!
813 rf, ff, rt, ft, NULLCHAR);
816 [A-Za-z][@*][a-l][0-9] {
817 /* Bughouse piece drop. */
818 currentMoveString[1] = '@';
819 currentMoveString[2] = yytext[2];
820 currentMoveString[3] = yytext[3];
821 currentMoveString[4] = NULLCHAR;
823 if (appData.debugMode) {
824 fprintf(debugFP, "Drop: %s\n", currentMoveString);
826 /* [HGM] do not allow values beyond board size */
827 if(currentMoveString[3] - ONE >= BOARD_HEIGHT ||
828 currentMoveString[2] - AAA >= BOARD_WIDTH )
829 return ImpossibleMove;
831 if (WhiteOnMove(yyboardindex)) {
832 currentMoveString[0] = ToUpper(yytext[0]);
834 currentMoveString[0] = ToLower(yytext[0]);
836 return LegalityTest(boards[yyboardindex], PosFlags(yyboardindex), DROP_RANK, // [HGM] does drops now too
837 CharToPiece(currentMoveString[0]), currentMoveString[3] - ONE, currentMoveString[2] - AAA, NULLCHAR);
841 if (WhiteOnMove(yyboardindex))
842 return (int) BlackWins;
844 return (int) WhiteWins;
847 (([Ww](hite)?)|([Bb](lack)?))" "(([Rr]esign)|([Ff]orfeit))(s|ed)? {
848 return (int) (ToUpper(yytext[0]) == 'W' ? BlackWins : WhiteWins);
851 (([Ww](hite)?)|([Bb](lack)?))" "[Dd]isconnect(s|ed) {
852 return (int) GameUnfinished;
856 return (int) GameIsDrawn;
860 return (int) GameIsDrawn;
864 if (WhiteOnMove(yyboardindex))
865 return (int) BlackWins;
867 return (int) WhiteWins;
871 if (WhiteOnMove(yyboardindex))
872 return (int) BlackWins;
874 return (int) WhiteWins;
877 [Dd]raw(n)?(" "by)?(" "[Rr]epetition)|(" "[Aa]gree(d|ment)) {
878 return (int) GameIsDrawn;
881 [Dd]raw(n)?(" (".*")")? {
882 return (int) GameIsDrawn;
885 (([Ww](hite)?)|([Bb](lack)?))" "(([Mm]ates)|([Ww][io]n(s)?)) {
886 return (int) (ToUpper(yytext[0]) == 'W' ? WhiteWins : BlackWins);
889 (([Ww](hite)?)|([Bb](lack)?))" "(([Mm]ated)|([Ll]os[tes]+)) {
890 return (int) (ToUpper(yytext[0]) == 'W' ? BlackWins : WhiteWins);
893 ("{"[^\}\n]*"} ")?(1-0|"1 - 0"|"1/0"|"1 / 0"|"1:0"|"1 : 0")(" (".*")"|" {".*"}")? {
894 return (int) WhiteWins;
897 ("{"[^\}\n]*"} ")?(0-1|"0 - 1"|"0/1"|"0 / 1"|"0:1"|"0 : 1")(" (".*")"|" {".*"}")? {
898 return (int) BlackWins;
901 ("{"[^\}\n]*"} ")?("1/2"|"1 / 2")(" "?[-:]" "?("1/2"|"1 / 2"))?(" (".*")"|" {".*"}")? {
902 return (int) GameIsDrawn;
905 ("{"[^\}\n]*"} ")?"*"(" (".*")"|" {".*"}")? {
906 return (int) GameUnfinished;
909 [1-9][0-9]*/"."?[ \t\n]*[a-lNnPpRrBQqKACFEWDGHOo] {
911 if ((yyleng == 1) && (yytext[0] == '1'))
912 return (int) MoveNumberOne;
915 \([0-9]+:[0-9][0-9](\.[0-9]+)?\)|\{[0-9]+:[0-9][0-9](\.[0-9]+)?\} {
916 /* elapsed time indication, e.g. (0:12) or {10:21.071} */
917 return (int) ElapsedTime;
921 /* position diagram enclosed in [-- --] */
922 return (int) PositionDiagram;
925 ^"{--------------"\n[^\}]*\n"--------------}"$ {
926 /* position diagram enclosed in {-- --} */
927 return (int) PositionDiagram;
930 \[[ \t\n]*[A-Za-z0-9][A-Za-z0-9_+#=-]*[ \t\n]*\"[^"]*\"[ \t\n]*\] {
934 [Gg](nu|NU)" "?[Cc](hess|HESS).*[Gg](ame|AME) {
935 return (int) GNUChessGame;
938 ^[#;%]" "[^ ]*(" game file"|" position file").*$ {
939 return (int) XBoardGame;
942 \$[0-9]+ { /* numeric annotation glyph */
946 \{[^\}]*\} { /* anything in {} */
947 return (int) Comment;
950 ;.*$ { /* ; to end of line */
951 return (int) Comment;
954 \[[^\]]*\] { /* anything in [] */
955 return (int) Comment;
958 \([^()]*(\([^()]*(\([^()]*(\([^()]*\)[^()]*)*\)[^()]*)*\)[^()]*)+[^()]*\) { /* very nested () */
959 return (int) Comment;
962 \([^)][^)]+\) { /* >=2 chars in () */
963 return (int) Comment;
966 ^[-a-zA-Z0-9]+:" ".*(\n[ \t]+.*)* {
967 /* Skip mail headers */
971 /* Skip random words */
975 /* Skip everything else */
981 static char *StringToLex;
990 if (StringToLex != NULL) {
996 } else if (unputCount > 0) {
997 ret = unputBuffer[--unputCount];
1009 * Return offset of next pattern within current file
1013 int offset = ftell(lexFP) - unputCount;
1021 static void output(ch)
1024 if(appData.debugMode) fprintf(debugFP, "PARSER BUG: unmatched character '%c' (0%o)\n",
1028 static void unput(ch)
1031 if (ch == 0) return;
1032 if (StringToLex != NULL) {
1035 if (unputCount >= UNPUT_BUF_SIZE)
1036 if(appData.debugMode) fprintf(debugFP, "PARSER BUG: unput buffer overflow '%c' (0%o)\n",
1038 unputBuffer[unputCount++] = ch;
1042 /* Get ready to lex from a new file. Kludge below sticks
1043 an artificial newline at the front of the file, which the
1044 above grammar ignores, but which makes ^ at start of pattern
1045 match at the real start of the file.
1053 unput('\n'); /* kludge */
1056 /* Get ready to lex from a string. ^ at start of pattern WON'T
1057 match at the start of the string!
1066 #endif /*!FLEX_SCANNER*/
1069 void my_yy_input(buf, result, max_size)
1076 if (StringToLex != NULL) {
1078 while (*StringToLex != NULLCHAR) {
1079 *buf++ = *StringToLex++;
1085 count = fread(buf, 1, max_size, yyin);
1095 static YY_BUFFER_STATE my_file_buffer = NULL;
1098 Return offset of next pattern in the current file.
1102 int pos = yy_c_buf_p - YY_CURRENT_BUFFER->yy_ch_buf;
1104 return(ftell(YY_CURRENT_BUFFER->yy_input_file) -
1112 if (my_file_buffer != NULL)
1113 yy_delete_buffer(my_file_buffer);
1115 my_file_buffer = yy_create_buffer(stdin, YY_BUF_SIZE);
1116 yy_switch_to_buffer(my_file_buffer);
1122 if (my_file_buffer != NULL)
1123 yy_delete_buffer(my_file_buffer);
1125 my_file_buffer = yy_create_buffer(f, YY_BUF_SIZE);
1126 yy_switch_to_buffer(my_file_buffer);
1128 #endif /*FLEX_SCANNER*/
1135 /* Parse a move from the given string s */
1136 /* ^ at start of pattern WON'T work here unless using flex */
1137 ChessMove yylexstr(boardIndex, s, text, len)
1138 int boardIndex, len;
1142 char *oldStringToLex;
1144 YY_BUFFER_STATE buffer, oldBuffer;
1147 yyboardindex = boardIndex;
1148 oldStringToLex = StringToLex;
1151 buffer = yy_create_buffer(stdin, YY_BUF_SIZE);
1152 oldBuffer = YY_CURRENT_BUFFER;
1153 yy_switch_to_buffer(buffer);
1154 #endif /*FLEX_SCANNER*/
1156 ret = (ChessMove) yylex();
1157 strncpy(text, yy_text, len-1); // [HGM] vari: yy_text is not available to caller after buffer switch ?!?
1158 text[len-1] = NULLCHAR;
1161 if (oldBuffer != NULL)
1162 yy_switch_to_buffer(oldBuffer);
1163 yy_delete_buffer(buffer);
1164 #endif /*FLEX_SCANNER*/
1165 StringToLex = oldStringToLex;