parser.c

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