parser.c

   1 /*
   2  * parser.c --
   3  *
   4  * Copyright 2011, 2012, 2013 Free Software Foundation, Inc.
   5  * ------------------------------------------------------------------------
   6  *
   7  * GNU XBoard is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation, either version 3 of the License, or (at
  10  * your option) any later version.
  11  *
  12  * GNU XBoard is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program. If not, see http://www.gnu.org/licenses/.  *
  19  *
  20  *------------------------------------------------------------------------
  21  ** See the file ChangeLog for a revision history.  */
  22
  23 #include "config.h"
  24 #include <stdio.h>
  25 #include <ctype.h>
  26 #include <string.h>
  27 #include "common.h"
  28 #include "backend.h"
  29 #include "frontend.h"
  30 #include "parser.h"
  31 #include "moves.h"
  32
  33
  34 extern Board    boards[MAX_MOVES];
  35 extern int      PosFlags(int nr);
  36 int             yyboardindex;
  37 int             yyskipmoves = FALSE;
  38 char            currentMoveString[4096]; // a bit ridiculous size?
  39 char *yy_text;
  40
  41 #define PARSEBUFSIZE 10000
  42
  43 static FILE *inputFile;
  44 static char *inPtr, *parsePtr, *parseStart;
  45 static char inputBuf[PARSEBUFSIZE];
  46 static char yytext[PARSEBUFSIZE];
  47 static char fromString = 0, lastChar = '\n';
  48
  49 #define NOTHING 0
  50 #define NUMERIC 1
  51 #define ALPHABETIC 2
  52 #define BADNUMBER (-2000000000)
  53
  54 int
  55 ReadLine ()
  56 {   // Read one line from the input file, and append to the buffer
  57     char c, *start = inPtr;
  58     if(fromString) return 0; // parsing string, so the end is a hard end
  59     if(!inputFile) return 0;
  60     while((c = fgetc(inputFile)) != EOF) {
  61         *inPtr++ = c;
  62         if(c == '\n') { *inPtr = NULLCHAR; return 1; }
  63         if(inPtr - inputBuf > PARSEBUFSIZE-2) inPtr--; //prevent crash on overflow
  64     }
  65     if(inPtr == start) return 0;
  66     *inPtr++ = '\n', *inPtr = NULLCHAR; // repair missing linefeed at EOF
  67     return 1;
  68 }
  69
  70 int
  71 Scan (char c, char **p)
  72 {   // line-spanning skip to mentioned character or EOF
  73     do {
  74         while(**p) if(*(*p)++ == c) return 0;
  75     } while(ReadLine());
  76     // no closing bracket; force match for entire rest of file.
  77     return 1;
  78 }
  79
  80 int
  81 SkipWhite (char **p)
  82 {   // skip spaces tabs and newlines; return 1 if anything was skipped
  83     char *start = *p;
  84     do{
  85         while(**p == ' ' || **p == '\t' || **p == '\n' || **p == '\r') (*p)++;
  86     } while(**p == NULLCHAR && ReadLine()); // continue as long as ReadLine reads something
  87     return *p != start;
  88 }
  89
  90 inline int
  91 Match (char *pattern, char **ptr)
  92 {
  93     char *p = pattern, *s = *ptr;
  94     while(*p && (*p == *s++ || s[-1] == '\r' && *p--)) p++;
  95     if(*p == 0) {
  96         *ptr = s;
  97         return 1;
  98     }
  99     return 0; // no match, no ptr update
 100 }
 101
 102 inline int
 103 Word (char *pattern, char **p)
 104 {
 105     if(Match(pattern, p)) return 1;
 106     if(*pattern >= 'a' && *pattern <= 'z' && *pattern - **p == 'a' - 'A') { // capitalized
 107         (*p)++;
 108         if(Match(pattern + 1, p)) return 1;
 109         (*p)--;
 110     }
 111     return 0;
 112 }
 113
 114 int
 115 Verb (char *pattern, char **p)
 116 {
 117     int res = Word(pattern, p);
 118     if(res && !Match("s", p)) Match("ed", p); // eat conjugation suffix, if any
 119     return res;
 120 }
 121
 122 int
 123 Number (char **p)
 124 {
 125     int val = 0;
 126     if(**p < '0' || **p > '9') return BADNUMBER;
 127     while(**p >= '0' && **p <= '9') {
 128         val = 10*val + *(*p)++ - '0';
 129     }
 130     return val;
 131 }
 132
 133 int
 134 RdTime (char c, char **p)
 135 {
 136     char *start = ++(*p), *sec; // increment *p, as it was pointing to the opening ( or {
 137     if(Number(p) == BADNUMBER) return 0;
 138     sec = *p;
 139     if(Match(":", p) && Number(p) != BADNUMBER && *p - sec == 3) { // well formed
 140         sec = *p;
 141         if(Match(".", p) && Number(p) != BADNUMBER && *(*p)++ == c) return 1; // well-formed fraction
 142         *p = sec;
 143         if(*(*p)++ == c) return 1; // matching bracket without fraction
 144     }
 145     *p = start; // failure
 146     return 0;
 147 }
 148
 149 char
 150 PromoSuffix (char **p)
 151 {
 152     char *start = *p;
 153     if(**p == 'e' && (Match("ep", p) || Match("e.p.", p))) { *p = start; return NULLCHAR; } // non-compliant e.p. suffix is no promoChar!
 154     if(**p == '+' && gameInfo.variant == VariantShogi) { (*p)++; return '+'; }
 155     if(**p == '=' || (gameInfo.variant == VariantSChess) && **p == '/') (*p)++; // optional = (or / for Seirawan gating)
 156     if(**p == '(' && (*p)[2] == ')' && isalpha( (*p)[1] )) { (*p) += 3; return ToLower((*p)[-2]); }
 157     if(isalpha(**p)) return ToLower(*(*p)++);
 158     if(*p != start) return '='; // must be the optional =
 159     return NULLCHAR; // no suffix detected
 160 }
 161
 162 int
 163 NextUnit (char **p)
 164 {       // Main parser routine
 165         int coord[4], n, result, piece, i;
 166         char type[4], promoted, separator, slash, *oldp, *commentEnd, c;
 167         int wom = quickFlag ? quickFlag&1 : WhiteOnMove(yyboardindex);
 168
 169         // ********* try white first, because it is so common **************************
 170         if(**p == ' ' || **p == '\n' || **p == '\t') { parseStart = (*p)++; return Nothing; }
 171
 172
 173         if(**p == NULLCHAR) { // make sure there is something to parse
 174             if(fromString) return 0; // we are parsing string, so the end is really the end
 175             *p = inPtr = inputBuf;
 176             if(!ReadLine()) return 0; // EOF
 177         } else if(inPtr > inputBuf + PARSEBUFSIZE/2) { // buffer fills up with already parsed stuff
 178             char *q = *p, *r = inputBuf;
 179             while(*r++ = *q++);
 180             *p = inputBuf; inPtr = r - 1;
 181         }
 182         parseStart = oldp = *p; // remember where we begin
 183
 184
 185         // ********* attempt to recognize a SAN move in the leading non-blank text *****
 186         piece = separator = promoted = slash = n = 0;
 187         for(i=0; i<4; i++) coord[i] = -1, type[i] = NOTHING;
 188         if(**p == '+') (*p)++, promoted++;
 189         if(**p >= 'a' && **p <= 'z' && (*p)[1]== '@') piece =*(*p)++ + 'A' - 'a'; else
 190         if(**p >= 'A' && **p <= 'Z') {
 191              piece = *(*p)++; // Note we could test for 2-byte non-ascii names here
 192              if(**p == '/') slash = *(*p)++;
 193         }
 194         while(n < 4) {
 195             if(**p >= 'a' && **p < 'x') coord[n] = *(*p)++ - 'a', type[n++] = ALPHABETIC;
 196             else if((i = Number(p)) != BADNUMBER) coord[n] = i, type[n++] = NUMERIC;
 197             else break;
 198             if(n == 2 && type[0] == type[1]) { // if two identical types, the opposite type in between must have been missing
 199                 type[2] = type[1]; coord[2] = coord[1];
 200                 type[1] = NOTHING; coord[1] = -1; n++;
 201             }
 202         }
 203         // we always get here, and might have read a +, a piece, and upto 4 potential coordinates
 204         if(n <= 2) { // could be from-square or disambiguator, when -:xX follow, or drop with @ directly after piece, but also to-square
 205              if(**p == '-' || **p == ':' || **p == 'x' || **p == 'X' || // these cannot be move suffix, so to-square must follow
 206                  (**p == '@' || **p == '*') && n == 0 && !promoted && piece) { // P@ must also be followed by to-square
 207                 separator = *(*p)++;
 208                 if(n == 1) coord[1] = coord[0]; // must be disambiguator, but we do not know which yet
 209                 n = 2;
 210                 while(n < 4) { // attempt to read to-square
 211                     if(**p >= 'a' && **p < 'x') coord[n] = *(*p)++ - 'a', type[n++] = ALPHABETIC;
 212                     else if((i = Number(p)) != BADNUMBER) coord[n] = i, type[n++] = NUMERIC;
 213                     else break;
 214                 }
 215             } else if((**p == '+' || **p == '=') && n == 1 && piece && type[0] == NUMERIC) { // can be traditional Xiangqi notation
 216                 separator = *(*p)++;
 217                 n = 2;
 218                 if((i = Number(p)) != BADNUMBER) coord[n] = i, type[n++] = NUMERIC;
 219             } else if(n == 2) { // only one square mentioned, must be to-square
 220                 while(n < 4) { coord[n] = coord[n-2], type[n] = type[n-2], coord[n-2] = -1, type[n-2] = NOTHING; n++; }
 221             }
 222         } else if(n == 3 && type[1] != NOTHING) { // must be hyphenless disambiguator + to-square
 223             for(i=3; i>0; i--) coord[i] = coord[i-1], type[i] = type[i-1]; // move to-square to where it belongs
 224             type[1] = NOTHING; // disambiguator goes in first two positions
 225             n = 4;
 226         }
 227         // we always get here; move must be completely read now, with to-square coord(s) at end
 228         if(n == 3) { // incomplete to-square. Could be Xiangqi traditional, or stuff like fxg
 229             if(piece && type[1] == NOTHING && type[0] == NUMERIC && type[2] == NUMERIC &&
 230                 (separator == '+' || separator == '=' || separator == '-')) {
 231                      // Xiangqi traditional
 232
 233                 return ImpossibleMove; // for now treat as invalid
 234             }
 235             // fxg stuff, but also things like 0-0, 0-1 and 1-0
 236             if(!piece && type[1] == NOTHING && type[0] == ALPHABETIC && type[2] == ALPHABETIC
 237                  && (coord[0] != 14 || coord[2] != 14) /* reserve oo for castling! */ ) {
 238                 piece = 'P'; n = 4; // kludge alert: fake full to-square
 239             }
 240         } else if(n == 1 && type[0] == NUMERIC && coord[0] > 1) { while(**p == '.') (*p)++; return Nothing; } // fast exit for move numbers
 241         if(n == 4 && type[2] != type[3] && // we have a valid to-square (kludge: type[3] can be NOTHING on fxg type move)
 242                      (piece || !promoted) && // promoted indicator only valid on named piece type
 243                      (type[2] == ALPHABETIC || gameInfo.variant == VariantShogi)) { // in Shogi also allow alphabetic rank
 244             DisambiguateClosure cl;
 245             int fromX, fromY, toX, toY;
 246
 247             if(slash && (!piece || type[1] == NOTHING)) goto badMove; // slash after piece only in ICS long format
 248             if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */
 249
 250             if(type[2] == NUMERIC) { // alpha-rank
 251                 coord[2] = BOARD_RGHT - BOARD_LEFT - coord[2];
 252                 coord[3] = BOARD_HEIGHT - coord[3];
 253                 if(coord[0] >= 0) coord[0] = BOARD_RGHT - BOARD_LEFT - coord[0];
 254                 if(coord[1] >= 0) coord[1] = BOARD_HEIGHT - coord[1];
 255             }
 256             toX = cl.ftIn = (currentMoveString[2] = coord[2] + 'a') - AAA;
 257             toY = cl.rtIn = (currentMoveString[3] = coord[3] + '0') - ONE;
 258             if(type[3] == NOTHING) cl.rtIn = -1; // for fxg type moves ask for toY disambiguation
 259             else if(toY >= BOARD_HEIGHT || toY < 0)   return ImpossibleMove; // vert off-board to-square
 260             if(toX < BOARD_LEFT || toX >= BOARD_RGHT) return ImpossibleMove;
 261             if(piece) {
 262                 cl.pieceIn = CharToPiece(wom ? piece : ToLower(piece));
 263                 if(cl.pieceIn == EmptySquare) return ImpossibleMove; // non-existent piece
 264                 if(promoted) cl.pieceIn = (ChessSquare) (PROMOTED cl.pieceIn);
 265             } else cl.pieceIn = EmptySquare;
 266             if(separator == '@' || separator == '*') { // drop move. We only get here without from-square or promoted piece
 267                 fromY = DROP_RANK; fromX = cl.pieceIn;
 268                 currentMoveString[0] = piece;
 269                 currentMoveString[1] = '@';
 270                 return LegalityTest(boards[yyboardindex], PosFlags(yyboardindex)&~F_MANDATORY_CAPTURE, fromY, fromX, toY, toX, NULLCHAR);
 271             }
 272             if(type[1] == NOTHING && type[0] != NOTHING) { // there is a disambiguator
 273                 if(type[0] != type[2]) coord[0] = -1, type[1] = type[0], type[0] = NOTHING; // it was a rank-disambiguator
 274             }
 275             if(  type[1] != type[2] && // means fromY is of opposite type as ToX, or NOTHING
 276                 (type[0] == NOTHING || type[0] == type[2]) ) { // well formed
 277
 278                 fromX = (currentMoveString[0] = coord[0] + 'a') - AAA;
 279                 fromY = (currentMoveString[1] = coord[1] + '0') - ONE;
 280                 currentMoveString[4] = cl.promoCharIn = PromoSuffix(p);
 281                 currentMoveString[5] = NULLCHAR;
 282                 if(type[0] != NOTHING && type[1] != NOTHING && type[3] != NOTHING) { // fully specified.
 283                     // Note that Disambiguate does not work for illegal moves, but flags them as impossible
 284                     if(piece) { // check if correct piece indicated
 285                         ChessSquare realPiece = boards[yyboardindex][fromY][fromX];
 286                         if(PieceToChar(realPiece) == '~') realPiece = (ChessSquare) (DEMOTED realPiece);
 287                         if(!(appData.icsActive && PieceToChar(realPiece) == '+') && // trust ICS if it moves promoted pieces
 288                            piece && realPiece != cl.pieceIn) return ImpossibleMove;
 289                     }
 290                     result = LegalityTest(boards[yyboardindex], PosFlags(yyboardindex), fromY, fromX, toY, toX, cl.promoCharIn);
 291                     if (currentMoveString[4] == NULLCHAR) { // suppy missing mandatory promotion character
 292                       if(result == WhitePromotion  || result == BlackPromotion) {
 293                         switch(gameInfo.variant) {
 294                           case VariantCourier:
 295                           case VariantShatranj: currentMoveString[4] = PieceToChar(BlackFerz); break;
 296                           case VariantGreat:    currentMoveString[4] = PieceToChar(BlackMan); break;
 297                           case VariantShogi:    currentMoveString[4] = '+'; break;
 298                           default:              currentMoveString[4] = PieceToChar(BlackQueen);
 299                         }
 300                       } else if(result == WhiteNonPromotion  || result == BlackNonPromotion) {
 301                                                 currentMoveString[4] = '=';
 302                       }
 303                     } else if(appData.testLegality && gameInfo.variant != VariantSChess && // strip off unnecessary and false promo characters
 304                        !(result == WhitePromotion  || result == BlackPromotion ||
 305                          result == WhiteNonPromotion || result == BlackNonPromotion)) currentMoveString[4] = NULLCHAR;
 306                     return result;
 307                 } else if(cl.pieceIn == EmptySquare) cl.pieceIn = wom ? WhitePawn : BlackPawn;
 308                 cl.ffIn = type[0] == NOTHING ? -1 : coord[0] + 'a' - AAA;
 309                 cl.rfIn = type[1] == NOTHING ? -1 : coord[1] + '0' - ONE;
 310
 311                 Disambiguate(boards[yyboardindex], PosFlags(yyboardindex), &cl);
 312
 313                 if(cl.kind == ImpossibleMove && !piece && type[1] == NOTHING // fxg5 type
 314                         && toY == (wom ? 4 : 3)) { // could be improperly written e.p.
 315                     cl.rtIn += wom ? 1 : -1; // shift target square to e.p. square
 316                     Disambiguate(boards[yyboardindex], PosFlags(yyboardindex), &cl);
 317                     if((cl.kind != WhiteCapturesEnPassant && cl.kind != BlackCapturesEnPassant))
 318                         return ImpossibleMove; // nice try, but no cigar
 319                 }
 320
 321                 currentMoveString[0] = cl.ff + AAA;
 322                 currentMoveString[1] = cl.rf + ONE;
 323                 currentMoveString[3] = cl.rt + ONE;
 324                 currentMoveString[4] = cl.promoChar;
 325
 326                 if((cl.kind == WhiteCapturesEnPassant || cl.kind == BlackCapturesEnPassant) && (Match("ep", p) || Match("e.p.", p)));
 327
 328                 return (int) cl.kind;
 329             }
 330         }
 331 badMove:// we failed to find algebraic move
 332         *p = oldp;
 333
 334
 335         // Next we do some common symbols where the first character commits us to things that cannot possibly be a move
 336
 337         // ********* PGN tags ******************************************
 338         if(**p == '[') {
 339             oldp = ++(*p);
 340             if(Match("--", p)) { // "[--" could be start of position diagram
 341                 if(!Scan(']', p) && (*p)[-3] == '-' && (*p)[-2] == '-') return PositionDiagram;
 342                 *p = oldp;
 343             }
 344             SkipWhite(p);
 345             if(isdigit(**p) || isalpha(**p)) {
 346                 do (*p)++; while(isdigit(**p) || isalpha(**p) || **p == '+' ||
 347                                 **p == '-' || **p == '=' || **p == '_' || **p == '#');
 348                 SkipWhite(p);
 349                 if(**p == '"') {
 350                     (*p)++;
 351                     while(**p != '\n' && (*(*p)++ != '"'|| (*p)[-2] == '\\')); // look for unescaped quote
 352                     if((*p)[-1] !='"') { *p = oldp; Scan(']', p); return Comment; } // string closing delimiter missing
 353                     SkipWhite(p); if(*(*p)++ == ']') return PGNTag;
 354                 }
 355             }
 356             Scan(']', p); return Comment;
 357         }
 358
 359         // ********* SAN Castings *************************************
 360         if(**p == 'O' || **p == 'o' || **p == '0' && !Match("00:", p)) { // exclude 00 in time stamps
 361             int castlingType = 0;
 362             if(Match("O-O-O", p) || Match("o-o-o", p) || Match("0-0-0", p) ||
 363                Match("OOO", p) || Match("ooo", p) || Match("000", p)) castlingType = 2;
 364             else if(Match("O-O", p) || Match("o-o", p) || Match("0-0", p) ||
 365                     Match("OO", p) || Match("oo", p) || Match("00", p)) castlingType = 1;
 366             if(castlingType) { //code from old parser, collapsed for both castling types, and streamlined a bit
 367                 int rf, ff, rt, ft; ChessSquare king;
 368                 char promo=NULLCHAR;
 369
 370                 if(gameInfo.variant == VariantSChess) promo = PromoSuffix(p);
 371
 372                 if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */
 373
 374                 if (wom) {
 375                     rf = 0;
 376                     rt = 0;
 377                     king = WhiteKing;
 378                 } else {
 379                     rf = BOARD_HEIGHT-1;
 380                     rt = BOARD_HEIGHT-1;
 381                     king = BlackKing;
 382                 }
 383                 ff = (BOARD_WIDTH-1)>>1; // this would be d-file
 384                 if (boards[yyboardindex][rf][ff] == king) {
 385                     /* ICS wild castling */
 386                     ft = castlingType == 1 ? BOARD_LEFT+1 : (gameInfo.variant == VariantJanus ? BOARD_RGHT-2 : BOARD_RGHT-3);
 387                 } else {
 388                     ff = BOARD_WIDTH>>1; // e-file
 389                     ft = castlingType == 1 ? BOARD_RGHT-2 : BOARD_LEFT+2;
 390                 }
 391                 if(PosFlags(0) & F_FRC_TYPE_CASTLING) {
 392                     if (wom) {
 393                         ff = initialRights[2];
 394                         ft = initialRights[castlingType-1];
 395                     } else {
 396                         ff = initialRights[5];
 397                         ft = initialRights[castlingType+2];
 398                     }
 399                     if (appData.debugMode) fprintf(debugFP, "Parser FRC (type=%d) %d %d\n", castlingType, ff, ft);
 400                     if(ff == NoRights || ft == NoRights) return ImpossibleMove;
 401                 }
 402                 sprintf(currentMoveString, "%c%c%c%c%c",ff+AAA,rf+ONE,ft+AAA,rt+ONE,promo);
 403                 if (appData.debugMode) fprintf(debugFP, "(%d-type) castling %d %d\n", castlingType, ff, ft);
 404
 405                 return (int) LegalityTest(boards[yyboardindex],
 406                               PosFlags(yyboardindex)&~F_MANDATORY_CAPTURE, // [HGM] losers: e.p.!
 407                               rf, ff, rt, ft, promo);
 408             }
 409         }
 410
 411
 412         // ********* variations (nesting) ******************************
 413         if(**p =='(') {
 414             if(RdTime(')', p)) return ElapsedTime;
 415             return Open;
 416         }
 417         if(**p ==')') { (*p)++; return Close; }
 418         if(**p == ';') { while(**p != '\n') (*p)++; return Comment; }
 419
 420
 421         // ********* Comments and result messages **********************
 422         *p = oldp; commentEnd = NULL; result = 0;
 423         if(**p == '{') {
 424             if(RdTime('}', p)) return ElapsedTime;
 425             if(lastChar == '\n' && Match("--------------\n", p)) {
 426                 char *q;
 427                 i = Scan ('}', p); q = *p - 16;
 428                 if(Match("\n--------------}\n", &q)) return PositionDiagram;
 429             } else i = Scan('}', p);
 430             commentEnd = *p; if(i) return Comment; // return comment that runs to EOF immediately
 431         }
 432         if(commentEnd) SkipWhite(p);
 433         if(Match("*", p)) result = GameUnfinished;
 434         else if(**p == '0') {
 435             if( Match("0-1", p) || Match("0/1", p) || Match("0:1", p) ||
 436                 Match("0 - 1", p) || Match("0 / 1", p) || Match("0 : 1", p)) result = BlackWins;
 437         } else if(**p == '1') {
 438             if( Match("1-0", p) || Match("1/0", p) || Match("1:0", p) ||
 439                 Match("1 - 0", p) || Match("1 / 0", p) || Match("1 : 0", p)) result = WhiteWins;
 440             else if(Match("1/2 - 1/2", p) || Match("1/2:1/2", p) || Match("1/2 : 1/2", p) || Match("1 / 2 - 1 / 2", p) ||
 441                     Match("1 / 2 : 1 / 2", p) || Match("1/2", p) || Match("1 / 2", p)) result = GameIsDrawn;
 442         }
 443         if(result) {
 444             if(Match(" (", p) && !Scan(')', p) || Match(" {", p) && !Scan('}', p)) { // there is a comment after the PGN result!
 445                 if(commentEnd) { *p = commentEnd; return Comment; } // so comment before it is normal comment; return that first
 446             }
 447             return result; // this returns a possible preceeding comment as result details
 448         }
 449         if(commentEnd) { *p = commentEnd; return Comment; } // there was no PGN result following, so return as normal comment
 450
 451
 452         // ********* Move numbers (after castlings or PGN results!) ***********
 453         if((i = Number(p)) != BADNUMBER) { // a single number was read as part of our attempt to read a move
 454             char *numEnd = *p;
 455             if(**p == '.') (*p)++; SkipWhite(p);
 456             if(**p == '+' || isalpha(**p) || gameInfo.variant == VariantShogi && *p != numEnd && isdigit(**p)) {
 457                 *p = numEnd;
 458                 return i == 1 ? MoveNumberOne : Nothing;
 459             }
 460             *p = numEnd; return Nothing;
 461         }
 462
 463
 464         // ********* non-compliant game-result indicators *********************
 465         if(Match("+-+", p) || Word("stalemate", p)) return GameIsDrawn;
 466         if(Match("++", p) || Verb("resign", p) || (Word("check", p) || 1) && Word("mate", p) )
 467             return (wom ? BlackWins : WhiteWins);
 468         c = ToUpper(**p);
 469         if(Word("w", p) && (Match("hite", p) || 1) || Word("b", p) && (Match("lack", p) || 1) ) {
 470             if(**p != ' ') return Nothing;
 471             ++*p;
 472             if(Verb("disconnect", p)) return GameUnfinished;
 473             if(Verb("resign", p) || Verb("forfeit", p) || Word("mated", p) || Word("lost", p) || Word("loses", p))
 474                 return (c == 'W' ? BlackWins : WhiteWins);
 475             if(Word("mates", p) || Word("wins", p) || Word("won", p))
 476                 return (c != 'W' ? BlackWins : WhiteWins);
 477             return Nothing;
 478         }
 479         if(Word("draw", p)) {
 480             if(**p == 'n') (*p)++;
 481             if(**p != ' ') return GameIsDrawn;
 482             oldp = ++*p;
 483             if(Word("agreed", p)) return GameIsDrawn;
 484             if(Match("by ", p) && (Word("repetition", p) || Word("agreement", p)) ) return GameIsDrawn;
 485             *p = oldp;
 486             if(*(*p)++ == '(') {
 487                 while(**p != '\n') if(*(*p)++ == ')') break;
 488                 if((*p)[-1] == ')')  return GameIsDrawn;
 489             }
 490             *p = oldp - 1; return GameIsDrawn;
 491         }
 492
 493
 494         // ********* Numeric annotation glyph **********************************
 495         if(**p == '$') { (*p)++; if(Number(p) != BADNUMBER) return NAG; return Nothing; }
 496
 497
 498         // ********** by now we are getting down to the silly stuff ************
 499         if(Word("gnu", p) || Match("GNU", p)) {
 500             if(**p == ' ') (*p)++;
 501             if(Word("chess", p) || Match("CHESS", p)) {
 502                 char *q;
 503                 if((q = strstr(*p, "game")) || (q = strstr(*p, "GAME")) || (q = strstr(*p, "Game"))) {
 504                     (*p) = q + 4; return GNUChessGame;
 505                 }
 506             }
 507             return Nothing;
 508         }
 509         if(lastChar == '\n' && (Match("# ", p) || Match("; ", p) || Match("% ", p))) {
 510             while(**p != '\n' && **p != ' ') (*p)++;
 511             if(**p == ' ' && (Match(" game file", p) || Match(" position file", p))) {
 512                 while(**p != '\n') (*p)++; // skip to EOLN
 513                 return XBoardGame;
 514             }
 515             *p = oldp; // we might need to re-match the skipped stuff
 516         }
 517
 518         if(Match("@@@@", p) || Match("--", p) || Match("Z0", p) || Match("pass", p) || Match("null", p)) {
 519             strncpy(currentMoveString, "@@@@", 5);
 520             return yyboardindex & F_WHITE_ON_MOVE ? WhiteDrop : BlackDrop;
 521         }
 522
 523         // ********* Efficient skipping of (mostly) alphabetic chatter **********
 524         while(isdigit(**p) || isalpha(**p) || **p == '-') (*p)++;
 525         if(*p != oldp) {
 526             if(**p == '\'') {
 527                 while(isdigit(**p) || isalpha(**p) || **p == '-' || **p == '\'') (*p)++;
 528                 return Nothing; // random word
 529             }
 530             if(lastChar == '\n' && Match(": ", p)) { // mail header, skip indented lines
 531                 do {
 532                     while(**p != '\n') (*p)++;
 533                     if(!ReadLine()) return Nothing; // append next line if not EOF
 534                 } while(Match("\n ", p) || Match("\n\t", p));
 535             }
 536             return Nothing;
 537         }
 538
 539         // ********* Prevent 00 in unprotected time stamps to be mistaken for castling *******
 540         if(Match(":00", p)) return Nothing;
 541
 542         // ********* Could not match to anything. Return offending character ****
 543         (*p)++;
 544         return Nothing;
 545 }
 546
 547 /*
 548     Return offset of next pattern in the current file.
 549 */
 550 int
 551 yyoffset ()
 552 {
 553     return ftell(inputFile) - (inPtr - parsePtr); // subtract what is read but not yet parsed
 554 }
 555
 556 void
 557 yynewfile (FILE *f)
 558 {   // prepare parse buffer for reading file
 559     inputFile = f;
 560     inPtr = parsePtr = inputBuf;
 561     fromString = 0;
 562     lastChar = '\n';
 563     *inPtr = NULLCHAR; // make sure we will start by reading a line
 564 }
 565
 566 void
 567 yynewstr P((char *s))
 568 {
 569     parsePtr = s;
 570     inputFile = NULL;
 571     fromString = 1;
 572 }
 573
 574 int
 575 yylex ()
 576 {   // this replaces the flex-generated parser
 577     int result = NextUnit(&parsePtr);
 578     char *p = parseStart, *q = yytext;
 579     while(p < parsePtr) *q++ = *p++; // copy the matched text to yytext[]
 580     *q = NULLCHAR;
 581     lastChar = q[-1];
 582     return result;
 583 }
 584
 585 int
 586 Myylex ()
 587 {   // [HGM] wrapper for yylex, which treats nesting of parentheses
 588     int symbol, nestingLevel = 0, i=0;
 589     char *p;
 590     static char buf[256*MSG_SIZ];
 591     buf[0] = NULLCHAR;
 592     do { // eat away anything not at level 0
 593         symbol = yylex();
 594         if(symbol == Open) nestingLevel++;
 595         if(nestingLevel) { // save all parsed text between (and including) the ()
 596             for(p=yytext; *p && i<256*MSG_SIZ-2;) buf[i++] = *p++;
 597             buf[i] = NULLCHAR;
 598         }
 599         if(symbol == 0) break; // ran into EOF
 600         if(symbol == Close) symbol = Comment, nestingLevel--;
 601     } while(nestingLevel || symbol == Nothing);
 602     yy_text = buf[0] ? buf : (char*)yytext;
 603     return symbol;
 604 }
 605
 606 ChessMove
 607 yylexstr (int boardIndex, char *s, char *buf, int buflen)
 608 {
 609     ChessMove ret;
 610     char *savPP = parsePtr;
 611     fromString = 1;
 612     yyboardindex = boardIndex;
 613     parsePtr = s;
 614     ret = (ChessMove) Myylex();
 615     strncpy(buf, yy_text, buflen-1);
 616     buf[buflen-1] = NULLCHAR;
 617     parsePtr = savPP;
 618     fromString = 0;
 619     return ret;
 620 }