backend.c

   1 /*
   2  * backend.c -- Common back end for X and Windows NT versions of
   3  *
   4  * Copyright 1991 by Digital Equipment Corporation, Maynard,
   5  * Massachusetts.
   6  *
   7  * Enhancements Copyright 1992-2001, 2002, 2003, 2004, 2005, 2006,
   8  * 2007, 2008, 2009 Free Software Foundation, Inc.
   9  *
  10  * Enhancements Copyright 2005 Alessandro Scotti
  11  *
  12  * The following terms apply to Digital Equipment Corporation's copyright
  13  * interest in XBoard:
  14  * ------------------------------------------------------------------------
  15  * All Rights Reserved
  16  *
  17  * Permission to use, copy, modify, and distribute this software and its
  18  * documentation for any purpose and without fee is hereby granted,
  19  * provided that the above copyright notice appear in all copies and that
  20  * both that copyright notice and this permission notice appear in
  21  * supporting documentation, and that the name of Digital not be
  22  * used in advertising or publicity pertaining to distribution of the
  23  * software without specific, written prior permission.
  24  *
  25  * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  26  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  27  * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  28  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  29  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  30  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  31  * SOFTWARE.
  32  * ------------------------------------------------------------------------
  33  *
  34  * The following terms apply to the enhanced version of XBoard
  35  * distributed by the Free Software Foundation:
  36  * ------------------------------------------------------------------------
  37  *
  38  * GNU XBoard is free software: you can redistribute it and/or modify
  39  * it under the terms of the GNU General Public License as published by
  40  * the Free Software Foundation, either version 3 of the License, or (at
  41  * your option) any later version.
  42  *
  43  * GNU XBoard is distributed in the hope that it will be useful, but
  44  * WITHOUT ANY WARRANTY; without even the implied warranty of
  45  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  46  * General Public License for more details.
  47  *
  48  * You should have received a copy of the GNU General Public License
  49  * along with this program. If not, see http://www.gnu.org/licenses/.  *
  50  *
  51  *------------------------------------------------------------------------
  52  ** See the file ChangeLog for a revision history.  */
  53
  54 /* [AS] Also useful here for debugging */
  55 #ifdef WIN32
  56 #include <windows.h>
  57
  58 #define DoSleep( n ) if( (n) != 0 ) Sleep( (n) );
  59
  60 #else
  61
  62 #define DoSleep( n ) if( (n) >= 0) sleep(n)
  63
  64 #endif
  65
  66 #include "config.h"
  67
  68 #include <assert.h>
  69 #include <stdio.h>
  70 #include <ctype.h>
  71 #include <errno.h>
  72 #include <sys/types.h>
  73 #include <sys/stat.h>
  74 #include <math.h>
  75 #include <ctype.h>
  76
  77 #if STDC_HEADERS
  78 # include <stdlib.h>
  79 # include <string.h>
  80 #else /* not STDC_HEADERS */
  81 # if HAVE_STRING_H
  82 #  include <string.h>
  83 # else /* not HAVE_STRING_H */
  84 #  include <strings.h>
  85 # endif /* not HAVE_STRING_H */
  86 #endif /* not STDC_HEADERS */
  87
  88 #if HAVE_SYS_FCNTL_H
  89 # include <sys/fcntl.h>
  90 #else /* not HAVE_SYS_FCNTL_H */
  91 # if HAVE_FCNTL_H
  92 #  include <fcntl.h>
  93 # endif /* HAVE_FCNTL_H */
  94 #endif /* not HAVE_SYS_FCNTL_H */
  95
  96 #if TIME_WITH_SYS_TIME
  97 # include <sys/time.h>
  98 # include <time.h>
  99 #else
 100 # if HAVE_SYS_TIME_H
 101 #  include <sys/time.h>
 102 # else
 103 #  include <time.h>
 104 # endif
 105 #endif
 106
 107 #if defined(_amigados) && !defined(__GNUC__)
 108 struct timezone {
 109     int tz_minuteswest;
 110     int tz_dsttime;
 111 };
 112 extern int gettimeofday(struct timeval *, struct timezone *);
 113 #endif
 114
 115 #if HAVE_UNISTD_H
 116 # include <unistd.h>
 117 #endif
 118
 119 #include "common.h"
 120 #include "frontend.h"
 121 #include "backend.h"
 122 #include "parser.h"
 123 #include "moves.h"
 124 #if ZIPPY
 125 # include "zippy.h"
 126 #endif
 127 #include "backendz.h"
 128 #include "gettext.h"
 129
 130 #ifdef ENABLE_NLS
 131 # define _(s) gettext (s)
 132 # define N_(s) gettext_noop (s)
 133 #else
 134 # define _(s) (s)
 135 # define N_(s) s
 136 #endif
 137
 138
 139 /* A point in time */
 140 typedef struct {
 141     long sec;  /* Assuming this is >= 32 bits */
 142     int ms;    /* Assuming this is >= 16 bits */
 143 } TimeMark;
 144
 145 int establish P((void));
 146 void read_from_player P((InputSourceRef isr, VOIDSTAR closure,
 147                          char *buf, int count, int error));
 148 void read_from_ics P((InputSourceRef isr, VOIDSTAR closure,
 149                       char *buf, int count, int error));
 150 void SendToICS P((char *s));
 151 void SendToICSDelayed P((char *s, long msdelay));
 152 void SendMoveToICS P((ChessMove moveType, int fromX, int fromY,
 153                       int toX, int toY));
 154 void HandleMachineMove P((char *message, ChessProgramState *cps));
 155 int AutoPlayOneMove P((void));
 156 int LoadGameOneMove P((ChessMove readAhead));
 157 int LoadGameFromFile P((char *filename, int n, char *title, int useList));
 158 int LoadPositionFromFile P((char *filename, int n, char *title));
 159 int SavePositionToFile P((char *filename));
 160 void ApplyMove P((int fromX, int fromY, int toX, int toY, int promoChar,
 161                   Board board, char *castle, char *ep));
 162 void MakeMove P((int fromX, int fromY, int toX, int toY, int promoChar));
 163 void ShowMove P((int fromX, int fromY, int toX, int toY));
 164 int FinishMove P((ChessMove moveType, int fromX, int fromY, int toX, int toY,
 165                    /*char*/int promoChar));
 166 void BackwardInner P((int target));
 167 void ForwardInner P((int target));
 168 void GameEnds P((ChessMove result, char *resultDetails, int whosays));
 169 void EditPositionDone P((void));
 170 void PrintOpponents P((FILE *fp));
 171 void PrintPosition P((FILE *fp, int move));
 172 void StartChessProgram P((ChessProgramState *cps));
 173 void SendToProgram P((char *message, ChessProgramState *cps));
 174 void SendMoveToProgram P((int moveNum, ChessProgramState *cps));
 175 void ReceiveFromProgram P((InputSourceRef isr, VOIDSTAR closure,
 176                            char *buf, int count, int error));
 177 void SendTimeControl P((ChessProgramState *cps,
 178                         int mps, long tc, int inc, int sd, int st));
 179 char *TimeControlTagValue P((void));
 180 void Attention P((ChessProgramState *cps));
 181 void FeedMovesToProgram P((ChessProgramState *cps, int upto));
 182 void ResurrectChessProgram P((void));
 183 void DisplayComment P((int moveNumber, char *text));
 184 void DisplayMove P((int moveNumber));
 185 void DisplayAnalysis P((void));
 186
 187 void ParseGameHistory P((char *game));
 188 void ParseBoard12 P((char *string));
 189 void StartClocks P((void));
 190 void SwitchClocks P((void));
 191 void StopClocks P((void));
 192 void ResetClocks P((void));
 193 char *PGNDate P((void));
 194 void SetGameInfo P((void));
 195 Boolean ParseFEN P((Board board, int *blackPlaysFirst, char *fen));
 196 int RegisterMove P((void));
 197 void MakeRegisteredMove P((void));
 198 void TruncateGame P((void));
 199 int looking_at P((char *, int *, char *));
 200 void CopyPlayerNameIntoFileName P((char **, char *));
 201 char *SavePart P((char *));
 202 int SaveGameOldStyle P((FILE *));
 203 int SaveGamePGN P((FILE *));
 204 void GetTimeMark P((TimeMark *));
 205 long SubtractTimeMarks P((TimeMark *, TimeMark *));
 206 int CheckFlags P((void));
 207 long NextTickLength P((long));
 208 void CheckTimeControl P((void));
 209 void show_bytes P((FILE *, char *, int));
 210 int string_to_rating P((char *str));
 211 void ParseFeatures P((char* args, ChessProgramState *cps));
 212 void InitBackEnd3 P((void));
 213 void FeatureDone P((ChessProgramState* cps, int val));
 214 void InitChessProgram P((ChessProgramState *cps, int setup));
 215 void OutputKibitz(int window, char *text);
 216 int PerpetualChase(int first, int last);
 217 int EngineOutputIsUp();
 218 void InitDrawingSizes(int x, int y);
 219
 220 #ifdef WIN32
 221        extern void ConsoleCreate();
 222 #endif
 223
 224 ChessProgramState *WhitePlayer();
 225 void InsertIntoMemo P((int which, char *text)); // [HGM] kibitz: in engineo.c
 226 int VerifyDisplayMode P(());
 227
 228 char *GetInfoFromComment( int, char * ); // [HGM] PV time: returns stripped comment
 229 void InitEngineUCI( const char * iniDir, ChessProgramState * cps ); // [HGM] moved here from winboard.c
 230 char *ProbeBook P((int moveNr, char *book)); // [HGM] book: returns a book move
 231 char *SendMoveToBookUser P((int nr, ChessProgramState *cps, int initial)); // [HGM] book
 232 extern char installDir[MSG_SIZ];
 233
 234 extern int tinyLayout, smallLayout;
 235 ChessProgramStats programStats;
 236 static int exiting = 0; /* [HGM] moved to top */
 237 static int setboardSpoiledMachineBlack = 0 /*, errorExitFlag = 0*/;
 238 int startedFromPositionFile = FALSE; Board filePosition;       /* [HGM] loadPos */
 239 char endingGame = 0;    /* [HGM] crash: flag to prevent recursion of GameEnds() */
 240 int whiteNPS, blackNPS; /* [HGM] nps: for easily making clocks aware of NPS     */
 241 VariantClass currentlyInitializedVariant; /* [HGM] variantswitch */
 242 int lastIndex = 0;      /* [HGM] autoinc: last game/position used in match mode */
 243 int opponentKibitzes;
 244 int lastSavedGame; /* [HGM] save: ID of game */
 245 char chatPartner[MAX_CHAT][MSG_SIZ]; /* [HGM] chat: list of chatting partners */
 246 extern int chatCount;
 247 int chattingPartner;
 248
 249 /* States for ics_getting_history */
 250 #define H_FALSE 0
 251 #define H_REQUESTED 1
 252 #define H_GOT_REQ_HEADER 2
 253 #define H_GOT_UNREQ_HEADER 3
 254 #define H_GETTING_MOVES 4
 255 #define H_GOT_UNWANTED_HEADER 5
 256
 257 /* whosays values for GameEnds */
 258 #define GE_ICS 0
 259 #define GE_ENGINE 1
 260 #define GE_PLAYER 2
 261 #define GE_FILE 3
 262 #define GE_XBOARD 4
 263 #define GE_ENGINE1 5
 264 #define GE_ENGINE2 6
 265
 266 /* Maximum number of games in a cmail message */
 267 #define CMAIL_MAX_GAMES 20
 268
 269 /* Different types of move when calling RegisterMove */
 270 #define CMAIL_MOVE   0
 271 #define CMAIL_RESIGN 1
 272 #define CMAIL_DRAW   2
 273 #define CMAIL_ACCEPT 3
 274
 275 /* Different types of result to remember for each game */
 276 #define CMAIL_NOT_RESULT 0
 277 #define CMAIL_OLD_RESULT 1
 278 #define CMAIL_NEW_RESULT 2
 279
 280 /* Telnet protocol constants */
 281 #define TN_WILL 0373
 282 #define TN_WONT 0374
 283 #define TN_DO   0375
 284 #define TN_DONT 0376
 285 #define TN_IAC  0377
 286 #define TN_ECHO 0001
 287 #define TN_SGA  0003
 288 #define TN_PORT 23
 289
 290 /* [AS] */
 291 static char * safeStrCpy( char * dst, const char * src, size_t count )
 292 {
 293     assert( dst != NULL );
 294     assert( src != NULL );
 295     assert( count > 0 );
 296
 297     strncpy( dst, src, count );
 298     dst[ count-1 ] = '\0';
 299     return dst;
 300 }
 301
 302 #if 0
 303 //[HGM] for future use? Conditioned out for now to suppress warning.
 304 static char * safeStrCat( char * dst, const char * src, size_t count )
 305 {
 306     size_t  dst_len;
 307
 308     assert( dst != NULL );
 309     assert( src != NULL );
 310     assert( count > 0 );
 311
 312     dst_len = strlen(dst);
 313
 314     assert( count > dst_len ); /* Buffer size must be greater than current length */
 315
 316     safeStrCpy( dst + dst_len, src, count - dst_len );
 317
 318     return dst;
 319 }
 320 #endif
 321
 322 /* Some compiler can't cast u64 to double
 323  * This function do the job for us:
 324
 325  * We use the highest bit for cast, this only
 326  * works if the highest bit is not
 327  * in use (This should not happen)
 328  *
 329  * We used this for all compiler
 330  */
 331 double
 332 u64ToDouble(u64 value)
 333 {
 334   double r;
 335   u64 tmp = value & u64Const(0x7fffffffffffffff);
 336   r = (double)(s64)tmp;
 337   if (value & u64Const(0x8000000000000000))
 338        r +=  9.2233720368547758080e18; /* 2^63 */
 339  return r;
 340 }
 341
 342 /* Fake up flags for now, as we aren't keeping track of castling
 343    availability yet. [HGM] Change of logic: the flag now only
 344    indicates the type of castlings allowed by the rule of the game.
 345    The actual rights themselves are maintained in the array
 346    castlingRights, as part of the game history, and are not probed
 347    by this function.
 348  */
 349 int
 350 PosFlags(index)
 351 {
 352   int flags = F_ALL_CASTLE_OK;
 353   if ((index % 2) == 0) flags |= F_WHITE_ON_MOVE;
 354   switch (gameInfo.variant) {
 355   case VariantSuicide:
 356     flags &= ~F_ALL_CASTLE_OK;
 357   case VariantGiveaway:         // [HGM] moved this case label one down: seems Giveaway does have castling on ICC!
 358     flags |= F_IGNORE_CHECK;
 359   case VariantLosers:
 360     flags |= F_MANDATORY_CAPTURE; //[HGM] losers: sets flag so TestLegality rejects non-capts if capts exist
 361     break;
 362   case VariantAtomic:
 363     flags |= F_IGNORE_CHECK | F_ATOMIC_CAPTURE;
 364     break;
 365   case VariantKriegspiel:
 366     flags |= F_KRIEGSPIEL_CAPTURE;
 367     break;
 368   case VariantCapaRandom:
 369   case VariantFischeRandom:
 370     flags |= F_FRC_TYPE_CASTLING; /* [HGM] enable this through flag */
 371   case VariantNoCastle:
 372   case VariantShatranj:
 373   case VariantCourier:
 374     flags &= ~F_ALL_CASTLE_OK;
 375     break;
 376   default:
 377     break;
 378   }
 379   return flags;
 380 }
 381
 382 FILE *gameFileFP, *debugFP;
 383
 384 /*
 385     [AS] Note: sometimes, the sscanf() function is used to parse the input
 386     into a fixed-size buffer. Because of this, we must be prepared to
 387     receive strings as long as the size of the input buffer, which is currently
 388     set to 4K for Windows and 8K for the rest.
 389     So, we must either allocate sufficiently large buffers here, or
 390     reduce the size of the input buffer in the input reading part.
 391 */
 392
 393 char cmailMove[CMAIL_MAX_GAMES][MOVE_LEN], cmailMsg[MSG_SIZ];
 394 char bookOutput[MSG_SIZ*10], thinkOutput[MSG_SIZ*10], lastHint[MSG_SIZ];
 395 char thinkOutput1[MSG_SIZ*10];
 396
 397 ChessProgramState first, second;
 398
 399 /* premove variables */
 400 int premoveToX = 0;
 401 int premoveToY = 0;
 402 int premoveFromX = 0;
 403 int premoveFromY = 0;
 404 int premovePromoChar = 0;
 405 int gotPremove = 0;
 406 Boolean alarmSounded;
 407 /* end premove variables */
 408
 409 char *ics_prefix = "$";
 410 int ics_type = ICS_GENERIC;
 411
 412 int currentMove = 0, forwardMostMove = 0, backwardMostMove = 0;
 413 int pauseExamForwardMostMove = 0;
 414 int nCmailGames = 0, nCmailResults = 0, nCmailMovesRegistered = 0;
 415 int cmailMoveRegistered[CMAIL_MAX_GAMES], cmailResult[CMAIL_MAX_GAMES];
 416 int cmailMsgLoaded = FALSE, cmailMailedMove = FALSE;
 417 int cmailOldMove = -1, firstMove = TRUE, flipView = FALSE;
 418 int blackPlaysFirst = FALSE, startedFromSetupPosition = FALSE;
 419 int searchTime = 0, pausing = FALSE, pauseExamInvalid = FALSE;
 420 int whiteFlag = FALSE, blackFlag = FALSE;
 421 int userOfferedDraw = FALSE;
 422 int ics_user_moved = 0, ics_gamenum = -1, ics_getting_history = H_FALSE;
 423 int matchMode = FALSE, hintRequested = FALSE, bookRequested = FALSE;
 424 int cmailMoveType[CMAIL_MAX_GAMES];
 425 long ics_clock_paused = 0;
 426 ProcRef icsPR = NoProc, cmailPR = NoProc;
 427 InputSourceRef telnetISR = NULL, fromUserISR = NULL, cmailISR = NULL;
 428 GameMode gameMode = BeginningOfGame;
 429 char moveList[MAX_MOVES][MOVE_LEN], parseList[MAX_MOVES][MOVE_LEN * 2];
 430 char *commentList[MAX_MOVES], *cmailCommentList[CMAIL_MAX_GAMES];
 431 ChessProgramStats_Move pvInfoList[MAX_MOVES]; /* [AS] Info about engine thinking */
 432 int hiddenThinkOutputState = 0; /* [AS] */
 433 int adjudicateLossThreshold = 0; /* [AS] Automatic adjudication */
 434 int adjudicateLossPlies = 6;
 435 char white_holding[64], black_holding[64];
 436 TimeMark lastNodeCountTime;
 437 long lastNodeCount=0;
 438 int have_sent_ICS_logon = 0;
 439 int movesPerSession;
 440 long whiteTimeRemaining, blackTimeRemaining, timeControl, timeIncrement;
 441 long timeControl_2; /* [AS] Allow separate time controls */
 442 char *fullTimeControlString = NULL; /* [HGM] secondary TC: merge of MPS, TC and inc */
 443 long timeRemaining[2][MAX_MOVES];
 444 int matchGame = 0;
 445 TimeMark programStartTime;
 446 char ics_handle[MSG_SIZ];
 447 int have_set_title = 0;
 448
 449 /* animateTraining preserves the state of appData.animate
 450  * when Training mode is activated. This allows the
 451  * response to be animated when appData.animate == TRUE and
 452  * appData.animateDragging == TRUE.
 453  */
 454 Boolean animateTraining;
 455
 456 GameInfo gameInfo;
 457
 458 AppData appData;
 459
 460 Board boards[MAX_MOVES];
 461 /* [HGM] Following 7 needed for accurate legality tests: */
 462 signed char  epStatus[MAX_MOVES];
 463 signed char  castlingRights[MAX_MOVES][BOARD_SIZE]; // stores files for pieces with castling rights or -1
 464 signed char  castlingRank[BOARD_SIZE]; // and corresponding ranks
 465 signed char  initialRights[BOARD_SIZE], FENcastlingRights[BOARD_SIZE], fileRights[BOARD_SIZE];
 466 int   nrCastlingRights; // For TwoKings, or to implement castling-unknown status
 467 int   initialRulePlies, FENrulePlies;
 468 char  FENepStatus;
 469 FILE  *serverMoves = NULL; // next two for broadcasting (/serverMoves option)
 470 int loadFlag = 0;
 471 int shuffleOpenings;
 472 int mute; // mute all sounds
 473
 474 ChessSquare  FIDEArray[2][BOARD_SIZE] = {
 475     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 476         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 477     { BlackRook, BlackKnight, BlackBishop, BlackQueen,
 478         BlackKing, BlackBishop, BlackKnight, BlackRook }
 479 };
 480
 481 ChessSquare twoKingsArray[2][BOARD_SIZE] = {
 482     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 483         WhiteKing, WhiteKing, WhiteKnight, WhiteRook },
 484     { BlackRook, BlackKnight, BlackBishop, BlackQueen,
 485         BlackKing, BlackKing, BlackKnight, BlackRook }
 486 };
 487
 488 ChessSquare  KnightmateArray[2][BOARD_SIZE] = {
 489     { WhiteRook, WhiteMan, WhiteBishop, WhiteQueen,
 490         WhiteUnicorn, WhiteBishop, WhiteMan, WhiteRook },
 491     { BlackRook, BlackMan, BlackBishop, BlackQueen,
 492         BlackUnicorn, BlackBishop, BlackMan, BlackRook }
 493 };
 494
 495 ChessSquare fairyArray[2][BOARD_SIZE] = { /* [HGM] Queen side differs from King side */
 496     { WhiteCannon, WhiteNightrider, WhiteAlfil, WhiteQueen,
 497         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 498     { BlackCannon, BlackNightrider, BlackAlfil, BlackQueen,
 499         BlackKing, BlackBishop, BlackKnight, BlackRook }
 500 };
 501
 502 ChessSquare ShatranjArray[2][BOARD_SIZE] = { /* [HGM] (movGen knows about Shatranj Q and P) */
 503     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteKing,
 504         WhiteFerz, WhiteAlfil, WhiteKnight, WhiteRook },
 505     { BlackRook, BlackKnight, BlackAlfil, BlackKing,
 506         BlackFerz, BlackAlfil, BlackKnight, BlackRook }
 507 };
 508
 509
 510 #if (BOARD_SIZE>=10)
 511 ChessSquare ShogiArray[2][BOARD_SIZE] = {
 512     { WhiteQueen, WhiteKnight, WhiteFerz, WhiteWazir,
 513         WhiteKing, WhiteWazir, WhiteFerz, WhiteKnight, WhiteQueen },
 514     { BlackQueen, BlackKnight, BlackFerz, BlackWazir,
 515         BlackKing, BlackWazir, BlackFerz, BlackKnight, BlackQueen }
 516 };
 517
 518 ChessSquare XiangqiArray[2][BOARD_SIZE] = {
 519     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteFerz,
 520         WhiteWazir, WhiteFerz, WhiteAlfil, WhiteKnight, WhiteRook },
 521     { BlackRook, BlackKnight, BlackAlfil, BlackFerz,
 522         BlackWazir, BlackFerz, BlackAlfil, BlackKnight, BlackRook }
 523 };
 524
 525 ChessSquare CapablancaArray[2][BOARD_SIZE] = {
 526     { WhiteRook, WhiteKnight, WhiteAngel, WhiteBishop, WhiteQueen,
 527         WhiteKing, WhiteBishop, WhiteMarshall, WhiteKnight, WhiteRook },
 528     { BlackRook, BlackKnight, BlackAngel, BlackBishop, BlackQueen,
 529         BlackKing, BlackBishop, BlackMarshall, BlackKnight, BlackRook }
 530 };
 531
 532 ChessSquare GreatArray[2][BOARD_SIZE] = {
 533     { WhiteDragon, WhiteKnight, WhiteAlfil, WhiteGrasshopper, WhiteKing,
 534         WhiteSilver, WhiteCardinal, WhiteAlfil, WhiteKnight, WhiteDragon },
 535     { BlackDragon, BlackKnight, BlackAlfil, BlackGrasshopper, BlackKing,
 536         BlackSilver, BlackCardinal, BlackAlfil, BlackKnight, BlackDragon },
 537 };
 538
 539 ChessSquare JanusArray[2][BOARD_SIZE] = {
 540     { WhiteRook, WhiteAngel, WhiteKnight, WhiteBishop, WhiteKing,
 541         WhiteQueen, WhiteBishop, WhiteKnight, WhiteAngel, WhiteRook },
 542     { BlackRook, BlackAngel, BlackKnight, BlackBishop, BlackKing,
 543         BlackQueen, BlackBishop, BlackKnight, BlackAngel, BlackRook }
 544 };
 545
 546 #ifdef GOTHIC
 547 ChessSquare GothicArray[2][BOARD_SIZE] = {
 548     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen, WhiteMarshall,
 549         WhiteKing, WhiteAngel, WhiteBishop, WhiteKnight, WhiteRook },
 550     { BlackRook, BlackKnight, BlackBishop, BlackQueen, BlackMarshall,
 551         BlackKing, BlackAngel, BlackBishop, BlackKnight, BlackRook }
 552 };
 553 #else // !GOTHIC
 554 #define GothicArray CapablancaArray
 555 #endif // !GOTHIC
 556
 557 #ifdef FALCON
 558 ChessSquare FalconArray[2][BOARD_SIZE] = {
 559     { WhiteRook, WhiteKnight, WhiteBishop, WhiteLance, WhiteQueen,
 560         WhiteKing, WhiteLance, WhiteBishop, WhiteKnight, WhiteRook },
 561     { BlackRook, BlackKnight, BlackBishop, BlackLance, BlackQueen,
 562         BlackKing, BlackLance, BlackBishop, BlackKnight, BlackRook }
 563 };
 564 #else // !FALCON
 565 #define FalconArray CapablancaArray
 566 #endif // !FALCON
 567
 568 #else // !(BOARD_SIZE>=10)
 569 #define XiangqiPosition FIDEArray
 570 #define CapablancaArray FIDEArray
 571 #define GothicArray FIDEArray
 572 #define GreatArray FIDEArray
 573 #endif // !(BOARD_SIZE>=10)
 574
 575 #if (BOARD_SIZE>=12)
 576 ChessSquare CourierArray[2][BOARD_SIZE] = {
 577     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteBishop, WhiteMan, WhiteKing,
 578         WhiteFerz, WhiteWazir, WhiteBishop, WhiteAlfil, WhiteKnight, WhiteRook },
 579     { BlackRook, BlackKnight, BlackAlfil, BlackBishop, BlackMan, BlackKing,
 580         BlackFerz, BlackWazir, BlackBishop, BlackAlfil, BlackKnight, BlackRook }
 581 };
 582 #else // !(BOARD_SIZE>=12)
 583 #define CourierArray CapablancaArray
 584 #endif // !(BOARD_SIZE>=12)
 585
 586
 587 Board initialPosition;
 588
 589
 590 /* Convert str to a rating. Checks for special cases of "----",
 591
 592    "++++", etc. Also strips ()'s */
 593 int
 594 string_to_rating(str)
 595   char *str;
 596 {
 597   while(*str && !isdigit(*str)) ++str;
 598   if (!*str)
 599     return 0;   /* One of the special "no rating" cases */
 600   else
 601     return atoi(str);
 602 }
 603
 604 void
 605 ClearProgramStats()
 606 {
 607     /* Init programStats */
 608     programStats.movelist[0] = 0;
 609     programStats.depth = 0;
 610     programStats.nr_moves = 0;
 611     programStats.moves_left = 0;
 612     programStats.nodes = 0;
 613     programStats.time = -1;        // [HGM] PGNtime: make invalid to recognize engine output
 614     programStats.score = 0;
 615     programStats.got_only_move = 0;
 616     programStats.got_fail = 0;
 617     programStats.line_is_book = 0;
 618 }
 619
 620 void
 621 InitBackEnd1()
 622 {
 623     int matched, min, sec;
 624
 625     ShowThinkingEvent(); // [HGM] thinking: make sure post/nopost state is set according to options
 626
 627     GetTimeMark(&programStartTime);
 628     srand(programStartTime.ms); // [HGM] book: makes sure random is unpredictabe to msec level
 629
 630     ClearProgramStats();
 631     programStats.ok_to_send = 1;
 632     programStats.seen_stat = 0;
 633
 634     /*
 635      * Initialize game list
 636      */
 637     ListNew(&gameList);
 638
 639
 640     /*
 641      * Internet chess server status
 642      */
 643     if (appData.icsActive) {
 644         appData.matchMode = FALSE;
 645         appData.matchGames = 0;
 646 #if ZIPPY
 647         appData.noChessProgram = !appData.zippyPlay;
 648 #else
 649         appData.zippyPlay = FALSE;
 650         appData.zippyTalk = FALSE;
 651         appData.noChessProgram = TRUE;
 652 #endif
 653         if (*appData.icsHelper != NULLCHAR) {
 654             appData.useTelnet = TRUE;
 655             appData.telnetProgram = appData.icsHelper;
 656         }
 657     } else {
 658         appData.zippyTalk = appData.zippyPlay = FALSE;
 659     }
 660
 661     /* [AS] Initialize pv info list [HGM] and game state */
 662     {
 663         int i, j;
 664
 665         for( i=0; i<MAX_MOVES; i++ ) {
 666             pvInfoList[i].depth = -1;
 667             epStatus[i]=EP_NONE;
 668             for( j=0; j<BOARD_SIZE; j++ ) castlingRights[i][j] = -1;
 669         }
 670     }
 671
 672     /*
 673      * Parse timeControl resource
 674      */
 675     if (!ParseTimeControl(appData.timeControl, appData.timeIncrement,
 676                           appData.movesPerSession)) {
 677         char buf[MSG_SIZ];
 678         snprintf(buf, sizeof(buf), _("bad timeControl option %s"), appData.timeControl);
 679         DisplayFatalError(buf, 0, 2);
 680     }
 681
 682     /*
 683      * Parse searchTime resource
 684      */
 685     if (*appData.searchTime != NULLCHAR) {
 686         matched = sscanf(appData.searchTime, "%d:%d", &min, &sec);
 687         if (matched == 1) {
 688             searchTime = min * 60;
 689         } else if (matched == 2) {
 690             searchTime = min * 60 + sec;
 691         } else {
 692             char buf[MSG_SIZ];
 693             snprintf(buf, sizeof(buf), _("bad searchTime option %s"), appData.searchTime);
 694             DisplayFatalError(buf, 0, 2);
 695         }
 696     }
 697
 698     /* [AS] Adjudication threshold */
 699     adjudicateLossThreshold = appData.adjudicateLossThreshold;
 700
 701     first.which = "first";
 702     second.which = "second";
 703     first.maybeThinking = second.maybeThinking = FALSE;
 704     first.pr = second.pr = NoProc;
 705     first.isr = second.isr = NULL;
 706     first.sendTime = second.sendTime = 2;
 707     first.sendDrawOffers = 1;
 708     if (appData.firstPlaysBlack) {
 709         first.twoMachinesColor = "black\n";
 710         second.twoMachinesColor = "white\n";
 711     } else {
 712         first.twoMachinesColor = "white\n";
 713         second.twoMachinesColor = "black\n";
 714     }
 715     first.program = appData.firstChessProgram;
 716     second.program = appData.secondChessProgram;
 717     first.host = appData.firstHost;
 718     second.host = appData.secondHost;
 719     first.dir = appData.firstDirectory;
 720     second.dir = appData.secondDirectory;
 721     first.other = &second;
 722     second.other = &first;
 723     first.initString = appData.initString;
 724     second.initString = appData.secondInitString;
 725     first.computerString = appData.firstComputerString;
 726     second.computerString = appData.secondComputerString;
 727     first.useSigint = second.useSigint = TRUE;
 728     first.useSigterm = second.useSigterm = TRUE;
 729     first.reuse = appData.reuseFirst;
 730     second.reuse = appData.reuseSecond;
 731     first.nps = appData.firstNPS;   // [HGM] nps: copy nodes per second
 732     second.nps = appData.secondNPS;
 733     first.useSetboard = second.useSetboard = FALSE;
 734     first.useSAN = second.useSAN = FALSE;
 735     first.usePing = second.usePing = FALSE;
 736     first.lastPing = second.lastPing = 0;
 737     first.lastPong = second.lastPong = 0;
 738     first.usePlayother = second.usePlayother = FALSE;
 739     first.useColors = second.useColors = TRUE;
 740     first.useUsermove = second.useUsermove = FALSE;
 741     first.sendICS = second.sendICS = FALSE;
 742     first.sendName = second.sendName = appData.icsActive;
 743     first.sdKludge = second.sdKludge = FALSE;
 744     first.stKludge = second.stKludge = FALSE;
 745     TidyProgramName(first.program, first.host, first.tidy);
 746     TidyProgramName(second.program, second.host, second.tidy);
 747     first.matchWins = second.matchWins = 0;
 748     strcpy(first.variants, appData.variant);
 749     strcpy(second.variants, appData.variant);
 750     first.analysisSupport = second.analysisSupport = 2; /* detect */
 751     first.analyzing = second.analyzing = FALSE;
 752     first.initDone = second.initDone = FALSE;
 753
 754     /* New features added by Tord: */
 755     first.useFEN960 = FALSE; second.useFEN960 = FALSE;
 756     first.useOOCastle = TRUE; second.useOOCastle = TRUE;
 757     /* End of new features added by Tord. */
 758     first.fenOverride  = appData.fenOverride1;
 759     second.fenOverride = appData.fenOverride2;
 760
 761     /* [HGM] time odds: set factor for each machine */
 762     first.timeOdds  = appData.firstTimeOdds;
 763     second.timeOdds = appData.secondTimeOdds;
 764     { int norm = 1;
 765         if(appData.timeOddsMode) {
 766             norm = first.timeOdds;
 767             if(norm > second.timeOdds) norm = second.timeOdds;
 768         }
 769         first.timeOdds /= norm;
 770         second.timeOdds /= norm;
 771     }
 772
 773     /* [HGM] secondary TC: how to handle sessions that do not fit in 'level'*/
 774     first.accumulateTC = appData.firstAccumulateTC;
 775     second.accumulateTC = appData.secondAccumulateTC;
 776     first.maxNrOfSessions = second.maxNrOfSessions = 1;
 777
 778     /* [HGM] debug */
 779     first.debug = second.debug = FALSE;
 780     first.supportsNPS = second.supportsNPS = UNKNOWN;
 781
 782     /* [HGM] options */
 783     first.optionSettings  = appData.firstOptions;
 784     second.optionSettings = appData.secondOptions;
 785
 786     first.scoreIsAbsolute = appData.firstScoreIsAbsolute; /* [AS] */
 787     second.scoreIsAbsolute = appData.secondScoreIsAbsolute; /* [AS] */
 788     first.isUCI = appData.firstIsUCI; /* [AS] */
 789     second.isUCI = appData.secondIsUCI; /* [AS] */
 790     first.hasOwnBookUCI = appData.firstHasOwnBookUCI; /* [AS] */
 791     second.hasOwnBookUCI = appData.secondHasOwnBookUCI; /* [AS] */
 792
 793     if (appData.firstProtocolVersion > PROTOVER ||
 794         appData.firstProtocolVersion < 1) {
 795       char buf[MSG_SIZ];
 796       sprintf(buf, _("protocol version %d not supported"),
 797               appData.firstProtocolVersion);
 798       DisplayFatalError(buf, 0, 2);
 799     } else {
 800       first.protocolVersion = appData.firstProtocolVersion;
 801     }
 802
 803     if (appData.secondProtocolVersion > PROTOVER ||
 804         appData.secondProtocolVersion < 1) {
 805       char buf[MSG_SIZ];
 806       sprintf(buf, _("protocol version %d not supported"),
 807               appData.secondProtocolVersion);
 808       DisplayFatalError(buf, 0, 2);
 809     } else {
 810       second.protocolVersion = appData.secondProtocolVersion;
 811     }
 812
 813     if (appData.icsActive) {
 814         appData.clockMode = TRUE;  /* changes dynamically in ICS mode */
 815     } else if (*appData.searchTime != NULLCHAR || appData.noChessProgram) {
 816         appData.clockMode = FALSE;
 817         first.sendTime = second.sendTime = 0;
 818     }
 819
 820 #if ZIPPY
 821     /* Override some settings from environment variables, for backward
 822        compatibility.  Unfortunately it's not feasible to have the env
 823        vars just set defaults, at least in xboard.  Ugh.
 824     */
 825     if (appData.icsActive && (appData.zippyPlay || appData.zippyTalk)) {
 826       ZippyInit();
 827     }
 828 #endif
 829
 830     if (appData.noChessProgram) {
 831         programVersion = (char*) malloc(5 + strlen(PACKAGE_STRING));
 832         sprintf(programVersion, "%s", PACKAGE_STRING);
 833     } else {
 834 #if 0
 835         char *p, *q;
 836         q = first.program;
 837         while (*q != ' ' && *q != NULLCHAR) q++;
 838         p = q;
 839         while (p > first.program && *(p-1) != '/' && *(p-1) != '\\') p--; /* [HGM] backslash added */
 840         programVersion = (char*) malloc(8 + strlen(PACKAGE_STRING + (q - p));
 841         sprintf(programVersion, "%s + ", PACKAGE_STRING);
 842         strncat(programVersion, p, q - p);
 843 #else
 844         /* [HGM] tidy: use tidy name, in stead of full pathname (which was probably a bug due to / vs \ ) */
 845         programVersion = (char*) malloc(8 + strlen(PACKAGE_STRING) + strlen(first.tidy));
 846         sprintf(programVersion, "%s + %s", PACKAGE_STRING, first.tidy);
 847 #endif
 848     }
 849
 850     if (!appData.icsActive) {
 851       char buf[MSG_SIZ];
 852       /* Check for variants that are supported only in ICS mode,
 853          or not at all.  Some that are accepted here nevertheless
 854          have bugs; see comments below.
 855       */
 856       VariantClass variant = StringToVariant(appData.variant);
 857       switch (variant) {
 858       case VariantBughouse:     /* need four players and two boards */
 859       case VariantKriegspiel:   /* need to hide pieces and move details */
 860       /* case VariantFischeRandom: (Fabien: moved below) */
 861         sprintf(buf, _("Variant %s supported only in ICS mode"), appData.variant);
 862         DisplayFatalError(buf, 0, 2);
 863         return;
 864
 865       case VariantUnknown:
 866       case VariantLoadable:
 867       case Variant29:
 868       case Variant30:
 869       case Variant31:
 870       case Variant32:
 871       case Variant33:
 872       case Variant34:
 873       case Variant35:
 874       case Variant36:
 875       default:
 876         sprintf(buf, _("Unknown variant name %s"), appData.variant);
 877         DisplayFatalError(buf, 0, 2);
 878         return;
 879
 880       case VariantXiangqi:    /* [HGM] repetition rules not implemented */
 881       case VariantFairy:      /* [HGM] TestLegality definitely off! */
 882       case VariantGothic:     /* [HGM] should work */
 883       case VariantCapablanca: /* [HGM] should work */
 884       case VariantCourier:    /* [HGM] initial forced moves not implemented */
 885       case VariantShogi:      /* [HGM] drops not tested for legality */
 886       case VariantKnightmate: /* [HGM] should work */
 887       case VariantCylinder:   /* [HGM] untested */
 888       case VariantFalcon:     /* [HGM] untested */
 889       case VariantCrazyhouse: /* holdings not shown, ([HGM] fixed that!)
 890                                  offboard interposition not understood */
 891       case VariantNormal:     /* definitely works! */
 892       case VariantWildCastle: /* pieces not automatically shuffled */
 893       case VariantNoCastle:   /* pieces not automatically shuffled */
 894       case VariantFischeRandom: /* [HGM] works and shuffles pieces */
 895       case VariantLosers:     /* should work except for win condition,
 896                                  and doesn't know captures are mandatory */
 897       case VariantSuicide:    /* should work except for win condition,
 898                                  and doesn't know captures are mandatory */
 899       case VariantGiveaway:   /* should work except for win condition,
 900                                  and doesn't know captures are mandatory */
 901       case VariantTwoKings:   /* should work */
 902       case VariantAtomic:     /* should work except for win condition */
 903       case Variant3Check:     /* should work except for win condition */
 904       case VariantShatranj:   /* should work except for all win conditions */
 905       case VariantBerolina:   /* might work if TestLegality is off */
 906       case VariantCapaRandom: /* should work */
 907       case VariantJanus:      /* should work */
 908       case VariantSuper:      /* experimental */
 909       case VariantGreat:      /* experimental, requires legality testing to be off */
 910         break;
 911       }
 912     }
 913
 914     InitEngineUCI( installDir, &first );  // [HGM] moved here from winboard.c, to make available in xboard
 915     InitEngineUCI( installDir, &second );
 916 }
 917
 918 int NextIntegerFromString( char ** str, long * value )
 919 {
 920     int result = -1;
 921     char * s = *str;
 922
 923     while( *s == ' ' || *s == '\t' ) {
 924         s++;
 925     }
 926
 927     *value = 0;
 928
 929     if( *s >= '0' && *s <= '9' ) {
 930         while( *s >= '0' && *s <= '9' ) {
 931             *value = *value * 10 + (*s - '0');
 932             s++;
 933         }
 934
 935         result = 0;
 936     }
 937
 938     *str = s;
 939
 940     return result;
 941 }
 942
 943 int NextTimeControlFromString( char ** str, long * value )
 944 {
 945     long temp;
 946     int result = NextIntegerFromString( str, &temp );
 947
 948     if( result == 0 ) {
 949         *value = temp * 60; /* Minutes */
 950         if( **str == ':' ) {
 951             (*str)++;
 952             result = NextIntegerFromString( str, &temp );
 953             *value += temp; /* Seconds */
 954         }
 955     }
 956
 957     return result;
 958 }
 959
 960 int NextSessionFromString( char ** str, int *moves, long * tc, long *inc)
 961 {   /* [HGM] routine added to read '+moves/time' for secondary time control */
 962     int result = -1; long temp, temp2;
 963
 964     if(**str != '+') return -1; // old params remain in force!
 965     (*str)++;
 966     if( NextTimeControlFromString( str, &temp ) ) return -1;
 967
 968     if(**str != '/') {
 969         /* time only: incremental or sudden-death time control */
 970         if(**str == '+') { /* increment follows; read it */
 971             (*str)++;
 972             if(result = NextIntegerFromString( str, &temp2)) return -1;
 973             *inc = temp2 * 1000;
 974         } else *inc = 0;
 975         *moves = 0; *tc = temp * 1000;
 976         return 0;
 977     } else if(temp % 60 != 0) return -1;     /* moves was given as min:sec */
 978
 979     (*str)++; /* classical time control */
 980     result = NextTimeControlFromString( str, &temp2);
 981     if(result == 0) {
 982         *moves = temp/60;
 983         *tc    = temp2 * 1000;
 984         *inc   = 0;
 985     }
 986     return result;
 987 }
 988
 989 int GetTimeQuota(int movenr)
 990 {   /* [HGM] get time to add from the multi-session time-control string */
 991     int moves=1; /* kludge to force reading of first session */
 992     long time, increment;
 993     char *s = fullTimeControlString;
 994
 995     if(appData.debugMode) fprintf(debugFP, "TC string = '%s'\n", fullTimeControlString);
 996     do {
 997         if(moves) NextSessionFromString(&s, &moves, &time, &increment);
 998         if(appData.debugMode) fprintf(debugFP, "mps=%d tc=%d inc=%d\n", moves, (int) time, (int) increment);
 999         if(movenr == -1) return time;    /* last move before new session     */
1000         if(!moves) return increment;     /* current session is incremental   */
1001         if(movenr >= 0) movenr -= moves; /* we already finished this session */
1002     } while(movenr >= -1);               /* try again for next session       */
1003
1004     return 0; // no new time quota on this move
1005 }
1006
1007 int
1008 ParseTimeControl(tc, ti, mps)
1009      char *tc;
1010      int ti;
1011      int mps;
1012 {
1013 #if 0
1014     int matched, min, sec;
1015
1016     matched = sscanf(tc, "%d:%d", &min, &sec);
1017     if (matched == 1) {
1018         timeControl = min * 60 * 1000;
1019     } else if (matched == 2) {
1020         timeControl = (min * 60 + sec) * 1000;
1021     } else {
1022         return FALSE;
1023     }
1024 #else
1025     long tc1;
1026     long tc2;
1027     char buf[MSG_SIZ];
1028
1029     if(ti >= 0 && !strchr(tc, '+') && !strchr(tc, '/') ) mps = 0;
1030     if(ti > 0) {
1031         if(mps)
1032              sprintf(buf, "+%d/%s+%d", mps, tc, ti);
1033         else sprintf(buf, "+%s+%d", tc, ti);
1034     } else {
1035         if(mps)
1036              sprintf(buf, "+%d/%s", mps, tc);
1037         else sprintf(buf, "+%s", tc);
1038     }
1039     fullTimeControlString = StrSave(buf);
1040
1041     if( NextTimeControlFromString( &tc, &tc1 ) != 0 ) {
1042         return FALSE;
1043     }
1044
1045     if( *tc == '/' ) {
1046         /* Parse second time control */
1047         tc++;
1048
1049         if( NextTimeControlFromString( &tc, &tc2 ) != 0 ) {
1050             return FALSE;
1051         }
1052
1053         if( tc2 == 0 ) {
1054             return FALSE;
1055         }
1056
1057         timeControl_2 = tc2 * 1000;
1058     }
1059     else {
1060         timeControl_2 = 0;
1061     }
1062
1063     if( tc1 == 0 ) {
1064         return FALSE;
1065     }
1066
1067     timeControl = tc1 * 1000;
1068 #endif
1069
1070     if (ti >= 0) {
1071         timeIncrement = ti * 1000;  /* convert to ms */
1072         movesPerSession = 0;
1073     } else {
1074         timeIncrement = 0;
1075         movesPerSession = mps;
1076     }
1077     return TRUE;
1078 }
1079
1080 void
1081 InitBackEnd2()
1082 {
1083     if (appData.debugMode) {
1084         fprintf(debugFP, "%s\n", programVersion);
1085     }
1086
1087     if (appData.matchGames > 0) {
1088         appData.matchMode = TRUE;
1089     } else if (appData.matchMode) {
1090         appData.matchGames = 1;
1091     }
1092     if(appData.matchMode && appData.sameColorGames > 0) /* [HGM] alternate: overrule matchGames */
1093         appData.matchGames = appData.sameColorGames;
1094     if(appData.rewindIndex > 1) { /* [HGM] autoinc: rewind implies auto-increment and overrules given index */
1095         if(appData.loadPositionIndex >= 0) appData.loadPositionIndex = -1;
1096         if(appData.loadGameIndex >= 0) appData.loadGameIndex = -1;
1097     }
1098     Reset(TRUE, FALSE);
1099     if (appData.noChessProgram || first.protocolVersion == 1) {
1100       InitBackEnd3();
1101     } else {
1102       /* kludge: allow timeout for initial "feature" commands */
1103       FreezeUI();
1104       DisplayMessage("", _("Starting chess program"));
1105       ScheduleDelayedEvent(InitBackEnd3, FEATURE_TIMEOUT);
1106     }
1107 }
1108
1109 void
1110 InitBackEnd3 P((void))
1111 {
1112     GameMode initialMode;
1113     char buf[MSG_SIZ];
1114     int err;
1115
1116     InitChessProgram(&first, startedFromSetupPosition);
1117
1118
1119     if (appData.icsActive) {
1120 #ifdef WIN32
1121         /* [DM] Make a console window if needed [HGM] merged ifs */
1122         ConsoleCreate();
1123 #endif
1124         err = establish();
1125         if (err != 0) {
1126             if (*appData.icsCommPort != NULLCHAR) {
1127                 sprintf(buf, _("Could not open comm port %s"),
1128                         appData.icsCommPort);
1129             } else {
1130                 snprintf(buf, sizeof(buf), _("Could not connect to host %s, port %s"),
1131                         appData.icsHost, appData.icsPort);
1132             }
1133             DisplayFatalError(buf, err, 1);
1134             return;
1135         }
1136         SetICSMode();
1137         telnetISR =
1138           AddInputSource(icsPR, FALSE, read_from_ics, &telnetISR);
1139         fromUserISR =
1140           AddInputSource(NoProc, FALSE, read_from_player, &fromUserISR);
1141     } else if (appData.noChessProgram) {
1142         SetNCPMode();
1143     } else {
1144         SetGNUMode();
1145     }
1146
1147     if (*appData.cmailGameName != NULLCHAR) {
1148         SetCmailMode();
1149         OpenLoopback(&cmailPR);
1150         cmailISR =
1151           AddInputSource(cmailPR, FALSE, CmailSigHandlerCallBack, &cmailISR);
1152     }
1153
1154     ThawUI();
1155     DisplayMessage("", "");
1156     if (StrCaseCmp(appData.initialMode, "") == 0) {
1157       initialMode = BeginningOfGame;
1158     } else if (StrCaseCmp(appData.initialMode, "TwoMachines") == 0) {
1159       initialMode = TwoMachinesPlay;
1160     } else if (StrCaseCmp(appData.initialMode, "AnalyzeFile") == 0) {
1161       initialMode = AnalyzeFile;
1162     } else if (StrCaseCmp(appData.initialMode, "Analysis") == 0) {
1163       initialMode = AnalyzeMode;
1164     } else if (StrCaseCmp(appData.initialMode, "MachineWhite") == 0) {
1165       initialMode = MachinePlaysWhite;
1166     } else if (StrCaseCmp(appData.initialMode, "MachineBlack") == 0) {
1167       initialMode = MachinePlaysBlack;
1168     } else if (StrCaseCmp(appData.initialMode, "EditGame") == 0) {
1169       initialMode = EditGame;
1170     } else if (StrCaseCmp(appData.initialMode, "EditPosition") == 0) {
1171       initialMode = EditPosition;
1172     } else if (StrCaseCmp(appData.initialMode, "Training") == 0) {
1173       initialMode = Training;
1174     } else {
1175       sprintf(buf, _("Unknown initialMode %s"), appData.initialMode);
1176       DisplayFatalError(buf, 0, 2);
1177       return;
1178     }
1179
1180     if (appData.matchMode) {
1181         /* Set up machine vs. machine match */
1182         if (appData.noChessProgram) {
1183             DisplayFatalError(_("Can't have a match with no chess programs"),
1184                               0, 2);
1185             return;
1186         }
1187         matchMode = TRUE;
1188         matchGame = 1;
1189         if (*appData.loadGameFile != NULLCHAR) {
1190             int index = appData.loadGameIndex; // [HGM] autoinc
1191             if(index<0) lastIndex = index = 1;
1192             if (!LoadGameFromFile(appData.loadGameFile,
1193                                   index,
1194                                   appData.loadGameFile, FALSE)) {
1195                 DisplayFatalError(_("Bad game file"), 0, 1);
1196                 return;
1197             }
1198         } else if (*appData.loadPositionFile != NULLCHAR) {
1199             int index = appData.loadPositionIndex; // [HGM] autoinc
1200             if(index<0) lastIndex = index = 1;
1201             if (!LoadPositionFromFile(appData.loadPositionFile,
1202                                       index,
1203                                       appData.loadPositionFile)) {
1204                 DisplayFatalError(_("Bad position file"), 0, 1);
1205                 return;
1206             }
1207         }
1208         TwoMachinesEvent();
1209     } else if (*appData.cmailGameName != NULLCHAR) {
1210         /* Set up cmail mode */
1211         ReloadCmailMsgEvent(TRUE);
1212     } else {
1213         /* Set up other modes */
1214         if (initialMode == AnalyzeFile) {
1215           if (*appData.loadGameFile == NULLCHAR) {
1216             DisplayFatalError(_("AnalyzeFile mode requires a game file"), 0, 1);
1217             return;
1218           }
1219         }
1220         if (*appData.loadGameFile != NULLCHAR) {
1221             (void) LoadGameFromFile(appData.loadGameFile,
1222                                     appData.loadGameIndex,
1223                                     appData.loadGameFile, TRUE);
1224         } else if (*appData.loadPositionFile != NULLCHAR) {
1225             (void) LoadPositionFromFile(appData.loadPositionFile,
1226                                         appData.loadPositionIndex,
1227                                         appData.loadPositionFile);
1228             /* [HGM] try to make self-starting even after FEN load */
1229             /* to allow automatic setup of fairy variants with wtm */
1230             if(initialMode == BeginningOfGame && !blackPlaysFirst) {
1231                 gameMode = BeginningOfGame;
1232                 setboardSpoiledMachineBlack = 1;
1233             }
1234             /* [HGM] loadPos: make that every new game uses the setup */
1235             /* from file as long as we do not switch variant          */
1236             if(!blackPlaysFirst) { int i;
1237                 startedFromPositionFile = TRUE;
1238                 CopyBoard(filePosition, boards[0]);
1239                 for(i=0; i<BOARD_SIZE; i++) fileRights[i] = castlingRights[0][i];
1240             }
1241         }
1242         if (initialMode == AnalyzeMode) {
1243           if (appData.noChessProgram) {
1244             DisplayFatalError(_("Analysis mode requires a chess engine"), 0, 2);
1245             return;
1246           }
1247           if (appData.icsActive) {
1248             DisplayFatalError(_("Analysis mode does not work with ICS mode"),0,2);
1249             return;
1250           }
1251           AnalyzeModeEvent();
1252         } else if (initialMode == AnalyzeFile) {
1253           appData.showThinking = TRUE; // [HGM] thinking: moved out of ShowThinkingEvent
1254           ShowThinkingEvent();
1255           AnalyzeFileEvent();
1256           AnalysisPeriodicEvent(1);
1257         } else if (initialMode == MachinePlaysWhite) {
1258           if (appData.noChessProgram) {
1259             DisplayFatalError(_("MachineWhite mode requires a chess engine"),
1260                               0, 2);
1261             return;
1262           }
1263           if (appData.icsActive) {
1264             DisplayFatalError(_("MachineWhite mode does not work with ICS mode"),
1265                               0, 2);
1266             return;
1267           }
1268           MachineWhiteEvent();
1269         } else if (initialMode == MachinePlaysBlack) {
1270           if (appData.noChessProgram) {
1271             DisplayFatalError(_("MachineBlack mode requires a chess engine"),
1272                               0, 2);
1273             return;
1274           }
1275           if (appData.icsActive) {
1276             DisplayFatalError(_("MachineBlack mode does not work with ICS mode"),
1277                               0, 2);
1278             return;
1279           }
1280           MachineBlackEvent();
1281         } else if (initialMode == TwoMachinesPlay) {
1282           if (appData.noChessProgram) {
1283             DisplayFatalError(_("TwoMachines mode requires a chess engine"),
1284                               0, 2);
1285             return;
1286           }
1287           if (appData.icsActive) {
1288             DisplayFatalError(_("TwoMachines mode does not work with ICS mode"),
1289                               0, 2);
1290             return;
1291           }
1292           TwoMachinesEvent();
1293         } else if (initialMode == EditGame) {
1294           EditGameEvent();
1295         } else if (initialMode == EditPosition) {
1296           EditPositionEvent();
1297         } else if (initialMode == Training) {
1298           if (*appData.loadGameFile == NULLCHAR) {
1299             DisplayFatalError(_("Training mode requires a game file"), 0, 2);
1300             return;
1301           }
1302           TrainingEvent();
1303         }
1304     }
1305 }
1306
1307 /*
1308  * Establish will establish a contact to a remote host.port.
1309  * Sets icsPR to a ProcRef for a process (or pseudo-process)
1310  *  used to talk to the host.
1311  * Returns 0 if okay, error code if not.
1312  */
1313 int
1314 establish()
1315 {
1316     char buf[MSG_SIZ];
1317
1318     if (*appData.icsCommPort != NULLCHAR) {
1319         /* Talk to the host through a serial comm port */
1320         return OpenCommPort(appData.icsCommPort, &icsPR);
1321
1322     } else if (*appData.gateway != NULLCHAR) {
1323         if (*appData.remoteShell == NULLCHAR) {
1324             /* Use the rcmd protocol to run telnet program on a gateway host */
1325             snprintf(buf, sizeof(buf), "%s %s %s",
1326                     appData.telnetProgram, appData.icsHost, appData.icsPort);
1327             return OpenRcmd(appData.gateway, appData.remoteUser, buf, &icsPR);
1328
1329         } else {
1330             /* Use the rsh program to run telnet program on a gateway host */
1331             if (*appData.remoteUser == NULLCHAR) {
1332                 snprintf(buf, sizeof(buf), "%s %s %s %s %s", appData.remoteShell,
1333                         appData.gateway, appData.telnetProgram,
1334                         appData.icsHost, appData.icsPort);
1335             } else {
1336                 snprintf(buf, sizeof(buf), "%s %s -l %s %s %s %s",
1337                         appData.remoteShell, appData.gateway,
1338                         appData.remoteUser, appData.telnetProgram,
1339                         appData.icsHost, appData.icsPort);
1340             }
1341             return StartChildProcess(buf, "", &icsPR);
1342
1343         }
1344     } else if (appData.useTelnet) {
1345         return OpenTelnet(appData.icsHost, appData.icsPort, &icsPR);
1346
1347     } else {
1348         /* TCP socket interface differs somewhat between
1349            Unix and NT; handle details in the front end.
1350            */
1351         return OpenTCP(appData.icsHost, appData.icsPort, &icsPR);
1352     }
1353 }
1354
1355 void
1356 show_bytes(fp, buf, count)
1357      FILE *fp;
1358      char *buf;
1359      int count;
1360 {
1361     while (count--) {
1362         if (*buf < 040 || *(unsigned char *) buf > 0177) {
1363             fprintf(fp, "\\%03o", *buf & 0xff);
1364         } else {
1365             putc(*buf, fp);
1366         }
1367         buf++;
1368     }
1369     fflush(fp);
1370 }
1371
1372 /* Returns an errno value */
1373 int
1374 OutputMaybeTelnet(pr, message, count, outError)
1375      ProcRef pr;
1376      char *message;
1377      int count;
1378      int *outError;
1379 {
1380     char buf[8192], *p, *q, *buflim;
1381     int left, newcount, outcount;
1382
1383     if (*appData.icsCommPort != NULLCHAR || appData.useTelnet ||
1384         *appData.gateway != NULLCHAR) {
1385         if (appData.debugMode) {
1386             fprintf(debugFP, ">ICS: ");
1387             show_bytes(debugFP, message, count);
1388             fprintf(debugFP, "\n");
1389         }
1390         return OutputToProcess(pr, message, count, outError);
1391     }
1392
1393     buflim = &buf[sizeof(buf)-1]; /* allow 1 byte for expanding last char */
1394     p = message;
1395     q = buf;
1396     left = count;
1397     newcount = 0;
1398     while (left) {
1399         if (q >= buflim) {
1400             if (appData.debugMode) {
1401                 fprintf(debugFP, ">ICS: ");
1402                 show_bytes(debugFP, buf, newcount);
1403                 fprintf(debugFP, "\n");
1404             }
1405             outcount = OutputToProcess(pr, buf, newcount, outError);
1406             if (outcount < newcount) return -1; /* to be sure */
1407             q = buf;
1408             newcount = 0;
1409         }
1410         if (*p == '\n') {
1411             *q++ = '\r';
1412             newcount++;
1413         } else if (((unsigned char) *p) == TN_IAC) {
1414             *q++ = (char) TN_IAC;
1415             newcount ++;
1416         }
1417         *q++ = *p++;
1418         newcount++;
1419         left--;
1420     }
1421     if (appData.debugMode) {
1422         fprintf(debugFP, ">ICS: ");
1423         show_bytes(debugFP, buf, newcount);
1424         fprintf(debugFP, "\n");
1425     }
1426     outcount = OutputToProcess(pr, buf, newcount, outError);
1427     if (outcount < newcount) return -1; /* to be sure */
1428     return count;
1429 }
1430
1431 void
1432 read_from_player(isr, closure, message, count, error)
1433      InputSourceRef isr;
1434      VOIDSTAR closure;
1435      char *message;
1436      int count;
1437      int error;
1438 {
1439     int outError, outCount;
1440     static int gotEof = 0;
1441
1442     /* Pass data read from player on to ICS */
1443     if (count > 0) {
1444         gotEof = 0;
1445         outCount = OutputMaybeTelnet(icsPR, message, count, &outError);
1446         if (outCount < count) {
1447             DisplayFatalError(_("Error writing to ICS"), outError, 1);
1448         }
1449     } else if (count < 0) {
1450         RemoveInputSource(isr);
1451         DisplayFatalError(_("Error reading from keyboard"), error, 1);
1452     } else if (gotEof++ > 0) {
1453         RemoveInputSource(isr);
1454         DisplayFatalError(_("Got end of file from keyboard"), 0, 0);
1455     }
1456 }
1457
1458 void
1459 KeepAlive()
1460 {   // [HGM] alive: periodically send dummy (date) command to ICS to prevent time-out
1461     SendToICS("date\n");
1462     if(appData.keepAlive) ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
1463 }
1464
1465 void
1466 SendToICS(s)
1467      char *s;
1468 {
1469     int count, outCount, outError;
1470
1471     if (icsPR == NULL) return;
1472
1473     count = strlen(s);
1474     outCount = OutputMaybeTelnet(icsPR, s, count, &outError);
1475     if (outCount < count) {
1476         DisplayFatalError(_("Error writing to ICS"), outError, 1);
1477     }
1478 }
1479
1480 /* This is used for sending logon scripts to the ICS. Sending
1481    without a delay causes problems when using timestamp on ICC
1482    (at least on my machine). */
1483 void
1484 SendToICSDelayed(s,msdelay)
1485      char *s;
1486      long msdelay;
1487 {
1488     int count, outCount, outError;
1489
1490     if (icsPR == NULL) return;
1491
1492     count = strlen(s);
1493     if (appData.debugMode) {
1494         fprintf(debugFP, ">ICS: ");
1495         show_bytes(debugFP, s, count);
1496         fprintf(debugFP, "\n");
1497     }
1498     outCount = OutputToProcessDelayed(icsPR, s, count, &outError,
1499                                       msdelay);
1500     if (outCount < count) {
1501         DisplayFatalError(_("Error writing to ICS"), outError, 1);
1502     }
1503 }
1504
1505
1506 /* Remove all highlighting escape sequences in s
1507    Also deletes any suffix starting with '('
1508    */
1509 char *
1510 StripHighlightAndTitle(s)
1511      char *s;
1512 {
1513     static char retbuf[MSG_SIZ];
1514     char *p = retbuf;
1515
1516     while (*s != NULLCHAR) {
1517         while (*s == '\033') {
1518             while (*s != NULLCHAR && !isalpha(*s)) s++;
1519             if (*s != NULLCHAR) s++;
1520         }
1521         while (*s != NULLCHAR && *s != '\033') {
1522             if (*s == '(' || *s == '[') {
1523                 *p = NULLCHAR;
1524                 return retbuf;
1525             }
1526             *p++ = *s++;
1527         }
1528     }
1529     *p = NULLCHAR;
1530     return retbuf;
1531 }
1532
1533 /* Remove all highlighting escape sequences in s */
1534 char *
1535 StripHighlight(s)
1536      char *s;
1537 {
1538     static char retbuf[MSG_SIZ];
1539     char *p = retbuf;
1540
1541     while (*s != NULLCHAR) {
1542         while (*s == '\033') {
1543             while (*s != NULLCHAR && !isalpha(*s)) s++;
1544             if (*s != NULLCHAR) s++;
1545         }
1546         while (*s != NULLCHAR && *s != '\033') {
1547             *p++ = *s++;
1548         }
1549     }
1550     *p = NULLCHAR;
1551     return retbuf;
1552 }
1553
1554 char *variantNames[] = VARIANT_NAMES;
1555 char *
1556 VariantName(v)
1557      VariantClass v;
1558 {
1559     return variantNames[v];
1560 }
1561
1562
1563 /* Identify a variant from the strings the chess servers use or the
1564    PGN Variant tag names we use. */
1565 VariantClass
1566 StringToVariant(e)
1567      char *e;
1568 {
1569     char *p;
1570     int wnum = -1;
1571     VariantClass v = VariantNormal;
1572     int i, found = FALSE;
1573     char buf[MSG_SIZ];
1574
1575     if (!e) return v;
1576
1577     /* [HGM] skip over optional board-size prefixes */
1578     if( sscanf(e, "%dx%d_", &i, &i) == 2 ||
1579         sscanf(e, "%dx%d+%d_", &i, &i, &i) == 3 ) {
1580         while( *e++ != '_');
1581     }
1582
1583     for (i=0; i<sizeof(variantNames)/sizeof(char*); i++) {
1584       if (StrCaseStr(e, variantNames[i])) {
1585         v = (VariantClass) i;
1586         found = TRUE;
1587         break;
1588       }
1589     }
1590
1591     if (!found) {
1592       if ((StrCaseStr(e, "fischer") && StrCaseStr(e, "random"))
1593           || StrCaseStr(e, "wild/fr")
1594           || StrCaseStr(e, "frc") || StrCaseStr(e, "960")) {
1595         v = VariantFischeRandom;
1596       } else if ((i = 4, p = StrCaseStr(e, "wild")) ||
1597                  (i = 1, p = StrCaseStr(e, "w"))) {
1598         p += i;
1599         while (*p && (isspace(*p) || *p == '(' || *p == '/')) p++;
1600         if (isdigit(*p)) {
1601           wnum = atoi(p);
1602         } else {
1603           wnum = -1;
1604         }
1605         switch (wnum) {
1606         case 0: /* FICS only, actually */
1607         case 1:
1608           /* Castling legal even if K starts on d-file */
1609           v = VariantWildCastle;
1610           break;
1611         case 2:
1612         case 3:
1613         case 4:
1614           /* Castling illegal even if K & R happen to start in
1615              normal positions. */
1616           v = VariantNoCastle;
1617           break;
1618         case 5:
1619         case 7:
1620         case 8:
1621         case 10:
1622         case 11:
1623         case 12:
1624         case 13:
1625         case 14:
1626         case 15:
1627         case 18:
1628         case 19:
1629           /* Castling legal iff K & R start in normal positions */
1630           v = VariantNormal;
1631           break;
1632         case 6:
1633         case 20:
1634         case 21:
1635           /* Special wilds for position setup; unclear what to do here */
1636           v = VariantLoadable;
1637           break;
1638         case 9:
1639           /* Bizarre ICC game */
1640           v = VariantTwoKings;
1641           break;
1642         case 16:
1643           v = VariantKriegspiel;
1644           break;
1645         case 17:
1646           v = VariantLosers;
1647           break;
1648         case 22:
1649           v = VariantFischeRandom;
1650           break;
1651         case 23:
1652           v = VariantCrazyhouse;
1653           break;
1654         case 24:
1655           v = VariantBughouse;
1656           break;
1657         case 25:
1658           v = Variant3Check;
1659           break;
1660         case 26:
1661           /* Not quite the same as FICS suicide! */
1662           v = VariantGiveaway;
1663           break;
1664         case 27:
1665           v = VariantAtomic;
1666           break;
1667         case 28:
1668           v = VariantShatranj;
1669           break;
1670
1671         /* Temporary names for future ICC types.  The name *will* change in
1672            the next xboard/WinBoard release after ICC defines it. */
1673         case 29:
1674           v = Variant29;
1675           break;
1676         case 30:
1677           v = Variant30;
1678           break;
1679         case 31:
1680           v = Variant31;
1681           break;
1682         case 32:
1683           v = Variant32;
1684           break;
1685         case 33:
1686           v = Variant33;
1687           break;
1688         case 34:
1689           v = Variant34;
1690           break;
1691         case 35:
1692           v = Variant35;
1693           break;
1694         case 36:
1695           v = Variant36;
1696           break;
1697         case 37:
1698           v = VariantShogi;
1699           break;
1700         case 38:
1701           v = VariantXiangqi;
1702           break;
1703         case 39:
1704           v = VariantCourier;
1705           break;
1706         case 40:
1707           v = VariantGothic;
1708           break;
1709         case 41:
1710           v = VariantCapablanca;
1711           break;
1712         case 42:
1713           v = VariantKnightmate;
1714           break;
1715         case 43:
1716           v = VariantFairy;
1717           break;
1718         case 44:
1719           v = VariantCylinder;
1720           break;
1721         case 45:
1722           v = VariantFalcon;
1723           break;
1724         case 46:
1725           v = VariantCapaRandom;
1726           break;
1727         case 47:
1728           v = VariantBerolina;
1729           break;
1730         case 48:
1731           v = VariantJanus;
1732           break;
1733         case 49:
1734           v = VariantSuper;
1735           break;
1736         case 50:
1737           v = VariantGreat;
1738           break;
1739         case -1:
1740           /* Found "wild" or "w" in the string but no number;
1741              must assume it's normal chess. */
1742           v = VariantNormal;
1743           break;
1744         default:
1745           sprintf(buf, _("Unknown wild type %d"), wnum);
1746           DisplayError(buf, 0);
1747           v = VariantUnknown;
1748           break;
1749         }
1750       }
1751     }
1752     if (appData.debugMode) {
1753       fprintf(debugFP, _("recognized '%s' (%d) as variant %s\n"),
1754               e, wnum, VariantName(v));
1755     }
1756     return v;
1757 }
1758
1759 static int leftover_start = 0, leftover_len = 0;
1760 char star_match[STAR_MATCH_N][MSG_SIZ];
1761
1762 /* Test whether pattern is present at &buf[*index]; if so, return TRUE,
1763    advance *index beyond it, and set leftover_start to the new value of
1764    *index; else return FALSE.  If pattern contains the character '*', it
1765    matches any sequence of characters not containing '\r', '\n', or the
1766    character following the '*' (if any), and the matched sequence(s) are
1767    copied into star_match.
1768    */
1769 int
1770 looking_at(buf, index, pattern)
1771      char *buf;
1772      int *index;
1773      char *pattern;
1774 {
1775     char *bufp = &buf[*index], *patternp = pattern;
1776     int star_count = 0;
1777     char *matchp = star_match[0];
1778
1779     for (;;) {
1780         if (*patternp == NULLCHAR) {
1781             *index = leftover_start = bufp - buf;
1782             *matchp = NULLCHAR;
1783             return TRUE;
1784         }
1785         if (*bufp == NULLCHAR) return FALSE;
1786         if (*patternp == '*') {
1787             if (*bufp == *(patternp + 1)) {
1788                 *matchp = NULLCHAR;
1789                 matchp = star_match[++star_count];
1790                 patternp += 2;
1791                 bufp++;
1792                 continue;
1793             } else if (*bufp == '\n' || *bufp == '\r') {
1794                 patternp++;
1795                 if (*patternp == NULLCHAR)
1796                   continue;
1797                 else
1798                   return FALSE;
1799             } else {
1800                 *matchp++ = *bufp++;
1801                 continue;
1802             }
1803         }
1804         if (*patternp != *bufp) return FALSE;
1805         patternp++;
1806         bufp++;
1807     }
1808 }
1809
1810 void
1811 SendToPlayer(data, length)
1812      char *data;
1813      int length;
1814 {
1815     int error, outCount;
1816     outCount = OutputToProcess(NoProc, data, length, &error);
1817     if (outCount < length) {
1818         DisplayFatalError(_("Error writing to display"), error, 1);
1819     }
1820 }
1821
1822 void
1823 PackHolding(packed, holding)
1824      char packed[];
1825      char *holding;
1826 {
1827     char *p = holding;
1828     char *q = packed;
1829     int runlength = 0;
1830     int curr = 9999;
1831     do {
1832         if (*p == curr) {
1833             runlength++;
1834         } else {
1835             switch (runlength) {
1836               case 0:
1837                 break;
1838               case 1:
1839                 *q++ = curr;
1840                 break;
1841               case 2:
1842                 *q++ = curr;
1843                 *q++ = curr;
1844                 break;
1845               default:
1846                 sprintf(q, "%d", runlength);
1847                 while (*q) q++;
1848                 *q++ = curr;
1849                 break;
1850             }
1851             runlength = 1;
1852             curr = *p;
1853         }
1854     } while (*p++);
1855     *q = NULLCHAR;
1856 }
1857
1858 /* Telnet protocol requests from the front end */
1859 void
1860 TelnetRequest(ddww, option)
1861      unsigned char ddww, option;
1862 {
1863     unsigned char msg[3];
1864     int outCount, outError;
1865
1866     if (*appData.icsCommPort != NULLCHAR || appData.useTelnet) return;
1867
1868     if (appData.debugMode) {
1869         char buf1[8], buf2[8], *ddwwStr, *optionStr;
1870         switch (ddww) {
1871           case TN_DO:
1872             ddwwStr = "DO";
1873             break;
1874           case TN_DONT:
1875             ddwwStr = "DONT";
1876             break;
1877           case TN_WILL:
1878             ddwwStr = "WILL";
1879             break;
1880           case TN_WONT:
1881             ddwwStr = "WONT";
1882             break;
1883           default:
1884             ddwwStr = buf1;
1885             sprintf(buf1, "%d", ddww);
1886             break;
1887         }
1888         switch (option) {
1889           case TN_ECHO:
1890             optionStr = "ECHO";
1891             break;
1892           default:
1893             optionStr = buf2;
1894             sprintf(buf2, "%d", option);
1895             break;
1896         }
1897         fprintf(debugFP, ">%s %s ", ddwwStr, optionStr);
1898     }
1899     msg[0] = TN_IAC;
1900     msg[1] = ddww;
1901     msg[2] = option;
1902     outCount = OutputToProcess(icsPR, (char *)msg, 3, &outError);
1903     if (outCount < 3) {
1904         DisplayFatalError(_("Error writing to ICS"), outError, 1);
1905     }
1906 }
1907
1908 void
1909 DoEcho()
1910 {
1911     if (!appData.icsActive) return;
1912     TelnetRequest(TN_DO, TN_ECHO);
1913 }
1914
1915 void
1916 DontEcho()
1917 {
1918     if (!appData.icsActive) return;
1919     TelnetRequest(TN_DONT, TN_ECHO);
1920 }
1921
1922 void
1923 CopyHoldings(Board board, char *holdings, ChessSquare lowestPiece)
1924 {
1925     /* put the holdings sent to us by the server on the board holdings area */
1926     int i, j, holdingsColumn, holdingsStartRow, direction, countsColumn;
1927     char p;
1928     ChessSquare piece;
1929
1930     if(gameInfo.holdingsWidth < 2)  return;
1931
1932     if( (int)lowestPiece >= BlackPawn ) {
1933         holdingsColumn = 0;
1934         countsColumn = 1;
1935         holdingsStartRow = BOARD_HEIGHT-1;
1936         direction = -1;
1937     } else {
1938         holdingsColumn = BOARD_WIDTH-1;
1939         countsColumn = BOARD_WIDTH-2;
1940         holdingsStartRow = 0;
1941         direction = 1;
1942     }
1943
1944     for(i=0; i<BOARD_HEIGHT; i++) { /* clear holdings */
1945         board[i][holdingsColumn] = EmptySquare;
1946         board[i][countsColumn]   = (ChessSquare) 0;
1947     }
1948     while( (p=*holdings++) != NULLCHAR ) {
1949         piece = CharToPiece( ToUpper(p) );
1950         if(piece == EmptySquare) continue;
1951         /*j = (int) piece - (int) WhitePawn;*/
1952         j = PieceToNumber(piece);
1953         if(j >= gameInfo.holdingsSize) continue; /* ignore pieces that do not fit */
1954         if(j < 0) continue;               /* should not happen */
1955         piece = (ChessSquare) ( (int)piece + (int)lowestPiece );
1956         board[holdingsStartRow+j*direction][holdingsColumn] = piece;
1957         board[holdingsStartRow+j*direction][countsColumn]++;
1958     }
1959
1960 }
1961
1962
1963 void
1964 VariantSwitch(Board board, VariantClass newVariant)
1965 {
1966    int newHoldingsWidth, newWidth = 8, newHeight = 8, i, j;
1967    int oldCurrentMove = currentMove, oldForwardMostMove = forwardMostMove, oldBackwardMostMove = backwardMostMove;
1968 //   Board tempBoard; int saveCastling[BOARD_SIZE], saveEP;
1969
1970    startedFromPositionFile = FALSE;
1971    if(gameInfo.variant == newVariant) return;
1972
1973    /* [HGM] This routine is called each time an assignment is made to
1974     * gameInfo.variant during a game, to make sure the board sizes
1975     * are set to match the new variant. If that means adding or deleting
1976     * holdings, we shift the playing board accordingly
1977     * This kludge is needed because in ICS observe mode, we get boards
1978     * of an ongoing game without knowing the variant, and learn about the
1979     * latter only later. This can be because of the move list we requested,
1980     * in which case the game history is refilled from the beginning anyway,
1981     * but also when receiving holdings of a crazyhouse game. In the latter
1982     * case we want to add those holdings to the already received position.
1983     */
1984
1985
1986   if (appData.debugMode) {
1987     fprintf(debugFP, "Switch board from %s to %s\n",
1988                VariantName(gameInfo.variant), VariantName(newVariant));
1989     setbuf(debugFP, NULL);
1990   }
1991     shuffleOpenings = 0;       /* [HGM] shuffle */
1992     gameInfo.holdingsSize = 5; /* [HGM] prepare holdings */
1993     switch(newVariant) {
1994             case VariantShogi:
1995               newWidth = 9;  newHeight = 9;
1996               gameInfo.holdingsSize = 7;
1997             case VariantBughouse:
1998             case VariantCrazyhouse:
1999               newHoldingsWidth = 2; break;
2000             default:
2001               newHoldingsWidth = gameInfo.holdingsSize = 0;
2002     }
2003
2004     if(newWidth  != gameInfo.boardWidth  ||
2005        newHeight != gameInfo.boardHeight ||
2006        newHoldingsWidth != gameInfo.holdingsWidth ) {
2007
2008         /* shift position to new playing area, if needed */
2009         if(newHoldingsWidth > gameInfo.holdingsWidth) {
2010            for(i=0; i<BOARD_HEIGHT; i++)
2011                for(j=BOARD_RGHT-1; j>=BOARD_LEFT; j--)
2012                    board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
2013                                                      board[i][j];
2014            for(i=0; i<newHeight; i++) {
2015                board[i][0] = board[i][newWidth+2*newHoldingsWidth-1] = EmptySquare;
2016                board[i][1] = board[i][newWidth+2*newHoldingsWidth-2] = (ChessSquare) 0;
2017            }
2018         } else if(newHoldingsWidth < gameInfo.holdingsWidth) {
2019            for(i=0; i<BOARD_HEIGHT; i++)
2020                for(j=BOARD_LEFT; j<BOARD_RGHT; j++)
2021                    board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
2022                                                  board[i][j];
2023         }
2024
2025         gameInfo.boardWidth  = newWidth;
2026         gameInfo.boardHeight = newHeight;
2027         gameInfo.holdingsWidth = newHoldingsWidth;
2028         gameInfo.variant = newVariant;
2029         InitDrawingSizes(-2, 0);
2030
2031         /* [HGM] The following should definitely be solved in a better way */
2032 #if 0
2033         CopyBoard(board, tempBoard); /* save position in case it is board[0] */
2034         for(i=0; i<BOARD_SIZE; i++) saveCastling[i] = castlingRights[0][i];
2035         saveEP = epStatus[0];
2036 #endif
2037         InitPosition(FALSE);          /* this sets up board[0], but also other stuff        */
2038 #if 0
2039         epStatus[0] = saveEP;
2040         for(i=0; i<BOARD_SIZE; i++) castlingRights[0][i] = saveCastling[i];
2041         CopyBoard(tempBoard, board); /* restore position received from ICS   */
2042 #endif
2043     } else { gameInfo.variant = newVariant; InitPosition(FALSE); }
2044
2045     forwardMostMove = oldForwardMostMove;
2046     backwardMostMove = oldBackwardMostMove;
2047     currentMove = oldCurrentMove; /* InitPos reset these, but we need still to redraw the position */
2048 }
2049
2050 static int loggedOn = FALSE;
2051
2052 /*-- Game start info cache: --*/
2053 int gs_gamenum;
2054 char gs_kind[MSG_SIZ];
2055 static char player1Name[128] = "";
2056 static char player2Name[128] = "";
2057 static int player1Rating = -1;
2058 static int player2Rating = -1;
2059 /*----------------------------*/
2060
2061 ColorClass curColor = ColorNormal;
2062 int suppressKibitz = 0;
2063
2064 void
2065 read_from_ics(isr, closure, data, count, error)
2066      InputSourceRef isr;
2067      VOIDSTAR closure;
2068      char *data;
2069      int count;
2070      int error;
2071 {
2072 #define BUF_SIZE 8192
2073 #define STARTED_NONE 0
2074 #define STARTED_MOVES 1
2075 #define STARTED_BOARD 2
2076 #define STARTED_OBSERVE 3
2077 #define STARTED_HOLDINGS 4
2078 #define STARTED_CHATTER 5
2079 #define STARTED_COMMENT 6
2080 #define STARTED_MOVES_NOHIDE 7
2081
2082     static int started = STARTED_NONE;
2083     static char parse[20000];
2084     static int parse_pos = 0;
2085     static char buf[BUF_SIZE + 1];
2086     static int firstTime = TRUE, intfSet = FALSE;
2087     static ColorClass prevColor = ColorNormal;
2088     static int savingComment = FALSE;
2089     char str[500];
2090     int i, oldi;
2091     int buf_len;
2092     int next_out;
2093     int tkind;
2094     int backup;    /* [DM] For zippy color lines */
2095     char *p;
2096     char talker[MSG_SIZ]; // [HGM] chat
2097     int channel;
2098
2099     if (appData.debugMode) {
2100       if (!error) {
2101         fprintf(debugFP, "<ICS: ");
2102         show_bytes(debugFP, data, count);
2103         fprintf(debugFP, "\n");
2104       }
2105     }
2106
2107     if (appData.debugMode) { int f = forwardMostMove;
2108         fprintf(debugFP, "ics input %d, castling = %d %d %d %d %d %d\n", f,
2109                 castlingRights[f][0],castlingRights[f][1],castlingRights[f][2],castlingRights[f][3],castlingRights[f][4],castlingRights[f][5]);
2110     }
2111     if (count > 0) {
2112         /* If last read ended with a partial line that we couldn't parse,
2113            prepend it to the new read and try again. */
2114         if (leftover_len > 0) {
2115             for (i=0; i<leftover_len; i++)
2116               buf[i] = buf[leftover_start + i];
2117         }
2118
2119         /* Copy in new characters, removing nulls and \r's */
2120         buf_len = leftover_len;
2121         for (i = 0; i < count; i++) {
2122             if (data[i] != NULLCHAR && data[i] != '\r')
2123               buf[buf_len++] = data[i];
2124             if(buf_len >= 5 && buf[buf_len-5]=='\n' && buf[buf_len-4]=='\\' &&
2125                                buf[buf_len-3]==' '  && buf[buf_len-2]==' '  && buf[buf_len-1]==' ') {
2126                 buf_len -= 5; // [HGM] ICS: join continuation line of Lasker 2.2.3 server with previous
2127                 buf[buf_len++] = ' '; // replace by space (assumes ICS does not break lines within word)
2128             }
2129         }
2130
2131         buf[buf_len] = NULLCHAR;
2132         next_out = leftover_len;
2133         leftover_start = 0;
2134
2135         i = 0;
2136         while (i < buf_len) {
2137             /* Deal with part of the TELNET option negotiation
2138                protocol.  We refuse to do anything beyond the
2139                defaults, except that we allow the WILL ECHO option,
2140                which ICS uses to turn off password echoing when we are
2141                directly connected to it.  We reject this option
2142                if localLineEditing mode is on (always on in xboard)
2143                and we are talking to port 23, which might be a real
2144                telnet server that will try to keep WILL ECHO on permanently.
2145              */
2146             if (buf_len - i >= 3 && (unsigned char) buf[i] == TN_IAC) {
2147                 static int remoteEchoOption = FALSE; /* telnet ECHO option */
2148                 unsigned char option;
2149                 oldi = i;
2150                 switch ((unsigned char) buf[++i]) {
2151                   case TN_WILL:
2152                     if (appData.debugMode)
2153                       fprintf(debugFP, "\n<WILL ");
2154                     switch (option = (unsigned char) buf[++i]) {
2155                       case TN_ECHO:
2156                         if (appData.debugMode)
2157                           fprintf(debugFP, "ECHO ");
2158                         /* Reply only if this is a change, according
2159                            to the protocol rules. */
2160                         if (remoteEchoOption) break;
2161                         if (appData.localLineEditing &&
2162                             atoi(appData.icsPort) == TN_PORT) {
2163                             TelnetRequest(TN_DONT, TN_ECHO);
2164                         } else {
2165                             EchoOff();
2166                             TelnetRequest(TN_DO, TN_ECHO);
2167                             remoteEchoOption = TRUE;
2168                         }
2169                         break;
2170                       default:
2171                         if (appData.debugMode)
2172                           fprintf(debugFP, "%d ", option);
2173                         /* Whatever this is, we don't want it. */
2174                         TelnetRequest(TN_DONT, option);
2175                         break;
2176                     }
2177                     break;
2178                   case TN_WONT:
2179                     if (appData.debugMode)
2180                       fprintf(debugFP, "\n<WONT ");
2181                     switch (option = (unsigned char) buf[++i]) {
2182                       case TN_ECHO:
2183                         if (appData.debugMode)
2184                           fprintf(debugFP, "ECHO ");
2185                         /* Reply only if this is a change, according
2186                            to the protocol rules. */
2187                         if (!remoteEchoOption) break;
2188                         EchoOn();
2189                         TelnetRequest(TN_DONT, TN_ECHO);
2190                         remoteEchoOption = FALSE;
2191                         break;
2192                       default:
2193                         if (appData.debugMode)
2194                           fprintf(debugFP, "%d ", (unsigned char) option);
2195                         /* Whatever this is, it must already be turned
2196                            off, because we never agree to turn on
2197                            anything non-default, so according to the
2198                            protocol rules, we don't reply. */
2199                         break;
2200                     }
2201                     break;
2202                   case TN_DO:
2203                     if (appData.debugMode)
2204                       fprintf(debugFP, "\n<DO ");
2205                     switch (option = (unsigned char) buf[++i]) {
2206                       default:
2207                         /* Whatever this is, we refuse to do it. */
2208                         if (appData.debugMode)
2209                           fprintf(debugFP, "%d ", option);
2210                         TelnetRequest(TN_WONT, option);
2211                         break;
2212                     }
2213                     break;
2214                   case TN_DONT:
2215                     if (appData.debugMode)
2216                       fprintf(debugFP, "\n<DONT ");
2217                     switch (option = (unsigned char) buf[++i]) {
2218                       default:
2219                         if (appData.debugMode)
2220                           fprintf(debugFP, "%d ", option);
2221                         /* Whatever this is, we are already not doing
2222                            it, because we never agree to do anything
2223                            non-default, so according to the protocol
2224                            rules, we don't reply. */
2225                         break;
2226                     }
2227                     break;
2228                   case TN_IAC:
2229                     if (appData.debugMode)
2230                       fprintf(debugFP, "\n<IAC ");
2231                     /* Doubled IAC; pass it through */
2232                     i--;
2233                     break;
2234                   default:
2235                     if (appData.debugMode)
2236                       fprintf(debugFP, "\n<%d ", (unsigned char) buf[i]);
2237                     /* Drop all other telnet commands on the floor */
2238                     break;
2239                 }
2240                 if (oldi > next_out)
2241                   SendToPlayer(&buf[next_out], oldi - next_out);
2242                 if (++i > next_out)
2243                   next_out = i;
2244                 continue;
2245             }
2246
2247             /* OK, this at least will *usually* work */
2248             if (!loggedOn && looking_at(buf, &i, "ics%")) {
2249                 loggedOn = TRUE;
2250             }
2251
2252             if (loggedOn && !intfSet) {
2253                 if (ics_type == ICS_ICC) {
2254                   sprintf(str,
2255                           "/set-quietly interface %s\n/set-quietly style 12\n",
2256                           programVersion);
2257
2258                 } else if (ics_type == ICS_CHESSNET) {
2259                   sprintf(str, "/style 12\n");
2260                 } else {
2261                   strcpy(str, "alias $ @\n$set interface ");
2262                   strcat(str, programVersion);
2263                   strcat(str, "\n$iset startpos 1\n$iset ms 1\n");
2264 #ifdef WIN32
2265                   strcat(str, "$iset nohighlight 1\n");
2266 #endif
2267                   strcat(str, "$iset lock 1\n$style 12\n");
2268                 }
2269                 SendToICS(str);
2270                 intfSet = TRUE;
2271             }
2272
2273             if (started == STARTED_COMMENT) {
2274                 /* Accumulate characters in comment */
2275                 parse[parse_pos++] = buf[i];
2276                 if (buf[i] == '\n') {
2277                     parse[parse_pos] = NULLCHAR;
2278                     if(chattingPartner>=0) {
2279                         char mess[MSG_SIZ];
2280                         sprintf(mess, "%s%s", talker, parse);
2281                         OutputChatMessage(chattingPartner, mess);
2282                         chattingPartner = -1;
2283                     } else
2284                     if(!suppressKibitz) // [HGM] kibitz
2285                         AppendComment(forwardMostMove, StripHighlight(parse));
2286                     else { // [HGM kibitz: divert memorized engine kibitz to engine-output window
2287                         int nrDigit = 0, nrAlph = 0, i;
2288                         if(parse_pos > MSG_SIZ - 30) // defuse unreasonably long input
2289                         { parse_pos = MSG_SIZ-30; parse[parse_pos - 1] = '\n'; }
2290                         parse[parse_pos] = NULLCHAR;
2291                         // try to be smart: if it does not look like search info, it should go to
2292                         // ICS interaction window after all, not to engine-output window.
2293                         for(i=0; i<parse_pos; i++) { // count letters and digits
2294                             nrDigit += (parse[i] >= '0' && parse[i] <= '9');
2295                             nrAlph  += (parse[i] >= 'a' && parse[i] <= 'z');
2296                             nrAlph  += (parse[i] >= 'A' && parse[i] <= 'Z');
2297                         }
2298                         if(nrAlph < 9*nrDigit) { // if more than 10% digit we assume search info
2299                             int depth=0; float score;
2300                             if(sscanf(parse, "!!! %f/%d", &score, &depth) == 2 && depth>0) {
2301                                 // [HGM] kibitz: save kibitzed opponent info for PGN and eval graph
2302                                 pvInfoList[forwardMostMove-1].depth = depth;
2303                                 pvInfoList[forwardMostMove-1].score = 100*score;
2304                             }
2305                             OutputKibitz(suppressKibitz, parse);
2306                         } else {
2307                             char tmp[MSG_SIZ];
2308                             sprintf(tmp, _("your opponent kibitzes: %s"), parse);
2309                             SendToPlayer(tmp, strlen(tmp));
2310                         }
2311                     }
2312                     started = STARTED_NONE;
2313                 } else {
2314                     /* Don't match patterns against characters in chatter */
2315                     i++;
2316                     continue;
2317                 }
2318             }
2319             if (started == STARTED_CHATTER) {
2320                 if (buf[i] != '\n') {
2321                     /* Don't match patterns against characters in chatter */
2322                     i++;
2323                     continue;
2324                 }
2325                 started = STARTED_NONE;
2326             }
2327
2328             /* Kludge to deal with rcmd protocol */
2329             if (firstTime && looking_at(buf, &i, "\001*")) {
2330                 DisplayFatalError(&buf[1], 0, 1);
2331                 continue;
2332             } else {
2333                 firstTime = FALSE;
2334             }
2335
2336             if (!loggedOn && looking_at(buf, &i, "chessclub.com")) {
2337                 ics_type = ICS_ICC;
2338                 ics_prefix = "/";
2339                 if (appData.debugMode)
2340                   fprintf(debugFP, "ics_type %d\n", ics_type);
2341                 continue;
2342             }
2343             if (!loggedOn && looking_at(buf, &i, "freechess.org")) {
2344                 ics_type = ICS_FICS;
2345                 ics_prefix = "$";
2346                 if (appData.debugMode)
2347                   fprintf(debugFP, "ics_type %d\n", ics_type);
2348                 continue;
2349             }
2350             if (!loggedOn && looking_at(buf, &i, "chess.net")) {
2351                 ics_type = ICS_CHESSNET;
2352                 ics_prefix = "/";
2353                 if (appData.debugMode)
2354                   fprintf(debugFP, "ics_type %d\n", ics_type);
2355                 continue;
2356             }
2357
2358             if (!loggedOn &&
2359                 (looking_at(buf, &i, "\"*\" is *a registered name") ||
2360                  looking_at(buf, &i, "Logging you in as \"*\"") ||
2361                  looking_at(buf, &i, "will be \"*\""))) {
2362               strcpy(ics_handle, star_match[0]);
2363               continue;
2364             }
2365
2366             if (loggedOn && !have_set_title && ics_handle[0] != NULLCHAR) {
2367               char buf[MSG_SIZ];
2368               snprintf(buf, sizeof(buf), "%s@%s", ics_handle, appData.icsHost);
2369               DisplayIcsInteractionTitle(buf);
2370               have_set_title = TRUE;
2371             }
2372
2373             /* skip finger notes */
2374             if (started == STARTED_NONE &&
2375                 ((buf[i] == ' ' && isdigit(buf[i+1])) ||
2376                  (buf[i] == '1' && buf[i+1] == '0')) &&
2377                 buf[i+2] == ':' && buf[i+3] == ' ') {
2378               started = STARTED_CHATTER;
2379               i += 3;
2380               continue;
2381             }
2382
2383             /* skip formula vars */
2384             if (started == STARTED_NONE &&
2385                 buf[i] == 'f' && isdigit(buf[i+1]) && buf[i+2] == ':') {
2386               started = STARTED_CHATTER;
2387               i += 3;
2388               continue;
2389             }
2390
2391             oldi = i;
2392             // [HGM] kibitz: try to recognize opponent engine-score kibitzes, to divert them to engine-output window
2393             if (appData.autoKibitz && started == STARTED_NONE &&
2394                 !appData.icsEngineAnalyze &&                     // [HGM] [DM] ICS analyze
2395                 (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack || gameMode == IcsObserving)) {
2396                 if(looking_at(buf, &i, "* kibitzes: ") &&
2397                    (StrStr(star_match[0], gameInfo.white) == star_match[0] ||
2398                     StrStr(star_match[0], gameInfo.black) == star_match[0]   )) { // kibitz of self or opponent
2399                         suppressKibitz = TRUE;
2400                         if((StrStr(star_match[0], gameInfo.white) == star_match[0]
2401                                 && (gameMode == IcsPlayingWhite)) ||
2402                            (StrStr(star_match[0], gameInfo.black) == star_match[0]
2403                                 && (gameMode == IcsPlayingBlack))   ) // opponent kibitz
2404                             started = STARTED_CHATTER; // own kibitz we simply discard
2405                         else {
2406                             started = STARTED_COMMENT; // make sure it will be collected in parse[]
2407                             parse_pos = 0; parse[0] = NULLCHAR;
2408                             savingComment = TRUE;
2409                             suppressKibitz = gameMode != IcsObserving ? 2 :
2410                                 (StrStr(star_match[0], gameInfo.white) == NULL) + 1;
2411                         }
2412                         continue;
2413                 } else
2414                 if(looking_at(buf, &i, "kibitzed to")) { // suppress the acknowledgements of our own autoKibitz
2415                     started = STARTED_CHATTER;
2416                     suppressKibitz = TRUE;
2417                 }
2418             } // [HGM] kibitz: end of patch
2419
2420 //if(appData.debugMode) fprintf(debugFP, "hunt for tell, buf = %s\n", buf+i);
2421
2422             // [HGM] chat: intercept tells by users for which we have an open chat window
2423             channel = -1;
2424             if(started == STARTED_NONE && (looking_at(buf, &i, "* tells you:") || looking_at(buf, &i, "* says:") ||
2425                                            looking_at(buf, &i, "* whispers:") ||
2426                                            looking_at(buf, &i, "*(*):") && (sscanf(star_match[1], "%d", &channel),1) ||
2427                                            looking_at(buf, &i, "*(*)(*):") && sscanf(star_match[2], "%d", &channel) == 1 )) {
2428                 int p;
2429                 sscanf(star_match[0], "%[^(]", talker+1); // strip (C) or (U) off ICS handle
2430                 chattingPartner = -1;
2431
2432                 if(channel >= 0) // channel broadcast; look if there is a chatbox for this channel
2433                 for(p=0; p<MAX_CHAT; p++) {
2434                     if(channel == atoi(chatPartner[p])) {
2435                     talker[0] = '['; strcat(talker, "]");
2436                     chattingPartner = p; break;
2437                     }
2438                 } else
2439                 if(buf[i-3] == 'r') // whisper; look if there is a WHISPER chatbox
2440                 for(p=0; p<MAX_CHAT; p++) {
2441                     if(!strcmp("WHISPER", chatPartner[p])) {
2442                         talker[0] = '['; strcat(talker, "]");
2443                         chattingPartner = p; break;
2444                     }
2445                 }
2446                 if(chattingPartner<0) // if not, look if there is a chatbox for this indivdual
2447                 for(p=0; p<MAX_CHAT; p++) if(!StrCaseCmp(talker+1, chatPartner[p])) {
2448                     talker[0] = 0;
2449                     chattingPartner = p; break;
2450                 }
2451                 if(chattingPartner<0) i = oldi; else {
2452                     started = STARTED_COMMENT;
2453                     parse_pos = 0; parse[0] = NULLCHAR;
2454                     savingComment = TRUE;
2455                     suppressKibitz = TRUE;
2456                 }
2457             } // [HGM] chat: end of patch
2458
2459             if (appData.zippyTalk || appData.zippyPlay) {
2460                 /* [DM] Backup address for color zippy lines */
2461                 backup = i;
2462 #if ZIPPY
2463        #ifdef WIN32
2464                if (loggedOn == TRUE)
2465                        if (ZippyControl(buf, &backup) || ZippyConverse(buf, &backup) ||
2466                           (appData.zippyPlay && ZippyMatch(buf, &backup)));
2467        #else
2468                 if (ZippyControl(buf, &i) ||
2469                     ZippyConverse(buf, &i) ||
2470                     (appData.zippyPlay && ZippyMatch(buf, &i))) {
2471                       loggedOn = TRUE;
2472                       if (!appData.colorize) continue;
2473                 }
2474        #endif
2475 #endif
2476             } // [DM] 'else { ' deleted
2477                 if (
2478                     /* Regular tells and says */
2479                     (tkind = 1, looking_at(buf, &i, "* tells you: ")) ||
2480                     looking_at(buf, &i, "* (your partner) tells you: ") ||
2481                     looking_at(buf, &i, "* says: ") ||
2482                     /* Don't color "message" or "messages" output */
2483                     (tkind = 5, looking_at(buf, &i, "*. * (*:*): ")) ||
2484                     looking_at(buf, &i, "*. * at *:*: ") ||
2485                     looking_at(buf, &i, "--* (*:*): ") ||
2486                     /* Message notifications (same color as tells) */
2487                     looking_at(buf, &i, "* has left a message ") ||
2488                     looking_at(buf, &i, "* just sent you a message:\n") ||
2489                     /* Whispers and kibitzes */
2490                     (tkind = 2, looking_at(buf, &i, "* whispers: ")) ||
2491                     looking_at(buf, &i, "* kibitzes: ") ||
2492                     /* Channel tells */
2493                     (tkind = 3, looking_at(buf, &i, "*(*: "))) {
2494
2495                   if (tkind == 1 && strchr(star_match[0], ':')) {
2496                       /* Avoid "tells you:" spoofs in channels */
2497                      tkind = 3;
2498                   }
2499                   if (star_match[0][0] == NULLCHAR ||
2500                       strchr(star_match[0], ' ') ||
2501                       (tkind == 3 && strchr(star_match[1], ' '))) {
2502                     /* Reject bogus matches */
2503                     i = oldi;
2504                   } else {
2505                     if (appData.colorize) {
2506                       if (oldi > next_out) {
2507                         SendToPlayer(&buf[next_out], oldi - next_out);
2508                         next_out = oldi;
2509                       }
2510                       switch (tkind) {
2511                       case 1:
2512                         Colorize(ColorTell, FALSE);
2513                         curColor = ColorTell;
2514                         break;
2515                       case 2:
2516                         Colorize(ColorKibitz, FALSE);
2517                         curColor = ColorKibitz;
2518                         break;
2519                       case 3:
2520                         p = strrchr(star_match[1], '(');
2521                         if (p == NULL) {
2522                           p = star_match[1];
2523                         } else {
2524                           p++;
2525                         }
2526                         if (atoi(p) == 1) {
2527                           Colorize(ColorChannel1, FALSE);
2528                           curColor = ColorChannel1;
2529                         } else {
2530                           Colorize(ColorChannel, FALSE);
2531                           curColor = ColorChannel;
2532                         }
2533                         break;
2534                       case 5:
2535                         curColor = ColorNormal;
2536                         break;
2537                       }
2538                     }
2539                     if (started == STARTED_NONE && appData.autoComment &&
2540                         (gameMode == IcsObserving ||
2541                          gameMode == IcsPlayingWhite ||
2542                          gameMode == IcsPlayingBlack)) {
2543                       parse_pos = i - oldi;
2544                       memcpy(parse, &buf[oldi], parse_pos);
2545                       parse[parse_pos] = NULLCHAR;
2546                       started = STARTED_COMMENT;
2547                       savingComment = TRUE;
2548                     } else {
2549                       started = STARTED_CHATTER;
2550                       savingComment = FALSE;
2551                     }
2552                     loggedOn = TRUE;
2553                     continue;
2554                   }
2555                 }
2556
2557                 if (looking_at(buf, &i, "* s-shouts: ") ||
2558                     looking_at(buf, &i, "* c-shouts: ")) {
2559                     if (appData.colorize) {
2560                         if (oldi > next_out) {
2561                             SendToPlayer(&buf[next_out], oldi - next_out);
2562                             next_out = oldi;
2563                         }
2564                         Colorize(ColorSShout, FALSE);
2565                         curColor = ColorSShout;
2566                     }
2567                     loggedOn = TRUE;
2568                     started = STARTED_CHATTER;
2569                     continue;
2570                 }
2571
2572                 if (looking_at(buf, &i, "--->")) {
2573                     loggedOn = TRUE;
2574                     continue;
2575                 }
2576
2577                 if (looking_at(buf, &i, "* shouts: ") ||
2578                     looking_at(buf, &i, "--> ")) {
2579                     if (appData.colorize) {
2580                         if (oldi > next_out) {
2581                             SendToPlayer(&buf[next_out], oldi - next_out);
2582                             next_out = oldi;
2583                         }
2584                         Colorize(ColorShout, FALSE);
2585                         curColor = ColorShout;
2586                     }
2587                     loggedOn = TRUE;
2588                     started = STARTED_CHATTER;
2589                     continue;
2590                 }
2591
2592                 if (looking_at( buf, &i, "Challenge:")) {
2593                     if (appData.colorize) {
2594                         if (oldi > next_out) {
2595                             SendToPlayer(&buf[next_out], oldi - next_out);
2596                             next_out = oldi;
2597                         }
2598                         Colorize(ColorChallenge, FALSE);
2599                         curColor = ColorChallenge;
2600                     }
2601                     loggedOn = TRUE;
2602                     continue;
2603                 }
2604
2605                 if (looking_at(buf, &i, "* offers you") ||
2606                     looking_at(buf, &i, "* offers to be") ||
2607                     looking_at(buf, &i, "* would like to") ||
2608                     looking_at(buf, &i, "* requests to") ||
2609                     looking_at(buf, &i, "Your opponent offers") ||
2610                     looking_at(buf, &i, "Your opponent requests")) {
2611
2612                     if (appData.colorize) {
2613                         if (oldi > next_out) {
2614                             SendToPlayer(&buf[next_out], oldi - next_out);
2615                             next_out = oldi;
2616                         }
2617                         Colorize(ColorRequest, FALSE);
2618                         curColor = ColorRequest;
2619                     }
2620                     continue;
2621                 }
2622
2623                 if (looking_at(buf, &i, "* (*) seeking")) {
2624                     if (appData.colorize) {
2625                         if (oldi > next_out) {
2626                             SendToPlayer(&buf[next_out], oldi - next_out);
2627                             next_out = oldi;
2628                         }
2629                         Colorize(ColorSeek, FALSE);
2630                         curColor = ColorSeek;
2631                     }
2632                     continue;
2633             }
2634
2635             if (looking_at(buf, &i, "\\   ")) {
2636                 if (prevColor != ColorNormal) {
2637                     if (oldi > next_out) {
2638                         SendToPlayer(&buf[next_out], oldi - next_out);
2639                         next_out = oldi;
2640                     }
2641                     Colorize(prevColor, TRUE);
2642                     curColor = prevColor;
2643                 }
2644                 if (savingComment) {
2645                     parse_pos = i - oldi;
2646                     memcpy(parse, &buf[oldi], parse_pos);
2647                     parse[parse_pos] = NULLCHAR;
2648                     started = STARTED_COMMENT;
2649                 } else {
2650                     started = STARTED_CHATTER;
2651                 }
2652                 continue;
2653             }
2654
2655             if (looking_at(buf, &i, "Black Strength :") ||
2656                 looking_at(buf, &i, "<<< style 10 board >>>") ||
2657                 looking_at(buf, &i, "<10>") ||
2658                 looking_at(buf, &i, "#@#")) {
2659                 /* Wrong board style */
2660                 loggedOn = TRUE;
2661                 SendToICS(ics_prefix);
2662                 SendToICS("set style 12\n");
2663                 SendToICS(ics_prefix);
2664                 SendToICS("refresh\n");
2665                 continue;
2666             }
2667
2668             if (!have_sent_ICS_logon && looking_at(buf, &i, "login:")) {
2669                 ICSInitScript();
2670                 have_sent_ICS_logon = 1;
2671                 continue;
2672             }
2673
2674             if (ics_getting_history != H_GETTING_MOVES /*smpos kludge*/ &&
2675                 (looking_at(buf, &i, "\n<12> ") ||
2676                  looking_at(buf, &i, "<12> "))) {
2677                 loggedOn = TRUE;
2678                 if (oldi > next_out) {
2679                     SendToPlayer(&buf[next_out], oldi - next_out);
2680                 }
2681                 next_out = i;
2682                 started = STARTED_BOARD;
2683                 parse_pos = 0;
2684                 continue;
2685             }
2686
2687             if ((started == STARTED_NONE && looking_at(buf, &i, "\n<b1> ")) ||
2688                 looking_at(buf, &i, "<b1> ")) {
2689                 if (oldi > next_out) {
2690                     SendToPlayer(&buf[next_out], oldi - next_out);
2691                 }
2692                 next_out = i;
2693                 started = STARTED_HOLDINGS;
2694                 parse_pos = 0;
2695                 continue;
2696             }
2697
2698             if (looking_at(buf, &i, "* *vs. * *--- *")) {
2699                 loggedOn = TRUE;
2700                 /* Header for a move list -- first line */
2701
2702                 switch (ics_getting_history) {
2703                   case H_FALSE:
2704                     switch (gameMode) {
2705                       case IcsIdle:
2706                       case BeginningOfGame:
2707                         /* User typed "moves" or "oldmoves" while we
2708                            were idle.  Pretend we asked for these
2709                            moves and soak them up so user can step
2710                            through them and/or save them.
2711                            */
2712                         Reset(FALSE, TRUE);
2713                         gameMode = IcsObserving;
2714                         ModeHighlight();
2715                         ics_gamenum = -1;
2716                         ics_getting_history = H_GOT_UNREQ_HEADER;
2717                         break;
2718                       case EditGame: /*?*/
2719                       case EditPosition: /*?*/
2720                         /* Should above feature work in these modes too? */
2721                         /* For now it doesn't */
2722                         ics_getting_history = H_GOT_UNWANTED_HEADER;
2723                         break;
2724                       default:
2725                         ics_getting_history = H_GOT_UNWANTED_HEADER;
2726                         break;
2727                     }
2728                     break;
2729                   case H_REQUESTED:
2730                     /* Is this the right one? */
2731                     if (gameInfo.white && gameInfo.black &&
2732                         strcmp(gameInfo.white, star_match[0]) == 0 &&
2733                         strcmp(gameInfo.black, star_match[2]) == 0) {
2734                         /* All is well */
2735                         ics_getting_history = H_GOT_REQ_HEADER;
2736                     }
2737                     break;
2738                   case H_GOT_REQ_HEADER:
2739                   case H_GOT_UNREQ_HEADER:
2740                   case H_GOT_UNWANTED_HEADER:
2741                   case H_GETTING_MOVES:
2742                     /* Should not happen */
2743                     DisplayError(_("Error gathering move list: two headers"), 0);
2744                     ics_getting_history = H_FALSE;
2745                     break;
2746                 }
2747
2748                 /* Save player ratings into gameInfo if needed */
2749                 if ((ics_getting_history == H_GOT_REQ_HEADER ||
2750                      ics_getting_history == H_GOT_UNREQ_HEADER) &&
2751                     (gameInfo.whiteRating == -1 ||
2752                      gameInfo.blackRating == -1)) {
2753
2754                     gameInfo.whiteRating = string_to_rating(star_match[1]);
2755                     gameInfo.blackRating = string_to_rating(star_match[3]);
2756                     if (appData.debugMode)
2757                       fprintf(debugFP, _("Ratings from header: W %d, B %d\n"),
2758                               gameInfo.whiteRating, gameInfo.blackRating);
2759                 }
2760                 continue;
2761             }
2762
2763             if (looking_at(buf, &i,
2764               "* * match, initial time: * minute*, increment: * second")) {
2765                 /* Header for a move list -- second line */
2766                 /* Initial board will follow if this is a wild game */
2767                 if (gameInfo.event != NULL) free(gameInfo.event);
2768                 sprintf(str, "ICS %s %s match", star_match[0], star_match[1]);
2769                 gameInfo.event = StrSave(str);
2770                 /* [HGM] we switched variant. Translate boards if needed. */
2771                 VariantSwitch(boards[currentMove], StringToVariant(gameInfo.event));
2772                 continue;
2773             }
2774
2775             if (looking_at(buf, &i, "Move  ")) {
2776                 /* Beginning of a move list */
2777                 switch (ics_getting_history) {
2778                   case H_FALSE:
2779                     /* Normally should not happen */
2780                     /* Maybe user hit reset while we were parsing */
2781                     break;
2782                   case H_REQUESTED:
2783                     /* Happens if we are ignoring a move list that is not
2784                      * the one we just requested.  Common if the user
2785                      * tries to observe two games without turning off
2786                      * getMoveList */
2787                     break;
2788                   case H_GETTING_MOVES:
2789                     /* Should not happen */
2790                     DisplayError(_("Error gathering move list: nested"), 0);
2791                     ics_getting_history = H_FALSE;
2792                     break;
2793                   case H_GOT_REQ_HEADER:
2794                     ics_getting_history = H_GETTING_MOVES;
2795                     started = STARTED_MOVES;
2796                     parse_pos = 0;
2797                     if (oldi > next_out) {
2798                         SendToPlayer(&buf[next_out], oldi - next_out);
2799                     }
2800                     break;
2801                   case H_GOT_UNREQ_HEADER:
2802                     ics_getting_history = H_GETTING_MOVES;
2803                     started = STARTED_MOVES_NOHIDE;
2804                     parse_pos = 0;
2805                     break;
2806                   case H_GOT_UNWANTED_HEADER:
2807                     ics_getting_history = H_FALSE;
2808                     break;
2809                 }
2810                 continue;
2811             }
2812
2813             if (looking_at(buf, &i, "% ") ||
2814                 ((started == STARTED_MOVES || started == STARTED_MOVES_NOHIDE)
2815                  && looking_at(buf, &i, "}*"))) { char *bookHit = NULL; // [HGM] book
2816                 savingComment = FALSE;
2817                 switch (started) {
2818                   case STARTED_MOVES:
2819                   case STARTED_MOVES_NOHIDE:
2820                     memcpy(&parse[parse_pos], &buf[oldi], i - oldi);
2821                     parse[parse_pos + i - oldi] = NULLCHAR;
2822                     ParseGameHistory(parse);
2823 #if ZIPPY
2824                     if (appData.zippyPlay && first.initDone) {
2825                         FeedMovesToProgram(&first, forwardMostMove);
2826                         if (gameMode == IcsPlayingWhite) {
2827                             if (WhiteOnMove(forwardMostMove)) {
2828                                 if (first.sendTime) {
2829                                   if (first.useColors) {
2830                                     SendToProgram("black\n", &first);
2831                                   }
2832                                   SendTimeRemaining(&first, TRUE);
2833                                 }
2834 #if 0
2835                                 if (first.useColors) {
2836                                   SendToProgram("white\ngo\n", &first);
2837                                 } else {
2838                                   SendToProgram("go\n", &first);
2839                                 }
2840 #else
2841                                 if (first.useColors) {
2842                                   SendToProgram("white\n", &first); // [HGM] book: made sending of "go\n" book dependent
2843                                 }
2844                                 bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: probe book for initial pos
2845 #endif
2846                                 first.maybeThinking = TRUE;
2847                             } else {
2848                                 if (first.usePlayother) {
2849                                   if (first.sendTime) {
2850                                     SendTimeRemaining(&first, TRUE);
2851                                   }
2852                                   SendToProgram("playother\n", &first);
2853                                   firstMove = FALSE;
2854                                 } else {
2855                                   firstMove = TRUE;
2856                                 }
2857                             }
2858                         } else if (gameMode == IcsPlayingBlack) {
2859                             if (!WhiteOnMove(forwardMostMove)) {
2860                                 if (first.sendTime) {
2861                                   if (first.useColors) {
2862                                     SendToProgram("white\n", &first);
2863                                   }
2864                                   SendTimeRemaining(&first, FALSE);
2865                                 }
2866 #if 0
2867                                 if (first.useColors) {
2868                                   SendToProgram("black\ngo\n", &first);
2869                                 } else {
2870                                   SendToProgram("go\n", &first);
2871                                 }
2872 #else
2873                                 if (first.useColors) {
2874                                   SendToProgram("black\n", &first);
2875                                 }
2876                                 bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE);
2877 #endif
2878                                 first.maybeThinking = TRUE;
2879                             } else {
2880                                 if (first.usePlayother) {
2881                                   if (first.sendTime) {
2882                                     SendTimeRemaining(&first, FALSE);
2883                                   }
2884                                   SendToProgram("playother\n", &first);
2885                                   firstMove = FALSE;
2886                                 } else {
2887                                   firstMove = TRUE;
2888                                 }
2889                             }
2890                         }
2891                     }
2892 #endif
2893                     if (gameMode == IcsObserving && ics_gamenum == -1) {
2894                         /* Moves came from oldmoves or moves command
2895                            while we weren't doing anything else.
2896                            */
2897                         currentMove = forwardMostMove;
2898                         ClearHighlights();/*!!could figure this out*/
2899                         flipView = appData.flipView;
2900                         DrawPosition(FALSE, boards[currentMove]);
2901                         DisplayBothClocks();
2902                         sprintf(str, "%s vs. %s",
2903                                 gameInfo.white, gameInfo.black);
2904                         DisplayTitle(str);
2905                         gameMode = IcsIdle;
2906                     } else {
2907                         /* Moves were history of an active game */
2908                         if (gameInfo.resultDetails != NULL) {
2909                             free(gameInfo.resultDetails);
2910                             gameInfo.resultDetails = NULL;
2911                         }
2912                     }
2913                     HistorySet(parseList, backwardMostMove,
2914                                forwardMostMove, currentMove-1);
2915                     DisplayMove(currentMove - 1);
2916                     if (started == STARTED_MOVES) next_out = i;
2917                     started = STARTED_NONE;
2918                     ics_getting_history = H_FALSE;
2919                     break;
2920
2921                   case STARTED_OBSERVE:
2922                     started = STARTED_NONE;
2923                     SendToICS(ics_prefix);
2924                     SendToICS("refresh\n");
2925                     break;
2926
2927                   default:
2928                     break;
2929                 }
2930                 if(bookHit) { // [HGM] book: simulate book reply
2931                     static char bookMove[MSG_SIZ]; // a bit generous?
2932
2933                     programStats.nodes = programStats.depth = programStats.time =
2934                     programStats.score = programStats.got_only_move = 0;
2935                     sprintf(programStats.movelist, "%s (xbook)", bookHit);
2936
2937                     strcpy(bookMove, "move ");
2938                     strcat(bookMove, bookHit);
2939                     HandleMachineMove(bookMove, &first);
2940                 }
2941                 continue;
2942             }
2943
2944             if ((started == STARTED_MOVES || started == STARTED_BOARD ||
2945                  started == STARTED_HOLDINGS ||
2946                  started == STARTED_MOVES_NOHIDE) && i >= leftover_len) {
2947                 /* Accumulate characters in move list or board */
2948                 parse[parse_pos++] = buf[i];
2949             }
2950
2951             /* Start of game messages.  Mostly we detect start of game
2952                when the first board image arrives.  On some versions
2953                of the ICS, though, we need to do a "refresh" after starting
2954                to observe in order to get the current board right away. */
2955             if (looking_at(buf, &i, "Adding game * to observation list")) {
2956                 started = STARTED_OBSERVE;
2957                 continue;
2958             }
2959
2960             /* Handle auto-observe */
2961             if (appData.autoObserve &&
2962                 (gameMode == IcsIdle || gameMode == BeginningOfGame) &&
2963                 looking_at(buf, &i, "Game notification: * (*) vs. * (*)")) {
2964                 char *player;
2965                 /* Choose the player that was highlighted, if any. */
2966                 if (star_match[0][0] == '\033' ||
2967                     star_match[1][0] != '\033') {
2968                     player = star_match[0];
2969                 } else {
2970                     player = star_match[2];
2971                 }
2972                 sprintf(str, "%sobserve %s\n",
2973                         ics_prefix, StripHighlightAndTitle(player));
2974                 SendToICS(str);
2975
2976                 /* Save ratings from notify string */
2977                 strcpy(player1Name, star_match[0]);
2978                 player1Rating = string_to_rating(star_match[1]);
2979                 strcpy(player2Name, star_match[2]);
2980                 player2Rating = string_to_rating(star_match[3]);
2981
2982                 if (appData.debugMode)
2983                   fprintf(debugFP,
2984                           "Ratings from 'Game notification:' %s %d, %s %d\n",
2985                           player1Name, player1Rating,
2986                           player2Name, player2Rating);
2987
2988                 continue;
2989             }
2990
2991             /* Deal with automatic examine mode after a game,
2992                and with IcsObserving -> IcsExamining transition */
2993             if (looking_at(buf, &i, "Entering examine mode for game *") ||
2994                 looking_at(buf, &i, "has made you an examiner of game *")) {
2995
2996                 int gamenum = atoi(star_match[0]);
2997                 if ((gameMode == IcsIdle || gameMode == IcsObserving) &&
2998                     gamenum == ics_gamenum) {
2999                     /* We were already playing or observing this game;
3000                        no need to refetch history */
3001                     gameMode = IcsExamining;
3002                     if (pausing) {
3003                         pauseExamForwardMostMove = forwardMostMove;
3004                     } else if (currentMove < forwardMostMove) {
3005                         ForwardInner(forwardMostMove);
3006                     }
3007                 } else {
3008                     /* I don't think this case really can happen */
3009                     SendToICS(ics_prefix);
3010                     SendToICS("refresh\n");
3011                 }
3012                 continue;
3013             }
3014
3015             /* Error messages */
3016 //          if (ics_user_moved) {
3017             if (1) { // [HGM] old way ignored error after move type in; ics_user_moved is not set then!
3018                 if (looking_at(buf, &i, "Illegal move") ||
3019                     looking_at(buf, &i, "Not a legal move") ||
3020                     looking_at(buf, &i, "Your king is in check") ||
3021                     looking_at(buf, &i, "It isn't your turn") ||
3022                     looking_at(buf, &i, "It is not your move")) {
3023                     /* Illegal move */
3024                     if (ics_user_moved && forwardMostMove > backwardMostMove) { // only backup if we already moved
3025                         currentMove = --forwardMostMove;
3026                         DisplayMove(currentMove - 1); /* before DMError */
3027                         DrawPosition(FALSE, boards[currentMove]);
3028                         SwitchClocks();
3029                         DisplayBothClocks();
3030                     }
3031                     DisplayMoveError(_("Illegal move (rejected by ICS)")); // [HGM] but always relay error msg
3032                     ics_user_moved = 0;
3033                     continue;
3034                 }
3035             }
3036
3037             if (looking_at(buf, &i, "still have time") ||
3038                 looking_at(buf, &i, "not out of time") ||
3039                 looking_at(buf, &i, "either player is out of time") ||
3040                 looking_at(buf, &i, "has timeseal; checking")) {
3041                 /* We must have called his flag a little too soon */
3042                 whiteFlag = blackFlag = FALSE;
3043                 continue;
3044             }
3045
3046             if (looking_at(buf, &i, "added * seconds to") ||
3047                 looking_at(buf, &i, "seconds were added to")) {
3048                 /* Update the clocks */
3049                 SendToICS(ics_prefix);
3050                 SendToICS("refresh\n");
3051                 continue;
3052             }
3053
3054             if (!ics_clock_paused && looking_at(buf, &i, "clock paused")) {
3055                 ics_clock_paused = TRUE;
3056                 StopClocks();
3057                 continue;
3058             }
3059
3060             if (ics_clock_paused && looking_at(buf, &i, "clock resumed")) {
3061                 ics_clock_paused = FALSE;
3062                 StartClocks();
3063                 continue;
3064             }
3065
3066             /* Grab player ratings from the Creating: message.
3067                Note we have to check for the special case when
3068                the ICS inserts things like [white] or [black]. */
3069             if (looking_at(buf, &i, "Creating: * (*)* * (*)") ||
3070                 looking_at(buf, &i, "Creating: * (*) [*] * (*)")) {
3071                 /* star_matches:
3072                    0    player 1 name (not necessarily white)
3073                    1    player 1 rating
3074                    2    empty, white, or black (IGNORED)
3075                    3    player 2 name (not necessarily black)
3076                    4    player 2 rating
3077
3078                    The names/ratings are sorted out when the game
3079                    actually starts (below).
3080                 */
3081                 strcpy(player1Name, StripHighlightAndTitle(star_match[0]));
3082                 player1Rating = string_to_rating(star_match[1]);
3083                 strcpy(player2Name, StripHighlightAndTitle(star_match[3]));
3084                 player2Rating = string_to_rating(star_match[4]);
3085
3086                 if (appData.debugMode)
3087                   fprintf(debugFP,
3088                           "Ratings from 'Creating:' %s %d, %s %d\n",
3089                           player1Name, player1Rating,
3090                           player2Name, player2Rating);
3091
3092                 continue;
3093             }
3094
3095             /* Improved generic start/end-of-game messages */
3096             if ((tkind=0, looking_at(buf, &i, "{Game * (* vs. *) *}*")) ||
3097                 (tkind=1, looking_at(buf, &i, "{Game * (*(*) vs. *(*)) *}*"))){
3098                 /* If tkind == 0: */
3099                 /* star_match[0] is the game number */
3100                 /*           [1] is the white player's name */
3101                 /*           [2] is the black player's name */
3102                 /* For end-of-game: */
3103                 /*           [3] is the reason for the game end */
3104                 /*           [4] is a PGN end game-token, preceded by " " */
3105                 /* For start-of-game: */
3106                 /*           [3] begins with "Creating" or "Continuing" */
3107                 /*           [4] is " *" or empty (don't care). */
3108                 int gamenum = atoi(star_match[0]);
3109                 char *whitename, *blackname, *why, *endtoken;
3110                 ChessMove endtype = (ChessMove) 0;
3111
3112                 if (tkind == 0) {
3113                   whitename = star_match[1];
3114                   blackname = star_match[2];
3115                   why = star_match[3];
3116                   endtoken = star_match[4];
3117                 } else {
3118                   whitename = star_match[1];
3119                   blackname = star_match[3];
3120                   why = star_match[5];
3121                   endtoken = star_match[6];
3122                 }
3123
3124                 /* Game start messages */
3125                 if (strncmp(why, "Creating ", 9) == 0 ||
3126                     strncmp(why, "Continuing ", 11) == 0) {
3127                     gs_gamenum = gamenum;
3128                     strcpy(gs_kind, strchr(why, ' ') + 1);
3129 #if ZIPPY
3130                     if (appData.zippyPlay) {
3131                         ZippyGameStart(whitename, blackname);
3132                     }
3133 #endif /*ZIPPY*/
3134                     continue;
3135                 }
3136
3137                 /* Game end messages */
3138                 if (gameMode == IcsIdle || gameMode == BeginningOfGame ||
3139                     ics_gamenum != gamenum) {
3140                     continue;
3141                 }
3142                 while (endtoken[0] == ' ') endtoken++;
3143                 switch (endtoken[0]) {
3144                   case '*':
3145                   default:
3146                     endtype = GameUnfinished;
3147                     break;
3148                   case '0':
3149                     endtype = BlackWins;
3150                     break;
3151                   case '1':
3152                     if (endtoken[1] == '/')
3153                       endtype = GameIsDrawn;
3154                     else
3155                       endtype = WhiteWins;
3156                     break;
3157                 }
3158                 GameEnds(endtype, why, GE_ICS);
3159 #if ZIPPY
3160                 if (appData.zippyPlay && first.initDone) {
3161                     ZippyGameEnd(endtype, why);
3162                     if (first.pr == NULL) {
3163                       /* Start the next process early so that we'll
3164                          be ready for the next challenge */
3165                       StartChessProgram(&first);
3166                     }
3167                     /* Send "new" early, in case this command takes
3168                        a long time to finish, so that we'll be ready
3169                        for the next challenge. */
3170                     gameInfo.variant = VariantNormal; // [HGM] variantswitch: suppress sending of 'variant'
3171                     Reset(TRUE, TRUE);
3172                 }
3173 #endif /*ZIPPY*/
3174                 continue;
3175             }
3176
3177             if (looking_at(buf, &i, "Removing game * from observation") ||
3178                 looking_at(buf, &i, "no longer observing game *") ||
3179                 looking_at(buf, &i, "Game * (*) has no examiners")) {
3180                 if (gameMode == IcsObserving &&
3181                     atoi(star_match[0]) == ics_gamenum)
3182                   {
3183                       /* icsEngineAnalyze */
3184                       if (appData.icsEngineAnalyze) {
3185                             ExitAnalyzeMode();
3186                             ModeHighlight();
3187                       }
3188                       StopClocks();
3189                       gameMode = IcsIdle;
3190                       ics_gamenum = -1;
3191                       ics_user_moved = FALSE;
3192                   }
3193                 continue;
3194             }
3195
3196             if (looking_at(buf, &i, "no longer examining game *")) {
3197                 if (gameMode == IcsExamining &&
3198                     atoi(star_match[0]) == ics_gamenum)
3199                   {
3200                       gameMode = IcsIdle;
3201                       ics_gamenum = -1;
3202                       ics_user_moved = FALSE;
3203                   }
3204                 continue;
3205             }
3206
3207             /* Advance leftover_start past any newlines we find,
3208                so only partial lines can get reparsed */
3209             if (looking_at(buf, &i, "\n")) {
3210                 prevColor = curColor;
3211                 if (curColor != ColorNormal) {
3212                     if (oldi > next_out) {
3213                         SendToPlayer(&buf[next_out], oldi - next_out);
3214                         next_out = oldi;
3215                     }
3216                     Colorize(ColorNormal, FALSE);
3217                     curColor = ColorNormal;
3218                 }
3219                 if (started == STARTED_BOARD) {
3220                     started = STARTED_NONE;
3221                     parse[parse_pos] = NULLCHAR;
3222                     ParseBoard12(parse);
3223                     ics_user_moved = 0;
3224
3225                     /* Send premove here */
3226                     if (appData.premove) {
3227                       char str[MSG_SIZ];
3228                       if (currentMove == 0 &&
3229                           gameMode == IcsPlayingWhite &&
3230                           appData.premoveWhite) {
3231                         sprintf(str, "%s%s\n", ics_prefix,
3232                                 appData.premoveWhiteText);
3233                         if (appData.debugMode)
3234                           fprintf(debugFP, "Sending premove:\n");
3235                         SendToICS(str);
3236                       } else if (currentMove == 1 &&
3237                                  gameMode == IcsPlayingBlack &&
3238                                  appData.premoveBlack) {
3239                         sprintf(str, "%s%s\n", ics_prefix,
3240                                 appData.premoveBlackText);
3241                         if (appData.debugMode)
3242                           fprintf(debugFP, "Sending premove:\n");
3243                         SendToICS(str);
3244                       } else if (gotPremove) {
3245                         gotPremove = 0;
3246                         ClearPremoveHighlights();
3247                         if (appData.debugMode)
3248                           fprintf(debugFP, "Sending premove:\n");
3249                           UserMoveEvent(premoveFromX, premoveFromY,
3250                                         premoveToX, premoveToY,
3251                                         premovePromoChar);
3252                       }
3253                     }
3254
3255                     /* Usually suppress following prompt */
3256                     if (!(forwardMostMove == 0 && gameMode == IcsExamining)) {
3257                         if (looking_at(buf, &i, "*% ")) {
3258                             savingComment = FALSE;
3259                         }
3260                     }
3261                     next_out = i;
3262                 } else if (started == STARTED_HOLDINGS) {
3263                     int gamenum;
3264                     char new_piece[MSG_SIZ];
3265                     started = STARTED_NONE;
3266                     parse[parse_pos] = NULLCHAR;
3267                     if (appData.debugMode)
3268                       fprintf(debugFP, "Parsing holdings: %s, currentMove = %d\n",
3269                                                         parse, currentMove);
3270                     if (sscanf(parse, " game %d", &gamenum) == 1 &&
3271                         gamenum == ics_gamenum) {
3272                         if (gameInfo.variant == VariantNormal) {
3273                           /* [HGM] We seem to switch variant during a game!
3274                            * Presumably no holdings were displayed, so we have
3275                            * to move the position two files to the right to
3276                            * create room for them!
3277                            */
3278                           VariantSwitch(boards[currentMove], VariantCrazyhouse); /* temp guess */
3279                           /* Get a move list just to see the header, which
3280                              will tell us whether this is really bug or zh */
3281                           if (ics_getting_history == H_FALSE) {
3282                             ics_getting_history = H_REQUESTED;
3283                             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3284                             SendToICS(str);
3285                           }
3286                         }
3287                         new_piece[0] = NULLCHAR;
3288                         sscanf(parse, "game %d white [%s black [%s <- %s",
3289                                &gamenum, white_holding, black_holding,
3290                                new_piece);
3291                         white_holding[strlen(white_holding)-1] = NULLCHAR;
3292                         black_holding[strlen(black_holding)-1] = NULLCHAR;
3293                         /* [HGM] copy holdings to board holdings area */
3294                         CopyHoldings(boards[currentMove], white_holding, WhitePawn);
3295                         CopyHoldings(boards[currentMove], black_holding, BlackPawn);
3296 #if ZIPPY
3297                         if (appData.zippyPlay && first.initDone) {
3298                             ZippyHoldings(white_holding, black_holding,
3299                                           new_piece);
3300                         }
3301 #endif /*ZIPPY*/
3302                         if (tinyLayout || smallLayout) {
3303                             char wh[16], bh[16];
3304                             PackHolding(wh, white_holding);
3305                             PackHolding(bh, black_holding);
3306                             sprintf(str, "[%s-%s] %s-%s", wh, bh,
3307                                     gameInfo.white, gameInfo.black);
3308                         } else {
3309                             sprintf(str, "%s [%s] vs. %s [%s]",
3310                                     gameInfo.white, white_holding,
3311                                     gameInfo.black, black_holding);
3312                         }
3313
3314                         DrawPosition(FALSE, boards[currentMove]);
3315                         DisplayTitle(str);
3316                     }
3317                     /* Suppress following prompt */
3318                     if (looking_at(buf, &i, "*% ")) {
3319                         savingComment = FALSE;
3320                     }
3321                     next_out = i;
3322                 }
3323                 continue;
3324             }
3325
3326             i++;                /* skip unparsed character and loop back */
3327         }
3328
3329         if (started != STARTED_MOVES && started != STARTED_BOARD && !suppressKibitz && // [HGM] kibitz suppress printing in ICS interaction window
3330             started != STARTED_HOLDINGS && i > next_out) {
3331             SendToPlayer(&buf[next_out], i - next_out);
3332             next_out = i;
3333         }
3334         suppressKibitz = FALSE; // [HGM] kibitz: has done its duty in if-statement above
3335
3336         leftover_len = buf_len - leftover_start;
3337         /* if buffer ends with something we couldn't parse,
3338            reparse it after appending the next read */
3339
3340     } else if (count == 0) {
3341         RemoveInputSource(isr);
3342         DisplayFatalError(_("Connection closed by ICS"), 0, 0);
3343     } else {
3344         DisplayFatalError(_("Error reading from ICS"), error, 1);
3345     }
3346 }
3347
3348
3349 /* Board style 12 looks like this:
3350
3351    <12> r-b---k- pp----pp ---bP--- ---p---- q------- ------P- P--Q--BP -----R-K W -1 0 0 0 0 0 0 paf MaxII 0 2 12 21 25 234 174 24 Q/d7-a4 (0:06) Qxa4 0 0
3352
3353  * The "<12> " is stripped before it gets to this routine.  The two
3354  * trailing 0's (flip state and clock ticking) are later addition, and
3355  * some chess servers may not have them, or may have only the first.
3356  * Additional trailing fields may be added in the future.
3357  */
3358
3359 #define PATTERN "%c%d%d%d%d%d%d%d%s%s%d%d%d%d%d%d%d%d%s%s%s%d%d"
3360
3361 #define RELATION_OBSERVING_PLAYED    0
3362 #define RELATION_OBSERVING_STATIC   -2   /* examined, oldmoves, or smoves */
3363 #define RELATION_PLAYING_MYMOVE      1
3364 #define RELATION_PLAYING_NOTMYMOVE  -1
3365 #define RELATION_EXAMINING           2
3366 #define RELATION_ISOLATED_BOARD     -3
3367 #define RELATION_STARTING_POSITION  -4   /* FICS only */
3368
3369 void
3370 ParseBoard12(string)
3371      char *string;
3372 {
3373     GameMode newGameMode;
3374     int gamenum, newGame, newMove, relation, basetime, increment, ics_flip = 0, i;
3375     int j, k, n, moveNum, white_stren, black_stren, white_time, black_time, takeback;
3376     int double_push, castle_ws, castle_wl, castle_bs, castle_bl, irrev_count;
3377     char to_play, board_chars[200];
3378     char move_str[500], str[500], elapsed_time[500];
3379     char black[32], white[32];
3380     Board board;
3381     int prevMove = currentMove;
3382     int ticking = 2;
3383     ChessMove moveType;
3384     int fromX, fromY, toX, toY;
3385     char promoChar;
3386     int ranks=1, files=0; /* [HGM] ICS80: allow variable board size */
3387     char *bookHit = NULL; // [HGM] book
3388
3389     fromX = fromY = toX = toY = -1;
3390
3391     newGame = FALSE;
3392
3393     if (appData.debugMode)
3394       fprintf(debugFP, _("Parsing board: %s\n"), string);
3395
3396     move_str[0] = NULLCHAR;
3397     elapsed_time[0] = NULLCHAR;
3398     {   /* [HGM] figure out how many ranks and files the board has, for ICS extension used by Capablanca server */
3399         int  i = 0, j;
3400         while(i < 199 && (string[i] != ' ' || string[i+2] != ' ')) {
3401             if(string[i] == ' ') { ranks++; files = 0; }
3402             else files++;
3403             i++;
3404         }
3405         for(j = 0; j <i; j++) board_chars[j] = string[j];
3406         board_chars[i] = '\0';
3407         string += i + 1;
3408     }
3409     n = sscanf(string, PATTERN, &to_play, &double_push,
3410                &castle_ws, &castle_wl, &castle_bs, &castle_bl, &irrev_count,
3411                &gamenum, white, black, &relation, &basetime, &increment,
3412                &white_stren, &black_stren, &white_time, &black_time,
3413                &moveNum, str, elapsed_time, move_str, &ics_flip,
3414                &ticking);
3415
3416     if (n < 21) {
3417         snprintf(str, sizeof(str), _("Failed to parse board string:\n\"%s\""), string);
3418         DisplayError(str, 0);
3419         return;
3420     }
3421
3422     /* Convert the move number to internal form */
3423     moveNum = (moveNum - 1) * 2;
3424     if (to_play == 'B') moveNum++;
3425     if (moveNum >= MAX_MOVES) {
3426       DisplayFatalError(_("Game too long; increase MAX_MOVES and recompile"),
3427                         0, 1);
3428       return;
3429     }
3430
3431     switch (relation) {
3432       case RELATION_OBSERVING_PLAYED:
3433       case RELATION_OBSERVING_STATIC:
3434         if (gamenum == -1) {
3435             /* Old ICC buglet */
3436             relation = RELATION_OBSERVING_STATIC;
3437         }
3438         newGameMode = IcsObserving;
3439         break;
3440       case RELATION_PLAYING_MYMOVE:
3441       case RELATION_PLAYING_NOTMYMOVE:
3442         newGameMode =
3443           ((relation == RELATION_PLAYING_MYMOVE) == (to_play == 'W')) ?
3444             IcsPlayingWhite : IcsPlayingBlack;
3445         break;
3446       case RELATION_EXAMINING:
3447         newGameMode = IcsExamining;
3448         break;
3449       case RELATION_ISOLATED_BOARD:
3450       default:
3451         /* Just display this board.  If user was doing something else,
3452            we will forget about it until the next board comes. */
3453         newGameMode = IcsIdle;
3454         break;
3455       case RELATION_STARTING_POSITION:
3456         newGameMode = gameMode;
3457         break;
3458     }
3459
3460     /* Modify behavior for initial board display on move listing
3461        of wild games.
3462        */
3463     switch (ics_getting_history) {
3464       case H_FALSE:
3465       case H_REQUESTED:
3466         break;
3467       case H_GOT_REQ_HEADER:
3468       case H_GOT_UNREQ_HEADER:
3469         /* This is the initial position of the current game */
3470         gamenum = ics_gamenum;
3471         moveNum = 0;            /* old ICS bug workaround */
3472         if (to_play == 'B') {
3473           startedFromSetupPosition = TRUE;
3474           blackPlaysFirst = TRUE;
3475           moveNum = 1;
3476           if (forwardMostMove == 0) forwardMostMove = 1;
3477           if (backwardMostMove == 0) backwardMostMove = 1;
3478           if (currentMove == 0) currentMove = 1;
3479         }
3480         newGameMode = gameMode;
3481         relation = RELATION_STARTING_POSITION; /* ICC needs this */
3482         break;
3483       case H_GOT_UNWANTED_HEADER:
3484         /* This is an initial board that we don't want */
3485         return;
3486       case H_GETTING_MOVES:
3487         /* Should not happen */
3488         DisplayError(_("Error gathering move list: extra board"), 0);
3489         ics_getting_history = H_FALSE;
3490         return;
3491     }
3492
3493     /* Take action if this is the first board of a new game, or of a
3494        different game than is currently being displayed.  */
3495     if (gamenum != ics_gamenum || newGameMode != gameMode ||
3496         relation == RELATION_ISOLATED_BOARD) {
3497
3498         /* Forget the old game and get the history (if any) of the new one */
3499         if (gameMode != BeginningOfGame) {
3500           Reset(FALSE, TRUE);
3501         }
3502         newGame = TRUE;
3503         if (appData.autoRaiseBoard) BoardToTop();
3504         prevMove = -3;
3505         if (gamenum == -1) {
3506             newGameMode = IcsIdle;
3507         } else if (moveNum > 0 && newGameMode != IcsIdle &&
3508                    appData.getMoveList) {
3509             /* Need to get game history */
3510             ics_getting_history = H_REQUESTED;
3511             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3512             SendToICS(str);
3513         }
3514
3515         /* Initially flip the board to have black on the bottom if playing
3516            black or if the ICS flip flag is set, but let the user change
3517            it with the Flip View button. */
3518         flipView = appData.autoFlipView ?
3519           (newGameMode == IcsPlayingBlack) || ics_flip :
3520           appData.flipView;
3521
3522         /* Done with values from previous mode; copy in new ones */
3523         gameMode = newGameMode;
3524         ModeHighlight();
3525         ics_gamenum = gamenum;
3526         if (gamenum == gs_gamenum) {
3527             int klen = strlen(gs_kind);
3528             if (gs_kind[klen - 1] == '.') gs_kind[klen - 1] = NULLCHAR;
3529             sprintf(str, "ICS %s", gs_kind);
3530             gameInfo.event = StrSave(str);
3531         } else {
3532             gameInfo.event = StrSave("ICS game");
3533         }
3534         gameInfo.site = StrSave(appData.icsHost);
3535         gameInfo.date = PGNDate();
3536         gameInfo.round = StrSave("-");
3537         gameInfo.white = StrSave(white);
3538         gameInfo.black = StrSave(black);
3539         timeControl = basetime * 60 * 1000;
3540         timeControl_2 = 0;
3541         timeIncrement = increment * 1000;
3542         movesPerSession = 0;
3543         gameInfo.timeControl = TimeControlTagValue();
3544         VariantSwitch(board, StringToVariant(gameInfo.event) );
3545   if (appData.debugMode) {
3546     fprintf(debugFP, "ParseBoard says variant = '%s'\n", gameInfo.event);
3547     fprintf(debugFP, "recognized as %s\n", VariantName(gameInfo.variant));
3548     setbuf(debugFP, NULL);
3549   }
3550
3551         gameInfo.outOfBook = NULL;
3552
3553         /* Do we have the ratings? */
3554         if (strcmp(player1Name, white) == 0 &&
3555             strcmp(player2Name, black) == 0) {
3556             if (appData.debugMode)
3557               fprintf(debugFP, "Remembered ratings: W %d, B %d\n",
3558                       player1Rating, player2Rating);
3559             gameInfo.whiteRating = player1Rating;
3560             gameInfo.blackRating = player2Rating;
3561         } else if (strcmp(player2Name, white) == 0 &&
3562                    strcmp(player1Name, black) == 0) {
3563             if (appData.debugMode)
3564               fprintf(debugFP, "Remembered ratings: W %d, B %d\n",
3565                       player2Rating, player1Rating);
3566             gameInfo.whiteRating = player2Rating;
3567             gameInfo.blackRating = player1Rating;
3568         }
3569         player1Name[0] = player2Name[0] = NULLCHAR;
3570
3571         /* Silence shouts if requested */
3572         if (appData.quietPlay &&
3573             (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack)) {
3574             SendToICS(ics_prefix);
3575             SendToICS("set shout 0\n");
3576         }
3577     }
3578
3579     /* Deal with midgame name changes */
3580     if (!newGame) {
3581         if (!gameInfo.white || strcmp(gameInfo.white, white) != 0) {
3582             if (gameInfo.white) free(gameInfo.white);
3583             gameInfo.white = StrSave(white);
3584         }
3585         if (!gameInfo.black || strcmp(gameInfo.black, black) != 0) {
3586             if (gameInfo.black) free(gameInfo.black);
3587             gameInfo.black = StrSave(black);
3588         }
3589     }
3590
3591     /* Throw away game result if anything actually changes in examine mode */
3592     if (gameMode == IcsExamining && !newGame) {
3593         gameInfo.result = GameUnfinished;
3594         if (gameInfo.resultDetails != NULL) {
3595             free(gameInfo.resultDetails);
3596             gameInfo.resultDetails = NULL;
3597         }
3598     }
3599
3600     /* In pausing && IcsExamining mode, we ignore boards coming
3601        in if they are in a different variation than we are. */
3602     if (pauseExamInvalid) return;
3603     if (pausing && gameMode == IcsExamining) {
3604         if (moveNum <= pauseExamForwardMostMove) {
3605             pauseExamInvalid = TRUE;
3606             forwardMostMove = pauseExamForwardMostMove;
3607             return;
3608         }
3609     }
3610
3611   if (appData.debugMode) {
3612     fprintf(debugFP, "load %dx%d board\n", files, ranks);
3613   }
3614     /* Parse the board */
3615     for (k = 0; k < ranks; k++) {
3616       for (j = 0; j < files; j++)
3617         board[k][j+gameInfo.holdingsWidth] = CharToPiece(board_chars[(ranks-1-k)*(files+1) + j]);
3618       if(gameInfo.holdingsWidth > 1) {
3619            board[k][0] = board[k][BOARD_WIDTH-1] = EmptySquare;
3620            board[k][1] = board[k][BOARD_WIDTH-2] = (ChessSquare) 0;;
3621       }
3622     }
3623     CopyBoard(boards[moveNum], board);
3624     if (moveNum == 0) {
3625         startedFromSetupPosition =
3626           !CompareBoards(board, initialPosition);
3627         if(startedFromSetupPosition)
3628             initialRulePlies = irrev_count; /* [HGM] 50-move counter offset */
3629     }
3630
3631     /* [HGM] Set castling rights. Take the outermost Rooks,
3632        to make it also work for FRC opening positions. Note that board12
3633        is really defective for later FRC positions, as it has no way to
3634        indicate which Rook can castle if they are on the same side of King.
3635        For the initial position we grant rights to the outermost Rooks,
3636        and remember thos rights, and we then copy them on positions
3637        later in an FRC game. This means WB might not recognize castlings with
3638        Rooks that have moved back to their original position as illegal,
3639        but in ICS mode that is not its job anyway.
3640     */
3641     if(moveNum == 0 || gameInfo.variant != VariantFischeRandom)
3642     { int i, j; ChessSquare wKing = WhiteKing, bKing = BlackKing;
3643
3644         for(i=BOARD_LEFT, j= -1; i<BOARD_RGHT; i++)
3645             if(board[0][i] == WhiteRook) j = i;
3646         initialRights[0] = castlingRights[moveNum][0] = (castle_ws == 0 && gameInfo.variant != VariantFischeRandom ? -1 : j);
3647         for(i=BOARD_RGHT-1, j= -1; i>=BOARD_LEFT; i--)
3648             if(board[0][i] == WhiteRook) j = i;
3649         initialRights[1] = castlingRights[moveNum][1] = (castle_wl == 0 && gameInfo.variant != VariantFischeRandom ? -1 : j);
3650         for(i=BOARD_LEFT, j= -1; i<BOARD_RGHT; i++)
3651             if(board[BOARD_HEIGHT-1][i] == BlackRook) j = i;
3652         initialRights[3] = castlingRights[moveNum][3] = (castle_bs == 0 && gameInfo.variant != VariantFischeRandom ? -1 : j);
3653         for(i=BOARD_RGHT-1, j= -1; i>=BOARD_LEFT; i--)
3654             if(board[BOARD_HEIGHT-1][i] == BlackRook) j = i;
3655         initialRights[4] = castlingRights[moveNum][4] = (castle_bl == 0 && gameInfo.variant != VariantFischeRandom ? -1 : j);
3656
3657         if(gameInfo.variant == VariantKnightmate) { wKing = WhiteUnicorn; bKing = BlackUnicorn; }
3658         for(k=BOARD_LEFT; k<BOARD_RGHT; k++)
3659             if(board[0][k] == wKing) initialRights[2] = castlingRights[moveNum][2] = k;
3660         for(k=BOARD_LEFT; k<BOARD_RGHT; k++)
3661             if(board[BOARD_HEIGHT-1][k] == bKing)
3662                 initialRights[5] = castlingRights[moveNum][5] = k;
3663     } else { int r;
3664         r = castlingRights[moveNum][0] = initialRights[0];
3665         if(board[0][r] != WhiteRook) castlingRights[moveNum][0] = -1;
3666         r = castlingRights[moveNum][1] = initialRights[1];
3667         if(board[0][r] != WhiteRook) castlingRights[moveNum][1] = -1;
3668         r = castlingRights[moveNum][3] = initialRights[3];
3669         if(board[BOARD_HEIGHT-1][r] != BlackRook) castlingRights[moveNum][3] = -1;
3670         r = castlingRights[moveNum][4] = initialRights[4];
3671         if(board[BOARD_HEIGHT-1][r] != BlackRook) castlingRights[moveNum][4] = -1;
3672         /* wildcastle kludge: always assume King has rights */
3673         r = castlingRights[moveNum][2] = initialRights[2];
3674         r = castlingRights[moveNum][5] = initialRights[5];
3675     }
3676     /* [HGM] e.p. rights. Assume that ICS sends file number here? */
3677     epStatus[moveNum] = double_push == -1 ? EP_NONE : double_push + BOARD_LEFT;
3678
3679
3680     if (ics_getting_history == H_GOT_REQ_HEADER ||
3681         ics_getting_history == H_GOT_UNREQ_HEADER) {
3682         /* This was an initial position from a move list, not
3683            the current position */
3684         return;
3685     }
3686
3687     /* Update currentMove and known move number limits */
3688     newMove = newGame || moveNum > forwardMostMove;
3689
3690     /* [DM] If we found takebacks during icsEngineAnalyze try send to engine */
3691     if (!newGame && appData.icsEngineAnalyze && moveNum < forwardMostMove) {
3692         takeback = forwardMostMove - moveNum;
3693         for (i = 0; i < takeback; i++) {
3694              if (appData.debugMode) fprintf(debugFP, "take back move\n");
3695              SendToProgram("undo\n", &first);
3696         }
3697     }
3698
3699     if (newGame) {
3700         forwardMostMove = backwardMostMove = currentMove = moveNum;
3701         if (gameMode == IcsExamining && moveNum == 0) {
3702           /* Workaround for ICS limitation: we are not told the wild
3703              type when starting to examine a game.  But if we ask for
3704              the move list, the move list header will tell us */
3705             ics_getting_history = H_REQUESTED;
3706             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3707             SendToICS(str);
3708         }
3709     } else if (moveNum == forwardMostMove + 1 || moveNum == forwardMostMove
3710                || (moveNum < forwardMostMove && moveNum >= backwardMostMove)) {
3711         forwardMostMove = moveNum;
3712         if (!pausing || currentMove > forwardMostMove)
3713           currentMove = forwardMostMove;
3714     } else {
3715         /* New part of history that is not contiguous with old part */
3716         if (pausing && gameMode == IcsExamining) {
3717             pauseExamInvalid = TRUE;
3718             forwardMostMove = pauseExamForwardMostMove;
3719             return;
3720         }
3721         forwardMostMove = backwardMostMove = currentMove = moveNum;
3722         if (gameMode == IcsExamining && moveNum > 0 && appData.getMoveList) {
3723             ics_getting_history = H_REQUESTED;
3724             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3725             SendToICS(str);
3726         }
3727     }
3728
3729     /* Update the clocks */
3730     if (strchr(elapsed_time, '.')) {
3731       /* Time is in ms */
3732       timeRemaining[0][moveNum] = whiteTimeRemaining = white_time;
3733       timeRemaining[1][moveNum] = blackTimeRemaining = black_time;
3734     } else {
3735       /* Time is in seconds */
3736       timeRemaining[0][moveNum] = whiteTimeRemaining = white_time * 1000;
3737       timeRemaining[1][moveNum] = blackTimeRemaining = black_time * 1000;
3738     }
3739
3740
3741 #if ZIPPY
3742     if (appData.zippyPlay && newGame &&
3743         gameMode != IcsObserving && gameMode != IcsIdle &&
3744         gameMode != IcsExamining)
3745       ZippyFirstBoard(moveNum, basetime, increment);
3746 #endif
3747
3748     /* Put the move on the move list, first converting
3749        to canonical algebraic form. */
3750     if (moveNum > 0) {
3751   if (appData.debugMode) {
3752     if (appData.debugMode) { int f = forwardMostMove;
3753         fprintf(debugFP, "parseboard %d, castling = %d %d %d %d %d %d\n", f,
3754                 castlingRights[f][0],castlingRights[f][1],castlingRights[f][2],castlingRights[f][3],castlingRights[f][4],castlingRights[f][5]);
3755     }
3756     fprintf(debugFP, "accepted move %s from ICS, parse it.\n", move_str);
3757     fprintf(debugFP, "moveNum = %d\n", moveNum);
3758     fprintf(debugFP, "board = %d-%d x %d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT);
3759     setbuf(debugFP, NULL);
3760   }
3761         if (moveNum <= backwardMostMove) {
3762             /* We don't know what the board looked like before
3763                this move.  Punt. */
3764             strcpy(parseList[moveNum - 1], move_str);
3765             strcat(parseList[moveNum - 1], " ");
3766             strcat(parseList[moveNum - 1], elapsed_time);
3767             moveList[moveNum - 1][0] = NULLCHAR;
3768         } else if (strcmp(move_str, "none") == 0) {
3769             // [HGM] long SAN: swapped order; test for 'none' before parsing move
3770             /* Again, we don't know what the board looked like;
3771                this is really the start of the game. */
3772             parseList[moveNum - 1][0] = NULLCHAR;
3773             moveList[moveNum - 1][0] = NULLCHAR;
3774             backwardMostMove = moveNum;
3775             startedFromSetupPosition = TRUE;
3776             fromX = fromY = toX = toY = -1;
3777         } else {
3778           // [HGM] long SAN: if legality-testing is off, disambiguation might not work or give wrong move.
3779           //                 So we parse the long-algebraic move string in stead of the SAN move
3780           int valid; char buf[MSG_SIZ], *prom;
3781
3782           // str looks something like "Q/a1-a2"; kill the slash
3783           if(str[1] == '/')
3784                 sprintf(buf, "%c%s", str[0], str+2);
3785           else  strcpy(buf, str); // might be castling
3786           if((prom = strstr(move_str, "=")) && !strstr(buf, "="))
3787                 strcat(buf, prom); // long move lacks promo specification!
3788           if(!appData.testLegality && move_str[1] != '@') { // drops never ambiguous (parser chokes on long form!)
3789                 if(appData.debugMode)
3790                         fprintf(debugFP, "replaced ICS move '%s' by '%s'\n", move_str, buf);
3791                 strcpy(move_str, buf);
3792           }
3793           valid = ParseOneMove(move_str, moveNum - 1, &moveType,
3794                                 &fromX, &fromY, &toX, &toY, &promoChar)
3795                || ParseOneMove(buf, moveNum - 1, &moveType,
3796                                 &fromX, &fromY, &toX, &toY, &promoChar);
3797           // end of long SAN patch
3798           if (valid) {
3799             (void) CoordsToAlgebraic(boards[moveNum - 1],
3800                                      PosFlags(moveNum - 1), EP_UNKNOWN,
3801                                      fromY, fromX, toY, toX, promoChar,
3802                                      parseList[moveNum-1]);
3803             switch (MateTest(boards[moveNum], PosFlags(moveNum), EP_UNKNOWN,
3804                              castlingRights[moveNum]) ) {
3805               case MT_NONE:
3806               case MT_STALEMATE:
3807               default:
3808                 break;
3809               case MT_CHECK:
3810                 if(gameInfo.variant != VariantShogi)
3811                     strcat(parseList[moveNum - 1], "+");
3812                 break;
3813               case MT_CHECKMATE:
3814               case MT_STAINMATE: // [HGM] xq: for notation stalemate that wins counts as checkmate
3815                 strcat(parseList[moveNum - 1], "#");
3816                 break;
3817             }
3818             strcat(parseList[moveNum - 1], " ");
3819             strcat(parseList[moveNum - 1], elapsed_time);
3820             /* currentMoveString is set as a side-effect of ParseOneMove */
3821             strcpy(moveList[moveNum - 1], currentMoveString);
3822             strcat(moveList[moveNum - 1], "\n");
3823           } else {
3824             /* Move from ICS was illegal!?  Punt. */
3825   if (appData.debugMode) {
3826     fprintf(debugFP, "Illegal move from ICS '%s'\n", move_str);
3827     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
3828   }
3829 #if 0
3830             if (appData.testLegality && appData.debugMode) {
3831                 sprintf(str, "Illegal move \"%s\" from ICS", move_str);
3832                 DisplayError(str, 0);
3833             }
3834 #endif
3835             strcpy(parseList[moveNum - 1], move_str);
3836             strcat(parseList[moveNum - 1], " ");
3837             strcat(parseList[moveNum - 1], elapsed_time);
3838             moveList[moveNum - 1][0] = NULLCHAR;
3839             fromX = fromY = toX = toY = -1;
3840           }
3841         }
3842   if (appData.debugMode) {
3843     fprintf(debugFP, "Move parsed to '%s'\n", parseList[moveNum - 1]);
3844     setbuf(debugFP, NULL);
3845   }
3846
3847 #if ZIPPY
3848         /* Send move to chess program (BEFORE animating it). */
3849         if (appData.zippyPlay && !newGame && newMove &&
3850            (!appData.getMoveList || backwardMostMove == 0) && first.initDone) {
3851
3852             if ((gameMode == IcsPlayingWhite && WhiteOnMove(moveNum)) ||
3853                 (gameMode == IcsPlayingBlack && !WhiteOnMove(moveNum))) {
3854                 if (moveList[moveNum - 1][0] == NULLCHAR) {
3855                     sprintf(str, _("Couldn't parse move \"%s\" from ICS"),
3856                             move_str);
3857                     DisplayError(str, 0);
3858                 } else {
3859                     if (first.sendTime) {
3860                         SendTimeRemaining(&first, gameMode == IcsPlayingWhite);
3861                     }
3862                     bookHit = SendMoveToBookUser(moveNum - 1, &first, FALSE); // [HGM] book
3863                     if (firstMove && !bookHit) {
3864                         firstMove = FALSE;
3865                         if (first.useColors) {
3866                           SendToProgram(gameMode == IcsPlayingWhite ?
3867                                         "white\ngo\n" :
3868                                         "black\ngo\n", &first);
3869                         } else {
3870                           SendToProgram("go\n", &first);
3871                         }
3872                         first.maybeThinking = TRUE;
3873                     }
3874                 }
3875             } else if (gameMode == IcsObserving || gameMode == IcsExamining) {
3876               if (moveList[moveNum - 1][0] == NULLCHAR) {
3877                 sprintf(str, _("Couldn't parse move \"%s\" from ICS"), move_str);
3878                 DisplayError(str, 0);
3879               } else {
3880                 if(gameInfo.variant == currentlyInitializedVariant) // [HGM] refrain sending moves engine can't understand!
3881                 SendMoveToProgram(moveNum - 1, &first);
3882               }
3883             }
3884         }
3885 #endif
3886     }
3887
3888     if (moveNum > 0 && !gotPremove && !appData.noGUI) {
3889         /* If move comes from a remote source, animate it.  If it
3890            isn't remote, it will have already been animated. */
3891         if (!pausing && !ics_user_moved && prevMove == moveNum - 1) {
3892             AnimateMove(boards[moveNum - 1], fromX, fromY, toX, toY);
3893         }
3894         if (!pausing && appData.highlightLastMove) {
3895             SetHighlights(fromX, fromY, toX, toY);
3896         }
3897     }
3898
3899     /* Start the clocks */
3900     whiteFlag = blackFlag = FALSE;
3901     appData.clockMode = !(basetime == 0 && increment == 0);
3902     if (ticking == 0) {
3903       ics_clock_paused = TRUE;
3904       StopClocks();
3905     } else if (ticking == 1) {
3906       ics_clock_paused = FALSE;
3907     }
3908     if (gameMode == IcsIdle ||
3909         relation == RELATION_OBSERVING_STATIC ||
3910         relation == RELATION_EXAMINING ||
3911         ics_clock_paused)
3912       DisplayBothClocks();
3913     else
3914       StartClocks();
3915
3916     /* Display opponents and material strengths */
3917     if (gameInfo.variant != VariantBughouse &&
3918         gameInfo.variant != VariantCrazyhouse && !appData.noGUI) {
3919         if (tinyLayout || smallLayout) {
3920             if(gameInfo.variant == VariantNormal)
3921                 sprintf(str, "%s(%d) %s(%d) {%d %d}",
3922                     gameInfo.white, white_stren, gameInfo.black, black_stren,
3923                     basetime, increment);
3924             else
3925                 sprintf(str, "%s(%d) %s(%d) {%d %d w%d}",
3926                     gameInfo.white, white_stren, gameInfo.black, black_stren,
3927                     basetime, increment, (int) gameInfo.variant);
3928         } else {
3929             if(gameInfo.variant == VariantNormal)
3930                 sprintf(str, "%s (%d) vs. %s (%d) {%d %d}",
3931                     gameInfo.white, white_stren, gameInfo.black, black_stren,
3932                     basetime, increment);
3933             else
3934                 sprintf(str, "%s (%d) vs. %s (%d) {%d %d %s}",
3935                     gameInfo.white, white_stren, gameInfo.black, black_stren,
3936                     basetime, increment, VariantName(gameInfo.variant));
3937         }
3938         DisplayTitle(str);
3939   if (appData.debugMode) {
3940     fprintf(debugFP, "Display title '%s, gameInfo.variant = %d'\n", str, gameInfo.variant);
3941   }
3942     }
3943
3944
3945     /* Display the board */
3946     if (!pausing && !appData.noGUI) {
3947
3948       if (appData.premove)
3949           if (!gotPremove ||
3950              ((gameMode == IcsPlayingWhite) && (WhiteOnMove(currentMove))) ||
3951              ((gameMode == IcsPlayingBlack) && (!WhiteOnMove(currentMove))))
3952               ClearPremoveHighlights();
3953
3954       DrawPosition(FALSE, boards[currentMove]);
3955       DisplayMove(moveNum - 1);
3956       if (appData.ringBellAfterMoves && /*!ics_user_moved*/ // [HGM] use absolute method to recognize own move
3957             !((gameMode == IcsPlayingWhite) && (!WhiteOnMove(moveNum)) ||
3958               (gameMode == IcsPlayingBlack) &&  (WhiteOnMove(moveNum))   ) ) {
3959         if(newMove) RingBell(); else PlayIcsUnfinishedSound();
3960       }
3961     }
3962
3963     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
3964 #if ZIPPY
3965     if(bookHit) { // [HGM] book: simulate book reply
3966         static char bookMove[MSG_SIZ]; // a bit generous?
3967
3968         programStats.nodes = programStats.depth = programStats.time =
3969         programStats.score = programStats.got_only_move = 0;
3970         sprintf(programStats.movelist, "%s (xbook)", bookHit);
3971
3972         strcpy(bookMove, "move ");
3973         strcat(bookMove, bookHit);
3974         HandleMachineMove(bookMove, &first);
3975     }
3976 #endif
3977 }
3978
3979 void
3980 GetMoveListEvent()
3981 {
3982     char buf[MSG_SIZ];
3983     if (appData.icsActive && gameMode != IcsIdle && ics_gamenum > 0) {
3984         ics_getting_history = H_REQUESTED;
3985         sprintf(buf, "%smoves %d\n", ics_prefix, ics_gamenum);
3986         SendToICS(buf);
3987     }
3988 }
3989
3990 void
3991 AnalysisPeriodicEvent(force)
3992      int force;
3993 {
3994     if (((programStats.ok_to_send == 0 || programStats.line_is_book)
3995          && !force) || !appData.periodicUpdates)
3996       return;
3997
3998     /* Send . command to Crafty to collect stats */
3999     SendToProgram(".\n", &first);
4000
4001     /* Don't send another until we get a response (this makes
4002        us stop sending to old Crafty's which don't understand
4003        the "." command (sending illegal cmds resets node count & time,
4004        which looks bad)) */
4005     programStats.ok_to_send = 0;
4006 }
4007
4008 void
4009 SendMoveToProgram(moveNum, cps)
4010      int moveNum;
4011      ChessProgramState *cps;
4012 {
4013     char buf[MSG_SIZ];
4014
4015     if (cps->useUsermove) {
4016       SendToProgram("usermove ", cps);
4017     }
4018     if (cps->useSAN) {
4019       char *space;
4020       if ((space = strchr(parseList[moveNum], ' ')) != NULL) {
4021         int len = space - parseList[moveNum];
4022         memcpy(buf, parseList[moveNum], len);
4023         buf[len++] = '\n';
4024         buf[len] = NULLCHAR;
4025       } else {
4026         sprintf(buf, "%s\n", parseList[moveNum]);
4027       }
4028       SendToProgram(buf, cps);
4029     } else {
4030       if(cps->alphaRank) { /* [HGM] shogi: temporarily convert to shogi coordinates before sending */
4031         AlphaRank(moveList[moveNum], 4);
4032         SendToProgram(moveList[moveNum], cps);
4033         AlphaRank(moveList[moveNum], 4); // and back
4034       } else
4035       /* Added by Tord: Send castle moves in "O-O" in FRC games if required by
4036        * the engine. It would be nice to have a better way to identify castle
4037        * moves here. */
4038       if((gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom)
4039                                                                          && cps->useOOCastle) {
4040         int fromX = moveList[moveNum][0] - AAA;
4041         int fromY = moveList[moveNum][1] - ONE;
4042         int toX = moveList[moveNum][2] - AAA;
4043         int toY = moveList[moveNum][3] - ONE;
4044         if((boards[moveNum][fromY][fromX] == WhiteKing
4045             && boards[moveNum][toY][toX] == WhiteRook)
4046            || (boards[moveNum][fromY][fromX] == BlackKing
4047                && boards[moveNum][toY][toX] == BlackRook)) {
4048           if(toX > fromX) SendToProgram("O-O\n", cps);
4049           else SendToProgram("O-O-O\n", cps);
4050         }
4051         else SendToProgram(moveList[moveNum], cps);
4052       }
4053       else SendToProgram(moveList[moveNum], cps);
4054       /* End of additions by Tord */
4055     }
4056
4057     /* [HGM] setting up the opening has brought engine in force mode! */
4058     /*       Send 'go' if we are in a mode where machine should play. */
4059     if( (moveNum == 0 && setboardSpoiledMachineBlack && cps == &first) &&
4060         (gameMode == TwoMachinesPlay   ||
4061 #ifdef ZIPPY
4062          gameMode == IcsPlayingBlack     || gameMode == IcsPlayingWhite ||
4063 #endif
4064          gameMode == MachinePlaysBlack || gameMode == MachinePlaysWhite) ) {
4065         SendToProgram("go\n", cps);
4066   if (appData.debugMode) {
4067     fprintf(debugFP, "(extra)\n");
4068   }
4069     }
4070     setboardSpoiledMachineBlack = 0;
4071 }
4072
4073 void
4074 SendMoveToICS(moveType, fromX, fromY, toX, toY)
4075      ChessMove moveType;
4076      int fromX, fromY, toX, toY;
4077 {
4078     char user_move[MSG_SIZ];
4079
4080     switch (moveType) {
4081       default:
4082         sprintf(user_move, _("say Internal error; bad moveType %d (%d,%d-%d,%d)"),
4083                 (int)moveType, fromX, fromY, toX, toY);
4084         DisplayError(user_move + strlen("say "), 0);
4085         break;
4086       case WhiteKingSideCastle:
4087       case BlackKingSideCastle:
4088       case WhiteQueenSideCastleWild:
4089       case BlackQueenSideCastleWild:
4090       /* PUSH Fabien */
4091       case WhiteHSideCastleFR:
4092       case BlackHSideCastleFR:
4093       /* POP Fabien */
4094         sprintf(user_move, "o-o\n");
4095         break;
4096       case WhiteQueenSideCastle:
4097       case BlackQueenSideCastle:
4098       case WhiteKingSideCastleWild:
4099       case BlackKingSideCastleWild:
4100       /* PUSH Fabien */
4101       case WhiteASideCastleFR:
4102       case BlackASideCastleFR:
4103       /* POP Fabien */
4104         sprintf(user_move, "o-o-o\n");
4105         break;
4106       case WhitePromotionQueen:
4107       case BlackPromotionQueen:
4108       case WhitePromotionRook:
4109       case BlackPromotionRook:
4110       case WhitePromotionBishop:
4111       case BlackPromotionBishop:
4112       case WhitePromotionKnight:
4113       case BlackPromotionKnight:
4114       case WhitePromotionKing:
4115       case BlackPromotionKing:
4116       case WhitePromotionChancellor:
4117       case BlackPromotionChancellor:
4118       case WhitePromotionArchbishop:
4119       case BlackPromotionArchbishop:
4120         if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier)
4121             sprintf(user_move, "%c%c%c%c=%c\n",
4122                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
4123                 PieceToChar(WhiteFerz));
4124         else if(gameInfo.variant == VariantGreat)
4125             sprintf(user_move, "%c%c%c%c=%c\n",
4126                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
4127                 PieceToChar(WhiteMan));
4128         else
4129             sprintf(user_move, "%c%c%c%c=%c\n",
4130                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
4131                 PieceToChar(PromoPiece(moveType)));
4132         break;
4133       case WhiteDrop:
4134       case BlackDrop:
4135         sprintf(user_move, "%c@%c%c\n",
4136                 ToUpper(PieceToChar((ChessSquare) fromX)),
4137                 AAA + toX, ONE + toY);
4138         break;
4139       case NormalMove:
4140       case WhiteCapturesEnPassant:
4141       case BlackCapturesEnPassant:
4142       case IllegalMove:  /* could be a variant we don't quite understand */
4143         sprintf(user_move, "%c%c%c%c\n",
4144                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY);
4145         break;
4146     }
4147     SendToICS(user_move);
4148     if(appData.keepAlive) // [HGM] alive: schedule sending of dummy 'date' command
4149         ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
4150 }
4151
4152 void
4153 CoordsToComputerAlgebraic(rf, ff, rt, ft, promoChar, move)
4154      int rf, ff, rt, ft;
4155      char promoChar;
4156      char move[7];
4157 {
4158     if (rf == DROP_RANK) {
4159         sprintf(move, "%c@%c%c\n",
4160                 ToUpper(PieceToChar((ChessSquare) ff)), AAA + ft, ONE + rt);
4161     } else {
4162         if (promoChar == 'x' || promoChar == NULLCHAR) {
4163             sprintf(move, "%c%c%c%c\n",
4164                     AAA + ff, ONE + rf, AAA + ft, ONE + rt);
4165         } else {
4166             sprintf(move, "%c%c%c%c%c\n",
4167                     AAA + ff, ONE + rf, AAA + ft, ONE + rt, promoChar);
4168         }
4169     }
4170 }
4171
4172 void
4173 ProcessICSInitScript(f)
4174      FILE *f;
4175 {
4176     char buf[MSG_SIZ];
4177
4178     while (fgets(buf, MSG_SIZ, f)) {
4179         SendToICSDelayed(buf,(long)appData.msLoginDelay);
4180     }
4181
4182     fclose(f);
4183 }
4184
4185
4186 /* [HGM] Shogi move preprocessor: swap digits for letters, vice versa */
4187 void
4188 AlphaRank(char *move, int n)
4189 {
4190 //    char *p = move, c; int x, y;
4191
4192     if (appData.debugMode) {
4193         fprintf(debugFP, "alphaRank(%s,%d)\n", move, n);
4194     }
4195
4196     if(move[1]=='*' &&
4197        move[2]>='0' && move[2]<='9' &&
4198        move[3]>='a' && move[3]<='x'    ) {
4199         move[1] = '@';
4200         move[2] = BOARD_RGHT  -1 - (move[2]-'1') + AAA;
4201         move[3] = BOARD_HEIGHT-1 - (move[3]-'a') + ONE;
4202     } else
4203     if(move[0]>='0' && move[0]<='9' &&
4204        move[1]>='a' && move[1]<='x' &&
4205        move[2]>='0' && move[2]<='9' &&
4206        move[3]>='a' && move[3]<='x'    ) {
4207         /* input move, Shogi -> normal */
4208         move[0] = BOARD_RGHT  -1 - (move[0]-'1') + AAA;
4209         move[1] = BOARD_HEIGHT-1 - (move[1]-'a') + ONE;
4210         move[2] = BOARD_RGHT  -1 - (move[2]-'1') + AAA;
4211         move[3] = BOARD_HEIGHT-1 - (move[3]-'a') + ONE;
4212     } else
4213     if(move[1]=='@' &&
4214        move[3]>='0' && move[3]<='9' &&
4215        move[2]>='a' && move[2]<='x'    ) {
4216         move[1] = '*';
4217         move[2] = BOARD_RGHT - 1 - (move[2]-AAA) + '1';
4218         move[3] = BOARD_HEIGHT-1 - (move[3]-ONE) + 'a';
4219     } else
4220     if(
4221        move[0]>='a' && move[0]<='x' &&
4222        move[3]>='0' && move[3]<='9' &&
4223        move[2]>='a' && move[2]<='x'    ) {
4224          /* output move, normal -> Shogi */
4225         move[0] = BOARD_RGHT - 1 - (move[0]-AAA) + '1';
4226         move[1] = BOARD_HEIGHT-1 - (move[1]-ONE) + 'a';
4227         move[2] = BOARD_RGHT - 1 - (move[2]-AAA) + '1';
4228         move[3] = BOARD_HEIGHT-1 - (move[3]-ONE) + 'a';
4229         if(move[4] == PieceToChar(BlackQueen)) move[4] = '+';
4230     }
4231     if (appData.debugMode) {
4232         fprintf(debugFP, "   out = '%s'\n", move);
4233     }
4234 }
4235
4236 /* Parser for moves from gnuchess, ICS, or user typein box */
4237 Boolean
4238 ParseOneMove(move, moveNum, moveType, fromX, fromY, toX, toY, promoChar)
4239      char *move;
4240      int moveNum;
4241      ChessMove *moveType;
4242      int *fromX, *fromY, *toX, *toY;
4243      char *promoChar;
4244 {
4245     if (appData.debugMode) {
4246         fprintf(debugFP, "move to parse: %s\n", move);
4247     }
4248     *moveType = yylexstr(moveNum, move);
4249
4250     switch (*moveType) {
4251       case WhitePromotionChancellor:
4252       case BlackPromotionChancellor:
4253       case WhitePromotionArchbishop:
4254       case BlackPromotionArchbishop:
4255       case WhitePromotionQueen:
4256       case BlackPromotionQueen:
4257       case WhitePromotionRook:
4258       case BlackPromotionRook:
4259       case WhitePromotionBishop:
4260       case BlackPromotionBishop:
4261       case WhitePromotionKnight:
4262       case BlackPromotionKnight:
4263       case WhitePromotionKing:
4264       case BlackPromotionKing:
4265       case NormalMove:
4266       case WhiteCapturesEnPassant:
4267       case BlackCapturesEnPassant:
4268       case WhiteKingSideCastle:
4269       case WhiteQueenSideCastle:
4270       case BlackKingSideCastle:
4271       case BlackQueenSideCastle:
4272       case WhiteKingSideCastleWild:
4273       case WhiteQueenSideCastleWild:
4274       case BlackKingSideCastleWild:
4275       case BlackQueenSideCastleWild:
4276       /* Code added by Tord: */
4277       case WhiteHSideCastleFR:
4278       case WhiteASideCastleFR:
4279       case BlackHSideCastleFR:
4280       case BlackASideCastleFR:
4281       /* End of code added by Tord */
4282       case IllegalMove:         /* bug or odd chess variant */
4283         *fromX = currentMoveString[0] - AAA;
4284         *fromY = currentMoveString[1] - ONE;
4285         *toX = currentMoveString[2] - AAA;
4286         *toY = currentMoveString[3] - ONE;
4287         *promoChar = currentMoveString[4];
4288         if (*fromX < BOARD_LEFT || *fromX >= BOARD_RGHT || *fromY < 0 || *fromY >= BOARD_HEIGHT ||
4289             *toX < BOARD_LEFT || *toX >= BOARD_RGHT || *toY < 0 || *toY >= BOARD_HEIGHT) {
4290     if (appData.debugMode) {
4291         fprintf(debugFP, "Off-board move (%d,%d)-(%d,%d)%c, type = %d\n", *fromX, *fromY, *toX, *toY, *promoChar, *moveType);
4292     }
4293             *fromX = *fromY = *toX = *toY = 0;
4294             return FALSE;
4295         }
4296         if (appData.testLegality) {
4297           return (*moveType != IllegalMove);
4298         } else {
4299           return !(fromX == fromY && toX == toY);
4300         }
4301
4302       case WhiteDrop:
4303       case BlackDrop:
4304         *fromX = *moveType == WhiteDrop ?
4305           (int) CharToPiece(ToUpper(currentMoveString[0])) :
4306           (int) CharToPiece(ToLower(currentMoveString[0]));
4307         *fromY = DROP_RANK;
4308         *toX = currentMoveString[2] - AAA;
4309         *toY = currentMoveString[3] - ONE;
4310         *promoChar = NULLCHAR;
4311         return TRUE;
4312
4313       case AmbiguousMove:
4314       case ImpossibleMove:
4315       case (ChessMove) 0:       /* end of file */
4316       case ElapsedTime:
4317       case Comment:
4318       case PGNTag:
4319       case NAG:
4320       case WhiteWins:
4321       case BlackWins:
4322       case GameIsDrawn:
4323       default:
4324     if (appData.debugMode) {
4325         fprintf(debugFP, "Impossible move %s, type = %d\n", currentMoveString, *moveType);
4326     }
4327         /* bug? */
4328         *fromX = *fromY = *toX = *toY = 0;
4329         *promoChar = NULLCHAR;
4330         return FALSE;
4331     }
4332 }
4333
4334 // [HGM] shuffle: a general way to suffle opening setups, applicable to arbitrary variants.
4335 // All positions will have equal probability, but the current method will not provide a unique
4336 // numbering scheme for arrays that contain 3 or more pieces of the same kind.
4337 #define DARK 1
4338 #define LITE 2
4339 #define ANY 3
4340
4341 int squaresLeft[4];
4342 int piecesLeft[(int)BlackPawn];
4343 int seed, nrOfShuffles;
4344
4345 void GetPositionNumber()
4346 {       // sets global variable seed
4347         int i;
4348
4349         seed = appData.defaultFrcPosition;
4350         if(seed < 0) { // randomize based on time for negative FRC position numbers
4351                 for(i=0; i<50; i++) seed += random();
4352                 seed = random() ^ random() >> 8 ^ random() << 8;
4353                 if(seed<0) seed = -seed;
4354         }
4355 }
4356
4357 int put(Board board, int pieceType, int rank, int n, int shade)
4358 // put the piece on the (n-1)-th empty squares of the given shade
4359 {
4360         int i;
4361
4362         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) {
4363                 if( (((i-BOARD_LEFT)&1)+1) & shade && board[rank][i] == EmptySquare && n-- == 0) {
4364                         board[rank][i] = (ChessSquare) pieceType;
4365                         squaresLeft[((i-BOARD_LEFT)&1) + 1]--;
4366                         squaresLeft[ANY]--;
4367                         piecesLeft[pieceType]--;
4368                         return i;
4369                 }
4370         }
4371         return -1;
4372 }
4373
4374
4375 void AddOnePiece(Board board, int pieceType, int rank, int shade)
4376 // calculate where the next piece goes, (any empty square), and put it there
4377 {
4378         int i;
4379
4380         i = seed % squaresLeft[shade];
4381         nrOfShuffles *= squaresLeft[shade];
4382         seed /= squaresLeft[shade];
4383         put(board, pieceType, rank, i, shade);
4384 }
4385
4386 void AddTwoPieces(Board board, int pieceType, int rank)
4387 // calculate where the next 2 identical pieces go, (any empty square), and put it there
4388 {
4389         int i, n=squaresLeft[ANY], j=n-1, k;
4390
4391         k = n*(n-1)/2; // nr of possibilities, not counting permutations
4392         i = seed % k;  // pick one
4393         nrOfShuffles *= k;
4394         seed /= k;
4395         while(i >= j) i -= j--;
4396         j = n - 1 - j; i += j;
4397         put(board, pieceType, rank, j, ANY);
4398         put(board, pieceType, rank, i, ANY);
4399 }
4400
4401 void SetUpShuffle(Board board, int number)
4402 {
4403         int i, p, first=1;
4404
4405         GetPositionNumber(); nrOfShuffles = 1;
4406
4407         squaresLeft[DARK] = (BOARD_RGHT - BOARD_LEFT + 1)/2;
4408         squaresLeft[ANY]  = BOARD_RGHT - BOARD_LEFT;
4409         squaresLeft[LITE] = squaresLeft[ANY] - squaresLeft[DARK];
4410
4411         for(p = 0; p<=(int)WhiteKing; p++) piecesLeft[p] = 0;
4412
4413         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) { // count pieces and clear board
4414             p = (int) board[0][i];
4415             if(p < (int) BlackPawn) piecesLeft[p] ++;
4416             board[0][i] = EmptySquare;
4417         }
4418
4419         if(PosFlags(0) & F_ALL_CASTLE_OK) {
4420             // shuffles restricted to allow normal castling put KRR first
4421             if(piecesLeft[(int)WhiteKing]) // King goes rightish of middle
4422                 put(board, WhiteKing, 0, (gameInfo.boardWidth+1)/2, ANY);
4423             else if(piecesLeft[(int)WhiteUnicorn]) // in Knightmate Unicorn castles
4424                 put(board, WhiteUnicorn, 0, (gameInfo.boardWidth+1)/2, ANY);
4425             if(piecesLeft[(int)WhiteRook]) // First supply a Rook for K-side castling
4426                 put(board, WhiteRook, 0, gameInfo.boardWidth-2, ANY);
4427             if(piecesLeft[(int)WhiteRook]) // Then supply a Rook for Q-side castling
4428                 put(board, WhiteRook, 0, 0, ANY);
4429             // in variants with super-numerary Kings and Rooks, we leave these for the shuffle
4430         }
4431
4432         if(((BOARD_RGHT-BOARD_LEFT) & 1) == 0)
4433             // only for even boards make effort to put pairs of colorbound pieces on opposite colors
4434             for(p = (int) WhiteKing; p > (int) WhitePawn; p--) {
4435                 if(p != (int) WhiteBishop && p != (int) WhiteFerz && p != (int) WhiteAlfil) continue;
4436                 while(piecesLeft[p] >= 2) {
4437                     AddOnePiece(board, p, 0, LITE);
4438                     AddOnePiece(board, p, 0, DARK);
4439                 }
4440                 // Odd color-bound pieces are shuffled with the rest (to not run out of paired squares)
4441             }
4442
4443         for(p = (int) WhiteKing - 2; p > (int) WhitePawn; p--) {
4444             // Remaining pieces (non-colorbound, or odd color bound) can be put anywhere
4445             // but we leave King and Rooks for last, to possibly obey FRC restriction
4446             if(p == (int)WhiteRook) continue;
4447             while(piecesLeft[p] >= 2) AddTwoPieces(board, p, 0); // add in pairs, for not counting permutations
4448             if(piecesLeft[p]) AddOnePiece(board, p, 0, ANY);     // add the odd piece
4449         }
4450
4451         // now everything is placed, except perhaps King (Unicorn) and Rooks
4452
4453         if(PosFlags(0) & F_FRC_TYPE_CASTLING) {
4454             // Last King gets castling rights
4455             while(piecesLeft[(int)WhiteUnicorn]) {
4456                 i = put(board, WhiteUnicorn, 0, piecesLeft[(int)WhiteRook]/2, ANY);
4457                 initialRights[2]  = initialRights[5]  = castlingRights[0][2] = castlingRights[0][5] = i;
4458             }
4459
4460             while(piecesLeft[(int)WhiteKing]) {
4461                 i = put(board, WhiteKing, 0, piecesLeft[(int)WhiteRook]/2, ANY);
4462                 initialRights[2]  = initialRights[5]  = castlingRights[0][2] = castlingRights[0][5] = i;
4463             }
4464
4465
4466         } else {
4467             while(piecesLeft[(int)WhiteKing])    AddOnePiece(board, WhiteKing, 0, ANY);
4468             while(piecesLeft[(int)WhiteUnicorn]) AddOnePiece(board, WhiteUnicorn, 0, ANY);
4469         }
4470
4471         // Only Rooks can be left; simply place them all
4472         while(piecesLeft[(int)WhiteRook]) {
4473                 i = put(board, WhiteRook, 0, 0, ANY);
4474                 if(PosFlags(0) & F_FRC_TYPE_CASTLING) { // first and last Rook get FRC castling rights
4475                         if(first) {
4476                                 first=0;
4477                                 initialRights[1]  = initialRights[4]  = castlingRights[0][1] = castlingRights[0][4] = i;
4478                         }
4479                         initialRights[0]  = initialRights[3]  = castlingRights[0][0] = castlingRights[0][3] = i;
4480                 }
4481         }
4482         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) { // copy black from white
4483             board[BOARD_HEIGHT-1][i] =  (int) board[0][i] < BlackPawn ? WHITE_TO_BLACK board[0][i] : EmptySquare;
4484         }
4485
4486         if(number >= 0) appData.defaultFrcPosition %= nrOfShuffles; // normalize
4487 }
4488
4489 int SetCharTable( char *table, const char * map )
4490 /* [HGM] moved here from winboard.c because of its general usefulness */
4491 /*       Basically a safe strcpy that uses the last character as King */
4492 {
4493     int result = FALSE; int NrPieces;
4494
4495     if( map != NULL && (NrPieces=strlen(map)) <= (int) EmptySquare
4496                     && NrPieces >= 12 && !(NrPieces&1)) {
4497         int i; /* [HGM] Accept even length from 12 to 34 */
4498
4499         for( i=0; i<(int) EmptySquare; i++ ) table[i] = '.';
4500         for( i=0; i<NrPieces/2-1; i++ ) {
4501             table[i] = map[i];
4502             table[i + (int)BlackPawn - (int) WhitePawn] = map[i+NrPieces/2];
4503         }
4504         table[(int) WhiteKing]  = map[NrPieces/2-1];
4505         table[(int) BlackKing]  = map[NrPieces-1];
4506
4507         result = TRUE;
4508     }
4509
4510     return result;
4511 }
4512
4513 void Prelude(Board board)
4514 {       // [HGM] superchess: random selection of exo-pieces
4515         int i, j, k; ChessSquare p;
4516         static ChessSquare exoPieces[4] = { WhiteAngel, WhiteMarshall, WhiteSilver, WhiteLance };
4517
4518         GetPositionNumber(); // use FRC position number
4519
4520         if(appData.pieceToCharTable != NULL) { // select pieces to participate from given char table
4521             SetCharTable(pieceToChar, appData.pieceToCharTable);
4522             for(i=(int)WhiteQueen+1, j=0; i<(int)WhiteKing && j<4; i++)
4523                 if(PieceToChar((ChessSquare)i) != '.') exoPieces[j++] = (ChessSquare) i;
4524         }
4525
4526         j = seed%4;                 seed /= 4;
4527         p = board[0][BOARD_LEFT+j];   board[0][BOARD_LEFT+j] = EmptySquare; k = PieceToNumber(p);
4528         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
4529         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
4530         j = seed%3 + (seed%3 >= j); seed /= 3;
4531         p = board[0][BOARD_LEFT+j];   board[0][BOARD_LEFT+j] = EmptySquare; k = PieceToNumber(p);
4532         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
4533         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
4534         j = seed%3;                 seed /= 3;
4535         p = board[0][BOARD_LEFT+j+5]; board[0][BOARD_LEFT+j+5] = EmptySquare; k = PieceToNumber(p);
4536         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
4537         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
4538         j = seed%2 + (seed%2 >= j); seed /= 2;
4539         p = board[0][BOARD_LEFT+j+5]; board[0][BOARD_LEFT+j+5] = EmptySquare; k = PieceToNumber(p);
4540         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
4541         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
4542         j = seed%4; seed /= 4; put(board, exoPieces[3],    0, j, ANY);
4543         j = seed%3; seed /= 3; put(board, exoPieces[2],   0, j, ANY);
4544         j = seed%2; seed /= 2; put(board, exoPieces[1], 0, j, ANY);
4545         put(board, exoPieces[0],    0, 0, ANY);
4546         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) board[BOARD_HEIGHT-1][i] = WHITE_TO_BLACK board[0][i];
4547 }
4548
4549 void
4550 InitPosition(redraw)
4551      int redraw;
4552 {
4553     ChessSquare (* pieces)[BOARD_SIZE];
4554     int i, j, pawnRow, overrule,
4555     oldx = gameInfo.boardWidth,
4556     oldy = gameInfo.boardHeight,
4557     oldh = gameInfo.holdingsWidth,
4558     oldv = gameInfo.variant;
4559
4560     if(appData.icsActive) shuffleOpenings = FALSE; // [HGM] shuffle: in ICS mode, only shuffle on ICS request
4561
4562     /* [AS] Initialize pv info list [HGM] and game status */
4563     {
4564         for( i=0; i<MAX_MOVES; i++ ) {
4565             pvInfoList[i].depth = 0;
4566             epStatus[i]=EP_NONE;
4567             for( j=0; j<BOARD_SIZE; j++ ) castlingRights[i][j] = -1;
4568         }
4569
4570         initialRulePlies = 0; /* 50-move counter start */
4571
4572         castlingRank[0] = castlingRank[1] = castlingRank[2] = 0;
4573         castlingRank[3] = castlingRank[4] = castlingRank[5] = BOARD_HEIGHT-1;
4574     }
4575
4576
4577     /* [HGM] logic here is completely changed. In stead of full positions */
4578     /* the initialized data only consist of the two backranks. The switch */
4579     /* selects which one we will use, which is than copied to the Board   */
4580     /* initialPosition, which for the rest is initialized by Pawns and    */
4581     /* empty squares. This initial position is then copied to boards[0],  */
4582     /* possibly after shuffling, so that it remains available.            */
4583
4584     gameInfo.holdingsWidth = 0; /* default board sizes */
4585     gameInfo.boardWidth    = 8;
4586     gameInfo.boardHeight   = 8;
4587     gameInfo.holdingsSize  = 0;
4588     nrCastlingRights = -1; /* [HGM] Kludge to indicate default should be used */
4589     for(i=0; i<BOARD_SIZE; i++) initialRights[i] = -1; /* but no rights yet */
4590     SetCharTable(pieceToChar, "PNBRQ...........Kpnbrq...........k");
4591
4592     switch (gameInfo.variant) {
4593     case VariantFischeRandom:
4594       shuffleOpenings = TRUE;
4595     default:
4596       pieces = FIDEArray;
4597       break;
4598     case VariantShatranj:
4599       pieces = ShatranjArray;
4600       nrCastlingRights = 0;
4601       SetCharTable(pieceToChar, "PN.R.QB...Kpn.r.qb...k");
4602       break;
4603     case VariantTwoKings:
4604       pieces = twoKingsArray;
4605       break;
4606     case VariantCapaRandom:
4607       shuffleOpenings = TRUE;
4608     case VariantCapablanca:
4609       pieces = CapablancaArray;
4610       gameInfo.boardWidth = 10;
4611       SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
4612       break;
4613     case VariantGothic:
4614       pieces = GothicArray;
4615       gameInfo.boardWidth = 10;
4616       SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
4617       break;
4618     case VariantJanus:
4619       pieces = JanusArray;
4620       gameInfo.boardWidth = 10;
4621       SetCharTable(pieceToChar, "PNBRQ..JKpnbrq..jk");
4622       nrCastlingRights = 6;
4623         castlingRights[0][0] = initialRights[0] = BOARD_RGHT-1;
4624         castlingRights[0][1] = initialRights[1] = BOARD_LEFT;
4625         castlingRights[0][2] = initialRights[2] =(BOARD_WIDTH-1)>>1;
4626         castlingRights[0][3] = initialRights[3] = BOARD_RGHT-1;
4627         castlingRights[0][4] = initialRights[4] = BOARD_LEFT;
4628         castlingRights[0][5] = initialRights[5] =(BOARD_WIDTH-1)>>1;
4629       break;
4630     case VariantFalcon:
4631       pieces = FalconArray;
4632       gameInfo.boardWidth = 10;
4633       SetCharTable(pieceToChar, "PNBRQ.............FKpnbrq.............fk");
4634       break;
4635     case VariantXiangqi:
4636       pieces = XiangqiArray;
4637       gameInfo.boardWidth  = 9;
4638       gameInfo.boardHeight = 10;
4639       nrCastlingRights = 0;
4640       SetCharTable(pieceToChar, "PH.R.AE..K.C.ph.r.ae..k.c.");
4641       break;
4642     case VariantShogi:
4643       pieces = ShogiArray;
4644       gameInfo.boardWidth  = 9;
4645       gameInfo.boardHeight = 9;
4646       gameInfo.holdingsSize = 7;
4647       nrCastlingRights = 0;
4648       SetCharTable(pieceToChar, "PNBRLS...G.++++++Kpnbrls...g.++++++k");
4649       break;
4650     case VariantCourier:
4651       pieces = CourierArray;
4652       gameInfo.boardWidth  = 12;
4653       nrCastlingRights = 0;
4654       SetCharTable(pieceToChar, "PNBR.FE..WMKpnbr.fe..wmk");
4655       for(i=0; i<BOARD_SIZE; i++) initialRights[i] = -1;
4656       break;
4657     case VariantKnightmate:
4658       pieces = KnightmateArray;
4659       SetCharTable(pieceToChar, "P.BRQ.....M.........K.p.brq.....m.........k.");
4660       break;
4661     case VariantFairy:
4662       pieces = fairyArray;
4663       SetCharTable(pieceToChar, "PNBRQFEACWMOHIJGDVSLUKpnbrqfeacwmohijgdvsluk");
4664       break;
4665     case VariantGreat:
4666       pieces = GreatArray;
4667       gameInfo.boardWidth = 10;
4668       SetCharTable(pieceToChar, "PN....E...S..HWGMKpn....e...s..hwgmk");
4669       gameInfo.holdingsSize = 8;
4670       break;
4671     case VariantSuper:
4672       pieces = FIDEArray;
4673       SetCharTable(pieceToChar, "PNBRQ..SE.......V.AKpnbrq..se.......v.ak");
4674       gameInfo.holdingsSize = 8;
4675       startedFromSetupPosition = TRUE;
4676       break;
4677     case VariantCrazyhouse:
4678     case VariantBughouse:
4679       pieces = FIDEArray;
4680       SetCharTable(pieceToChar, "PNBRQ.......~~~~Kpnbrq.......~~~~k");
4681       gameInfo.holdingsSize = 5;
4682       break;
4683     case VariantWildCastle:
4684       pieces = FIDEArray;
4685       /* !!?shuffle with kings guaranteed to be on d or e file */
4686       shuffleOpenings = 1;
4687       break;
4688     case VariantNoCastle:
4689       pieces = FIDEArray;
4690       nrCastlingRights = 0;
4691       for(i=0; i<BOARD_SIZE; i++) initialRights[i] = -1;
4692       /* !!?unconstrained back-rank shuffle */
4693       shuffleOpenings = 1;
4694       break;
4695     }
4696
4697     overrule = 0;
4698     if(appData.NrFiles >= 0) {
4699         if(gameInfo.boardWidth != appData.NrFiles) overrule++;
4700         gameInfo.boardWidth = appData.NrFiles;
4701     }
4702     if(appData.NrRanks >= 0) {
4703         gameInfo.boardHeight = appData.NrRanks;
4704     }
4705     if(appData.holdingsSize >= 0) {
4706         i = appData.holdingsSize;
4707         if(i > gameInfo.boardHeight) i = gameInfo.boardHeight;
4708         gameInfo.holdingsSize = i;
4709     }
4710     if(gameInfo.holdingsSize) gameInfo.holdingsWidth = 2;
4711     if(BOARD_HEIGHT > BOARD_SIZE || BOARD_WIDTH > BOARD_SIZE)
4712         DisplayFatalError(_("Recompile to support this BOARD_SIZE!"), 0, 2);
4713
4714     pawnRow = gameInfo.boardHeight - 7; /* seems to work in all common variants */
4715     if(pawnRow < 1) pawnRow = 1;
4716
4717     /* User pieceToChar list overrules defaults */
4718     if(appData.pieceToCharTable != NULL)
4719         SetCharTable(pieceToChar, appData.pieceToCharTable);
4720
4721     for( j=0; j<BOARD_WIDTH; j++ ) { ChessSquare s = EmptySquare;
4722
4723         if(j==BOARD_LEFT-1 || j==BOARD_RGHT)
4724             s = (ChessSquare) 0; /* account holding counts in guard band */
4725         for( i=0; i<BOARD_HEIGHT; i++ )
4726             initialPosition[i][j] = s;
4727
4728         if(j < BOARD_LEFT || j >= BOARD_RGHT || overrule) continue;
4729         initialPosition[0][j] = pieces[0][j-gameInfo.holdingsWidth];
4730         initialPosition[pawnRow][j] = WhitePawn;
4731         initialPosition[BOARD_HEIGHT-pawnRow-1][j] = BlackPawn;
4732         if(gameInfo.variant == VariantXiangqi) {
4733             if(j&1) {
4734                 initialPosition[pawnRow][j] =
4735                 initialPosition[BOARD_HEIGHT-pawnRow-1][j] = EmptySquare;
4736                 if(j==BOARD_LEFT+1 || j>=BOARD_RGHT-2) {
4737                    initialPosition[2][j] = WhiteCannon;
4738                    initialPosition[BOARD_HEIGHT-3][j] = BlackCannon;
4739                 }
4740             }
4741         }
4742         initialPosition[BOARD_HEIGHT-1][j] =  pieces[1][j-gameInfo.holdingsWidth];
4743     }
4744     if( (gameInfo.variant == VariantShogi) && !overrule ) {
4745
4746             j=BOARD_LEFT+1;
4747             initialPosition[1][j] = WhiteBishop;
4748             initialPosition[BOARD_HEIGHT-2][j] = BlackRook;
4749             j=BOARD_RGHT-2;
4750             initialPosition[1][j] = WhiteRook;
4751             initialPosition[BOARD_HEIGHT-2][j] = BlackBishop;
4752     }
4753
4754     if( nrCastlingRights == -1) {
4755         /* [HGM] Build normal castling rights (must be done after board sizing!) */
4756         /*       This sets default castling rights from none to normal corners   */
4757         /* Variants with other castling rights must set them themselves above    */
4758         nrCastlingRights = 6;
4759
4760         castlingRights[0][0] = initialRights[0] = BOARD_RGHT-1;
4761         castlingRights[0][1] = initialRights[1] = BOARD_LEFT;
4762         castlingRights[0][2] = initialRights[2] = BOARD_WIDTH>>1;
4763         castlingRights[0][3] = initialRights[3] = BOARD_RGHT-1;
4764         castlingRights[0][4] = initialRights[4] = BOARD_LEFT;
4765         castlingRights[0][5] = initialRights[5] = BOARD_WIDTH>>1;
4766      }
4767
4768      if(gameInfo.variant == VariantSuper) Prelude(initialPosition);
4769      if(gameInfo.variant == VariantGreat) { // promotion commoners
4770         initialPosition[PieceToNumber(WhiteMan)][BOARD_WIDTH-1] = WhiteMan;
4771         initialPosition[PieceToNumber(WhiteMan)][BOARD_WIDTH-2] = 9;
4772         initialPosition[BOARD_HEIGHT-1-PieceToNumber(WhiteMan)][0] = BlackMan;
4773         initialPosition[BOARD_HEIGHT-1-PieceToNumber(WhiteMan)][1] = 9;
4774      }
4775 #if 0
4776     if(gameInfo.variant == VariantFischeRandom) {
4777       if( appData.defaultFrcPosition < 0 ) {
4778         ShuffleFRC( initialPosition );
4779       }
4780       else {
4781         SetupFRC( initialPosition, appData.defaultFrcPosition );
4782       }
4783       startedFromSetupPosition = TRUE;
4784     } else
4785 #else
4786   if (appData.debugMode) {
4787     fprintf(debugFP, "shuffleOpenings = %d\n", shuffleOpenings);
4788   }
4789     if(shuffleOpenings) {
4790         SetUpShuffle(initialPosition, appData.defaultFrcPosition);
4791         startedFromSetupPosition = TRUE;
4792     }
4793 #endif
4794     if(startedFromPositionFile) {
4795       /* [HGM] loadPos: use PositionFile for every new game */
4796       CopyBoard(initialPosition, filePosition);
4797       for(i=0; i<nrCastlingRights; i++)
4798           castlingRights[0][i] = initialRights[i] = fileRights[i];
4799       startedFromSetupPosition = TRUE;
4800     }
4801
4802     CopyBoard(boards[0], initialPosition);
4803
4804     if(oldx != gameInfo.boardWidth ||
4805        oldy != gameInfo.boardHeight ||
4806        oldh != gameInfo.holdingsWidth
4807 #ifdef GOTHIC
4808        || oldv == VariantGothic ||        // For licensing popups
4809        gameInfo.variant == VariantGothic
4810 #endif
4811 #ifdef FALCON
4812        || oldv == VariantFalcon ||
4813        gameInfo.variant == VariantFalcon
4814 #endif
4815                                          )
4816             InitDrawingSizes(-2 ,0);
4817
4818     if (redraw)
4819       DrawPosition(TRUE, boards[currentMove]);
4820 }
4821
4822 void
4823 SendBoard(cps, moveNum)
4824      ChessProgramState *cps;
4825      int moveNum;
4826 {
4827     char message[MSG_SIZ];
4828
4829     if (cps->useSetboard) {
4830       char* fen = PositionToFEN(moveNum, cps->fenOverride);
4831       sprintf(message, "setboard %s\n", fen);
4832       SendToProgram(message, cps);
4833       free(fen);
4834
4835     } else {
4836       ChessSquare *bp;
4837       int i, j;
4838       /* Kludge to set black to move, avoiding the troublesome and now
4839        * deprecated "black" command.
4840        */
4841       if (!WhiteOnMove(moveNum)) SendToProgram("a2a3\n", cps);
4842
4843       SendToProgram("edit\n", cps);
4844       SendToProgram("#\n", cps);
4845       for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
4846         bp = &boards[moveNum][i][BOARD_LEFT];
4847         for (j = BOARD_LEFT; j < BOARD_RGHT; j++, bp++) {
4848           if ((int) *bp < (int) BlackPawn) {
4849             sprintf(message, "%c%c%c\n", PieceToChar(*bp),
4850                     AAA + j, ONE + i);
4851             if(message[0] == '+' || message[0] == '~') {
4852                 sprintf(message, "%c%c%c+\n",
4853                         PieceToChar((ChessSquare)(DEMOTED *bp)),
4854                         AAA + j, ONE + i);
4855             }
4856             if(cps->alphaRank) { /* [HGM] shogi: translate coords */
4857                 message[1] = BOARD_RGHT   - 1 - j + '1';
4858                 message[2] = BOARD_HEIGHT - 1 - i + 'a';
4859             }
4860             SendToProgram(message, cps);
4861           }
4862         }
4863       }
4864
4865       SendToProgram("c\n", cps);
4866       for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
4867         bp = &boards[moveNum][i][BOARD_LEFT];
4868         for (j = BOARD_LEFT; j < BOARD_RGHT; j++, bp++) {
4869           if (((int) *bp != (int) EmptySquare)
4870               && ((int) *bp >= (int) BlackPawn)) {
4871             sprintf(message, "%c%c%c\n", ToUpper(PieceToChar(*bp)),
4872                     AAA + j, ONE + i);
4873             if(message[0] == '+' || message[0] == '~') {
4874                 sprintf(message, "%c%c%c+\n",
4875                         PieceToChar((ChessSquare)(DEMOTED *bp)),
4876                         AAA + j, ONE + i);
4877             }
4878             if(cps->alphaRank) { /* [HGM] shogi: translate coords */
4879                 message[1] = BOARD_RGHT   - 1 - j + '1';
4880                 message[2] = BOARD_HEIGHT - 1 - i + 'a';
4881             }
4882             SendToProgram(message, cps);
4883           }
4884         }
4885       }
4886
4887       SendToProgram(".\n", cps);
4888     }
4889     setboardSpoiledMachineBlack = 0; /* [HGM] assume WB 4.2.7 already solves this after sending setboard */
4890 }
4891
4892 int
4893 IsPromotion(fromX, fromY, toX, toY)
4894      int fromX, fromY, toX, toY;
4895 {
4896     /* [HGM] add Shogi promotions */
4897     int promotionZoneSize=1, highestPromotingPiece = (int)WhitePawn;
4898     ChessSquare piece;
4899
4900     if(gameMode == EditPosition || gameInfo.variant == VariantXiangqi ||
4901       !(fromX >=0 && fromY >= 0 && toX >= 0 && toY >= 0) ) return FALSE;
4902    /* [HGM] Note to self: line above also weeds out drops */
4903     piece = boards[currentMove][fromY][fromX];
4904     if(gameInfo.variant == VariantShogi) {
4905         promotionZoneSize = 3;
4906         highestPromotingPiece = (int)WhiteKing;
4907         /* [HGM] Should be Silver = Ferz, really, but legality testing is off,
4908            and if in normal chess we then allow promotion to King, why not
4909            allow promotion of other piece in Shogi?                         */
4910     }
4911     if((int)piece >= BlackPawn) {
4912         if(toY >= promotionZoneSize && fromY >= promotionZoneSize)
4913              return FALSE;
4914         highestPromotingPiece = WHITE_TO_BLACK highestPromotingPiece;
4915     } else {
4916         if(  toY < BOARD_HEIGHT - promotionZoneSize &&
4917            fromY < BOARD_HEIGHT - promotionZoneSize) return FALSE;
4918     }
4919     return ( (int)piece <= highestPromotingPiece );
4920 }
4921
4922 int
4923 InPalace(row, column)
4924      int row, column;
4925 {   /* [HGM] for Xiangqi */
4926     if( (row < 3 || row > BOARD_HEIGHT-4) &&
4927          column < (BOARD_WIDTH + 4)/2 &&
4928          column > (BOARD_WIDTH - 5)/2 ) return TRUE;
4929     return FALSE;
4930 }
4931
4932 int
4933 PieceForSquare (x, y)
4934      int x;
4935      int y;
4936 {
4937   if (x < 0 || x >= BOARD_WIDTH || y < 0 || y >= BOARD_HEIGHT)
4938      return -1;
4939   else
4940      return boards[currentMove][y][x];
4941 }
4942
4943 int
4944 OKToStartUserMove(x, y)
4945      int x, y;
4946 {
4947     ChessSquare from_piece;
4948     int white_piece;
4949
4950     if (matchMode) return FALSE;
4951     if (gameMode == EditPosition) return TRUE;
4952
4953     if (x >= 0 && y >= 0)
4954       from_piece = boards[currentMove][y][x];
4955     else
4956       from_piece = EmptySquare;
4957
4958     if (from_piece == EmptySquare) return FALSE;
4959
4960     white_piece = (int)from_piece >= (int)WhitePawn &&
4961       (int)from_piece < (int)BlackPawn; /* [HGM] can be > King! */
4962
4963     switch (gameMode) {
4964       case PlayFromGameFile:
4965       case AnalyzeFile:
4966       case TwoMachinesPlay:
4967       case EndOfGame:
4968         return FALSE;
4969
4970       case IcsObserving:
4971       case IcsIdle:
4972         return FALSE;
4973
4974       case MachinePlaysWhite:
4975       case IcsPlayingBlack:
4976         if (appData.zippyPlay) return FALSE;
4977         if (white_piece) {
4978             DisplayMoveError(_("You are playing Black"));
4979             return FALSE;
4980         }
4981         break;
4982
4983       case MachinePlaysBlack:
4984       case IcsPlayingWhite:
4985         if (appData.zippyPlay) return FALSE;
4986         if (!white_piece) {
4987             DisplayMoveError(_("You are playing White"));
4988             return FALSE;
4989         }
4990         break;
4991
4992       case EditGame:
4993         if (!white_piece && WhiteOnMove(currentMove)) {
4994             DisplayMoveError(_("It is White's turn"));
4995             return FALSE;
4996         }
4997         if (white_piece && !WhiteOnMove(currentMove)) {
4998             DisplayMoveError(_("It is Black's turn"));
4999             return FALSE;
5000         }
5001         if (cmailMsgLoaded && (currentMove < cmailOldMove)) {
5002             /* Editing correspondence game history */
5003             /* Could disallow this or prompt for confirmation */
5004             cmailOldMove = -1;
5005         }
5006         if (currentMove < forwardMostMove) {
5007             /* Discarding moves */
5008             /* Could prompt for confirmation here,
5009                but I don't think that's such a good idea */
5010             forwardMostMove = currentMove;
5011         }
5012         break;
5013
5014       case BeginningOfGame:
5015         if (appData.icsActive) return FALSE;
5016         if (!appData.noChessProgram) {
5017             if (!white_piece) {
5018                 DisplayMoveError(_("You are playing White"));
5019                 return FALSE;
5020             }
5021         }
5022         break;
5023
5024       case Training:
5025         if (!white_piece && WhiteOnMove(currentMove)) {
5026             DisplayMoveError(_("It is White's turn"));
5027             return FALSE;
5028         }
5029         if (white_piece && !WhiteOnMove(currentMove)) {
5030             DisplayMoveError(_("It is Black's turn"));
5031             return FALSE;
5032         }
5033         break;
5034
5035       default:
5036       case IcsExamining:
5037         break;
5038     }
5039     if (currentMove != forwardMostMove && gameMode != AnalyzeMode
5040         && gameMode != AnalyzeFile && gameMode != Training) {
5041         DisplayMoveError(_("Displayed position is not current"));
5042         return FALSE;
5043     }
5044     return TRUE;
5045 }
5046
5047 FILE *lastLoadGameFP = NULL, *lastLoadPositionFP = NULL;
5048 int lastLoadGameNumber = 0, lastLoadPositionNumber = 0;
5049 int lastLoadGameUseList = FALSE;
5050 char lastLoadGameTitle[MSG_SIZ], lastLoadPositionTitle[MSG_SIZ];
5051 ChessMove lastLoadGameStart = (ChessMove) 0;
5052
5053
5054 ChessMove
5055 UserMoveTest(fromX, fromY, toX, toY, promoChar)
5056      int fromX, fromY, toX, toY;
5057      int promoChar;
5058 {
5059     ChessMove moveType;
5060     ChessSquare pdown, pup;
5061
5062     if (fromX < 0 || fromY < 0) return ImpossibleMove;
5063     if ((fromX == toX) && (fromY == toY)) {
5064         return ImpossibleMove;
5065     }
5066
5067     /* [HGM] suppress all moves into holdings area and guard band */
5068     if( toX < BOARD_LEFT || toX >= BOARD_RGHT || toY < 0 )
5069             return ImpossibleMove;
5070
5071     /* [HGM] <sameColor> moved to here from winboard.c */
5072     /* note: this code seems to exist for filtering out some obviously illegal premoves */
5073     pdown = boards[currentMove][fromY][fromX];
5074     pup = boards[currentMove][toY][toX];
5075     if (    gameMode != EditPosition &&
5076             (WhitePawn <= pdown && pdown < BlackPawn &&
5077              WhitePawn <= pup && pup < BlackPawn  ||
5078              BlackPawn <= pdown && pdown < EmptySquare &&
5079              BlackPawn <= pup && pup < EmptySquare
5080             ) && !((gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom) &&
5081                     (pup == WhiteRook && pdown == WhiteKing && fromY == 0 && toY == 0||
5082                      pup == BlackRook && pdown == BlackKing && fromY == BOARD_HEIGHT-1 && toY == BOARD_HEIGHT-1  )
5083         )           )
5084          return ImpossibleMove;
5085
5086     /* Check if the user is playing in turn.  This is complicated because we
5087        let the user "pick up" a piece before it is his turn.  So the piece he
5088        tried to pick up may have been captured by the time he puts it down!
5089        Therefore we use the color the user is supposed to be playing in this
5090        test, not the color of the piece that is currently on the starting
5091        square---except in EditGame mode, where the user is playing both
5092        sides; fortunately there the capture race can't happen.  (It can
5093        now happen in IcsExamining mode, but that's just too bad.  The user
5094        will get a somewhat confusing message in that case.)
5095        */
5096
5097     switch (gameMode) {
5098       case PlayFromGameFile:
5099       case AnalyzeFile:
5100       case TwoMachinesPlay:
5101       case EndOfGame:
5102       case IcsObserving:
5103       case IcsIdle:
5104         /* We switched into a game mode where moves are not accepted,
5105            perhaps while the mouse button was down. */
5106         return ImpossibleMove;
5107
5108       case MachinePlaysWhite:
5109         /* User is moving for Black */
5110         if (WhiteOnMove(currentMove)) {
5111             DisplayMoveError(_("It is White's turn"));
5112             return ImpossibleMove;
5113         }
5114         break;
5115
5116       case MachinePlaysBlack:
5117         /* User is moving for White */
5118         if (!WhiteOnMove(currentMove)) {
5119             DisplayMoveError(_("It is Black's turn"));
5120             return ImpossibleMove;
5121         }
5122         break;
5123
5124       case EditGame:
5125       case IcsExamining:
5126       case BeginningOfGame:
5127       case AnalyzeMode:
5128       case Training:
5129         if ((int) boards[currentMove][fromY][fromX] >= (int) BlackPawn &&
5130             (int) boards[currentMove][fromY][fromX] < (int) EmptySquare) {
5131             /* User is moving for Black */
5132             if (WhiteOnMove(currentMove)) {
5133                 DisplayMoveError(_("It is White's turn"));
5134                 return ImpossibleMove;
5135             }
5136         } else {
5137             /* User is moving for White */
5138             if (!WhiteOnMove(currentMove)) {
5139                 DisplayMoveError(_("It is Black's turn"));
5140                 return ImpossibleMove;
5141             }
5142         }
5143         break;
5144
5145       case IcsPlayingBlack:
5146         /* User is moving for Black */
5147         if (WhiteOnMove(currentMove)) {
5148             if (!appData.premove) {
5149                 DisplayMoveError(_("It is White's turn"));
5150             } else if (toX >= 0 && toY >= 0) {
5151                 premoveToX = toX;
5152                 premoveToY = toY;
5153                 premoveFromX = fromX;
5154                 premoveFromY = fromY;
5155                 premovePromoChar = promoChar;
5156                 gotPremove = 1;
5157                 if (appData.debugMode)
5158                     fprintf(debugFP, "Got premove: fromX %d,"
5159                             "fromY %d, toX %d, toY %d\n",
5160                             fromX, fromY, toX, toY);
5161                 if(!WhiteOnMove(currentMove) && gotPremove == 1) {
5162                     // [HGM] race: we must have been hit by an opponent move from the ICS while preparing the premove
5163                     if (appData.debugMode)
5164                         fprintf(debugFP, "Execute as normal move\n");
5165                     gotPremove = 0; break;
5166                 }
5167             }
5168             return ImpossibleMove;
5169         }
5170         break;
5171
5172       case IcsPlayingWhite:
5173         /* User is moving for White */
5174         if (!WhiteOnMove(currentMove)) {
5175             if (!appData.premove) {
5176                 DisplayMoveError(_("It is Black's turn"));
5177             } else if (toX >= 0 && toY >= 0) {
5178                 premoveToX = toX;
5179                 premoveToY = toY;
5180                 premoveFromX = fromX;
5181                 premoveFromY = fromY;
5182                 premovePromoChar = promoChar;
5183                 gotPremove = 1;
5184                 if (appData.debugMode)
5185                     fprintf(debugFP, "Got premove: fromX %d,"
5186                             "fromY %d, toX %d, toY %d\n",
5187                             fromX, fromY, toX, toY);
5188                 if(WhiteOnMove(currentMove) && gotPremove == 1) {
5189                     // [HGM] race: we must have been hit by an opponent move from the ICS while preparing the premove
5190                     if (appData.debugMode)
5191                         fprintf(debugFP, "Execute as normal move\n");
5192                     gotPremove = 0; break;
5193                 }
5194             }
5195             return ImpossibleMove;
5196         }
5197         break;
5198
5199       default:
5200         break;
5201
5202       case EditPosition:
5203         /* EditPosition, empty square, or different color piece;
5204            click-click move is possible */
5205         if (toX == -2 || toY == -2) {
5206             boards[0][fromY][fromX] = EmptySquare;
5207             return AmbiguousMove;
5208         } else if (toX >= 0 && toY >= 0) {
5209             boards[0][toY][toX] = boards[0][fromY][fromX];
5210             boards[0][fromY][fromX] = EmptySquare;
5211             return AmbiguousMove;
5212         }
5213         return ImpossibleMove;
5214     }
5215
5216     /* [HGM] If move started in holdings, it means a drop */
5217     if( fromX == BOARD_LEFT-2 || fromX == BOARD_RGHT+1) {
5218          if( pup != EmptySquare ) return ImpossibleMove;
5219          if(appData.testLegality) {
5220              /* it would be more logical if LegalityTest() also figured out
5221               * which drops are legal. For now we forbid pawns on back rank.
5222               * Shogi is on its own here...
5223               */
5224              if( (pdown == WhitePawn || pdown == BlackPawn) &&
5225                  (toY == 0 || toY == BOARD_HEIGHT -1 ) )
5226                  return(ImpossibleMove); /* no pawn drops on 1st/8th */
5227          }
5228          return WhiteDrop; /* Not needed to specify white or black yet */
5229     }
5230
5231     userOfferedDraw = FALSE;
5232
5233     /* [HGM] always test for legality, to get promotion info */
5234     moveType = LegalityTest(boards[currentMove], PosFlags(currentMove),
5235                           epStatus[currentMove], castlingRights[currentMove],
5236                                          fromY, fromX, toY, toX, promoChar);
5237
5238     /* [HGM] but possibly ignore an IllegalMove result */
5239     if (appData.testLegality) {
5240         if (moveType == IllegalMove || moveType == ImpossibleMove) {
5241             DisplayMoveError(_("Illegal move"));
5242             return ImpossibleMove;
5243         }
5244     }
5245 if(appData.debugMode) fprintf(debugFP, "moveType 3 = %d, promochar = %x\n", moveType, promoChar);
5246     return moveType;
5247     /* [HGM] <popupFix> in stead of calling FinishMove directly, this
5248        function is made into one that returns an OK move type if FinishMove
5249        should be called. This to give the calling driver routine the
5250        opportunity to finish the userMove input with a promotion popup,
5251        without bothering the user with this for invalid or illegal moves */
5252
5253 /*    FinishMove(moveType, fromX, fromY, toX, toY, promoChar); */
5254 }
5255
5256 /* Common tail of UserMoveEvent and DropMenuEvent */
5257 int
5258 FinishMove(moveType, fromX, fromY, toX, toY, promoChar)
5259      ChessMove moveType;
5260      int fromX, fromY, toX, toY;
5261      /*char*/int promoChar;
5262 {
5263     char *bookHit = 0;
5264 if(appData.debugMode) fprintf(debugFP, "moveType 5 = %d, promochar = %x\n", moveType, promoChar);
5265     if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) && promoChar != NULLCHAR) {
5266         // [HGM] superchess: suppress promotions to non-available piece
5267         int k = PieceToNumber(CharToPiece(ToUpper(promoChar)));
5268         if(WhiteOnMove(currentMove)) {
5269             if(!boards[currentMove][k][BOARD_WIDTH-2]) return 0;
5270         } else {
5271             if(!boards[currentMove][BOARD_HEIGHT-1-k][1]) return 0;
5272         }
5273     }
5274
5275     /* [HGM] <popupFix> kludge to avoid having to know the exact promotion
5276        move type in caller when we know the move is a legal promotion */
5277     if(moveType == NormalMove && promoChar)
5278         moveType = PromoCharToMoveType(WhiteOnMove(currentMove), promoChar);
5279 if(appData.debugMode) fprintf(debugFP, "moveType 1 = %d, promochar = %x\n", moveType, promoChar);
5280     /* [HGM] convert drag-and-drop piece drops to standard form */
5281     if( fromX == BOARD_LEFT-2 || fromX == BOARD_RGHT+1) {
5282          moveType = WhiteOnMove(currentMove) ? WhiteDrop : BlackDrop;
5283            if(appData.debugMode) fprintf(debugFP, "Drop move %d, curr=%d, x=%d,y=%d, p=%d\n",
5284                 moveType, currentMove, fromX, fromY, boards[currentMove][fromY][fromX]);
5285 //         fromX = boards[currentMove][fromY][fromX];
5286            // holdings might not be sent yet in ICS play; we have to figure out which piece belongs here
5287            if(fromX == 0) fromY = BOARD_HEIGHT-1 - fromY; // black holdings upside-down
5288            fromX = fromX ? WhitePawn : BlackPawn; // first piece type in selected holdings
5289            while(PieceToChar(fromX) == '.' || PieceToNumber(fromX) != fromY && fromX != (int) EmptySquare) fromX++;
5290          fromY = DROP_RANK;
5291     }
5292
5293     /* [HGM] <popupFix> The following if has been moved here from
5294        UserMoveEvent(). Because it seemed to belon here (why not allow
5295        piece drops in training games?), and because it can only be
5296        performed after it is known to what we promote. */
5297     if (gameMode == Training) {
5298       /* compare the move played on the board to the next move in the
5299        * game. If they match, display the move and the opponent's response.
5300        * If they don't match, display an error message.
5301        */
5302       int saveAnimate;
5303       Board testBoard; char testRights[BOARD_SIZE]; char testStatus;
5304       CopyBoard(testBoard, boards[currentMove]);
5305       ApplyMove(fromX, fromY, toX, toY, promoChar, testBoard, testRights, &testStatus);
5306
5307       if (CompareBoards(testBoard, boards[currentMove+1])) {
5308         ForwardInner(currentMove+1);
5309
5310         /* Autoplay the opponent's response.
5311          * if appData.animate was TRUE when Training mode was entered,
5312          * the response will be animated.
5313          */
5314         saveAnimate = appData.animate;
5315         appData.animate = animateTraining;
5316         ForwardInner(currentMove+1);
5317         appData.animate = saveAnimate;
5318
5319         /* check for the end of the game */
5320         if (currentMove >= forwardMostMove) {
5321           gameMode = PlayFromGameFile;
5322           ModeHighlight();
5323           SetTrainingModeOff();
5324           DisplayInformation(_("End of game"));
5325         }
5326       } else {
5327         DisplayError(_("Incorrect move"), 0);
5328       }
5329       return 1;
5330     }
5331
5332   /* Ok, now we know that the move is good, so we can kill
5333      the previous line in Analysis Mode */
5334   if (gameMode == AnalyzeMode && currentMove < forwardMostMove) {
5335     forwardMostMove = currentMove;
5336   }
5337
5338   /* If we need the chess program but it's dead, restart it */
5339   ResurrectChessProgram();
5340
5341   /* A user move restarts a paused game*/
5342   if (pausing)
5343     PauseEvent();
5344
5345   thinkOutput[0] = NULLCHAR;
5346
5347   MakeMove(fromX, fromY, toX, toY, promoChar); /*updates forwardMostMove*/
5348
5349   if (gameMode == BeginningOfGame) {
5350     if (appData.noChessProgram) {
5351       gameMode = EditGame;
5352       SetGameInfo();
5353     } else {
5354       char buf[MSG_SIZ];
5355       gameMode = MachinePlaysBlack;
5356       StartClocks();
5357       SetGameInfo();
5358       sprintf(buf, "%s vs. %s", gameInfo.white, gameInfo.black);
5359       DisplayTitle(buf);
5360       if (first.sendName) {
5361         sprintf(buf, "name %s\n", gameInfo.white);
5362         SendToProgram(buf, &first);
5363       }
5364       StartClocks();
5365     }
5366     ModeHighlight();
5367   }
5368 if(appData.debugMode) fprintf(debugFP, "moveType 2 = %d, promochar = %x\n", moveType, promoChar);
5369   /* Relay move to ICS or chess engine */
5370   if (appData.icsActive) {
5371     if (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack ||
5372         gameMode == IcsExamining) {
5373       SendMoveToICS(moveType, fromX, fromY, toX, toY);
5374       ics_user_moved = 1;
5375     }
5376   } else {
5377     if (first.sendTime && (gameMode == BeginningOfGame ||
5378                            gameMode == MachinePlaysWhite ||
5379                            gameMode == MachinePlaysBlack)) {
5380       SendTimeRemaining(&first, gameMode != MachinePlaysBlack);
5381     }
5382     if (gameMode != EditGame && gameMode != PlayFromGameFile) {
5383          // [HGM] book: if program might be playing, let it use book
5384         bookHit = SendMoveToBookUser(forwardMostMove-1, &first, FALSE);
5385         first.maybeThinking = TRUE;
5386     } else SendMoveToProgram(forwardMostMove-1, &first);
5387     if (currentMove == cmailOldMove + 1) {
5388       cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
5389     }
5390   }
5391
5392   ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
5393
5394   switch (gameMode) {
5395   case EditGame:
5396     switch (MateTest(boards[currentMove], PosFlags(currentMove),
5397                      EP_UNKNOWN, castlingRights[currentMove]) ) {
5398     case MT_NONE:
5399     case MT_CHECK:
5400       break;
5401     case MT_CHECKMATE:
5402     case MT_STAINMATE:
5403       if (WhiteOnMove(currentMove)) {
5404         GameEnds(BlackWins, "Black mates", GE_PLAYER);
5405       } else {
5406         GameEnds(WhiteWins, "White mates", GE_PLAYER);
5407       }
5408       break;
5409     case MT_STALEMATE:
5410       GameEnds(GameIsDrawn, "Stalemate", GE_PLAYER);
5411       break;
5412     }
5413     break;
5414
5415   case MachinePlaysBlack:
5416   case MachinePlaysWhite:
5417     /* disable certain menu options while machine is thinking */
5418     SetMachineThinkingEnables();
5419     break;
5420
5421   default:
5422     break;
5423   }
5424
5425   if(bookHit) { // [HGM] book: simulate book reply
5426         static char bookMove[MSG_SIZ]; // a bit generous?
5427
5428         programStats.nodes = programStats.depth = programStats.time =
5429         programStats.score = programStats.got_only_move = 0;
5430         sprintf(programStats.movelist, "%s (xbook)", bookHit);
5431
5432         strcpy(bookMove, "move ");
5433         strcat(bookMove, bookHit);
5434         HandleMachineMove(bookMove, &first);
5435   }
5436   return 1;
5437 }
5438
5439 void
5440 UserMoveEvent(fromX, fromY, toX, toY, promoChar)
5441      int fromX, fromY, toX, toY;
5442      int promoChar;
5443 {
5444     /* [HGM] This routine was added to allow calling of its two logical
5445        parts from other modules in the old way. Before, UserMoveEvent()
5446        automatically called FinishMove() if the move was OK, and returned
5447        otherwise. I separated the two, in order to make it possible to
5448        slip a promotion popup in between. But that it always needs two
5449        calls, to the first part, (now called UserMoveTest() ), and to
5450        FinishMove if the first part succeeded. Calls that do not need
5451        to do anything in between, can call this routine the old way.
5452     */
5453     ChessMove moveType = UserMoveTest(fromX, fromY, toX, toY, promoChar);
5454 if(appData.debugMode) fprintf(debugFP, "moveType 4 = %d, promochar = %x\n", moveType, promoChar);
5455     if(moveType == AmbiguousMove)
5456         DrawPosition(FALSE, boards[currentMove]);
5457     else if(moveType != ImpossibleMove)
5458         FinishMove(moveType, fromX, fromY, toX, toY, promoChar);
5459 }
5460
5461 void SendProgramStatsToFrontend( ChessProgramState * cps, ChessProgramStats * cpstats )
5462 {
5463 //    char * hint = lastHint;
5464     FrontEndProgramStats stats;
5465
5466     stats.which = cps == &first ? 0 : 1;
5467     stats.depth = cpstats->depth;
5468     stats.nodes = cpstats->nodes;
5469     stats.score = cpstats->score;
5470     stats.time = cpstats->time;
5471     stats.pv = cpstats->movelist;
5472     stats.hint = lastHint;
5473     stats.an_move_index = 0;
5474     stats.an_move_count = 0;
5475
5476     if( gameMode == AnalyzeMode || gameMode == AnalyzeFile ) {
5477         stats.hint = cpstats->move_name;
5478         stats.an_move_index = cpstats->nr_moves - cpstats->moves_left;
5479         stats.an_move_count = cpstats->nr_moves;
5480     }
5481
5482     SetProgramStats( &stats );
5483 }
5484
5485 char *SendMoveToBookUser(int moveNr, ChessProgramState *cps, int initial)
5486 {   // [HGM] book: this routine intercepts moves to simulate book replies
5487     char *bookHit = NULL;
5488
5489     //first determine if the incoming move brings opponent into his book
5490     if(appData.usePolyglotBook && (cps == &first ? !appData.firstHasOwnBookUCI : !appData.secondHasOwnBookUCI))
5491         bookHit = ProbeBook(moveNr+1, appData.polyglotBook); // returns move
5492     if(appData.debugMode) fprintf(debugFP, "book hit = %s\n", bookHit ? bookHit : "(NULL)");
5493     if(bookHit != NULL && !cps->bookSuspend) {
5494         // make sure opponent is not going to reply after receiving move to book position
5495         SendToProgram("force\n", cps);
5496         cps->bookSuspend = TRUE; // flag indicating it has to be restarted
5497     }
5498     if(!initial) SendMoveToProgram(moveNr, cps); // with hit on initial position there is no move
5499     // now arrange restart after book miss
5500     if(bookHit) {
5501         // after a book hit we never send 'go', and the code after the call to this routine
5502         // has '&& !bookHit' added to suppress potential sending there (based on 'firstMove').
5503         char buf[MSG_SIZ];
5504         if (cps->useUsermove) sprintf(buf, "usermove "); // sorry, no SAN yet :(
5505         sprintf(buf, "%s\n", bookHit); // force book move into program supposed to play it
5506         SendToProgram(buf, cps);
5507         if(!initial) firstMove = FALSE; // normally we would clear the firstMove condition after return & sending 'go'
5508     } else if(initial) { // 'go' was needed irrespective of firstMove, and it has to be done in this routine
5509         SendToProgram("go\n", cps);
5510         cps->bookSuspend = FALSE; // after a 'go' we are never suspended
5511     } else { // 'go' might be sent based on 'firstMove' after this routine returns
5512         if(cps->bookSuspend && !firstMove) // 'go' needed, and it will not be done after we return
5513             SendToProgram("go\n", cps);
5514         cps->bookSuspend = FALSE; // anyhow, we will not be suspended after a miss
5515     }
5516     return bookHit; // notify caller of hit, so it can take action to send move to opponent
5517 }
5518
5519 char *savedMessage;
5520 ChessProgramState *savedState;
5521 void DeferredBookMove(void)
5522 {
5523         if(savedState->lastPing != savedState->lastPong)
5524                     ScheduleDelayedEvent(DeferredBookMove, 10);
5525         else
5526         HandleMachineMove(savedMessage, savedState);
5527 }
5528
5529 void
5530 HandleMachineMove(message, cps)
5531      char *message;
5532      ChessProgramState *cps;
5533 {
5534     char machineMove[MSG_SIZ], buf1[MSG_SIZ*10], buf2[MSG_SIZ];
5535     char realname[MSG_SIZ];
5536     int fromX, fromY, toX, toY;
5537     ChessMove moveType;
5538     char promoChar;
5539     char *p;
5540     int machineWhite;
5541     char *bookHit;
5542
5543 FakeBookMove: // [HGM] book: we jump here to simulate machine moves after book hit
5544     /*
5545      * Kludge to ignore BEL characters
5546      */
5547     while (*message == '\007') message++;
5548
5549     /*
5550      * [HGM] engine debug message: ignore lines starting with '#' character
5551      */
5552     if(cps->debug && *message == '#') return;
5553
5554     /*
5555      * Look for book output
5556      */
5557     if (cps == &first && bookRequested) {
5558         if (message[0] == '\t' || message[0] == ' ') {
5559             /* Part of the book output is here; append it */
5560             strcat(bookOutput, message);
5561             strcat(bookOutput, "  \n");
5562             return;
5563         } else if (bookOutput[0] != NULLCHAR) {
5564             /* All of book output has arrived; display it */
5565             char *p = bookOutput;
5566             while (*p != NULLCHAR) {
5567                 if (*p == '\t') *p = ' ';
5568                 p++;
5569             }
5570             DisplayInformation(bookOutput);
5571             bookRequested = FALSE;
5572             /* Fall through to parse the current output */
5573         }
5574     }
5575
5576     /*
5577      * Look for machine move.
5578      */
5579     if ((sscanf(message, "%s %s %s", buf1, buf2, machineMove) == 3 && strcmp(buf2, "...") == 0) ||
5580         (sscanf(message, "%s %s", buf1, machineMove) == 2 && strcmp(buf1, "move") == 0))
5581     {
5582         /* This method is only useful on engines that support ping */
5583         if (cps->lastPing != cps->lastPong) {
5584           if (gameMode == BeginningOfGame) {
5585             /* Extra move from before last new; ignore */
5586             if (appData.debugMode) {
5587                 fprintf(debugFP, "Ignoring extra move from %s\n", cps->which);
5588             }
5589           } else {
5590             if (appData.debugMode) {
5591                 fprintf(debugFP, "Undoing extra move from %s, gameMode %d\n",
5592                         cps->which, gameMode);
5593             }
5594
5595             SendToProgram("undo\n", cps);
5596           }
5597           return;
5598         }
5599
5600         switch (gameMode) {
5601           case BeginningOfGame:
5602             /* Extra move from before last reset; ignore */
5603             if (appData.debugMode) {
5604                 fprintf(debugFP, "Ignoring extra move from %s\n", cps->which);
5605             }
5606             return;
5607
5608           case EndOfGame:
5609           case IcsIdle:
5610           default:
5611             /* Extra move after we tried to stop.  The mode test is
5612                not a reliable way of detecting this problem, but it's
5613                the best we can do on engines that don't support ping.
5614             */
5615             if (appData.debugMode) {
5616                 fprintf(debugFP, "Undoing extra move from %s, gameMode %d\n",
5617                         cps->which, gameMode);
5618             }
5619             SendToProgram("undo\n", cps);
5620             return;
5621
5622           case MachinePlaysWhite:
5623           case IcsPlayingWhite:
5624             machineWhite = TRUE;
5625             break;
5626
5627           case MachinePlaysBlack:
5628           case IcsPlayingBlack:
5629             machineWhite = FALSE;
5630             break;
5631
5632           case TwoMachinesPlay:
5633             machineWhite = (cps->twoMachinesColor[0] == 'w');
5634             break;
5635         }
5636         if (WhiteOnMove(forwardMostMove) != machineWhite) {
5637             if (appData.debugMode) {
5638                 fprintf(debugFP,
5639                         "Ignoring move out of turn by %s, gameMode %d"
5640                         ", forwardMost %d\n",
5641                         cps->which, gameMode, forwardMostMove);
5642             }
5643             return;
5644         }
5645
5646     if (appData.debugMode) { int f = forwardMostMove;
5647         fprintf(debugFP, "machine move %d, castling = %d %d %d %d %d %d\n", f,
5648                 castlingRights[f][0],castlingRights[f][1],castlingRights[f][2],castlingRights[f][3],castlingRights[f][4],castlingRights[f][5]);
5649     }
5650         if(cps->alphaRank) AlphaRank(machineMove, 4);
5651         if (!ParseOneMove(machineMove, forwardMostMove, &moveType,
5652                               &fromX, &fromY, &toX, &toY, &promoChar)) {
5653             /* Machine move could not be parsed; ignore it. */
5654             sprintf(buf1, _("Illegal move \"%s\" from %s machine"),
5655                     machineMove, cps->which);
5656             DisplayError(buf1, 0);
5657             sprintf(buf1, "Xboard: Forfeit due to invalid move: %s (%c%c%c%c) res=%d",
5658                     machineMove, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, moveType);
5659             if (gameMode == TwoMachinesPlay) {
5660               GameEnds(machineWhite ? BlackWins : WhiteWins,
5661                        buf1, GE_XBOARD);
5662             }
5663             return;
5664         }
5665
5666         /* [HGM] Apparently legal, but so far only tested with EP_UNKOWN */
5667         /* So we have to redo legality test with true e.p. status here,  */
5668         /* to make sure an illegal e.p. capture does not slip through,   */
5669         /* to cause a forfeit on a justified illegal-move complaint      */
5670         /* of the opponent.                                              */
5671         if( gameMode==TwoMachinesPlay && appData.testLegality
5672             && fromY != DROP_RANK /* [HGM] temporary; should still add legality test for drops */
5673                                                               ) {
5674            ChessMove moveType;
5675            moveType = LegalityTest(boards[forwardMostMove], PosFlags(forwardMostMove),
5676                         epStatus[forwardMostMove], castlingRights[forwardMostMove],
5677                              fromY, fromX, toY, toX, promoChar);
5678             if (appData.debugMode) {
5679                 int i;
5680                 for(i=0; i< nrCastlingRights; i++) fprintf(debugFP, "(%d,%d) ",
5681                     castlingRights[forwardMostMove][i], castlingRank[i]);
5682                 fprintf(debugFP, "castling rights\n");
5683             }
5684             if(moveType == IllegalMove) {
5685                 sprintf(buf1, "Xboard: Forfeit due to illegal move: %s (%c%c%c%c)%c",
5686                         machineMove, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, 0);
5687                 GameEnds(machineWhite ? BlackWins : WhiteWins,
5688                            buf1, GE_XBOARD);
5689                 return;
5690            } else if(gameInfo.variant != VariantFischeRandom && gameInfo.variant != VariantCapaRandom)
5691            /* [HGM] Kludge to handle engines that send FRC-style castling
5692               when they shouldn't (like TSCP-Gothic) */
5693            switch(moveType) {
5694              case WhiteASideCastleFR:
5695              case BlackASideCastleFR:
5696                toX+=2;
5697                currentMoveString[2]++;
5698                break;
5699              case WhiteHSideCastleFR:
5700              case BlackHSideCastleFR:
5701                toX--;
5702                currentMoveString[2]--;
5703                break;
5704              default: ; // nothing to do, but suppresses warning of pedantic compilers
5705            }
5706         }
5707         hintRequested = FALSE;
5708         lastHint[0] = NULLCHAR;
5709         bookRequested = FALSE;
5710         /* Program may be pondering now */
5711         cps->maybeThinking = TRUE;
5712         if (cps->sendTime == 2) cps->sendTime = 1;
5713         if (cps->offeredDraw) cps->offeredDraw--;
5714
5715 #if ZIPPY
5716         if ((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack) &&
5717             first.initDone) {
5718           SendMoveToICS(moveType, fromX, fromY, toX, toY);
5719           ics_user_moved = 1;
5720           if(appData.autoKibitz && !appData.icsEngineAnalyze ) { /* [HGM] kibitz: send most-recent PV info to ICS */
5721                 char buf[3*MSG_SIZ];
5722
5723                 sprintf(buf, "kibitz !!! %+.2f/%d (%.2f sec, %u nodes, %.0f knps) PV=%s\n",
5724                         programStats.score / 100.,
5725                         programStats.depth,
5726                         programStats.time / 100.,
5727                         (unsigned int)programStats.nodes,
5728                         (unsigned int)programStats.nodes / (10*abs(programStats.time) + 1.),
5729                         programStats.movelist);
5730                 SendToICS(buf);
5731 if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.nodes, programStats.nodes);
5732           }
5733         }
5734 #endif
5735         /* currentMoveString is set as a side-effect of ParseOneMove */
5736         strcpy(machineMove, currentMoveString);
5737         strcat(machineMove, "\n");
5738         strcpy(moveList[forwardMostMove], machineMove);
5739
5740         /* [AS] Save move info and clear stats for next move */
5741         pvInfoList[ forwardMostMove ].score = programStats.score;
5742         pvInfoList[ forwardMostMove ].depth = programStats.depth;
5743         pvInfoList[ forwardMostMove ].time =  programStats.time; // [HGM] PGNtime: take time from engine stats
5744         ClearProgramStats();
5745         thinkOutput[0] = NULLCHAR;
5746         hiddenThinkOutputState = 0;
5747
5748         MakeMove(fromX, fromY, toX, toY, promoChar);/*updates forwardMostMove*/
5749
5750         /* [AS] Adjudicate game if needed (note: remember that forwardMostMove now points past the last move) */
5751         if( gameMode == TwoMachinesPlay && adjudicateLossThreshold != 0 && forwardMostMove >= adjudicateLossPlies ) {
5752             int count = 0;
5753
5754             while( count < adjudicateLossPlies ) {
5755                 int score = pvInfoList[ forwardMostMove - count - 1 ].score;
5756
5757                 if( count & 1 ) {
5758                     score = -score; /* Flip score for winning side */
5759                 }
5760
5761                 if( score > adjudicateLossThreshold ) {
5762                     break;
5763                 }
5764
5765                 count++;
5766             }
5767
5768             if( count >= adjudicateLossPlies ) {
5769                 ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
5770
5771                 GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
5772                     "Xboard adjudication",
5773                     GE_XBOARD );
5774
5775                 return;
5776             }
5777         }
5778
5779         if( gameMode == TwoMachinesPlay ) {
5780           // [HGM] some adjudications useful with buggy engines
5781             int k, count = 0, epFile = epStatus[forwardMostMove]; static int bare = 1;
5782           if(gameInfo.holdingsSize == 0 || gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
5783
5784
5785             if( appData.testLegality )
5786             {   /* [HGM] Some more adjudications for obstinate engines */
5787                 int NrWN=0, NrBN=0, NrWB=0, NrBB=0, NrWR=0, NrBR=0,
5788                     NrWQ=0, NrBQ=0, NrW=0, NrK=0, bishopsColor = 0,
5789                     NrPieces=0, NrPawns=0, PawnAdvance=0, i, j;
5790                 static int moveCount = 6;
5791                 ChessMove result;
5792                 char *reason = NULL;
5793
5794                 /* Count what is on board. */
5795                 for(i=0; i<BOARD_HEIGHT; i++) for(j=BOARD_LEFT; j<BOARD_RGHT; j++)
5796                 {   ChessSquare p = boards[forwardMostMove][i][j];
5797                     int m=i;
5798
5799                     switch((int) p)
5800                     {   /* count B,N,R and other of each side */
5801                         case WhiteKing:
5802                         case BlackKing:
5803                              NrK++; break; // [HGM] atomic: count Kings
5804                         case WhiteKnight:
5805                              NrWN++; break;
5806                         case WhiteBishop:
5807                         case WhiteFerz:    // [HGM] shatranj: kludge to mke it work in shatranj
5808                              bishopsColor |= 1 << ((i^j)&1);
5809                              NrWB++; break;
5810                         case BlackKnight:
5811                              NrBN++; break;
5812                         case BlackBishop:
5813                         case BlackFerz:    // [HGM] shatranj: kludge to mke it work in shatranj
5814                              bishopsColor |= 1 << ((i^j)&1);
5815                              NrBB++; break;
5816                         case WhiteRook:
5817                              NrWR++; break;
5818                         case BlackRook:
5819                              NrBR++; break;
5820                         case WhiteQueen:
5821                              NrWQ++; break;
5822                         case BlackQueen:
5823                              NrBQ++; break;
5824                         case EmptySquare:
5825                              break;
5826                         case BlackPawn:
5827                              m = 7-i;
5828                         case WhitePawn:
5829                              PawnAdvance += m; NrPawns++;
5830                     }
5831                     NrPieces += (p != EmptySquare);
5832                     NrW += ((int)p < (int)BlackPawn);
5833                     if(gameInfo.variant == VariantXiangqi &&
5834                       (p == WhiteFerz || p == WhiteAlfil || p == BlackFerz || p == BlackAlfil)) {
5835                         NrPieces--; // [HGM] XQ: do not count purely defensive pieces
5836                         NrW -= ((int)p < (int)BlackPawn);
5837                     }
5838                 }
5839
5840                 /* Some material-based adjudications that have to be made before stalemate test */
5841                 if(gameInfo.variant == VariantAtomic && NrK < 2) {
5842                     // [HGM] atomic: stm must have lost his King on previous move, as destroying own K is illegal
5843                      epStatus[forwardMostMove] = EP_CHECKMATE; // make claimable as if stm is checkmated
5844                      if(appData.checkMates) {
5845                          SendMoveToProgram(forwardMostMove-1, cps->other); // make sure opponent gets move
5846                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
5847                          GameEnds( WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins,
5848                                                         "Xboard adjudication: King destroyed", GE_XBOARD );
5849                          return;
5850                      }
5851                 }
5852
5853                 /* Bare King in Shatranj (loses) or Losers (wins) */
5854                 if( NrW == 1 || NrPieces - NrW == 1) {
5855                   if( gameInfo.variant == VariantLosers) { // [HGM] losers: bare King wins (stm must have it first)
5856                      epStatus[forwardMostMove] = EP_WINS;  // mark as win, so it becomes claimable
5857                      if(appData.checkMates) {
5858                          SendMoveToProgram(forwardMostMove-1, cps->other); // make sure opponent gets to see move
5859                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
5860                          GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
5861                                                         "Xboard adjudication: Bare king", GE_XBOARD );
5862                          return;
5863                      }
5864                   } else
5865                   if( gameInfo.variant == VariantShatranj && --bare < 0)
5866                   {    /* bare King */
5867                         epStatus[forwardMostMove] = EP_WINS; // make claimable as win for stm
5868                         if(appData.checkMates) {
5869                             /* but only adjudicate if adjudication enabled */
5870                             SendMoveToProgram(forwardMostMove-1, cps->other); // make sure opponent gets move
5871                             ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
5872                             GameEnds( NrW > 1 ? WhiteWins : NrPieces - NrW > 1 ? BlackWins : GameIsDrawn,
5873                                                         "Xboard adjudication: Bare king", GE_XBOARD );
5874                             return;
5875                         }
5876                   }
5877                 } else bare = 1;
5878
5879
5880             // don't wait for engine to announce game end if we can judge ourselves
5881             switch (MateTest(boards[forwardMostMove], PosFlags(forwardMostMove), epFile,
5882                                        castlingRights[forwardMostMove]) ) {
5883               case MT_CHECK:
5884                 if(gameInfo.variant == Variant3Check) { // [HGM] 3check: when in check, test if 3rd time
5885                     int i, checkCnt = 0;    // (should really be done by making nr of checks part of game state)
5886                     for(i=forwardMostMove-2; i>=backwardMostMove; i-=2) {
5887                         if(MateTest(boards[i], PosFlags(i), epStatus[i], castlingRights[i]) == MT_CHECK)
5888                             checkCnt++;
5889                         if(checkCnt >= 2) {
5890                             reason = "Xboard adjudication: 3rd check";
5891                             epStatus[forwardMostMove] = EP_CHECKMATE;
5892                             break;
5893                         }
5894                     }
5895                 }
5896               case MT_NONE:
5897               default:
5898                 break;
5899               case MT_STALEMATE:
5900               case MT_STAINMATE:
5901                 reason = "Xboard adjudication: Stalemate";
5902                 if(epStatus[forwardMostMove] != EP_CHECKMATE) { // [HGM] don't touch win through baring or K-capt
5903                     epStatus[forwardMostMove] = EP_STALEMATE;   // default result for stalemate is draw
5904                     if(gameInfo.variant == VariantLosers  || gameInfo.variant == VariantGiveaway) // [HGM] losers:
5905                         epStatus[forwardMostMove] = EP_WINS;    // in these variants stalemated is always a win
5906                     else if(gameInfo.variant == VariantSuicide) // in suicide it depends
5907                         epStatus[forwardMostMove] = NrW == NrPieces-NrW ? EP_STALEMATE :
5908                                                    ((NrW < NrPieces-NrW) != WhiteOnMove(forwardMostMove) ?
5909                                                                         EP_CHECKMATE : EP_WINS);
5910                     else if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantXiangqi)
5911                         epStatus[forwardMostMove] = EP_CHECKMATE; // and in these variants being stalemated loses
5912                 }
5913                 break;
5914               case MT_CHECKMATE:
5915                 reason = "Xboard adjudication: Checkmate";
5916                 epStatus[forwardMostMove] = (gameInfo.variant == VariantLosers ? EP_WINS : EP_CHECKMATE);
5917                 break;
5918             }
5919
5920                 switch(i = epStatus[forwardMostMove]) {
5921                     case EP_STALEMATE:
5922                         result = GameIsDrawn; break;
5923                     case EP_CHECKMATE:
5924                         result = WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins; break;
5925                     case EP_WINS:
5926                         result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins; break;
5927                     default:
5928                         result = (ChessMove) 0;
5929                 }
5930                 if(appData.checkMates && result) { // [HGM] mates: adjudicate finished games if requested
5931                     SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see move */
5932                     ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
5933                     GameEnds( result, reason, GE_XBOARD );
5934                     return;
5935                 }
5936
5937                 /* Next absolutely insufficient mating material. */
5938                 if( NrPieces == 2 || gameInfo.variant != VariantXiangqi &&
5939                                      gameInfo.variant != VariantShatranj && // [HGM] baring will remain possible
5940                         (NrPieces == 3 && NrWN+NrBN+NrWB+NrBB == 1 ||
5941                          NrPieces == NrBB+NrWB+2 && bishopsColor != 3)) // [HGM] all Bishops (Ferz!) same color
5942                 {    /* KBK, KNK, KK of KBKB with like Bishops */
5943
5944                      /* always flag draws, for judging claims */
5945                      epStatus[forwardMostMove] = EP_INSUF_DRAW;
5946
5947                      if(appData.materialDraws) {
5948                          /* but only adjudicate them if adjudication enabled */
5949                          SendToProgram("force\n", cps->other); // suppress reply
5950                          SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see last move */
5951                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
5952                          GameEnds( GameIsDrawn, "Xboard adjudication: Insufficient mating material", GE_XBOARD );
5953                          return;
5954                      }
5955                 }
5956
5957                 /* Then some trivial draws (only adjudicate, cannot be claimed) */
5958                 if(NrPieces == 4 &&
5959                    (   NrWR == 1 && NrBR == 1 /* KRKR */
5960                    || NrWQ==1 && NrBQ==1     /* KQKQ */
5961                    || NrWN==2 || NrBN==2     /* KNNK */
5962                    || NrWN+NrWB == 1 && NrBN+NrBB == 1 /* KBKN, KBKB, KNKN */
5963                   ) ) {
5964                      if(--moveCount < 0 && appData.trivialDraws)
5965                      {    /* if the first 3 moves do not show a tactical win, declare draw */
5966                           SendToProgram("force\n", cps->other); // suppress reply
5967                           SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see move */
5968                           ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
5969                           GameEnds( GameIsDrawn, "Xboard adjudication: Trivial draw", GE_XBOARD );
5970                           return;
5971                      }
5972                 } else moveCount = 6;
5973             }
5974           }
5975 #if 1
5976     if (appData.debugMode) { int i;
5977       fprintf(debugFP, "repeat test fmm=%d bmm=%d ep=%d, reps=%d\n",
5978               forwardMostMove, backwardMostMove, epStatus[backwardMostMove],
5979               appData.drawRepeats);
5980       for( i=forwardMostMove; i>=backwardMostMove; i-- )
5981            fprintf(debugFP, "%d ep=%d\n", i, epStatus[i]);
5982
5983     }
5984 #endif
5985                 /* Check for rep-draws */
5986                 count = 0;
5987                 for(k = forwardMostMove-2;
5988                     k>=backwardMostMove && k>=forwardMostMove-100 &&
5989                         epStatus[k] < EP_UNKNOWN &&
5990                         epStatus[k+2] <= EP_NONE && epStatus[k+1] <= EP_NONE;
5991                     k-=2)
5992                 {   int rights=0;
5993 #if 0
5994     if (appData.debugMode) {
5995       fprintf(debugFP, " loop\n");
5996     }
5997 #endif
5998                     if(CompareBoards(boards[k], boards[forwardMostMove])) {
5999 #if 0
6000     if (appData.debugMode) {
6001       fprintf(debugFP, "match\n");
6002     }
6003 #endif
6004                         /* compare castling rights */
6005                         if( castlingRights[forwardMostMove][2] != castlingRights[k][2] &&
6006                              (castlingRights[k][0] >= 0 || castlingRights[k][1] >= 0) )
6007                                 rights++; /* King lost rights, while rook still had them */
6008                         if( castlingRights[forwardMostMove][2] >= 0 ) { /* king has rights */
6009                             if( castlingRights[forwardMostMove][0] != castlingRights[k][0] ||
6010                                 castlingRights[forwardMostMove][1] != castlingRights[k][1] )
6011                                    rights++; /* but at least one rook lost them */
6012                         }
6013                         if( castlingRights[forwardMostMove][5] != castlingRights[k][5] &&
6014                              (castlingRights[k][3] >= 0 || castlingRights[k][4] >= 0) )
6015                                 rights++;
6016                         if( castlingRights[forwardMostMove][5] >= 0 ) {
6017                             if( castlingRights[forwardMostMove][3] != castlingRights[k][3] ||
6018                                 castlingRights[forwardMostMove][4] != castlingRights[k][4] )
6019                                    rights++;
6020                         }
6021 #if 0
6022     if (appData.debugMode) {
6023       for(i=0; i<nrCastlingRights; i++)
6024       fprintf(debugFP, " (%d,%d)", castlingRights[forwardMostMove][i], castlingRights[k][i]);
6025     }
6026
6027     if (appData.debugMode) {
6028       fprintf(debugFP, " %d %d\n", rights, k);
6029     }
6030 #endif
6031                         if( rights == 0 && ++count > appData.drawRepeats-2
6032                             && appData.drawRepeats > 1) {
6033                              /* adjudicate after user-specified nr of repeats */
6034                              SendToProgram("force\n", cps->other); // suppress reply
6035                              SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see move */
6036                              ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6037                              if(gameInfo.variant == VariantXiangqi && appData.testLegality) {
6038                                 // [HGM] xiangqi: check for forbidden perpetuals
6039                                 int m, ourPerpetual = 1, hisPerpetual = 1;
6040                                 for(m=forwardMostMove; m>k; m-=2) {
6041                                     if(MateTest(boards[m], PosFlags(m),
6042                                                         EP_NONE, castlingRights[m]) != MT_CHECK)
6043                                         ourPerpetual = 0; // the current mover did not always check
6044                                     if(MateTest(boards[m-1], PosFlags(m-1),
6045                                                         EP_NONE, castlingRights[m-1]) != MT_CHECK)
6046                                         hisPerpetual = 0; // the opponent did not always check
6047                                 }
6048                                 if(appData.debugMode) fprintf(debugFP, "XQ perpetual test, our=%d, his=%d\n",
6049                                                                         ourPerpetual, hisPerpetual);
6050                                 if(ourPerpetual && !hisPerpetual) { // we are actively checking him: forfeit
6051                                     GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
6052                                            "Xboard adjudication: perpetual checking", GE_XBOARD );
6053                                     return;
6054                                 }
6055                                 if(hisPerpetual && !ourPerpetual)   // he is checking us, but did not repeat yet
6056                                     break; // (or we would have caught him before). Abort repetition-checking loop.
6057                                 // Now check for perpetual chases
6058                                 if(!ourPerpetual && !hisPerpetual) { // no perpetual check, test for chase
6059                                     hisPerpetual = PerpetualChase(k, forwardMostMove);
6060                                     ourPerpetual = PerpetualChase(k+1, forwardMostMove);
6061                                     if(ourPerpetual && !hisPerpetual) { // we are actively chasing him: forfeit
6062                                         GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
6063                                                       "Xboard adjudication: perpetual chasing", GE_XBOARD );
6064                                         return;
6065                                     }
6066                                     if(hisPerpetual && !ourPerpetual)   // he is chasing us, but did not repeat yet
6067                                         break; // Abort repetition-checking loop.
6068                                 }
6069                                 // if neither of us is checking or chasing all the time, or both are, it is draw
6070                              }
6071                              GameEnds( GameIsDrawn, "Xboard adjudication: repetition draw", GE_XBOARD );
6072                              return;
6073                         }
6074                         if( rights == 0 && count > 1 ) /* occurred 2 or more times before */
6075                              epStatus[forwardMostMove] = EP_REP_DRAW;
6076                     }
6077                 }
6078
6079                 /* Now we test for 50-move draws. Determine ply count */
6080                 count = forwardMostMove;
6081                 /* look for last irreversble move */
6082                 while( epStatus[count] <= EP_NONE && count > backwardMostMove )
6083                     count--;
6084                 /* if we hit starting position, add initial plies */
6085                 if( count == backwardMostMove )
6086                     count -= initialRulePlies;
6087                 count = forwardMostMove - count;
6088                 if( count >= 100)
6089                          epStatus[forwardMostMove] = EP_RULE_DRAW;
6090                          /* this is used to judge if draw claims are legal */
6091                 if(appData.ruleMoves > 0 && count >= 2*appData.ruleMoves) {
6092                          SendToProgram("force\n", cps->other); // suppress reply
6093                          SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see move */
6094                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6095                          GameEnds( GameIsDrawn, "Xboard adjudication: 50-move rule", GE_XBOARD );
6096                          return;
6097                 }
6098
6099                 /* if draw offer is pending, treat it as a draw claim
6100                  * when draw condition present, to allow engines a way to
6101                  * claim draws before making their move to avoid a race
6102                  * condition occurring after their move
6103                  */
6104                 if( cps->other->offeredDraw || cps->offeredDraw ) {
6105                          char *p = NULL;
6106                          if(epStatus[forwardMostMove] == EP_RULE_DRAW)
6107                              p = "Draw claim: 50-move rule";
6108                          if(epStatus[forwardMostMove] == EP_REP_DRAW)
6109                              p = "Draw claim: 3-fold repetition";
6110                          if(epStatus[forwardMostMove] == EP_INSUF_DRAW)
6111                              p = "Draw claim: insufficient mating material";
6112                          if( p != NULL ) {
6113                              SendToProgram("force\n", cps->other); // suppress reply
6114                              SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see move */
6115                              GameEnds( GameIsDrawn, p, GE_XBOARD );
6116                              ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6117                              return;
6118                          }
6119                 }
6120
6121
6122                 if( appData.adjudicateDrawMoves > 0 && forwardMostMove > (2*appData.adjudicateDrawMoves) ) {
6123                     SendToProgram("force\n", cps->other); // suppress reply
6124                     SendMoveToProgram(forwardMostMove-1, cps->other); /* make sure opponent gets to see move */
6125                     ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6126
6127                     GameEnds( GameIsDrawn, "Xboard adjudication: long game", GE_XBOARD );
6128
6129                     return;
6130                 }
6131         }
6132
6133         bookHit = NULL;
6134         if (gameMode == TwoMachinesPlay) {
6135             /* [HGM] relaying draw offers moved to after reception of move */
6136             /* and interpreting offer as claim if it brings draw condition */
6137             if (cps->offeredDraw == 1 && cps->other->sendDrawOffers) {
6138                 SendToProgram("draw\n", cps->other);
6139             }
6140             if (cps->other->sendTime) {
6141                 SendTimeRemaining(cps->other,
6142                                   cps->other->twoMachinesColor[0] == 'w');
6143             }
6144             bookHit = SendMoveToBookUser(forwardMostMove-1, cps->other, FALSE);
6145             if (firstMove && !bookHit) {
6146                 firstMove = FALSE;
6147                 if (cps->other->useColors) {
6148                   SendToProgram(cps->other->twoMachinesColor, cps->other);
6149                 }
6150                 SendToProgram("go\n", cps->other);
6151             }
6152             cps->other->maybeThinking = TRUE;
6153         }
6154
6155         ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6156
6157         if (!pausing && appData.ringBellAfterMoves) {
6158             RingBell();
6159         }
6160
6161         /*
6162          * Reenable menu items that were disabled while
6163          * machine was thinking
6164          */
6165         if (gameMode != TwoMachinesPlay)
6166             SetUserThinkingEnables();
6167
6168         // [HGM] book: after book hit opponent has received move and is now in force mode
6169         // force the book reply into it, and then fake that it outputted this move by jumping
6170         // back to the beginning of HandleMachineMove, with cps toggled and message set to this move
6171         if(bookHit) {
6172                 static char bookMove[MSG_SIZ]; // a bit generous?
6173
6174                 strcpy(bookMove, "move ");
6175                 strcat(bookMove, bookHit);
6176                 message = bookMove;
6177                 cps = cps->other;
6178                 programStats.nodes = programStats.depth = programStats.time =
6179                 programStats.score = programStats.got_only_move = 0;
6180                 sprintf(programStats.movelist, "%s (xbook)", bookHit);
6181
6182                 if(cps->lastPing != cps->lastPong) {
6183                     savedMessage = message; // args for deferred call
6184                     savedState = cps;
6185                     ScheduleDelayedEvent(DeferredBookMove, 10);
6186                     return;
6187                 }
6188                 goto FakeBookMove;
6189         }
6190
6191         return;
6192     }
6193
6194     /* Set special modes for chess engines.  Later something general
6195      *  could be added here; for now there is just one kludge feature,
6196      *  needed because Crafty 15.10 and earlier don't ignore SIGINT
6197      *  when "xboard" is given as an interactive command.
6198      */
6199     if (strncmp(message, "kibitz Hello from Crafty", 24) == 0) {
6200         cps->useSigint = FALSE;
6201         cps->useSigterm = FALSE;
6202     }
6203     if (strncmp(message, "feature ", 8) == 0) { // [HGM] moved forward to pre-empt non-compliant commands
6204       ParseFeatures(message+8, cps);
6205       return; // [HGM] This return was missing, causing option features to be recognized as non-compliant commands!
6206     }
6207
6208     /* [HGM] Allow engine to set up a position. Don't ask me why one would
6209      * want this, I was asked to put it in, and obliged.
6210      */
6211     if (!strncmp(message, "setboard ", 9)) {
6212         Board initial_position; int i;
6213
6214         GameEnds(GameUnfinished, "Engine aborts game", GE_XBOARD);
6215
6216         if (!ParseFEN(initial_position, &blackPlaysFirst, message + 9)) {
6217             DisplayError(_("Bad FEN received from engine"), 0);
6218             return ;
6219         } else {
6220            Reset(FALSE, FALSE);
6221            CopyBoard(boards[0], initial_position);
6222            initialRulePlies = FENrulePlies;
6223            epStatus[0] = FENepStatus;
6224            for( i=0; i<nrCastlingRights; i++ )
6225                 castlingRights[0][i] = FENcastlingRights[i];
6226            if(blackPlaysFirst) gameMode = MachinePlaysWhite;
6227            else gameMode = MachinePlaysBlack;
6228            DrawPosition(FALSE, boards[currentMove]);
6229         }
6230         return;
6231     }
6232
6233     /*
6234      * Look for communication commands
6235      */
6236     if (!strncmp(message, "telluser ", 9)) {
6237         DisplayNote(message + 9);
6238         return;
6239     }
6240     if (!strncmp(message, "tellusererror ", 14)) {
6241         DisplayError(message + 14, 0);
6242         return;
6243     }
6244     if (!strncmp(message, "tellopponent ", 13)) {
6245       if (appData.icsActive) {
6246         if (loggedOn) {
6247           snprintf(buf1, sizeof(buf1), "%ssay %s\n", ics_prefix, message + 13);
6248           SendToICS(buf1);
6249         }
6250       } else {
6251         DisplayNote(message + 13);
6252       }
6253       return;
6254     }
6255     if (!strncmp(message, "tellothers ", 11)) {
6256       if (appData.icsActive) {
6257         if (loggedOn) {
6258           snprintf(buf1, sizeof(buf1), "%swhisper %s\n", ics_prefix, message + 11);
6259           SendToICS(buf1);
6260         }
6261       }
6262       return;
6263     }
6264     if (!strncmp(message, "tellall ", 8)) {
6265       if (appData.icsActive) {
6266         if (loggedOn) {
6267           snprintf(buf1, sizeof(buf1), "%skibitz %s\n", ics_prefix, message + 8);
6268           SendToICS(buf1);
6269         }
6270       } else {
6271         DisplayNote(message + 8);
6272       }
6273       return;
6274     }
6275     if (strncmp(message, "warning", 7) == 0) {
6276         /* Undocumented feature, use tellusererror in new code */
6277         DisplayError(message, 0);
6278         return;
6279     }
6280     if (sscanf(message, "askuser %s %[^\n]", buf1, buf2) == 2) {
6281         strcpy(realname, cps->tidy);
6282         strcat(realname, " query");
6283         AskQuestion(realname, buf2, buf1, cps->pr);
6284         return;
6285     }
6286     /* Commands from the engine directly to ICS.  We don't allow these to be
6287      *  sent until we are logged on. Crafty kibitzes have been known to
6288      *  interfere with the login process.
6289      */
6290     if (loggedOn) {
6291         if (!strncmp(message, "tellics ", 8)) {
6292             SendToICS(message + 8);
6293             SendToICS("\n");
6294             return;
6295         }
6296         if (!strncmp(message, "tellicsnoalias ", 15)) {
6297             SendToICS(ics_prefix);
6298             SendToICS(message + 15);
6299             SendToICS("\n");
6300             return;
6301         }
6302         /* The following are for backward compatibility only */
6303         if (!strncmp(message,"whisper",7) || !strncmp(message,"kibitz",6) ||
6304             !strncmp(message,"draw",4) || !strncmp(message,"tell",3)) {
6305             SendToICS(ics_prefix);
6306             SendToICS(message);
6307             SendToICS("\n");
6308             return;
6309         }
6310     }
6311     if (sscanf(message, "pong %d", &cps->lastPong) == 1) {
6312         return;
6313     }
6314     /*
6315      * If the move is illegal, cancel it and redraw the board.
6316      * Also deal with other error cases.  Matching is rather loose
6317      * here to accommodate engines written before the spec.
6318      */
6319     if (strncmp(message + 1, "llegal move", 11) == 0 ||
6320         strncmp(message, "Error", 5) == 0) {
6321         if (StrStr(message, "name") ||
6322             StrStr(message, "rating") || StrStr(message, "?") ||
6323             StrStr(message, "result") || StrStr(message, "board") ||
6324             StrStr(message, "bk") || StrStr(message, "computer") ||
6325             StrStr(message, "variant") || StrStr(message, "hint") ||
6326             StrStr(message, "random") || StrStr(message, "depth") ||
6327             StrStr(message, "accepted")) {
6328             return;
6329         }
6330         if (StrStr(message, "protover")) {
6331           /* Program is responding to input, so it's apparently done
6332              initializing, and this error message indicates it is
6333              protocol version 1.  So we don't need to wait any longer
6334              for it to initialize and send feature commands. */
6335           FeatureDone(cps, 1);
6336           cps->protocolVersion = 1;
6337           return;
6338         }
6339         cps->maybeThinking = FALSE;
6340
6341         if (StrStr(message, "draw")) {
6342             /* Program doesn't have "draw" command */
6343             cps->sendDrawOffers = 0;
6344             return;
6345         }
6346         if (cps->sendTime != 1 &&
6347             (StrStr(message, "time") || StrStr(message, "otim"))) {
6348           /* Program apparently doesn't have "time" or "otim" command */
6349           cps->sendTime = 0;
6350           return;
6351         }
6352         if (StrStr(message, "analyze")) {
6353             cps->analysisSupport = FALSE;
6354             cps->analyzing = FALSE;
6355             Reset(FALSE, TRUE);
6356             sprintf(buf2, _("%s does not support analysis"), cps->tidy);
6357             DisplayError(buf2, 0);
6358             return;
6359         }
6360         if (StrStr(message, "(no matching move)st")) {
6361           /* Special kludge for GNU Chess 4 only */
6362           cps->stKludge = TRUE;
6363           SendTimeControl(cps, movesPerSession, timeControl,
6364                           timeIncrement, appData.searchDepth,
6365                           searchTime);
6366           return;
6367         }
6368         if (StrStr(message, "(no matching move)sd")) {
6369           /* Special kludge for GNU Chess 4 only */
6370           cps->sdKludge = TRUE;
6371           SendTimeControl(cps, movesPerSession, timeControl,
6372                           timeIncrement, appData.searchDepth,
6373                           searchTime);
6374           return;
6375         }
6376         if (!StrStr(message, "llegal")) {
6377             return;
6378         }
6379         if (gameMode == BeginningOfGame || gameMode == EndOfGame ||
6380             gameMode == IcsIdle) return;
6381         if (forwardMostMove <= backwardMostMove) return;
6382 #if 0
6383         /* Following removed: it caused a bug where a real illegal move
6384            message in analyze mored would be ignored. */
6385         if (cps == &first && programStats.ok_to_send == 0) {
6386             /* Bogus message from Crafty responding to "."  This filtering
6387                can miss some of the bad messages, but fortunately the bug
6388                is fixed in current Crafty versions, so it doesn't matter. */
6389             return;
6390         }
6391 #endif
6392         if (pausing) PauseEvent();
6393         if (gameMode == PlayFromGameFile) {
6394             /* Stop reading this game file */
6395             gameMode = EditGame;
6396             ModeHighlight();
6397         }
6398         currentMove = --forwardMostMove;
6399         DisplayMove(currentMove-1); /* before DisplayMoveError */
6400         SwitchClocks();
6401         DisplayBothClocks();
6402         sprintf(buf1, _("Illegal move \"%s\" (rejected by %s chess program)"),
6403                 parseList[currentMove], cps->which);
6404         DisplayMoveError(buf1);
6405         DrawPosition(FALSE, boards[currentMove]);
6406
6407         /* [HGM] illegal-move claim should forfeit game when Xboard */
6408         /* only passes fully legal moves                            */
6409         if( appData.testLegality && gameMode == TwoMachinesPlay ) {
6410             GameEnds( cps->twoMachinesColor[0] == 'w' ? BlackWins : WhiteWins,
6411                                 "False illegal-move claim", GE_XBOARD );
6412         }
6413         return;
6414     }
6415     if (strncmp(message, "time", 4) == 0 && StrStr(message, "Illegal")) {
6416         /* Program has a broken "time" command that
6417            outputs a string not ending in newline.
6418            Don't use it. */
6419         cps->sendTime = 0;
6420     }
6421
6422     /*
6423      * If chess program startup fails, exit with an error message.
6424      * Attempts to recover here are futile.
6425      */
6426     if ((StrStr(message, "unknown host") != NULL)
6427         || (StrStr(message, "No remote directory") != NULL)
6428         || (StrStr(message, "not found") != NULL)
6429         || (StrStr(message, "No such file") != NULL)
6430         || (StrStr(message, "can't alloc") != NULL)
6431         || (StrStr(message, "Permission denied") != NULL)) {
6432
6433         cps->maybeThinking = FALSE;
6434         snprintf(buf1, sizeof(buf1), _("Failed to start %s chess program %s on %s: %s\n"),
6435                 cps->which, cps->program, cps->host, message);
6436         RemoveInputSource(cps->isr);
6437         DisplayFatalError(buf1, 0, 1);
6438         return;
6439     }
6440
6441     /*
6442      * Look for hint output
6443      */
6444     if (sscanf(message, "Hint: %s", buf1) == 1) {
6445         if (cps == &first && hintRequested) {
6446             hintRequested = FALSE;
6447             if (ParseOneMove(buf1, forwardMostMove, &moveType,
6448                                  &fromX, &fromY, &toX, &toY, &promoChar)) {
6449                 (void) CoordsToAlgebraic(boards[forwardMostMove],
6450                                     PosFlags(forwardMostMove), EP_UNKNOWN,
6451                                     fromY, fromX, toY, toX, promoChar, buf1);
6452                 snprintf(buf2, sizeof(buf2), _("Hint: %s"), buf1);
6453                 DisplayInformation(buf2);
6454             } else {
6455                 /* Hint move could not be parsed!? */
6456               snprintf(buf2, sizeof(buf2),
6457                         _("Illegal hint move \"%s\"\nfrom %s chess program"),
6458                         buf1, cps->which);
6459                 DisplayError(buf2, 0);
6460             }
6461         } else {
6462             strcpy(lastHint, buf1);
6463         }
6464         return;
6465     }
6466
6467     /*
6468      * Ignore other messages if game is not in progress
6469      */
6470     if (gameMode == BeginningOfGame || gameMode == EndOfGame ||
6471         gameMode == IcsIdle || cps->lastPing != cps->lastPong) return;
6472
6473     /*
6474      * look for win, lose, draw, or draw offer
6475      */
6476     if (strncmp(message, "1-0", 3) == 0) {
6477         char *p, *q, *r = "";
6478         p = strchr(message, '{');
6479         if (p) {
6480             q = strchr(p, '}');
6481             if (q) {
6482                 *q = NULLCHAR;
6483                 r = p + 1;
6484             }
6485         }
6486         GameEnds(WhiteWins, r, GE_ENGINE1 + (cps != &first)); /* [HGM] pass claimer indication for claim test */
6487         return;
6488     } else if (strncmp(message, "0-1", 3) == 0) {
6489         char *p, *q, *r = "";
6490         p = strchr(message, '{');
6491         if (p) {
6492             q = strchr(p, '}');
6493             if (q) {
6494                 *q = NULLCHAR;
6495                 r = p + 1;
6496             }
6497         }
6498         /* Kludge for Arasan 4.1 bug */
6499         if (strcmp(r, "Black resigns") == 0) {
6500             GameEnds(WhiteWins, r, GE_ENGINE1 + (cps != &first));
6501             return;
6502         }
6503         GameEnds(BlackWins, r, GE_ENGINE1 + (cps != &first));
6504         return;
6505     } else if (strncmp(message, "1/2", 3) == 0) {
6506         char *p, *q, *r = "";
6507         p = strchr(message, '{');
6508         if (p) {
6509             q = strchr(p, '}');
6510             if (q) {
6511                 *q = NULLCHAR;
6512                 r = p + 1;
6513             }
6514         }
6515
6516         GameEnds(GameIsDrawn, r, GE_ENGINE1 + (cps != &first));
6517         return;
6518
6519     } else if (strncmp(message, "White resign", 12) == 0) {
6520         GameEnds(BlackWins, "White resigns", GE_ENGINE1 + (cps != &first));
6521         return;
6522     } else if (strncmp(message, "Black resign", 12) == 0) {
6523         GameEnds(WhiteWins, "Black resigns", GE_ENGINE1 + (cps != &first));
6524         return;
6525     } else if (strncmp(message, "White matches", 13) == 0 ||
6526                strncmp(message, "Black matches", 13) == 0   ) {
6527         /* [HGM] ignore GNUShogi noises */
6528         return;
6529     } else if (strncmp(message, "White", 5) == 0 &&
6530                message[5] != '(' &&
6531                StrStr(message, "Black") == NULL) {
6532         GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
6533         return;
6534     } else if (strncmp(message, "Black", 5) == 0 &&
6535                message[5] != '(') {
6536         GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
6537         return;
6538     } else if (strcmp(message, "resign") == 0 ||
6539                strcmp(message, "computer resigns") == 0) {
6540         switch (gameMode) {
6541           case MachinePlaysBlack:
6542           case IcsPlayingBlack:
6543             GameEnds(WhiteWins, "Black resigns", GE_ENGINE);
6544             break;
6545           case MachinePlaysWhite:
6546           case IcsPlayingWhite:
6547             GameEnds(BlackWins, "White resigns", GE_ENGINE);
6548             break;
6549           case TwoMachinesPlay:
6550             if (cps->twoMachinesColor[0] == 'w')
6551               GameEnds(BlackWins, "White resigns", GE_ENGINE1 + (cps != &first));
6552             else
6553               GameEnds(WhiteWins, "Black resigns", GE_ENGINE1 + (cps != &first));
6554             break;
6555           default:
6556             /* can't happen */
6557             break;
6558         }
6559         return;
6560     } else if (strncmp(message, "opponent mates", 14) == 0) {
6561         switch (gameMode) {
6562           case MachinePlaysBlack:
6563           case IcsPlayingBlack:
6564             GameEnds(WhiteWins, "White mates", GE_ENGINE);
6565             break;
6566           case MachinePlaysWhite:
6567           case IcsPlayingWhite:
6568             GameEnds(BlackWins, "Black mates", GE_ENGINE);
6569             break;
6570           case TwoMachinesPlay:
6571             if (cps->twoMachinesColor[0] == 'w')
6572               GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
6573             else
6574               GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
6575             break;
6576           default:
6577             /* can't happen */
6578             break;
6579         }
6580         return;
6581     } else if (strncmp(message, "computer mates", 14) == 0) {
6582         switch (gameMode) {
6583           case MachinePlaysBlack:
6584           case IcsPlayingBlack:
6585             GameEnds(BlackWins, "Black mates", GE_ENGINE1);
6586             break;
6587           case MachinePlaysWhite:
6588           case IcsPlayingWhite:
6589             GameEnds(WhiteWins, "White mates", GE_ENGINE);
6590             break;
6591           case TwoMachinesPlay:
6592             if (cps->twoMachinesColor[0] == 'w')
6593               GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
6594             else
6595               GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
6596             break;
6597           default:
6598             /* can't happen */
6599             break;
6600         }
6601         return;
6602     } else if (strncmp(message, "checkmate", 9) == 0) {
6603         if (WhiteOnMove(forwardMostMove)) {
6604             GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
6605         } else {
6606             GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
6607         }
6608         return;
6609     } else if (strstr(message, "Draw") != NULL ||
6610                strstr(message, "game is a draw") != NULL) {
6611         GameEnds(GameIsDrawn, "Draw", GE_ENGINE1 + (cps != &first));
6612         return;
6613     } else if (strstr(message, "offer") != NULL &&
6614                strstr(message, "draw") != NULL) {
6615 #if ZIPPY
6616         if (appData.zippyPlay && first.initDone) {
6617             /* Relay offer to ICS */
6618             SendToICS(ics_prefix);
6619             SendToICS("draw\n");
6620         }
6621 #endif
6622         cps->offeredDraw = 2; /* valid until this engine moves twice */
6623         if (gameMode == TwoMachinesPlay) {
6624             if (cps->other->offeredDraw) {
6625                 GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
6626             /* [HGM] in two-machine mode we delay relaying draw offer      */
6627             /* until after we also have move, to see if it is really claim */
6628             }
6629 #if 0
6630               else {
6631                 if (cps->other->sendDrawOffers) {
6632                     SendToProgram("draw\n", cps->other);
6633                 }
6634             }
6635 #endif
6636         } else if (gameMode == MachinePlaysWhite ||
6637                    gameMode == MachinePlaysBlack) {
6638           if (userOfferedDraw) {
6639             DisplayInformation(_("Machine accepts your draw offer"));
6640             GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
6641           } else {
6642             DisplayInformation(_("Machine offers a draw\nSelect Action / Draw to agree"));
6643           }
6644         }
6645     }
6646
6647
6648     /*
6649      * Look for thinking output
6650      */
6651     if ( appData.showThinking // [HGM] thinking: test all options that cause this output
6652           || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp()
6653                                 ) {
6654         int plylev, mvleft, mvtot, curscore, time;
6655         char mvname[MOVE_LEN];
6656         u64 nodes; // [DM]
6657         char plyext;
6658         int ignore = FALSE;
6659         int prefixHint = FALSE;
6660         mvname[0] = NULLCHAR;
6661
6662         switch (gameMode) {
6663           case MachinePlaysBlack:
6664           case IcsPlayingBlack:
6665             if (WhiteOnMove(forwardMostMove)) prefixHint = TRUE;
6666             break;
6667           case MachinePlaysWhite:
6668           case IcsPlayingWhite:
6669             if (!WhiteOnMove(forwardMostMove)) prefixHint = TRUE;
6670             break;
6671           case AnalyzeMode:
6672           case AnalyzeFile:
6673             break;
6674           case IcsObserving: /* [DM] icsEngineAnalyze */
6675             if (!appData.icsEngineAnalyze) ignore = TRUE;
6676             break;
6677           case TwoMachinesPlay:
6678             if ((cps->twoMachinesColor[0] == 'w') != WhiteOnMove(forwardMostMove)) {
6679                 ignore = TRUE;
6680             }
6681             break;
6682           default:
6683             ignore = TRUE;
6684             break;
6685         }
6686
6687         if (!ignore) {
6688             buf1[0] = NULLCHAR;
6689             if (sscanf(message, "%d%c %d %d " u64Display " %[^\n]\n",
6690                        &plylev, &plyext, &curscore, &time, &nodes, buf1) >= 5) {
6691
6692                 if (plyext != ' ' && plyext != '\t') {
6693                     time *= 100;
6694                 }
6695
6696                 /* [AS] Negate score if machine is playing black and reporting absolute scores */
6697                 if( cps->scoreIsAbsolute &&
6698                     ((gameMode == MachinePlaysBlack) || (gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b')) )
6699                 {
6700                     curscore = -curscore;
6701                 }
6702
6703
6704                 programStats.depth = plylev;
6705                 programStats.nodes = nodes;
6706                 programStats.time = time;
6707                 programStats.score = curscore;
6708                 programStats.got_only_move = 0;
6709
6710                 if(cps->nps >= 0) { /* [HGM] nps: use engine nodes or time to decrement clock */
6711                         int ticklen;
6712
6713                         if(cps->nps == 0) ticklen = 10*time;                    // use engine reported time
6714                         else ticklen = (1000. * u64ToDouble(nodes)) / cps->nps; // convert node count to time
6715                         if(WhiteOnMove(forwardMostMove))
6716                              whiteTimeRemaining = timeRemaining[0][forwardMostMove] - ticklen;
6717                         else blackTimeRemaining = timeRemaining[1][forwardMostMove] - ticklen;
6718                 }
6719
6720                 /* Buffer overflow protection */
6721                 if (buf1[0] != NULLCHAR) {
6722                     if (strlen(buf1) >= sizeof(programStats.movelist)
6723                         && appData.debugMode) {
6724                         fprintf(debugFP,
6725                                 "PV is too long; using the first %d bytes.\n",
6726                                 sizeof(programStats.movelist) - 1);
6727                     }
6728
6729                     safeStrCpy( programStats.movelist, buf1, sizeof(programStats.movelist) );
6730                 } else {
6731                     sprintf(programStats.movelist, " no PV\n");
6732                 }
6733
6734                 if (programStats.seen_stat) {
6735                     programStats.ok_to_send = 1;
6736                 }
6737
6738                 if (strchr(programStats.movelist, '(') != NULL) {
6739                     programStats.line_is_book = 1;
6740                     programStats.nr_moves = 0;
6741                     programStats.moves_left = 0;
6742                 } else {
6743                     programStats.line_is_book = 0;
6744                 }
6745
6746                 SendProgramStatsToFrontend( cps, &programStats );
6747
6748                 /*
6749                     [AS] Protect the thinkOutput buffer from overflow... this
6750                     is only useful if buf1 hasn't overflowed first!
6751                 */
6752                 sprintf(thinkOutput, "[%d]%c%+.2f %s%s",
6753                         plylev,
6754                         (gameMode == TwoMachinesPlay ?
6755                          ToUpper(cps->twoMachinesColor[0]) : ' '),
6756                         ((double) curscore) / 100.0,
6757                         prefixHint ? lastHint : "",
6758                         prefixHint ? " " : "" );
6759
6760                 if( buf1[0] != NULLCHAR ) {
6761                     unsigned max_len = sizeof(thinkOutput) - strlen(thinkOutput) - 1;
6762
6763                     if( strlen(buf1) > max_len ) {
6764                         if( appData.debugMode) {
6765                             fprintf(debugFP,"PV is too long for thinkOutput, truncating.\n");
6766                         }
6767                         buf1[max_len+1] = '\0';
6768                     }
6769
6770                     strcat( thinkOutput, buf1 );
6771                 }
6772
6773                 if (currentMove == forwardMostMove || gameMode == AnalyzeMode
6774                         || gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
6775                     DisplayMove(currentMove - 1);
6776                     DisplayAnalysis();
6777                 }
6778                 return;
6779
6780             } else if ((p=StrStr(message, "(only move)")) != NULL) {
6781                 /* crafty (9.25+) says "(only move) <move>"
6782                  * if there is only 1 legal move
6783                  */
6784                 sscanf(p, "(only move) %s", buf1);
6785                 sprintf(thinkOutput, "%s (only move)", buf1);
6786                 sprintf(programStats.movelist, "%s (only move)", buf1);
6787                 programStats.depth = 1;
6788                 programStats.nr_moves = 1;
6789                 programStats.moves_left = 1;
6790                 programStats.nodes = 1;
6791                 programStats.time = 1;
6792                 programStats.got_only_move = 1;
6793
6794                 /* Not really, but we also use this member to
6795                    mean "line isn't going to change" (Crafty
6796                    isn't searching, so stats won't change) */
6797                 programStats.line_is_book = 1;
6798
6799                 SendProgramStatsToFrontend( cps, &programStats );
6800
6801                 if (currentMove == forwardMostMove || gameMode==AnalyzeMode ||
6802                            gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
6803                     DisplayMove(currentMove - 1);
6804                     DisplayAnalysis();
6805                 }
6806                 return;
6807             } else if (sscanf(message,"stat01: %d " u64Display " %d %d %d %s",
6808                               &time, &nodes, &plylev, &mvleft,
6809                               &mvtot, mvname) >= 5) {
6810                 /* The stat01: line is from Crafty (9.29+) in response
6811                    to the "." command */
6812                 programStats.seen_stat = 1;
6813                 cps->maybeThinking = TRUE;
6814
6815                 if (programStats.got_only_move || !appData.periodicUpdates)
6816                   return;
6817
6818                 programStats.depth = plylev;
6819                 programStats.time = time;
6820                 programStats.nodes = nodes;
6821                 programStats.moves_left = mvleft;
6822                 programStats.nr_moves = mvtot;
6823                 strcpy(programStats.move_name, mvname);
6824                 programStats.ok_to_send = 1;
6825                 programStats.movelist[0] = '\0';
6826
6827                 SendProgramStatsToFrontend( cps, &programStats );
6828
6829                 DisplayAnalysis();
6830                 return;
6831
6832             } else if (strncmp(message,"++",2) == 0) {
6833                 /* Crafty 9.29+ outputs this */
6834                 programStats.got_fail = 2;
6835                 return;
6836
6837             } else if (strncmp(message,"--",2) == 0) {
6838                 /* Crafty 9.29+ outputs this */
6839                 programStats.got_fail = 1;
6840                 return;
6841
6842             } else if (thinkOutput[0] != NULLCHAR &&
6843                        strncmp(message, "    ", 4) == 0) {
6844                 unsigned message_len;
6845
6846                 p = message;
6847                 while (*p && *p == ' ') p++;
6848
6849                 message_len = strlen( p );
6850
6851                 /* [AS] Avoid buffer overflow */
6852                 if( sizeof(thinkOutput) - strlen(thinkOutput) - 1 > message_len ) {
6853                     strcat(thinkOutput, " ");
6854                     strcat(thinkOutput, p);
6855                 }
6856
6857                 if( sizeof(programStats.movelist) - strlen(programStats.movelist) - 1 > message_len ) {
6858                     strcat(programStats.movelist, " ");
6859                     strcat(programStats.movelist, p);
6860                 }
6861
6862                 if (currentMove == forwardMostMove || gameMode==AnalyzeMode ||
6863                            gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
6864                     DisplayMove(currentMove - 1);
6865                     DisplayAnalysis();
6866                 }
6867                 return;
6868             }
6869         }
6870         else {
6871             buf1[0] = NULLCHAR;
6872
6873             if (sscanf(message, "%d%c %d %d " u64Display " %[^\n]\n",
6874                        &plylev, &plyext, &curscore, &time, &nodes, buf1) >= 5)
6875             {
6876                 ChessProgramStats cpstats;
6877
6878                 if (plyext != ' ' && plyext != '\t') {
6879                     time *= 100;
6880                 }
6881
6882                 /* [AS] Negate score if machine is playing black and reporting absolute scores */
6883                 if( cps->scoreIsAbsolute && ((gameMode == MachinePlaysBlack) || (gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b')) ) {
6884                     curscore = -curscore;
6885                 }
6886
6887                 cpstats.depth = plylev;
6888                 cpstats.nodes = nodes;
6889                 cpstats.time = time;
6890                 cpstats.score = curscore;
6891                 cpstats.got_only_move = 0;
6892                 cpstats.movelist[0] = '\0';
6893
6894                 if (buf1[0] != NULLCHAR) {
6895                     safeStrCpy( cpstats.movelist, buf1, sizeof(cpstats.movelist) );
6896                 }
6897
6898                 cpstats.ok_to_send = 0;
6899                 cpstats.line_is_book = 0;
6900                 cpstats.nr_moves = 0;
6901                 cpstats.moves_left = 0;
6902
6903                 SendProgramStatsToFrontend( cps, &cpstats );
6904             }
6905         }
6906     }
6907 }
6908
6909
6910 /* Parse a game score from the character string "game", and
6911    record it as the history of the current game.  The game
6912    score is NOT assumed to start from the standard position.
6913    The display is not updated in any way.
6914    */
6915 void
6916 ParseGameHistory(game)
6917      char *game;
6918 {
6919     ChessMove moveType;
6920     int fromX, fromY, toX, toY, boardIndex;
6921     char promoChar;
6922     char *p, *q;
6923     char buf[MSG_SIZ];
6924
6925     if (appData.debugMode)
6926       fprintf(debugFP, "Parsing game history: %s\n", game);
6927
6928     if (gameInfo.event == NULL) gameInfo.event = StrSave("ICS game");
6929     gameInfo.site = StrSave(appData.icsHost);
6930     gameInfo.date = PGNDate();
6931     gameInfo.round = StrSave("-");
6932
6933     /* Parse out names of players */
6934     while (*game == ' ') game++;
6935     p = buf;
6936     while (*game != ' ') *p++ = *game++;
6937     *p = NULLCHAR;
6938     gameInfo.white = StrSave(buf);
6939     while (*game == ' ') game++;
6940     p = buf;
6941     while (*game != ' ' && *game != '\n') *p++ = *game++;
6942     *p = NULLCHAR;
6943     gameInfo.black = StrSave(buf);
6944
6945     /* Parse moves */
6946     boardIndex = blackPlaysFirst ? 1 : 0;
6947     yynewstr(game);
6948     for (;;) {
6949         yyboardindex = boardIndex;
6950         moveType = (ChessMove) yylex();
6951         switch (moveType) {
6952           case IllegalMove:             /* maybe suicide chess, etc. */
6953   if (appData.debugMode) {
6954     fprintf(debugFP, "Illegal move from ICS: '%s'\n", yy_text);
6955     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
6956     setbuf(debugFP, NULL);
6957   }
6958           case WhitePromotionChancellor:
6959           case BlackPromotionChancellor:
6960           case WhitePromotionArchbishop:
6961           case BlackPromotionArchbishop:
6962           case WhitePromotionQueen:
6963           case BlackPromotionQueen:
6964           case WhitePromotionRook:
6965           case BlackPromotionRook:
6966           case WhitePromotionBishop:
6967           case BlackPromotionBishop:
6968           case WhitePromotionKnight:
6969           case BlackPromotionKnight:
6970           case WhitePromotionKing:
6971           case BlackPromotionKing:
6972           case NormalMove:
6973           case WhiteCapturesEnPassant:
6974           case BlackCapturesEnPassant:
6975           case WhiteKingSideCastle:
6976           case WhiteQueenSideCastle:
6977           case BlackKingSideCastle:
6978           case BlackQueenSideCastle:
6979           case WhiteKingSideCastleWild:
6980           case WhiteQueenSideCastleWild:
6981           case BlackKingSideCastleWild:
6982           case BlackQueenSideCastleWild:
6983           /* PUSH Fabien */
6984           case WhiteHSideCastleFR:
6985           case WhiteASideCastleFR:
6986           case BlackHSideCastleFR:
6987           case BlackASideCastleFR:
6988           /* POP Fabien */
6989             fromX = currentMoveString[0] - AAA;
6990             fromY = currentMoveString[1] - ONE;
6991             toX = currentMoveString[2] - AAA;
6992             toY = currentMoveString[3] - ONE;
6993             promoChar = currentMoveString[4];
6994             break;
6995           case WhiteDrop:
6996           case BlackDrop:
6997             fromX = moveType == WhiteDrop ?
6998               (int) CharToPiece(ToUpper(currentMoveString[0])) :
6999             (int) CharToPiece(ToLower(currentMoveString[0]));
7000             fromY = DROP_RANK;
7001             toX = currentMoveString[2] - AAA;
7002             toY = currentMoveString[3] - ONE;
7003             promoChar = NULLCHAR;
7004             break;
7005           case AmbiguousMove:
7006             /* bug? */
7007             sprintf(buf, _("Ambiguous move in ICS output: \"%s\""), yy_text);
7008   if (appData.debugMode) {
7009     fprintf(debugFP, "Ambiguous move from ICS: '%s'\n", yy_text);
7010     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
7011     setbuf(debugFP, NULL);
7012   }
7013             DisplayError(buf, 0);
7014             return;
7015           case ImpossibleMove:
7016             /* bug? */
7017             sprintf(buf, _("Illegal move in ICS output: \"%s\""), yy_text);
7018   if (appData.debugMode) {
7019     fprintf(debugFP, "Impossible move from ICS: '%s'\n", yy_text);
7020     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
7021     setbuf(debugFP, NULL);
7022   }
7023             DisplayError(buf, 0);
7024             return;
7025           case (ChessMove) 0:   /* end of file */
7026             if (boardIndex < backwardMostMove) {
7027                 /* Oops, gap.  How did that happen? */
7028                 DisplayError(_("Gap in move list"), 0);
7029                 return;
7030             }
7031             backwardMostMove =  blackPlaysFirst ? 1 : 0;
7032             if (boardIndex > forwardMostMove) {
7033                 forwardMostMove = boardIndex;
7034             }
7035             return;
7036           case ElapsedTime:
7037             if (boardIndex > (blackPlaysFirst ? 1 : 0)) {
7038                 strcat(parseList[boardIndex-1], " ");
7039                 strcat(parseList[boardIndex-1], yy_text);
7040             }
7041             continue;
7042           case Comment:
7043           case PGNTag:
7044           case NAG:
7045           default:
7046             /* ignore */
7047             continue;
7048           case WhiteWins:
7049           case BlackWins:
7050           case GameIsDrawn:
7051           case GameUnfinished:
7052             if (gameMode == IcsExamining) {
7053                 if (boardIndex < backwardMostMove) {
7054                     /* Oops, gap.  How did that happen? */
7055                     return;
7056                 }
7057                 backwardMostMove = blackPlaysFirst ? 1 : 0;
7058                 return;
7059             }
7060             gameInfo.result = moveType;
7061             p = strchr(yy_text, '{');
7062             if (p == NULL) p = strchr(yy_text, '(');
7063             if (p == NULL) {
7064                 p = yy_text;
7065                 if (p[0] == '0' || p[0] == '1' || p[0] == '*') p = "";
7066             } else {
7067                 q = strchr(p, *p == '{' ? '}' : ')');
7068                 if (q != NULL) *q = NULLCHAR;
7069                 p++;
7070             }
7071             gameInfo.resultDetails = StrSave(p);
7072             continue;
7073         }
7074         if (boardIndex >= forwardMostMove &&
7075             !(gameMode == IcsObserving && ics_gamenum == -1)) {
7076             backwardMostMove = blackPlaysFirst ? 1 : 0;
7077             return;
7078         }
7079         (void) CoordsToAlgebraic(boards[boardIndex], PosFlags(boardIndex),
7080                                  EP_UNKNOWN, fromY, fromX, toY, toX, promoChar,
7081                                  parseList[boardIndex]);
7082         CopyBoard(boards[boardIndex + 1], boards[boardIndex]);
7083         {int i; for(i=0; i<BOARD_SIZE; i++) castlingRights[boardIndex+1][i] = castlingRights[boardIndex][i];}
7084         /* currentMoveString is set as a side-effect of yylex */
7085         strcpy(moveList[boardIndex], currentMoveString);
7086         strcat(moveList[boardIndex], "\n");
7087         boardIndex++;
7088         ApplyMove(fromX, fromY, toX, toY, promoChar, boards[boardIndex],
7089                                         castlingRights[boardIndex], &epStatus[boardIndex]);
7090         switch (MateTest(boards[boardIndex], PosFlags(boardIndex),
7091                                  EP_UNKNOWN, castlingRights[boardIndex]) ) {
7092           case MT_NONE:
7093           case MT_STALEMATE:
7094           default:
7095             break;
7096           case MT_CHECK:
7097             if(gameInfo.variant != VariantShogi)
7098                 strcat(parseList[boardIndex - 1], "+");
7099             break;
7100           case MT_CHECKMATE:
7101           case MT_STAINMATE:
7102             strcat(parseList[boardIndex - 1], "#");
7103             break;
7104         }
7105     }
7106 }
7107
7108
7109 /* Apply a move to the given board  */
7110 void
7111 ApplyMove(fromX, fromY, toX, toY, promoChar, board, castling, ep)
7112      int fromX, fromY, toX, toY;
7113      int promoChar;
7114      Board board;
7115      char *castling;
7116      char *ep;
7117 {
7118   ChessSquare captured = board[toY][toX], piece, king; int p, oldEP = EP_NONE, berolina = 0;
7119
7120     /* [HGM] compute & store e.p. status and castling rights for new position */
7121     /* we can always do that 'in place', now pointers to these rights are passed to ApplyMove */
7122     { int i;
7123
7124       if(gameInfo.variant == VariantBerolina) berolina = EP_BEROLIN_A;
7125       oldEP = *ep;
7126       *ep = EP_NONE;
7127
7128       if( board[toY][toX] != EmptySquare )
7129            *ep = EP_CAPTURE;
7130
7131       if( board[fromY][fromX] == WhitePawn ) {
7132            if(fromY != toY) // [HGM] Xiangqi sideway Pawn moves should not count as 50-move breakers
7133                *ep = EP_PAWN_MOVE;
7134            if( toY-fromY==2) {
7135                if(toX>BOARD_LEFT   && board[toY][toX-1] == BlackPawn &&
7136                         gameInfo.variant != VariantBerolina || toX < fromX)
7137                       *ep = toX | berolina;
7138                if(toX<BOARD_RGHT-1 && board[toY][toX+1] == BlackPawn &&
7139                         gameInfo.variant != VariantBerolina || toX > fromX)
7140                       *ep = toX;
7141            }
7142       } else
7143       if( board[fromY][fromX] == BlackPawn ) {
7144            if(fromY != toY) // [HGM] Xiangqi sideway Pawn moves should not count as 50-move breakers
7145                *ep = EP_PAWN_MOVE;
7146            if( toY-fromY== -2) {
7147                if(toX>BOARD_LEFT   && board[toY][toX-1] == WhitePawn &&
7148                         gameInfo.variant != VariantBerolina || toX < fromX)
7149                       *ep = toX | berolina;
7150                if(toX<BOARD_RGHT-1 && board[toY][toX+1] == WhitePawn &&
7151                         gameInfo.variant != VariantBerolina || toX > fromX)
7152                       *ep = toX;
7153            }
7154        }
7155
7156        for(i=0; i<nrCastlingRights; i++) {
7157            if(castling[i] == fromX && castlingRank[i] == fromY ||
7158               castling[i] == toX   && castlingRank[i] == toY
7159              ) castling[i] = -1; // revoke for moved or captured piece
7160        }
7161
7162     }
7163
7164   /* [HGM] In Shatranj and Courier all promotions are to Ferz */
7165   if((gameInfo.variant==VariantShatranj || gameInfo.variant==VariantCourier)
7166        && promoChar != 0) promoChar = PieceToChar(WhiteFerz);
7167
7168   if (fromX == toX && fromY == toY) return;
7169
7170   if (fromY == DROP_RANK) {
7171         /* must be first */
7172         piece = board[toY][toX] = (ChessSquare) fromX;
7173   } else {
7174      piece = board[fromY][fromX]; /* [HGM] remember, for Shogi promotion */
7175      king = piece < (int) BlackPawn ? WhiteKing : BlackKing; /* [HGM] Knightmate simplify testing for castling */
7176      if(gameInfo.variant == VariantKnightmate)
7177          king += (int) WhiteUnicorn - (int) WhiteKing;
7178
7179     /* Code added by Tord: */
7180     /* FRC castling assumed when king captures friendly rook. */
7181     if (board[fromY][fromX] == WhiteKing &&
7182              board[toY][toX] == WhiteRook) {
7183       board[fromY][fromX] = EmptySquare;
7184       board[toY][toX] = EmptySquare;
7185       if(toX > fromX) {
7186         board[0][BOARD_RGHT-2] = WhiteKing; board[0][BOARD_RGHT-3] = WhiteRook;
7187       } else {
7188         board[0][BOARD_LEFT+2] = WhiteKing; board[0][BOARD_LEFT+3] = WhiteRook;
7189       }
7190     } else if (board[fromY][fromX] == BlackKing &&
7191                board[toY][toX] == BlackRook) {
7192       board[fromY][fromX] = EmptySquare;
7193       board[toY][toX] = EmptySquare;
7194       if(toX > fromX) {
7195         board[BOARD_HEIGHT-1][BOARD_RGHT-2] = BlackKing; board[BOARD_HEIGHT-1][BOARD_RGHT-3] = BlackRook;
7196       } else {
7197         board[BOARD_HEIGHT-1][BOARD_LEFT+2] = BlackKing; board[BOARD_HEIGHT-1][BOARD_LEFT+3] = BlackRook;
7198       }
7199     /* End of code added by Tord */
7200
7201     } else if (board[fromY][fromX] == king
7202         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
7203         && toY == fromY && toX > fromX+1) {
7204         board[fromY][fromX] = EmptySquare;
7205         board[toY][toX] = king;
7206         board[toY][toX-1] = board[fromY][BOARD_RGHT-1];
7207         board[fromY][BOARD_RGHT-1] = EmptySquare;
7208     } else if (board[fromY][fromX] == king
7209         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
7210                && toY == fromY && toX < fromX-1) {
7211         board[fromY][fromX] = EmptySquare;
7212         board[toY][toX] = king;
7213         board[toY][toX+1] = board[fromY][BOARD_LEFT];
7214         board[fromY][BOARD_LEFT] = EmptySquare;
7215     } else if (board[fromY][fromX] == WhitePawn
7216                && toY == BOARD_HEIGHT-1
7217                && gameInfo.variant != VariantXiangqi
7218                ) {
7219         /* white pawn promotion */
7220         board[toY][toX] = CharToPiece(ToUpper(promoChar));
7221         if (board[toY][toX] == EmptySquare) {
7222             board[toY][toX] = WhiteQueen;
7223         }
7224         if(gameInfo.variant==VariantBughouse ||
7225            gameInfo.variant==VariantCrazyhouse) /* [HGM] use shadow piece */
7226             board[toY][toX] = (ChessSquare) (PROMOTED board[toY][toX]);
7227         board[fromY][fromX] = EmptySquare;
7228     } else if ((fromY == BOARD_HEIGHT-4)
7229                && (toX != fromX)
7230                && gameInfo.variant != VariantXiangqi
7231                && gameInfo.variant != VariantBerolina
7232                && (board[fromY][fromX] == WhitePawn)
7233                && (board[toY][toX] == EmptySquare)) {
7234         board[fromY][fromX] = EmptySquare;
7235         board[toY][toX] = WhitePawn;
7236         captured = board[toY - 1][toX];
7237         board[toY - 1][toX] = EmptySquare;
7238     } else if ((fromY == BOARD_HEIGHT-4)
7239                && (toX == fromX)
7240                && gameInfo.variant == VariantBerolina
7241                && (board[fromY][fromX] == WhitePawn)
7242                && (board[toY][toX] == EmptySquare)) {
7243         board[fromY][fromX] = EmptySquare;
7244         board[toY][toX] = WhitePawn;
7245         if(oldEP & EP_BEROLIN_A) {
7246                 captured = board[fromY][fromX-1];
7247                 board[fromY][fromX-1] = EmptySquare;
7248         }else{  captured = board[fromY][fromX+1];
7249                 board[fromY][fromX+1] = EmptySquare;
7250         }
7251     } else if (board[fromY][fromX] == king
7252         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
7253                && toY == fromY && toX > fromX+1) {
7254         board[fromY][fromX] = EmptySquare;
7255         board[toY][toX] = king;
7256         board[toY][toX-1] = board[fromY][BOARD_RGHT-1];
7257         board[fromY][BOARD_RGHT-1] = EmptySquare;
7258     } else if (board[fromY][fromX] == king
7259         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
7260                && toY == fromY && toX < fromX-1) {
7261         board[fromY][fromX] = EmptySquare;
7262         board[toY][toX] = king;
7263         board[toY][toX+1] = board[fromY][BOARD_LEFT];
7264         board[fromY][BOARD_LEFT] = EmptySquare;
7265     } else if (fromY == 7 && fromX == 3
7266                && board[fromY][fromX] == BlackKing
7267                && toY == 7 && toX == 5) {
7268         board[fromY][fromX] = EmptySquare;
7269         board[toY][toX] = BlackKing;
7270         board[fromY][7] = EmptySquare;
7271         board[toY][4] = BlackRook;
7272     } else if (fromY == 7 && fromX == 3
7273                && board[fromY][fromX] == BlackKing
7274                && toY == 7 && toX == 1) {
7275         board[fromY][fromX] = EmptySquare;
7276         board[toY][toX] = BlackKing;
7277         board[fromY][0] = EmptySquare;
7278         board[toY][2] = BlackRook;
7279     } else if (board[fromY][fromX] == BlackPawn
7280                && toY == 0
7281                && gameInfo.variant != VariantXiangqi
7282                ) {
7283         /* black pawn promotion */
7284         board[0][toX] = CharToPiece(ToLower(promoChar));
7285         if (board[0][toX] == EmptySquare) {
7286             board[0][toX] = BlackQueen;
7287         }
7288         if(gameInfo.variant==VariantBughouse ||
7289            gameInfo.variant==VariantCrazyhouse) /* [HGM] use shadow piece */
7290             board[toY][toX] = (ChessSquare) (PROMOTED board[toY][toX]);
7291         board[fromY][fromX] = EmptySquare;
7292     } else if ((fromY == 3)
7293                && (toX != fromX)
7294                && gameInfo.variant != VariantXiangqi
7295                && gameInfo.variant != VariantBerolina
7296                && (board[fromY][fromX] == BlackPawn)
7297                && (board[toY][toX] == EmptySquare)) {
7298         board[fromY][fromX] = EmptySquare;
7299         board[toY][toX] = BlackPawn;
7300         captured = board[toY + 1][toX];
7301         board[toY + 1][toX] = EmptySquare;
7302     } else if ((fromY == 3)
7303                && (toX == fromX)
7304                && gameInfo.variant == VariantBerolina
7305                && (board[fromY][fromX] == BlackPawn)
7306                && (board[toY][toX] == EmptySquare)) {
7307         board[fromY][fromX] = EmptySquare;
7308         board[toY][toX] = BlackPawn;
7309         if(oldEP & EP_BEROLIN_A) {
7310                 captured = board[fromY][fromX-1];
7311                 board[fromY][fromX-1] = EmptySquare;
7312         }else{  captured = board[fromY][fromX+1];
7313                 board[fromY][fromX+1] = EmptySquare;
7314         }
7315     } else {
7316         board[toY][toX] = board[fromY][fromX];
7317         board[fromY][fromX] = EmptySquare;
7318     }
7319
7320     /* [HGM] now we promote for Shogi, if needed */
7321     if(gameInfo.variant == VariantShogi && promoChar == 'q')
7322         board[toY][toX] = (ChessSquare) (PROMOTED piece);
7323   }
7324
7325     if (gameInfo.holdingsWidth != 0) {
7326
7327       /* !!A lot more code needs to be written to support holdings  */
7328       /* [HGM] OK, so I have written it. Holdings are stored in the */
7329       /* penultimate board files, so they are automaticlly stored   */
7330       /* in the game history.                                       */
7331       if (fromY == DROP_RANK) {
7332         /* Delete from holdings, by decreasing count */
7333         /* and erasing image if necessary            */
7334         p = (int) fromX;
7335         if(p < (int) BlackPawn) { /* white drop */
7336              p -= (int)WhitePawn;
7337              if(p >= gameInfo.holdingsSize) p = 0;
7338              if(--board[p][BOARD_WIDTH-2] == 0)
7339                   board[p][BOARD_WIDTH-1] = EmptySquare;
7340         } else {                  /* black drop */
7341              p -= (int)BlackPawn;
7342              if(p >= gameInfo.holdingsSize) p = 0;
7343              if(--board[BOARD_HEIGHT-1-p][1] == 0)
7344                   board[BOARD_HEIGHT-1-p][0] = EmptySquare;
7345         }
7346       }
7347       if (captured != EmptySquare && gameInfo.holdingsSize > 0
7348           && gameInfo.variant != VariantBughouse        ) {
7349         /* [HGM] holdings: Add to holdings, if holdings exist */
7350         if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
7351                 // [HGM] superchess: suppress flipping color of captured pieces by reverse pre-flip
7352                 captured = (int) captured >= (int) BlackPawn ? BLACK_TO_WHITE captured : WHITE_TO_BLACK captured;
7353         }
7354         p = (int) captured;
7355         if (p >= (int) BlackPawn) {
7356           p -= (int)BlackPawn;
7357           if(gameInfo.variant == VariantShogi && DEMOTED p >= 0) {
7358                   /* in Shogi restore piece to its original  first */
7359                   captured = (ChessSquare) (DEMOTED captured);
7360                   p = DEMOTED p;
7361           }
7362           p = PieceToNumber((ChessSquare)p);
7363           if(p >= gameInfo.holdingsSize) { p = 0; captured = BlackPawn; }
7364           board[p][BOARD_WIDTH-2]++;
7365           board[p][BOARD_WIDTH-1] = BLACK_TO_WHITE captured;
7366         } else {
7367           p -= (int)WhitePawn;
7368           if(gameInfo.variant == VariantShogi && DEMOTED p >= 0) {
7369                   captured = (ChessSquare) (DEMOTED captured);
7370                   p = DEMOTED p;
7371           }
7372           p = PieceToNumber((ChessSquare)p);
7373           if(p >= gameInfo.holdingsSize) { p = 0; captured = WhitePawn; }
7374           board[BOARD_HEIGHT-1-p][1]++;
7375           board[BOARD_HEIGHT-1-p][0] = WHITE_TO_BLACK captured;
7376         }
7377       }
7378
7379     } else if (gameInfo.variant == VariantAtomic) {
7380       if (captured != EmptySquare) {
7381         int y, x;
7382         for (y = toY-1; y <= toY+1; y++) {
7383           for (x = toX-1; x <= toX+1; x++) {
7384             if (y >= 0 && y < BOARD_HEIGHT && x >= BOARD_LEFT && x < BOARD_RGHT &&
7385                 board[y][x] != WhitePawn && board[y][x] != BlackPawn) {
7386               board[y][x] = EmptySquare;
7387             }
7388           }
7389         }
7390         board[toY][toX] = EmptySquare;
7391       }
7392     }
7393     if(gameInfo.variant == VariantShogi && promoChar != NULLCHAR && promoChar != '=') {
7394         /* [HGM] Shogi promotions */
7395         board[toY][toX] = (ChessSquare) (PROMOTED piece);
7396     }
7397
7398     if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat)
7399                 && promoChar != NULLCHAR && gameInfo.holdingsSize) {
7400         // [HGM] superchess: take promotion piece out of holdings
7401         int k = PieceToNumber(CharToPiece(ToUpper(promoChar)));
7402         if((int)piece < (int)BlackPawn) { // determine stm from piece color
7403             if(!--board[k][BOARD_WIDTH-2])
7404                 board[k][BOARD_WIDTH-1] = EmptySquare;
7405         } else {
7406             if(!--board[BOARD_HEIGHT-1-k][1])
7407                 board[BOARD_HEIGHT-1-k][0] = EmptySquare;
7408         }
7409     }
7410
7411 }
7412
7413 /* Updates forwardMostMove */
7414 void
7415 MakeMove(fromX, fromY, toX, toY, promoChar)
7416      int fromX, fromY, toX, toY;
7417      int promoChar;
7418 {
7419 //    forwardMostMove++; // [HGM] bare: moved downstream
7420
7421     if(serverMoves != NULL) { /* [HGM] write moves on file for broadcasting (should be separate routine, really) */
7422         int timeLeft; static int lastLoadFlag=0; int king, piece;
7423         piece = boards[forwardMostMove][fromY][fromX];
7424         king = piece < (int) BlackPawn ? WhiteKing : BlackKing;
7425         if(gameInfo.variant == VariantKnightmate)
7426             king += (int) WhiteUnicorn - (int) WhiteKing;
7427         if(forwardMostMove == 0) {
7428             if(blackPlaysFirst)
7429                 fprintf(serverMoves, "%s;", second.tidy);
7430             fprintf(serverMoves, "%s;", first.tidy);
7431             if(!blackPlaysFirst)
7432                 fprintf(serverMoves, "%s;", second.tidy);
7433         } else fprintf(serverMoves, loadFlag|lastLoadFlag ? ":" : ";");
7434         lastLoadFlag = loadFlag;
7435         // print base move
7436         fprintf(serverMoves, "%c%c:%c%c", AAA+fromX, ONE+fromY, AAA+toX, ONE+toY);
7437         // print castling suffix
7438         if( toY == fromY && piece == king ) {
7439             if(toX-fromX > 1)
7440                 fprintf(serverMoves, ":%c%c:%c%c", AAA+BOARD_RGHT-1, ONE+fromY, AAA+toX-1,ONE+toY);
7441             if(fromX-toX >1)
7442                 fprintf(serverMoves, ":%c%c:%c%c", AAA+BOARD_LEFT, ONE+fromY, AAA+toX+1,ONE+toY);
7443         }
7444         // e.p. suffix
7445         if( (boards[forwardMostMove][fromY][fromX] == WhitePawn ||
7446              boards[forwardMostMove][fromY][fromX] == BlackPawn   ) &&
7447              boards[forwardMostMove][toY][toX] == EmptySquare
7448              && fromX != toX )
7449                 fprintf(serverMoves, ":%c%c:%c%c", AAA+fromX, ONE+fromY, AAA+toX, ONE+fromY);
7450         // promotion suffix
7451         if(promoChar != NULLCHAR)
7452                 fprintf(serverMoves, ":%c:%c%c", promoChar, AAA+toX, ONE+toY);
7453         if(!loadFlag) {
7454             fprintf(serverMoves, "/%d/%d",
7455                pvInfoList[forwardMostMove].depth, pvInfoList[forwardMostMove].score);
7456             if(forwardMostMove+1 & 1) timeLeft = whiteTimeRemaining/1000;
7457             else                      timeLeft = blackTimeRemaining/1000;
7458             fprintf(serverMoves, "/%d", timeLeft);
7459         }
7460         fflush(serverMoves);
7461     }
7462
7463     if (forwardMostMove+1 >= MAX_MOVES) {
7464       DisplayFatalError(_("Game too long; increase MAX_MOVES and recompile"),
7465                         0, 1);
7466       return;
7467     }
7468     SwitchClocks();
7469     timeRemaining[0][forwardMostMove+1] = whiteTimeRemaining;
7470     timeRemaining[1][forwardMostMove+1] = blackTimeRemaining;
7471     if (commentList[forwardMostMove+1] != NULL) {
7472         free(commentList[forwardMostMove+1]);
7473         commentList[forwardMostMove+1] = NULL;
7474     }
7475     CopyBoard(boards[forwardMostMove+1], boards[forwardMostMove]);
7476     {int i; for(i=0; i<BOARD_SIZE; i++) castlingRights[forwardMostMove+1][i] = castlingRights[forwardMostMove][i];}
7477     ApplyMove(fromX, fromY, toX, toY, promoChar, boards[forwardMostMove+1],
7478                                 castlingRights[forwardMostMove+1], &epStatus[forwardMostMove+1]);
7479     forwardMostMove++; // [HGM] bare: moved to after ApplyMove, to make sure clock interrupt finds complete board
7480     gameInfo.result = GameUnfinished;
7481     if (gameInfo.resultDetails != NULL) {
7482         free(gameInfo.resultDetails);
7483         gameInfo.resultDetails = NULL;
7484     }
7485     CoordsToComputerAlgebraic(fromY, fromX, toY, toX, promoChar,
7486                               moveList[forwardMostMove - 1]);
7487     (void) CoordsToAlgebraic(boards[forwardMostMove - 1],
7488                              PosFlags(forwardMostMove - 1), EP_UNKNOWN,
7489                              fromY, fromX, toY, toX, promoChar,
7490                              parseList[forwardMostMove - 1]);
7491     switch (MateTest(boards[forwardMostMove], PosFlags(forwardMostMove),
7492                        epStatus[forwardMostMove], /* [HGM] use true e.p. */
7493                             castlingRights[forwardMostMove]) ) {
7494       case MT_NONE:
7495       case MT_STALEMATE:
7496       default:
7497         break;
7498       case MT_CHECK:
7499         if(gameInfo.variant != VariantShogi)
7500             strcat(parseList[forwardMostMove - 1], "+");
7501         break;
7502       case MT_CHECKMATE:
7503       case MT_STAINMATE:
7504         strcat(parseList[forwardMostMove - 1], "#");
7505         break;
7506     }
7507     if (appData.debugMode) {
7508         fprintf(debugFP, "move: %s, parse: %s (%c)\n", moveList[forwardMostMove-1], parseList[forwardMostMove-1], moveList[forwardMostMove-1][4]);
7509     }
7510
7511 }
7512
7513 /* Updates currentMove if not pausing */
7514 void
7515 ShowMove(fromX, fromY, toX, toY)
7516 {
7517     int instant = (gameMode == PlayFromGameFile) ?
7518         (matchMode || (appData.timeDelay == 0 && !pausing)) : pausing;
7519     if(appData.noGUI) return;
7520     if (!pausing || gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
7521         if (!instant) {
7522             if (forwardMostMove == currentMove + 1) {
7523                 AnimateMove(boards[forwardMostMove - 1],
7524                             fromX, fromY, toX, toY);
7525             }
7526             if (appData.highlightLastMove) {
7527                 SetHighlights(fromX, fromY, toX, toY);
7528             }
7529         }
7530         currentMove = forwardMostMove;
7531     }
7532
7533     if (instant) return;
7534
7535     DisplayMove(currentMove - 1);
7536     DrawPosition(FALSE, boards[currentMove]);
7537     DisplayBothClocks();
7538     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
7539 }
7540
7541 void SendEgtPath(ChessProgramState *cps)
7542 {       /* [HGM] EGT: match formats given in feature with those given by user, and send info for each match */
7543         char buf[MSG_SIZ], name[MSG_SIZ], *p;
7544
7545         if((p = cps->egtFormats) == NULL || appData.egtFormats == NULL) return;
7546
7547         while(*p) {
7548             char c, *q = name+1, *r, *s;
7549
7550             name[0] = ','; // extract next format name from feature and copy with prefixed ','
7551             while(*p && *p != ',') *q++ = *p++;
7552             *q++ = ':'; *q = 0;
7553             if( appData.defaultPathEGTB && appData.defaultPathEGTB[0] &&
7554                 strcmp(name, ",nalimov:") == 0 ) {
7555                 // take nalimov path from the menu-changeable option first, if it is defined
7556                 sprintf(buf, "egtpath nalimov %s\n", appData.defaultPathEGTB);
7557                 SendToProgram(buf,cps);     // send egtbpath command for nalimov
7558             } else
7559             if( (s = StrStr(appData.egtFormats, name+1)) == appData.egtFormats ||
7560                 (s = StrStr(appData.egtFormats, name)) != NULL) {
7561                 // format name occurs amongst user-supplied formats, at beginning or immediately after comma
7562                 s = r = StrStr(s, ":") + 1; // beginning of path info
7563                 while(*r && *r != ',') r++; // path info is everything upto next ';' or end of string
7564                 c = *r; *r = 0;             // temporarily null-terminate path info
7565                     *--q = 0;               // strip of trailig ':' from name
7566                     sprintf(buf, "egtpath %s %s\n", name+1, s);
7567                 *r = c;
7568                 SendToProgram(buf,cps);     // send egtbpath command for this format
7569             }
7570             if(*p == ',') p++; // read away comma to position for next format name
7571         }
7572 }
7573
7574 void
7575 InitChessProgram(cps, setup)
7576      ChessProgramState *cps;
7577      int setup; /* [HGM] needed to setup FRC opening position */
7578 {
7579     char buf[MSG_SIZ], b[MSG_SIZ]; int overruled;
7580     if (appData.noChessProgram) return;
7581     hintRequested = FALSE;
7582     bookRequested = FALSE;
7583
7584     /* [HGM] some new WB protocol commands to configure engine are sent now, if engine supports them */
7585     /*       moved to before sending initstring in 4.3.15, so Polyglot can delay UCI 'isready' to recepton of 'new' */
7586     if(cps->memSize) { /* [HGM] memory */
7587         sprintf(buf, "memory %d\n", appData.defaultHashSize + appData.defaultCacheSizeEGTB);
7588         SendToProgram(buf, cps);
7589     }
7590     SendEgtPath(cps); /* [HGM] EGT */
7591     if(cps->maxCores) { /* [HGM] SMP: (protocol specified must be last settings command before new!) */
7592         sprintf(buf, "cores %d\n", appData.smpCores);
7593         SendToProgram(buf, cps);
7594     }
7595
7596     SendToProgram(cps->initString, cps);
7597     if (gameInfo.variant != VariantNormal &&
7598         gameInfo.variant != VariantLoadable
7599         /* [HGM] also send variant if board size non-standard */
7600         || gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0
7601                                             ) {
7602       char *v = VariantName(gameInfo.variant);
7603       if (cps->protocolVersion != 1 && StrStr(cps->variants, v) == NULL) {
7604         /* [HGM] in protocol 1 we have to assume all variants valid */
7605         sprintf(buf, _("Variant %s not supported by %s"), v, cps->tidy);
7606         DisplayFatalError(buf, 0, 1);
7607         return;
7608       }
7609
7610       /* [HGM] make prefix for non-standard board size. Awkward testing... */
7611       overruled = gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0;
7612       if( gameInfo.variant == VariantXiangqi )
7613            overruled = gameInfo.boardWidth != 9 || gameInfo.boardHeight != 10 || gameInfo.holdingsSize != 0;
7614       if( gameInfo.variant == VariantShogi )
7615            overruled = gameInfo.boardWidth != 9 || gameInfo.boardHeight != 9 || gameInfo.holdingsSize != 7;
7616       if( gameInfo.variant == VariantBughouse || gameInfo.variant == VariantCrazyhouse )
7617            overruled = gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 5;
7618       if( gameInfo.variant == VariantCapablanca || gameInfo.variant == VariantCapaRandom ||
7619                                gameInfo.variant == VariantGothic  || gameInfo.variant == VariantFalcon )
7620            overruled = gameInfo.boardWidth != 10 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0;
7621       if( gameInfo.variant == VariantCourier )
7622            overruled = gameInfo.boardWidth != 12 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0;
7623       if( gameInfo.variant == VariantSuper )
7624            overruled = gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 8;
7625       if( gameInfo.variant == VariantGreat )
7626            overruled = gameInfo.boardWidth != 10 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 8;
7627
7628       if(overruled) {
7629            sprintf(b, "%dx%d+%d_%s", gameInfo.boardWidth, gameInfo.boardHeight,
7630                                gameInfo.holdingsSize, VariantName(gameInfo.variant)); // cook up sized variant name
7631            /* [HGM] varsize: try first if this defiant size variant is specifically known */
7632            if(StrStr(cps->variants, b) == NULL) {
7633                // specific sized variant not known, check if general sizing allowed
7634                if (cps->protocolVersion != 1) { // for protocol 1 we cannot check and hope for the best
7635                    if(StrStr(cps->variants, "boardsize") == NULL) {
7636                        sprintf(buf, "Board size %dx%d+%d not supported by %s",
7637                             gameInfo.boardWidth, gameInfo.boardHeight, gameInfo.holdingsSize, cps->tidy);
7638                        DisplayFatalError(buf, 0, 1);
7639                        return;
7640                    }
7641                    /* [HGM] here we really should compare with the maximum supported board size */
7642                }
7643            }
7644       } else sprintf(b, "%s", VariantName(gameInfo.variant));
7645       sprintf(buf, "variant %s\n", b);
7646       SendToProgram(buf, cps);
7647     }
7648     currentlyInitializedVariant = gameInfo.variant;
7649
7650     /* [HGM] send opening position in FRC to first engine */
7651     if(setup) {
7652           SendToProgram("force\n", cps);
7653           SendBoard(cps, 0);
7654           /* engine is now in force mode! Set flag to wake it up after first move. */
7655           setboardSpoiledMachineBlack = 1;
7656     }
7657
7658     if (cps->sendICS) {
7659       snprintf(buf, sizeof(buf), "ics %s\n", appData.icsActive ? appData.icsHost : "-");
7660       SendToProgram(buf, cps);
7661     }
7662     cps->maybeThinking = FALSE;
7663     cps->offeredDraw = 0;
7664     if (!appData.icsActive) {
7665         SendTimeControl(cps, movesPerSession, timeControl,
7666                         timeIncrement, appData.searchDepth,
7667                         searchTime);
7668     }
7669     if (appData.showThinking
7670         // [HGM] thinking: four options require thinking output to be sent
7671         || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp()
7672                                 ) {
7673         SendToProgram("post\n", cps);
7674     }
7675     SendToProgram("hard\n", cps);
7676     if (!appData.ponderNextMove) {
7677         /* Warning: "easy" is a toggle in GNU Chess, so don't send
7678            it without being sure what state we are in first.  "hard"
7679            is not a toggle, so that one is OK.
7680          */
7681         SendToProgram("easy\n", cps);
7682     }
7683     if (cps->usePing) {
7684       sprintf(buf, "ping %d\n", ++cps->lastPing);
7685       SendToProgram(buf, cps);
7686     }
7687     cps->initDone = TRUE;
7688 }
7689
7690
7691 void
7692 StartChessProgram(cps)
7693      ChessProgramState *cps;
7694 {
7695     char buf[MSG_SIZ];
7696     int err;
7697
7698     if (appData.noChessProgram) return;
7699     cps->initDone = FALSE;
7700
7701     if (strcmp(cps->host, "localhost") == 0) {
7702         err = StartChildProcess(cps->program, cps->dir, &cps->pr);
7703     } else if (*appData.remoteShell == NULLCHAR) {
7704         err = OpenRcmd(cps->host, appData.remoteUser, cps->program, &cps->pr);
7705     } else {
7706         if (*appData.remoteUser == NULLCHAR) {
7707           snprintf(buf, sizeof(buf), "%s %s %s", appData.remoteShell, cps->host,
7708                     cps->program);
7709         } else {
7710           snprintf(buf, sizeof(buf), "%s %s -l %s %s", appData.remoteShell,
7711                     cps->host, appData.remoteUser, cps->program);
7712         }
7713         err = StartChildProcess(buf, "", &cps->pr);
7714     }
7715
7716     if (err != 0) {
7717         sprintf(buf, _("Startup failure on '%s'"), cps->program);
7718         DisplayFatalError(buf, err, 1);
7719         cps->pr = NoProc;
7720         cps->isr = NULL;
7721         return;
7722     }
7723
7724     cps->isr = AddInputSource(cps->pr, TRUE, ReceiveFromProgram, cps);
7725     if (cps->protocolVersion > 1) {
7726       sprintf(buf, "xboard\nprotover %d\n", cps->protocolVersion);
7727       cps->nrOptions = 0; // [HGM] options: clear all engine-specific options
7728       cps->comboCnt = 0;  //                and values of combo boxes
7729       SendToProgram(buf, cps);
7730     } else {
7731       SendToProgram("xboard\n", cps);
7732     }
7733 }
7734
7735
7736 void
7737 TwoMachinesEventIfReady P((void))
7738 {
7739   if (first.lastPing != first.lastPong) {
7740     DisplayMessage("", _("Waiting for first chess program"));
7741     ScheduleDelayedEvent(TwoMachinesEventIfReady, 10); // [HGM] fast: lowered from 1000
7742     return;
7743   }
7744   if (second.lastPing != second.lastPong) {
7745     DisplayMessage("", _("Waiting for second chess program"));
7746     ScheduleDelayedEvent(TwoMachinesEventIfReady, 10); // [HGM] fast: lowered from 1000
7747     return;
7748   }
7749   ThawUI();
7750   TwoMachinesEvent();
7751 }
7752
7753 void
7754 NextMatchGame P((void))
7755 {
7756     int index; /* [HGM] autoinc: step lod index during match */
7757     Reset(FALSE, TRUE);
7758     if (*appData.loadGameFile != NULLCHAR) {
7759         index = appData.loadGameIndex;
7760         if(index < 0) { // [HGM] autoinc
7761             lastIndex = index = (index == -2 && first.twoMachinesColor[0] == 'b') ? lastIndex : lastIndex+1;
7762             if(appData.rewindIndex > 0 && index > appData.rewindIndex) lastIndex = index = 1;
7763         }
7764         LoadGameFromFile(appData.loadGameFile,
7765                          index,
7766                          appData.loadGameFile, FALSE);
7767     } else if (*appData.loadPositionFile != NULLCHAR) {
7768         index = appData.loadPositionIndex;
7769         if(index < 0) { // [HGM] autoinc
7770             lastIndex = index = (index == -2 && first.twoMachinesColor[0] == 'b') ? lastIndex : lastIndex+1;
7771             if(appData.rewindIndex > 0 && index > appData.rewindIndex) lastIndex = index = 1;
7772         }
7773         LoadPositionFromFile(appData.loadPositionFile,
7774                              index,
7775                              appData.loadPositionFile);
7776     }
7777     TwoMachinesEventIfReady();
7778 }
7779
7780 void UserAdjudicationEvent( int result )
7781 {
7782     ChessMove gameResult = GameIsDrawn;
7783
7784     if( result > 0 ) {
7785         gameResult = WhiteWins;
7786     }
7787     else if( result < 0 ) {
7788         gameResult = BlackWins;
7789     }
7790
7791     if( gameMode == TwoMachinesPlay ) {
7792         GameEnds( gameResult, "User adjudication", GE_XBOARD );
7793     }
7794 }
7795
7796
7797 // [HGM] save: calculate checksum of game to make games easily identifiable
7798 int StringCheckSum(char *s)
7799 {
7800         int i = 0;
7801         if(s==NULL) return 0;
7802         while(*s) i = i*259 + *s++;
7803         return i;
7804 }
7805
7806 int GameCheckSum()
7807 {
7808         int i, sum=0;
7809         for(i=backwardMostMove; i<forwardMostMove; i++) {
7810                 sum += pvInfoList[i].depth;
7811                 sum += StringCheckSum(parseList[i]);
7812                 sum += StringCheckSum(commentList[i]);
7813                 sum *= 261;
7814         }
7815         if(i>1 && sum==0) sum++; // make sure never zero for non-empty game
7816         return sum + StringCheckSum(commentList[i]);
7817 } // end of save patch
7818
7819 void
7820 GameEnds(result, resultDetails, whosays)
7821      ChessMove result;
7822      char *resultDetails;
7823      int whosays;
7824 {
7825     GameMode nextGameMode;
7826     int isIcsGame;
7827     char buf[MSG_SIZ];
7828
7829     if(endingGame) return; /* [HGM] crash: forbid recursion */
7830     endingGame = 1;
7831
7832     if (appData.debugMode) {
7833       fprintf(debugFP, "GameEnds(%d, %s, %d)\n",
7834               result, resultDetails ? resultDetails : "(null)", whosays);
7835     }
7836
7837     if (appData.icsActive && (whosays == GE_ENGINE || whosays >= GE_ENGINE1)) {
7838         /* If we are playing on ICS, the server decides when the
7839            game is over, but the engine can offer to draw, claim
7840            a draw, or resign.
7841          */
7842 #if ZIPPY
7843         if (appData.zippyPlay && first.initDone) {
7844             if (result == GameIsDrawn) {
7845                 /* In case draw still needs to be claimed */
7846                 SendToICS(ics_prefix);
7847                 SendToICS("draw\n");
7848             } else if (StrCaseStr(resultDetails, "resign")) {
7849                 SendToICS(ics_prefix);
7850                 SendToICS("resign\n");
7851             }
7852         }
7853 #endif
7854         endingGame = 0; /* [HGM] crash */
7855         return;
7856     }
7857
7858     /* If we're loading the game from a file, stop */
7859     if (whosays == GE_FILE) {
7860       (void) StopLoadGameTimer();
7861       gameFileFP = NULL;
7862     }
7863
7864     /* Cancel draw offers */
7865     first.offeredDraw = second.offeredDraw = 0;
7866
7867     /* If this is an ICS game, only ICS can really say it's done;
7868        if not, anyone can. */
7869     isIcsGame = (gameMode == IcsPlayingWhite ||
7870                  gameMode == IcsPlayingBlack ||
7871                  gameMode == IcsObserving    ||
7872                  gameMode == IcsExamining);
7873
7874     if (!isIcsGame || whosays == GE_ICS) {
7875         /* OK -- not an ICS game, or ICS said it was done */
7876         StopClocks();
7877         if (!isIcsGame && !appData.noChessProgram)
7878           SetUserThinkingEnables();
7879
7880         /* [HGM] if a machine claims the game end we verify this claim */
7881         if(gameMode == TwoMachinesPlay && appData.testClaims) {
7882             if(appData.testLegality && whosays >= GE_ENGINE1 ) {
7883                 char claimer;
7884                 ChessMove trueResult = (ChessMove) -1;
7885
7886                 claimer = whosays == GE_ENGINE1 ?      /* color of claimer */
7887                                             first.twoMachinesColor[0] :
7888                                             second.twoMachinesColor[0] ;
7889
7890                 // [HGM] losers: because the logic is becoming a bit hairy, determine true result first
7891                 if(epStatus[forwardMostMove] == EP_CHECKMATE) {
7892                     /* [HGM] verify: engine mate claims accepted if they were flagged */
7893                     trueResult = WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins;
7894                 } else
7895                 if(epStatus[forwardMostMove] == EP_WINS) { // added code for games where being mated is a win
7896                     /* [HGM] verify: engine mate claims accepted if they were flagged */
7897                     trueResult = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
7898                 } else
7899                 if(epStatus[forwardMostMove] == EP_STALEMATE) { // only used to indicate draws now
7900                     trueResult = GameIsDrawn; // default; in variants where stalemate loses, Status is CHECKMATE
7901                 }
7902
7903                 // now verify win claims, but not in drop games, as we don't understand those yet
7904                 if( (gameInfo.holdingsWidth == 0 || gameInfo.variant == VariantSuper
7905                                                  || gameInfo.variant == VariantGreat) &&
7906                     (result == WhiteWins && claimer == 'w' ||
7907                      result == BlackWins && claimer == 'b'   ) ) { // case to verify: engine claims own win
7908                       if (appData.debugMode) {
7909                         fprintf(debugFP, "result=%d sp=%d move=%d\n",
7910                                 result, epStatus[forwardMostMove], forwardMostMove);
7911                       }
7912                       if(result != trueResult) {
7913                               sprintf(buf, "False win claim: '%s'", resultDetails);
7914                               result = claimer == 'w' ? BlackWins : WhiteWins;
7915                               resultDetails = buf;
7916                       }
7917                 } else
7918                 if( result == GameIsDrawn && epStatus[forwardMostMove] > EP_DRAWS
7919                     && (forwardMostMove <= backwardMostMove ||
7920                         epStatus[forwardMostMove-1] > EP_DRAWS ||
7921                         (claimer=='b')==(forwardMostMove&1))
7922                                                                                   ) {
7923                       /* [HGM] verify: draws that were not flagged are false claims */
7924                       sprintf(buf, "False draw claim: '%s'", resultDetails);
7925                       result = claimer == 'w' ? BlackWins : WhiteWins;
7926                       resultDetails = buf;
7927                 }
7928                 /* (Claiming a loss is accepted no questions asked!) */
7929             }
7930             /* [HGM] bare: don't allow bare King to win */
7931             if((gameInfo.holdingsWidth == 0 || gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat)
7932                && gameInfo.variant != VariantLosers && gameInfo.variant != VariantGiveaway
7933                && gameInfo.variant != VariantSuicide // [HGM] losers: except in losers, of course...
7934                && result != GameIsDrawn)
7935             {   int i, j, k=0, color = (result==WhiteWins ? (int)WhitePawn : (int)BlackPawn);
7936                 for(j=BOARD_LEFT; j<BOARD_RGHT; j++) for(i=0; i<BOARD_HEIGHT; i++) {
7937                         int p = (int)boards[forwardMostMove][i][j] - color;
7938                         if(p >= 0 && p <= (int)WhiteKing) k++;
7939                 }
7940                 if (appData.debugMode) {
7941                      fprintf(debugFP, "GE(%d, %s, %d) bare king k=%d color=%d\n",
7942                         result, resultDetails ? resultDetails : "(null)", whosays, k, color);
7943                 }
7944                 if(k <= 1) {
7945                         result = GameIsDrawn;
7946                         sprintf(buf, "%s but bare king", resultDetails);
7947                         resultDetails = buf;
7948                 }
7949             }
7950         }
7951
7952
7953         if(serverMoves != NULL && !loadFlag) { char c = '=';
7954             if(result==WhiteWins) c = '+';
7955             if(result==BlackWins) c = '-';
7956             if(resultDetails != NULL)
7957                 fprintf(serverMoves, ";%c;%s\n", c, resultDetails);
7958         }
7959         if (resultDetails != NULL) {
7960             gameInfo.result = result;
7961             gameInfo.resultDetails = StrSave(resultDetails);
7962
7963             /* display last move only if game was not loaded from file */
7964             if ((whosays != GE_FILE) && (currentMove == forwardMostMove))
7965                 DisplayMove(currentMove - 1);
7966
7967             if (forwardMostMove != 0) {
7968                 if (gameMode != PlayFromGameFile && gameMode != EditGame
7969                     && lastSavedGame != GameCheckSum() // [HGM] save: suppress duplicates
7970                                                                 ) {
7971                     if (*appData.saveGameFile != NULLCHAR) {
7972                         SaveGameToFile(appData.saveGameFile, TRUE);
7973                     } else if (appData.autoSaveGames) {
7974                         AutoSaveGame();
7975                     }
7976                     if (*appData.savePositionFile != NULLCHAR) {
7977                         SavePositionToFile(appData.savePositionFile);
7978                     }
7979                 }
7980             }
7981
7982             /* Tell program how game ended in case it is learning */
7983             /* [HGM] Moved this to after saving the PGN, just in case */
7984             /* engine died and we got here through time loss. In that */
7985             /* case we will get a fatal error writing the pipe, which */
7986             /* would otherwise lose us the PGN.                       */
7987             /* [HGM] crash: not needed anymore, but doesn't hurt;     */
7988             /* output during GameEnds should never be fatal anymore   */
7989             if (gameMode == MachinePlaysWhite ||
7990                 gameMode == MachinePlaysBlack ||
7991                 gameMode == TwoMachinesPlay ||
7992                 gameMode == IcsPlayingWhite ||
7993                 gameMode == IcsPlayingBlack ||
7994                 gameMode == BeginningOfGame) {
7995                 char buf[MSG_SIZ];
7996                 sprintf(buf, "result %s {%s}\n", PGNResult(result),
7997                         resultDetails);
7998                 if (first.pr != NoProc) {
7999                     SendToProgram(buf, &first);
8000                 }
8001                 if (second.pr != NoProc &&
8002                     gameMode == TwoMachinesPlay) {
8003                     SendToProgram(buf, &second);
8004                 }
8005             }
8006         }
8007
8008         if (appData.icsActive) {
8009             if (appData.quietPlay &&
8010                 (gameMode == IcsPlayingWhite ||
8011                  gameMode == IcsPlayingBlack)) {
8012                 SendToICS(ics_prefix);
8013                 SendToICS("set shout 1\n");
8014             }
8015             nextGameMode = IcsIdle;
8016             ics_user_moved = FALSE;
8017             /* clean up premove.  It's ugly when the game has ended and the
8018              * premove highlights are still on the board.
8019              */
8020             if (gotPremove) {
8021               gotPremove = FALSE;
8022               ClearPremoveHighlights();
8023               DrawPosition(FALSE, boards[currentMove]);
8024             }
8025             if (whosays == GE_ICS) {
8026                 switch (result) {
8027                 case WhiteWins:
8028                     if (gameMode == IcsPlayingWhite)
8029                         PlayIcsWinSound();
8030                     else if(gameMode == IcsPlayingBlack)
8031                         PlayIcsLossSound();
8032                     break;
8033                 case BlackWins:
8034                     if (gameMode == IcsPlayingBlack)
8035                         PlayIcsWinSound();
8036                     else if(gameMode == IcsPlayingWhite)
8037                         PlayIcsLossSound();
8038                     break;
8039                 case GameIsDrawn:
8040                     PlayIcsDrawSound();
8041                     break;
8042                 default:
8043                     PlayIcsUnfinishedSound();
8044                 }
8045             }
8046         } else if (gameMode == EditGame ||
8047                    gameMode == PlayFromGameFile ||
8048                    gameMode == AnalyzeMode ||
8049                    gameMode == AnalyzeFile) {
8050             nextGameMode = gameMode;
8051         } else {
8052             nextGameMode = EndOfGame;
8053         }
8054         pausing = FALSE;
8055         ModeHighlight();
8056     } else {
8057         nextGameMode = gameMode;
8058     }
8059
8060     if (appData.noChessProgram) {
8061         gameMode = nextGameMode;
8062         ModeHighlight();
8063         endingGame = 0; /* [HGM] crash */
8064         return;
8065     }
8066
8067     if (first.reuse) {
8068         /* Put first chess program into idle state */
8069         if (first.pr != NoProc &&
8070             (gameMode == MachinePlaysWhite ||
8071              gameMode == MachinePlaysBlack ||
8072              gameMode == TwoMachinesPlay ||
8073              gameMode == IcsPlayingWhite ||
8074              gameMode == IcsPlayingBlack ||
8075              gameMode == BeginningOfGame)) {
8076             SendToProgram("force\n", &first);
8077             if (first.usePing) {
8078               char buf[MSG_SIZ];
8079               sprintf(buf, "ping %d\n", ++first.lastPing);
8080               SendToProgram(buf, &first);
8081             }
8082         }
8083     } else if (result != GameUnfinished || nextGameMode == IcsIdle) {
8084         /* Kill off first chess program */
8085         if (first.isr != NULL)
8086           RemoveInputSource(first.isr);
8087         first.isr = NULL;
8088
8089         if (first.pr != NoProc) {
8090             ExitAnalyzeMode();
8091             DoSleep( appData.delayBeforeQuit );
8092             SendToProgram("quit\n", &first);
8093             DoSleep( appData.delayAfterQuit );
8094             DestroyChildProcess(first.pr, first.useSigterm);
8095         }
8096         first.pr = NoProc;
8097     }
8098     if (second.reuse) {
8099         /* Put second chess program into idle state */
8100         if (second.pr != NoProc &&
8101             gameMode == TwoMachinesPlay) {
8102             SendToProgram("force\n", &second);
8103             if (second.usePing) {
8104               char buf[MSG_SIZ];
8105               sprintf(buf, "ping %d\n", ++second.lastPing);
8106               SendToProgram(buf, &second);
8107             }
8108         }
8109     } else if (result != GameUnfinished || nextGameMode == IcsIdle) {
8110         /* Kill off second chess program */
8111         if (second.isr != NULL)
8112           RemoveInputSource(second.isr);
8113         second.isr = NULL;
8114
8115         if (second.pr != NoProc) {
8116             DoSleep( appData.delayBeforeQuit );
8117             SendToProgram("quit\n", &second);
8118             DoSleep( appData.delayAfterQuit );
8119             DestroyChildProcess(second.pr, second.useSigterm);
8120         }
8121         second.pr = NoProc;
8122     }
8123
8124     if (matchMode && gameMode == TwoMachinesPlay) {
8125         switch (result) {
8126         case WhiteWins:
8127           if (first.twoMachinesColor[0] == 'w') {
8128             first.matchWins++;
8129           } else {
8130             second.matchWins++;
8131           }
8132           break;
8133         case BlackWins:
8134           if (first.twoMachinesColor[0] == 'b') {
8135             first.matchWins++;
8136           } else {
8137             second.matchWins++;
8138           }
8139           break;
8140         default:
8141           break;
8142         }
8143         if (matchGame < appData.matchGames) {
8144             char *tmp;
8145             if(appData.sameColorGames <= 1) { /* [HGM] alternate: suppress color swap */
8146                 tmp = first.twoMachinesColor;
8147                 first.twoMachinesColor = second.twoMachinesColor;
8148                 second.twoMachinesColor = tmp;
8149             }
8150             gameMode = nextGameMode;
8151             matchGame++;
8152             if(appData.matchPause>10000 || appData.matchPause<10)
8153                 appData.matchPause = 10000; /* [HGM] make pause adjustable */
8154             ScheduleDelayedEvent(NextMatchGame, appData.matchPause);
8155             endingGame = 0; /* [HGM] crash */
8156             return;
8157         } else {
8158             char buf[MSG_SIZ];
8159             gameMode = nextGameMode;
8160             sprintf(buf, _("Match %s vs. %s: final score %d-%d-%d"),
8161                     first.tidy, second.tidy,
8162                     first.matchWins, second.matchWins,
8163                     appData.matchGames - (first.matchWins + second.matchWins));
8164             DisplayFatalError(buf, 0, 0);
8165         }
8166     }
8167     if ((gameMode == AnalyzeMode || gameMode == AnalyzeFile) &&
8168         !(nextGameMode == AnalyzeMode || nextGameMode == AnalyzeFile))
8169       ExitAnalyzeMode();
8170     gameMode = nextGameMode;
8171     ModeHighlight();
8172     endingGame = 0;  /* [HGM] crash */
8173 }
8174
8175 /* Assumes program was just initialized (initString sent).
8176    Leaves program in force mode. */
8177 void
8178 FeedMovesToProgram(cps, upto)
8179      ChessProgramState *cps;
8180      int upto;
8181 {
8182     int i;
8183
8184     if (appData.debugMode)
8185       fprintf(debugFP, "Feeding %smoves %d through %d to %s chess program\n",
8186               startedFromSetupPosition ? "position and " : "",
8187               backwardMostMove, upto, cps->which);
8188     if(currentlyInitializedVariant != gameInfo.variant) { char buf[MSG_SIZ];
8189         // [HGM] variantswitch: make engine aware of new variant
8190         if(cps->protocolVersion > 1 && StrStr(cps->variants, VariantName(gameInfo.variant)) == NULL)
8191                 return; // [HGM] refrain from feeding moves altogether if variant is unsupported!
8192         sprintf(buf, "variant %s\n", VariantName(gameInfo.variant));
8193         SendToProgram(buf, cps);
8194         currentlyInitializedVariant = gameInfo.variant;
8195     }
8196     SendToProgram("force\n", cps);
8197     if (startedFromSetupPosition) {
8198         SendBoard(cps, backwardMostMove);
8199     if (appData.debugMode) {
8200         fprintf(debugFP, "feedMoves\n");
8201     }
8202     }
8203     for (i = backwardMostMove; i < upto; i++) {
8204         SendMoveToProgram(i, cps);
8205     }
8206 }
8207
8208
8209 void
8210 ResurrectChessProgram()
8211 {
8212      /* The chess program may have exited.
8213         If so, restart it and feed it all the moves made so far. */
8214
8215     if (appData.noChessProgram || first.pr != NoProc) return;
8216
8217     StartChessProgram(&first);
8218     InitChessProgram(&first, FALSE);
8219     FeedMovesToProgram(&first, currentMove);
8220
8221     if (!first.sendTime) {
8222         /* can't tell gnuchess what its clock should read,
8223            so we bow to its notion. */
8224         ResetClocks();
8225         timeRemaining[0][currentMove] = whiteTimeRemaining;
8226         timeRemaining[1][currentMove] = blackTimeRemaining;
8227     }
8228
8229     if ((gameMode == AnalyzeMode || gameMode == AnalyzeFile ||
8230                 appData.icsEngineAnalyze) && first.analysisSupport) {
8231       SendToProgram("analyze\n", &first);
8232       first.analyzing = TRUE;
8233     }
8234 }
8235
8236 /*
8237  * Button procedures
8238  */
8239 void
8240 Reset(redraw, init)
8241      int redraw, init;
8242 {
8243     int i;
8244
8245     if (appData.debugMode) {
8246         fprintf(debugFP, "Reset(%d, %d) from gameMode %d\n",
8247                 redraw, init, gameMode);
8248     }
8249     pausing = pauseExamInvalid = FALSE;
8250     startedFromSetupPosition = blackPlaysFirst = FALSE;
8251     firstMove = TRUE;
8252     whiteFlag = blackFlag = FALSE;
8253     userOfferedDraw = FALSE;
8254     hintRequested = bookRequested = FALSE;
8255     first.maybeThinking = FALSE;
8256     second.maybeThinking = FALSE;
8257     first.bookSuspend = FALSE; // [HGM] book
8258     second.bookSuspend = FALSE;
8259     thinkOutput[0] = NULLCHAR;
8260     lastHint[0] = NULLCHAR;
8261     ClearGameInfo(&gameInfo);
8262     gameInfo.variant = StringToVariant(appData.variant);
8263     ics_user_moved = ics_clock_paused = FALSE;
8264     ics_getting_history = H_FALSE;
8265     ics_gamenum = -1;
8266     white_holding[0] = black_holding[0] = NULLCHAR;
8267     ClearProgramStats();
8268     opponentKibitzes = FALSE; // [HGM] kibitz: do not reserve space in engine-output window in zippy mode
8269
8270     ResetFrontEnd();
8271     ClearHighlights();
8272     flipView = appData.flipView;
8273     ClearPremoveHighlights();
8274     gotPremove = FALSE;
8275     alarmSounded = FALSE;
8276
8277     GameEnds((ChessMove) 0, NULL, GE_PLAYER);
8278     if(appData.serverMovesName != NULL) {
8279         /* [HGM] prepare to make moves file for broadcasting */
8280         clock_t t = clock();
8281         if(serverMoves != NULL) fclose(serverMoves);
8282         serverMoves = fopen(appData.serverMovesName, "r");
8283         if(serverMoves != NULL) {
8284             fclose(serverMoves);
8285             /* delay 15 sec before overwriting, so all clients can see end */
8286             while(clock()-t < appData.serverPause*CLOCKS_PER_SEC);
8287         }
8288         serverMoves = fopen(appData.serverMovesName, "w");
8289     }
8290
8291     ExitAnalyzeMode();
8292     gameMode = BeginningOfGame;
8293     ModeHighlight();
8294     if(appData.icsActive) gameInfo.variant = VariantNormal;
8295     currentMove = forwardMostMove = backwardMostMove = 0;
8296     InitPosition(redraw);
8297     for (i = 0; i < MAX_MOVES; i++) {
8298         if (commentList[i] != NULL) {
8299             free(commentList[i]);
8300             commentList[i] = NULL;
8301         }
8302     }
8303     ResetClocks();
8304     timeRemaining[0][0] = whiteTimeRemaining;
8305     timeRemaining[1][0] = blackTimeRemaining;
8306     if (first.pr == NULL) {
8307         StartChessProgram(&first);
8308     }
8309     if (init) {
8310             InitChessProgram(&first, startedFromSetupPosition);
8311     }
8312     DisplayTitle("");
8313     DisplayMessage("", "");
8314     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
8315     lastSavedGame = 0; // [HGM] save: make sure next game counts as unsaved
8316 }
8317
8318 void
8319 AutoPlayGameLoop()
8320 {
8321     for (;;) {
8322         if (!AutoPlayOneMove())
8323           return;
8324         if (matchMode || appData.timeDelay == 0)
8325           continue;
8326         if (appData.timeDelay < 0 || gameMode == AnalyzeFile)
8327           return;
8328         StartLoadGameTimer((long)(1000.0 * appData.timeDelay));
8329         break;
8330     }
8331 }
8332
8333
8334 int
8335 AutoPlayOneMove()
8336 {
8337     int fromX, fromY, toX, toY;
8338
8339     if (appData.debugMode) {
8340       fprintf(debugFP, "AutoPlayOneMove(): current %d\n", currentMove);
8341     }
8342
8343     if (gameMode != PlayFromGameFile)
8344       return FALSE;
8345
8346     if (currentMove >= forwardMostMove) {
8347       gameMode = EditGame;
8348       ModeHighlight();
8349
8350       /* [AS] Clear current move marker at the end of a game */
8351       /* HistorySet(parseList, backwardMostMove, forwardMostMove, -1); */
8352
8353       return FALSE;
8354     }
8355
8356     toX = moveList[currentMove][2] - AAA;
8357     toY = moveList[currentMove][3] - ONE;
8358
8359     if (moveList[currentMove][1] == '@') {
8360         if (appData.highlightLastMove) {
8361             SetHighlights(-1, -1, toX, toY);
8362         }
8363     } else {
8364         fromX = moveList[currentMove][0] - AAA;
8365         fromY = moveList[currentMove][1] - ONE;
8366
8367         HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove); /* [AS] */
8368
8369         AnimateMove(boards[currentMove], fromX, fromY, toX, toY);
8370
8371         if (appData.highlightLastMove) {
8372             SetHighlights(fromX, fromY, toX, toY);
8373         }
8374     }
8375     DisplayMove(currentMove);
8376     SendMoveToProgram(currentMove++, &first);
8377     DisplayBothClocks();
8378     DrawPosition(FALSE, boards[currentMove]);
8379     // [HGM] PV info: always display, routine tests if empty
8380     DisplayComment(currentMove - 1, commentList[currentMove]);
8381     return TRUE;
8382 }
8383
8384
8385 int
8386 LoadGameOneMove(readAhead)
8387      ChessMove readAhead;
8388 {
8389     int fromX = 0, fromY = 0, toX = 0, toY = 0, done;
8390     char promoChar = NULLCHAR;
8391     ChessMove moveType;
8392     char move[MSG_SIZ];
8393     char *p, *q;
8394
8395     if (gameMode != PlayFromGameFile && gameMode != AnalyzeFile &&
8396         gameMode != AnalyzeMode && gameMode != Training) {
8397         gameFileFP = NULL;
8398         return FALSE;
8399     }
8400
8401     yyboardindex = forwardMostMove;
8402     if (readAhead != (ChessMove)0) {
8403       moveType = readAhead;
8404     } else {
8405       if (gameFileFP == NULL)
8406           return FALSE;
8407       moveType = (ChessMove) yylex();
8408     }
8409
8410     done = FALSE;
8411     switch (moveType) {
8412       case Comment:
8413         if (appData.debugMode)
8414           fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
8415         p = yy_text;
8416         if (*p == '{' || *p == '[' || *p == '(') {
8417             p[strlen(p) - 1] = NULLCHAR;
8418             p++;
8419         }
8420
8421         /* append the comment but don't display it */
8422         while (*p == '\n') p++;
8423         AppendComment(currentMove, p);
8424         return TRUE;
8425
8426       case WhiteCapturesEnPassant:
8427       case BlackCapturesEnPassant:
8428       case WhitePromotionChancellor:
8429       case BlackPromotionChancellor:
8430       case WhitePromotionArchbishop:
8431       case BlackPromotionArchbishop:
8432       case WhitePromotionCentaur:
8433       case BlackPromotionCentaur:
8434       case WhitePromotionQueen:
8435       case BlackPromotionQueen:
8436       case WhitePromotionRook:
8437       case BlackPromotionRook:
8438       case WhitePromotionBishop:
8439       case BlackPromotionBishop:
8440       case WhitePromotionKnight:
8441       case BlackPromotionKnight:
8442       case WhitePromotionKing:
8443       case BlackPromotionKing:
8444       case NormalMove:
8445       case WhiteKingSideCastle:
8446       case WhiteQueenSideCastle:
8447       case BlackKingSideCastle:
8448       case BlackQueenSideCastle:
8449       case WhiteKingSideCastleWild:
8450       case WhiteQueenSideCastleWild:
8451       case BlackKingSideCastleWild:
8452       case BlackQueenSideCastleWild:
8453       /* PUSH Fabien */
8454       case WhiteHSideCastleFR:
8455       case WhiteASideCastleFR:
8456       case BlackHSideCastleFR:
8457       case BlackASideCastleFR:
8458       /* POP Fabien */
8459         if (appData.debugMode)
8460           fprintf(debugFP, "Parsed %s into %s\n", yy_text, currentMoveString);
8461         fromX = currentMoveString[0] - AAA;
8462         fromY = currentMoveString[1] - ONE;
8463         toX = currentMoveString[2] - AAA;
8464         toY = currentMoveString[3] - ONE;
8465         promoChar = currentMoveString[4];
8466         break;
8467
8468       case WhiteDrop:
8469       case BlackDrop:
8470         if (appData.debugMode)
8471           fprintf(debugFP, "Parsed %s into %s\n", yy_text, currentMoveString);
8472         fromX = moveType == WhiteDrop ?
8473           (int) CharToPiece(ToUpper(currentMoveString[0])) :
8474         (int) CharToPiece(ToLower(currentMoveString[0]));
8475         fromY = DROP_RANK;
8476         toX = currentMoveString[2] - AAA;
8477         toY = currentMoveString[3] - ONE;
8478         break;
8479
8480       case WhiteWins:
8481       case BlackWins:
8482       case GameIsDrawn:
8483       case GameUnfinished:
8484         if (appData.debugMode)
8485           fprintf(debugFP, "Parsed game end: %s\n", yy_text);
8486         p = strchr(yy_text, '{');
8487         if (p == NULL) p = strchr(yy_text, '(');
8488         if (p == NULL) {
8489             p = yy_text;
8490             if (p[0] == '0' || p[0] == '1' || p[0] == '*') p = "";
8491         } else {
8492             q = strchr(p, *p == '{' ? '}' : ')');
8493             if (q != NULL) *q = NULLCHAR;
8494             p++;
8495         }
8496         GameEnds(moveType, p, GE_FILE);
8497         done = TRUE;
8498         if (cmailMsgLoaded) {
8499             ClearHighlights();
8500             flipView = WhiteOnMove(currentMove);
8501             if (moveType == GameUnfinished) flipView = !flipView;
8502             if (appData.debugMode)
8503               fprintf(debugFP, "Setting flipView to %d\n", flipView) ;
8504         }
8505         break;
8506
8507       case (ChessMove) 0:       /* end of file */
8508         if (appData.debugMode)
8509           fprintf(debugFP, "Parser hit end of file\n");
8510         switch (MateTest(boards[currentMove], PosFlags(currentMove),
8511                          EP_UNKNOWN, castlingRights[currentMove]) ) {
8512           case MT_NONE:
8513           case MT_CHECK:
8514             break;
8515           case MT_CHECKMATE:
8516           case MT_STAINMATE:
8517             if (WhiteOnMove(currentMove)) {
8518                 GameEnds(BlackWins, "Black mates", GE_FILE);
8519             } else {
8520                 GameEnds(WhiteWins, "White mates", GE_FILE);
8521             }
8522             break;
8523           case MT_STALEMATE:
8524             GameEnds(GameIsDrawn, "Stalemate", GE_FILE);
8525             break;
8526         }
8527         done = TRUE;
8528         break;
8529
8530       case MoveNumberOne:
8531         if (lastLoadGameStart == GNUChessGame) {
8532             /* GNUChessGames have numbers, but they aren't move numbers */
8533             if (appData.debugMode)
8534               fprintf(debugFP, "Parser ignoring: '%s' (%d)\n",
8535                       yy_text, (int) moveType);
8536             return LoadGameOneMove((ChessMove)0); /* tail recursion */
8537         }
8538         /* else fall thru */
8539
8540       case XBoardGame:
8541       case GNUChessGame:
8542       case PGNTag:
8543         /* Reached start of next game in file */
8544         if (appData.debugMode)
8545           fprintf(debugFP, "Parsed start of next game: %s\n", yy_text);
8546         switch (MateTest(boards[currentMove], PosFlags(currentMove),
8547                          EP_UNKNOWN, castlingRights[currentMove]) ) {
8548           case MT_NONE:
8549           case MT_CHECK:
8550             break;
8551           case MT_CHECKMATE:
8552           case MT_STAINMATE:
8553             if (WhiteOnMove(currentMove)) {
8554                 GameEnds(BlackWins, "Black mates", GE_FILE);
8555             } else {
8556                 GameEnds(WhiteWins, "White mates", GE_FILE);
8557             }
8558             break;
8559           case MT_STALEMATE:
8560             GameEnds(GameIsDrawn, "Stalemate", GE_FILE);
8561             break;
8562         }
8563         done = TRUE;
8564         break;
8565
8566       case PositionDiagram:     /* should not happen; ignore */
8567       case ElapsedTime:         /* ignore */
8568       case NAG:                 /* ignore */
8569         if (appData.debugMode)
8570           fprintf(debugFP, "Parser ignoring: '%s' (%d)\n",
8571                   yy_text, (int) moveType);
8572         return LoadGameOneMove((ChessMove)0); /* tail recursion */
8573
8574       case IllegalMove:
8575         if (appData.testLegality) {
8576             if (appData.debugMode)
8577               fprintf(debugFP, "Parsed IllegalMove: %s\n", yy_text);
8578             sprintf(move, _("Illegal move: %d.%s%s"),
8579                     (forwardMostMove / 2) + 1,
8580                     WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
8581             DisplayError(move, 0);
8582             done = TRUE;
8583         } else {
8584             if (appData.debugMode)
8585               fprintf(debugFP, "Parsed %s into IllegalMove %s\n",
8586                       yy_text, currentMoveString);
8587             fromX = currentMoveString[0] - AAA;
8588             fromY = currentMoveString[1] - ONE;
8589             toX = currentMoveString[2] - AAA;
8590             toY = currentMoveString[3] - ONE;
8591             promoChar = currentMoveString[4];
8592         }
8593         break;
8594
8595       case AmbiguousMove:
8596         if (appData.debugMode)
8597           fprintf(debugFP, "Parsed AmbiguousMove: %s\n", yy_text);
8598         sprintf(move, _("Ambiguous move: %d.%s%s"),
8599                 (forwardMostMove / 2) + 1,
8600                 WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
8601         DisplayError(move, 0);
8602         done = TRUE;
8603         break;
8604
8605       default:
8606       case ImpossibleMove:
8607         if (appData.debugMode)
8608           fprintf(debugFP, "Parsed ImpossibleMove (type = %d): %s\n", moveType, yy_text);
8609         sprintf(move, _("Illegal move: %d.%s%s"),
8610                 (forwardMostMove / 2) + 1,
8611                 WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
8612         DisplayError(move, 0);
8613         done = TRUE;
8614         break;
8615     }
8616
8617     if (done) {
8618         if (appData.matchMode || (appData.timeDelay == 0 && !pausing)) {
8619             DrawPosition(FALSE, boards[currentMove]);
8620             DisplayBothClocks();
8621             if (!appData.matchMode) // [HGM] PV info: routine tests if empty
8622               DisplayComment(currentMove - 1, commentList[currentMove]);
8623         }
8624         (void) StopLoadGameTimer();
8625         gameFileFP = NULL;
8626         cmailOldMove = forwardMostMove;
8627         return FALSE;
8628     } else {
8629         /* currentMoveString is set as a side-effect of yylex */
8630         strcat(currentMoveString, "\n");
8631         strcpy(moveList[forwardMostMove], currentMoveString);
8632
8633         thinkOutput[0] = NULLCHAR;
8634         MakeMove(fromX, fromY, toX, toY, promoChar);
8635         currentMove = forwardMostMove;
8636         return TRUE;
8637     }
8638 }
8639
8640 /* Load the nth game from the given file */
8641 int
8642 LoadGameFromFile(filename, n, title, useList)
8643      char *filename;
8644      int n;
8645      char *title;
8646      /*Boolean*/ int useList;
8647 {
8648     FILE *f;
8649     char buf[MSG_SIZ];
8650
8651     if (strcmp(filename, "-") == 0) {
8652         f = stdin;
8653         title = "stdin";
8654     } else {
8655         f = fopen(filename, "rb");
8656         if (f == NULL) {
8657           snprintf(buf, sizeof(buf),  _("Can't open \"%s\""), filename);
8658             DisplayError(buf, errno);
8659             return FALSE;
8660         }
8661     }
8662     if (fseek(f, 0, 0) == -1) {
8663         /* f is not seekable; probably a pipe */
8664         useList = FALSE;
8665     }
8666     if (useList && n == 0) {
8667         int error = GameListBuild(f);
8668         if (error) {
8669             DisplayError(_("Cannot build game list"), error);
8670         } else if (!ListEmpty(&gameList) &&
8671                    ((ListGame *) gameList.tailPred)->number > 1) {
8672             GameListPopUp(f, title);
8673             return TRUE;
8674         }
8675         GameListDestroy();
8676         n = 1;
8677     }
8678     if (n == 0) n = 1;
8679     return LoadGame(f, n, title, FALSE);
8680 }
8681
8682
8683 void
8684 MakeRegisteredMove()
8685 {
8686     int fromX, fromY, toX, toY;
8687     char promoChar;
8688     if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
8689         switch (cmailMoveType[lastLoadGameNumber - 1]) {
8690           case CMAIL_MOVE:
8691           case CMAIL_DRAW:
8692             if (appData.debugMode)
8693               fprintf(debugFP, "Restoring %s for game %d\n",
8694                       cmailMove[lastLoadGameNumber - 1], lastLoadGameNumber);
8695
8696             thinkOutput[0] = NULLCHAR;
8697             strcpy(moveList[currentMove], cmailMove[lastLoadGameNumber - 1]);
8698             fromX = cmailMove[lastLoadGameNumber - 1][0] - AAA;
8699             fromY = cmailMove[lastLoadGameNumber - 1][1] - ONE;
8700             toX = cmailMove[lastLoadGameNumber - 1][2] - AAA;
8701             toY = cmailMove[lastLoadGameNumber - 1][3] - ONE;
8702             promoChar = cmailMove[lastLoadGameNumber - 1][4];
8703             MakeMove(fromX, fromY, toX, toY, promoChar);
8704             ShowMove(fromX, fromY, toX, toY);
8705
8706             switch (MateTest(boards[currentMove], PosFlags(currentMove),
8707                              EP_UNKNOWN, castlingRights[currentMove]) ) {
8708               case MT_NONE:
8709               case MT_CHECK:
8710                 break;
8711
8712               case MT_CHECKMATE:
8713               case MT_STAINMATE:
8714                 if (WhiteOnMove(currentMove)) {
8715                     GameEnds(BlackWins, "Black mates", GE_PLAYER);
8716                 } else {
8717                     GameEnds(WhiteWins, "White mates", GE_PLAYER);
8718                 }
8719                 break;
8720
8721               case MT_STALEMATE:
8722                 GameEnds(GameIsDrawn, "Stalemate", GE_PLAYER);
8723                 break;
8724             }
8725
8726             break;
8727
8728           case CMAIL_RESIGN:
8729             if (WhiteOnMove(currentMove)) {
8730                 GameEnds(BlackWins, "White resigns", GE_PLAYER);
8731             } else {
8732                 GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
8733             }
8734             break;
8735
8736           case CMAIL_ACCEPT:
8737             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
8738             break;
8739
8740           default:
8741             break;
8742         }
8743     }
8744
8745     return;
8746 }
8747
8748 /* Wrapper around LoadGame for use when a Cmail message is loaded */
8749 int
8750 CmailLoadGame(f, gameNumber, title, useList)
8751      FILE *f;
8752      int gameNumber;
8753      char *title;
8754      int useList;
8755 {
8756     int retVal;
8757
8758     if (gameNumber > nCmailGames) {
8759         DisplayError(_("No more games in this message"), 0);
8760         return FALSE;
8761     }
8762     if (f == lastLoadGameFP) {
8763         int offset = gameNumber - lastLoadGameNumber;
8764         if (offset == 0) {
8765             cmailMsg[0] = NULLCHAR;
8766             if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
8767                 cmailMoveRegistered[lastLoadGameNumber - 1] = FALSE;
8768                 nCmailMovesRegistered--;
8769             }
8770             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
8771             if (cmailResult[lastLoadGameNumber - 1] == CMAIL_NEW_RESULT) {
8772                 cmailResult[lastLoadGameNumber - 1] = CMAIL_NOT_RESULT;
8773             }
8774         } else {
8775             if (! RegisterMove()) return FALSE;
8776         }
8777     }
8778
8779     retVal = LoadGame(f, gameNumber, title, useList);
8780
8781     /* Make move registered during previous look at this game, if any */
8782     MakeRegisteredMove();
8783
8784     if (cmailCommentList[lastLoadGameNumber - 1] != NULL) {
8785         commentList[currentMove]
8786           = StrSave(cmailCommentList[lastLoadGameNumber - 1]);
8787         DisplayComment(currentMove - 1, commentList[currentMove]);
8788     }
8789
8790     return retVal;
8791 }
8792
8793 /* Support for LoadNextGame, LoadPreviousGame, ReloadSameGame */
8794 int
8795 ReloadGame(offset)
8796      int offset;
8797 {
8798     int gameNumber = lastLoadGameNumber + offset;
8799     if (lastLoadGameFP == NULL) {
8800         DisplayError(_("No game has been loaded yet"), 0);
8801         return FALSE;
8802     }
8803     if (gameNumber <= 0) {
8804         DisplayError(_("Can't back up any further"), 0);
8805         return FALSE;
8806     }
8807     if (cmailMsgLoaded) {
8808         return CmailLoadGame(lastLoadGameFP, gameNumber,
8809                              lastLoadGameTitle, lastLoadGameUseList);
8810     } else {
8811         return LoadGame(lastLoadGameFP, gameNumber,
8812                         lastLoadGameTitle, lastLoadGameUseList);
8813     }
8814 }
8815
8816
8817
8818 /* Load the nth game from open file f */
8819 int
8820 LoadGame(f, gameNumber, title, useList)
8821      FILE *f;
8822      int gameNumber;
8823      char *title;
8824      int useList;
8825 {
8826     ChessMove cm;
8827     char buf[MSG_SIZ];
8828     int gn = gameNumber;
8829     ListGame *lg = NULL;
8830     int numPGNTags = 0;
8831     int err;
8832     GameMode oldGameMode;
8833     VariantClass oldVariant = gameInfo.variant; /* [HGM] PGNvariant */
8834
8835     if (appData.debugMode)
8836         fprintf(debugFP, "LoadGame(): on entry, gameMode %d\n", gameMode);
8837
8838     if (gameMode == Training )
8839         SetTrainingModeOff();
8840
8841     oldGameMode = gameMode;
8842     if (gameMode != BeginningOfGame) {
8843       Reset(FALSE, TRUE);
8844     }
8845
8846     gameFileFP = f;
8847     if (lastLoadGameFP != NULL && lastLoadGameFP != f) {
8848         fclose(lastLoadGameFP);
8849     }
8850
8851     if (useList) {
8852         lg = (ListGame *) ListElem(&gameList, gameNumber-1);
8853
8854         if (lg) {
8855             fseek(f, lg->offset, 0);
8856             GameListHighlight(gameNumber);
8857             gn = 1;
8858         }
8859         else {
8860             DisplayError(_("Game number out of range"), 0);
8861             return FALSE;
8862         }
8863     } else {
8864         GameListDestroy();
8865         if (fseek(f, 0, 0) == -1) {
8866             if (f == lastLoadGameFP ?
8867                 gameNumber == lastLoadGameNumber + 1 :
8868                 gameNumber == 1) {
8869                 gn = 1;
8870             } else {
8871                 DisplayError(_("Can't seek on game file"), 0);
8872                 return FALSE;
8873             }
8874         }
8875     }
8876     lastLoadGameFP = f;
8877     lastLoadGameNumber = gameNumber;
8878     strcpy(lastLoadGameTitle, title);
8879     lastLoadGameUseList = useList;
8880
8881     yynewfile(f);
8882
8883     if (lg && lg->gameInfo.white && lg->gameInfo.black) {
8884       snprintf(buf, sizeof(buf), "%s vs. %s", lg->gameInfo.white,
8885                 lg->gameInfo.black);
8886             DisplayTitle(buf);
8887     } else if (*title != NULLCHAR) {
8888         if (gameNumber > 1) {
8889             sprintf(buf, "%s %d", title, gameNumber);
8890             DisplayTitle(buf);
8891         } else {
8892             DisplayTitle(title);
8893         }
8894     }
8895
8896     if (gameMode != AnalyzeFile && gameMode != AnalyzeMode) {
8897         gameMode = PlayFromGameFile;
8898         ModeHighlight();
8899     }
8900
8901     currentMove = forwardMostMove = backwardMostMove = 0;
8902     CopyBoard(boards[0], initialPosition);
8903     StopClocks();
8904
8905     /*
8906      * Skip the first gn-1 games in the file.
8907      * Also skip over anything that precedes an identifiable
8908      * start of game marker, to avoid being confused by
8909      * garbage at the start of the file.  Currently
8910      * recognized start of game markers are the move number "1",
8911      * the pattern "gnuchess .* game", the pattern
8912      * "^[#;%] [^ ]* game file", and a PGN tag block.
8913      * A game that starts with one of the latter two patterns
8914      * will also have a move number 1, possibly
8915      * following a position diagram.
8916      * 5-4-02: Let's try being more lenient and allowing a game to
8917      * start with an unnumbered move.  Does that break anything?
8918      */
8919     cm = lastLoadGameStart = (ChessMove) 0;
8920     while (gn > 0) {
8921         yyboardindex = forwardMostMove;
8922         cm = (ChessMove) yylex();
8923         switch (cm) {
8924           case (ChessMove) 0:
8925             if (cmailMsgLoaded) {
8926                 nCmailGames = CMAIL_MAX_GAMES - gn;
8927             } else {
8928                 Reset(TRUE, TRUE);
8929                 DisplayError(_("Game not found in file"), 0);
8930             }
8931             return FALSE;
8932
8933           case GNUChessGame:
8934           case XBoardGame:
8935             gn--;
8936             lastLoadGameStart = cm;
8937             break;
8938
8939           case MoveNumberOne:
8940             switch (lastLoadGameStart) {
8941               case GNUChessGame:
8942               case XBoardGame:
8943               case PGNTag:
8944                 break;
8945               case MoveNumberOne:
8946               case (ChessMove) 0:
8947                 gn--;           /* count this game */
8948                 lastLoadGameStart = cm;
8949                 break;
8950               default:
8951                 /* impossible */
8952                 break;
8953             }
8954             break;
8955
8956           case PGNTag:
8957             switch (lastLoadGameStart) {
8958               case GNUChessGame:
8959               case PGNTag:
8960               case MoveNumberOne:
8961               case (ChessMove) 0:
8962                 gn--;           /* count this game */
8963                 lastLoadGameStart = cm;
8964                 break;
8965               case XBoardGame:
8966                 lastLoadGameStart = cm; /* game counted already */
8967                 break;
8968               default:
8969                 /* impossible */
8970                 break;
8971             }
8972             if (gn > 0) {
8973                 do {
8974                     yyboardindex = forwardMostMove;
8975                     cm = (ChessMove) yylex();
8976                 } while (cm == PGNTag || cm == Comment);
8977             }
8978             break;
8979
8980           case WhiteWins:
8981           case BlackWins:
8982           case GameIsDrawn:
8983             if (cmailMsgLoaded && (CMAIL_MAX_GAMES == lastLoadGameNumber)) {
8984                 if (   cmailResult[CMAIL_MAX_GAMES - gn - 1]
8985                     != CMAIL_OLD_RESULT) {
8986                     nCmailResults ++ ;
8987                     cmailResult[  CMAIL_MAX_GAMES
8988                                 - gn - 1] = CMAIL_OLD_RESULT;
8989                 }
8990             }
8991             break;
8992
8993           case NormalMove:
8994             /* Only a NormalMove can be at the start of a game
8995              * without a position diagram. */
8996             if (lastLoadGameStart == (ChessMove) 0) {
8997               gn--;
8998               lastLoadGameStart = MoveNumberOne;
8999             }
9000             break;
9001
9002           default:
9003             break;
9004         }
9005     }
9006
9007     if (appData.debugMode)
9008       fprintf(debugFP, "Parsed game start '%s' (%d)\n", yy_text, (int) cm);
9009
9010     if (cm == XBoardGame) {
9011         /* Skip any header junk before position diagram and/or move 1 */
9012         for (;;) {
9013             yyboardindex = forwardMostMove;
9014             cm = (ChessMove) yylex();
9015
9016             if (cm == (ChessMove) 0 ||
9017                 cm == GNUChessGame || cm == XBoardGame) {
9018                 /* Empty game; pretend end-of-file and handle later */
9019                 cm = (ChessMove) 0;
9020                 break;
9021             }
9022
9023             if (cm == MoveNumberOne || cm == PositionDiagram ||
9024                 cm == PGNTag || cm == Comment)
9025               break;
9026         }
9027     } else if (cm == GNUChessGame) {
9028         if (gameInfo.event != NULL) {
9029             free(gameInfo.event);
9030         }
9031         gameInfo.event = StrSave(yy_text);
9032     }
9033
9034     startedFromSetupPosition = FALSE;
9035     while (cm == PGNTag) {
9036         if (appData.debugMode)
9037           fprintf(debugFP, "Parsed PGNTag: %s\n", yy_text);
9038         err = ParsePGNTag(yy_text, &gameInfo);
9039         if (!err) numPGNTags++;
9040
9041         /* [HGM] PGNvariant: automatically switch to variant given in PGN tag */
9042         if(gameInfo.variant != oldVariant) {
9043             startedFromPositionFile = FALSE; /* [HGM] loadPos: variant switch likely makes position invalid */
9044             InitPosition(TRUE);
9045             oldVariant = gameInfo.variant;
9046             if (appData.debugMode)
9047               fprintf(debugFP, "New variant %d\n", (int) oldVariant);
9048         }
9049
9050
9051         if (gameInfo.fen != NULL) {
9052           Board initial_position;
9053           startedFromSetupPosition = TRUE;
9054           if (!ParseFEN(initial_position, &blackPlaysFirst, gameInfo.fen)) {
9055             Reset(TRUE, TRUE);
9056             DisplayError(_("Bad FEN position in file"), 0);
9057             return FALSE;
9058           }
9059           CopyBoard(boards[0], initial_position);
9060           if (blackPlaysFirst) {
9061             currentMove = forwardMostMove = backwardMostMove = 1;
9062             CopyBoard(boards[1], initial_position);
9063             strcpy(moveList[0], "");
9064             strcpy(parseList[0], "");
9065             timeRemaining[0][1] = whiteTimeRemaining;
9066             timeRemaining[1][1] = blackTimeRemaining;
9067             if (commentList[0] != NULL) {
9068               commentList[1] = commentList[0];
9069               commentList[0] = NULL;
9070             }
9071           } else {
9072             currentMove = forwardMostMove = backwardMostMove = 0;
9073           }
9074           /* [HGM] copy FEN attributes as well. Bugfix 4.3.14m and 4.3.15e: moved to after 'blackPlaysFirst' */
9075           {   int i;
9076               initialRulePlies = FENrulePlies;
9077               epStatus[forwardMostMove] = FENepStatus;
9078               for( i=0; i< nrCastlingRights; i++ )
9079                   initialRights[i] = castlingRights[forwardMostMove][i] = FENcastlingRights[i];
9080           }
9081           yyboardindex = forwardMostMove;
9082           free(gameInfo.fen);
9083           gameInfo.fen = NULL;
9084         }
9085
9086         yyboardindex = forwardMostMove;
9087         cm = (ChessMove) yylex();
9088
9089         /* Handle comments interspersed among the tags */
9090         while (cm == Comment) {
9091             char *p;
9092             if (appData.debugMode)
9093               fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
9094             p = yy_text;
9095             if (*p == '{' || *p == '[' || *p == '(') {
9096                 p[strlen(p) - 1] = NULLCHAR;
9097                 p++;
9098             }
9099             while (*p == '\n') p++;
9100             AppendComment(currentMove, p);
9101             yyboardindex = forwardMostMove;
9102             cm = (ChessMove) yylex();
9103         }
9104     }
9105
9106     /* don't rely on existence of Event tag since if game was
9107      * pasted from clipboard the Event tag may not exist
9108      */
9109     if (numPGNTags > 0){
9110         char *tags;
9111         if (gameInfo.variant == VariantNormal) {
9112           gameInfo.variant = StringToVariant(gameInfo.event);
9113         }
9114         if (!matchMode) {
9115           if( appData.autoDisplayTags ) {
9116             tags = PGNTags(&gameInfo);
9117             TagsPopUp(tags, CmailMsg());
9118             free(tags);
9119           }
9120         }
9121     } else {
9122         /* Make something up, but don't display it now */
9123         SetGameInfo();
9124         TagsPopDown();
9125     }
9126
9127     if (cm == PositionDiagram) {
9128         int i, j;
9129         char *p;
9130         Board initial_position;
9131
9132         if (appData.debugMode)
9133           fprintf(debugFP, "Parsed PositionDiagram: %s\n", yy_text);
9134
9135         if (!startedFromSetupPosition) {
9136             p = yy_text;
9137             for (i = BOARD_HEIGHT - 1; i >= 0; i--)
9138               for (j = BOARD_LEFT; j < BOARD_RGHT; p++)
9139                 switch (*p) {
9140                   case '[':
9141                   case '-':
9142                   case ' ':
9143                   case '\t':
9144                   case '\n':
9145                   case '\r':
9146                     break;
9147                   default:
9148                     initial_position[i][j++] = CharToPiece(*p);
9149                     break;
9150                 }
9151             while (*p == ' ' || *p == '\t' ||
9152                    *p == '\n' || *p == '\r') p++;
9153
9154             if (strncmp(p, "black", strlen("black"))==0)
9155               blackPlaysFirst = TRUE;
9156             else
9157               blackPlaysFirst = FALSE;
9158             startedFromSetupPosition = TRUE;
9159
9160             CopyBoard(boards[0], initial_position);
9161             if (blackPlaysFirst) {
9162                 currentMove = forwardMostMove = backwardMostMove = 1;
9163                 CopyBoard(boards[1], initial_position);
9164                 strcpy(moveList[0], "");
9165                 strcpy(parseList[0], "");
9166                 timeRemaining[0][1] = whiteTimeRemaining;
9167                 timeRemaining[1][1] = blackTimeRemaining;
9168                 if (commentList[0] != NULL) {
9169                     commentList[1] = commentList[0];
9170                     commentList[0] = NULL;
9171                 }
9172             } else {
9173                 currentMove = forwardMostMove = backwardMostMove = 0;
9174             }
9175         }
9176         yyboardindex = forwardMostMove;
9177         cm = (ChessMove) yylex();
9178     }
9179
9180     if (first.pr == NoProc) {
9181         StartChessProgram(&first);
9182     }
9183     InitChessProgram(&first, FALSE);
9184     SendToProgram("force\n", &first);
9185     if (startedFromSetupPosition) {
9186         SendBoard(&first, forwardMostMove);
9187     if (appData.debugMode) {
9188         fprintf(debugFP, "Load Game\n");
9189     }
9190         DisplayBothClocks();
9191     }
9192
9193     /* [HGM] server: flag to write setup moves in broadcast file as one */
9194     loadFlag = appData.suppressLoadMoves;
9195
9196     while (cm == Comment) {
9197         char *p;
9198         if (appData.debugMode)
9199           fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
9200         p = yy_text;
9201         if (*p == '{' || *p == '[' || *p == '(') {
9202             p[strlen(p) - 1] = NULLCHAR;
9203             p++;
9204         }
9205         while (*p == '\n') p++;
9206         AppendComment(currentMove, p);
9207         yyboardindex = forwardMostMove;
9208         cm = (ChessMove) yylex();
9209     }
9210
9211     if ((cm == (ChessMove) 0 && lastLoadGameStart != (ChessMove) 0) ||
9212         cm == WhiteWins || cm == BlackWins ||
9213         cm == GameIsDrawn || cm == GameUnfinished) {
9214         DisplayMessage("", _("No moves in game"));
9215         if (cmailMsgLoaded) {
9216             if (appData.debugMode)
9217               fprintf(debugFP, "Setting flipView to %d.\n", FALSE);
9218             ClearHighlights();
9219             flipView = FALSE;
9220         }
9221         DrawPosition(FALSE, boards[currentMove]);
9222         DisplayBothClocks();
9223         gameMode = EditGame;
9224         ModeHighlight();
9225         gameFileFP = NULL;
9226         cmailOldMove = 0;
9227         return TRUE;
9228     }
9229
9230     // [HGM] PV info: routine tests if comment empty
9231     if (!matchMode && (pausing || appData.timeDelay != 0)) {
9232         DisplayComment(currentMove - 1, commentList[currentMove]);
9233     }
9234     if (!matchMode && appData.timeDelay != 0)
9235       DrawPosition(FALSE, boards[currentMove]);
9236
9237     if (gameMode == AnalyzeFile || gameMode == AnalyzeMode) {
9238       programStats.ok_to_send = 1;
9239     }
9240
9241     /* if the first token after the PGN tags is a move
9242      * and not move number 1, retrieve it from the parser
9243      */
9244     if (cm != MoveNumberOne)
9245         LoadGameOneMove(cm);
9246
9247     /* load the remaining moves from the file */
9248     while (LoadGameOneMove((ChessMove)0)) {
9249       timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
9250       timeRemaining[1][forwardMostMove] = blackTimeRemaining;
9251     }
9252
9253     /* rewind to the start of the game */
9254     currentMove = backwardMostMove;
9255
9256     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
9257
9258     if (oldGameMode == AnalyzeFile ||
9259         oldGameMode == AnalyzeMode) {
9260       AnalyzeFileEvent();
9261     }
9262
9263     if (matchMode || appData.timeDelay == 0) {
9264       ToEndEvent();
9265       gameMode = EditGame;
9266       ModeHighlight();
9267     } else if (appData.timeDelay > 0) {
9268       AutoPlayGameLoop();
9269     }
9270
9271     if (appData.debugMode)
9272         fprintf(debugFP, "LoadGame(): on exit, gameMode %d\n", gameMode);
9273
9274     loadFlag = 0; /* [HGM] true game starts */
9275     return TRUE;
9276 }
9277
9278 /* Support for LoadNextPosition, LoadPreviousPosition, ReloadSamePosition */
9279 int
9280 ReloadPosition(offset)
9281      int offset;
9282 {
9283     int positionNumber = lastLoadPositionNumber + offset;
9284     if (lastLoadPositionFP == NULL) {
9285         DisplayError(_("No position has been loaded yet"), 0);
9286         return FALSE;
9287     }
9288     if (positionNumber <= 0) {
9289         DisplayError(_("Can't back up any further"), 0);
9290         return FALSE;
9291     }
9292     return LoadPosition(lastLoadPositionFP, positionNumber,
9293                         lastLoadPositionTitle);
9294 }
9295
9296 /* Load the nth position from the given file */
9297 int
9298 LoadPositionFromFile(filename, n, title)
9299      char *filename;
9300      int n;
9301      char *title;
9302 {
9303     FILE *f;
9304     char buf[MSG_SIZ];
9305
9306     if (strcmp(filename, "-") == 0) {
9307         return LoadPosition(stdin, n, "stdin");
9308     } else {
9309         f = fopen(filename, "rb");
9310         if (f == NULL) {
9311             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
9312             DisplayError(buf, errno);
9313             return FALSE;
9314         } else {
9315             return LoadPosition(f, n, title);
9316         }
9317     }
9318 }
9319
9320 /* Load the nth position from the given open file, and close it */
9321 int
9322 LoadPosition(f, positionNumber, title)
9323      FILE *f;
9324      int positionNumber;
9325      char *title;
9326 {
9327     char *p, line[MSG_SIZ];
9328     Board initial_position;
9329     int i, j, fenMode, pn;
9330
9331     if (gameMode == Training )
9332         SetTrainingModeOff();
9333
9334     if (gameMode != BeginningOfGame) {
9335         Reset(FALSE, TRUE);
9336     }
9337     if (lastLoadPositionFP != NULL && lastLoadPositionFP != f) {
9338         fclose(lastLoadPositionFP);
9339     }
9340     if (positionNumber == 0) positionNumber = 1;
9341     lastLoadPositionFP = f;
9342     lastLoadPositionNumber = positionNumber;
9343     strcpy(lastLoadPositionTitle, title);
9344     if (first.pr == NoProc) {
9345       StartChessProgram(&first);
9346       InitChessProgram(&first, FALSE);
9347     }
9348     pn = positionNumber;
9349     if (positionNumber < 0) {
9350         /* Negative position number means to seek to that byte offset */
9351         if (fseek(f, -positionNumber, 0) == -1) {
9352             DisplayError(_("Can't seek on position file"), 0);
9353             return FALSE;
9354         };
9355         pn = 1;
9356     } else {
9357         if (fseek(f, 0, 0) == -1) {
9358             if (f == lastLoadPositionFP ?
9359                 positionNumber == lastLoadPositionNumber + 1 :
9360                 positionNumber == 1) {
9361                 pn = 1;
9362             } else {
9363                 DisplayError(_("Can't seek on position file"), 0);
9364                 return FALSE;
9365             }
9366         }
9367     }
9368     /* See if this file is FEN or old-style xboard */
9369     if (fgets(line, MSG_SIZ, f) == NULL) {
9370         DisplayError(_("Position not found in file"), 0);
9371         return FALSE;
9372     }
9373 #if 0
9374     switch (line[0]) {
9375       case '#':  case 'x':
9376       default:
9377         fenMode = FALSE;
9378         break;
9379       case 'p':  case 'n':  case 'b':  case 'r':  case 'q':  case 'k':
9380       case 'P':  case 'N':  case 'B':  case 'R':  case 'Q':  case 'K':
9381       case '1':  case '2':  case '3':  case '4':  case '5':  case '6':
9382       case '7':  case '8':  case '9':
9383       case 'H':  case 'A':  case 'M':  case 'h':  case 'a':  case 'm':
9384       case 'E':  case 'F':  case 'G':  case 'e':  case 'f':  case 'g':
9385       case 'C':  case 'W':             case 'c':  case 'w':
9386         fenMode = TRUE;
9387         break;
9388     }
9389 #else
9390     // [HGM] FEN can begin with digit, any piece letter valid in this variant, or a + for Shogi promoted pieces
9391     fenMode = line[0] >= '0' && line[0] <= '9' || line[0] == '+' || CharToPiece(line[0]) != EmptySquare;
9392 #endif
9393
9394     if (pn >= 2) {
9395         if (fenMode || line[0] == '#') pn--;
9396         while (pn > 0) {
9397             /* skip positions before number pn */
9398             if (fgets(line, MSG_SIZ, f) == NULL) {
9399                 Reset(TRUE, TRUE);
9400                 DisplayError(_("Position not found in file"), 0);
9401                 return FALSE;
9402             }
9403             if (fenMode || line[0] == '#') pn--;
9404         }
9405     }
9406
9407     if (fenMode) {
9408         if (!ParseFEN(initial_position, &blackPlaysFirst, line)) {
9409             DisplayError(_("Bad FEN position in file"), 0);
9410             return FALSE;
9411         }
9412     } else {
9413         (void) fgets(line, MSG_SIZ, f);
9414         (void) fgets(line, MSG_SIZ, f);
9415
9416         for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
9417             (void) fgets(line, MSG_SIZ, f);
9418             for (p = line, j = BOARD_LEFT; j < BOARD_RGHT; p++) {
9419                 if (*p == ' ')
9420                   continue;
9421                 initial_position[i][j++] = CharToPiece(*p);
9422             }
9423         }
9424
9425         blackPlaysFirst = FALSE;
9426         if (!feof(f)) {
9427             (void) fgets(line, MSG_SIZ, f);
9428             if (strncmp(line, "black", strlen("black"))==0)
9429               blackPlaysFirst = TRUE;
9430         }
9431     }
9432     startedFromSetupPosition = TRUE;
9433
9434     SendToProgram("force\n", &first);
9435     CopyBoard(boards[0], initial_position);
9436     if (blackPlaysFirst) {
9437         currentMove = forwardMostMove = backwardMostMove = 1;
9438         strcpy(moveList[0], "");
9439         strcpy(parseList[0], "");
9440         CopyBoard(boards[1], initial_position);
9441         DisplayMessage("", _("Black to play"));
9442     } else {
9443         currentMove = forwardMostMove = backwardMostMove = 0;
9444         DisplayMessage("", _("White to play"));
9445     }
9446           /* [HGM] copy FEN attributes as well */
9447           {   int i;
9448               initialRulePlies = FENrulePlies;
9449               epStatus[forwardMostMove] = FENepStatus;
9450               for( i=0; i< nrCastlingRights; i++ )
9451                   castlingRights[forwardMostMove][i] = FENcastlingRights[i];
9452           }
9453     SendBoard(&first, forwardMostMove);
9454     if (appData.debugMode) {
9455 int i, j;
9456   for(i=0;i<2;i++){for(j=0;j<6;j++)fprintf(debugFP, " %d", castlingRights[i][j]);fprintf(debugFP,"\n");}
9457   for(j=0;j<6;j++)fprintf(debugFP, " %d", initialRights[j]);fprintf(debugFP,"\n");
9458         fprintf(debugFP, "Load Position\n");
9459     }
9460
9461     if (positionNumber > 1) {
9462         sprintf(line, "%s %d", title, positionNumber);
9463         DisplayTitle(line);
9464     } else {
9465         DisplayTitle(title);
9466     }
9467     gameMode = EditGame;
9468     ModeHighlight();
9469     ResetClocks();
9470     timeRemaining[0][1] = whiteTimeRemaining;
9471     timeRemaining[1][1] = blackTimeRemaining;
9472     DrawPosition(FALSE, boards[currentMove]);
9473
9474     return TRUE;
9475 }
9476
9477
9478 void
9479 CopyPlayerNameIntoFileName(dest, src)
9480      char **dest, *src;
9481 {
9482     while (*src != NULLCHAR && *src != ',') {
9483         if (*src == ' ') {
9484             *(*dest)++ = '_';
9485             src++;
9486         } else {
9487             *(*dest)++ = *src++;
9488         }
9489     }
9490 }
9491
9492 char *DefaultFileName(ext)
9493      char *ext;
9494 {
9495     static char def[MSG_SIZ];
9496     char *p;
9497
9498     if (gameInfo.white != NULL && gameInfo.white[0] != '-') {
9499         p = def;
9500         CopyPlayerNameIntoFileName(&p, gameInfo.white);
9501         *p++ = '-';
9502         CopyPlayerNameIntoFileName(&p, gameInfo.black);
9503         *p++ = '.';
9504         strcpy(p, ext);
9505     } else {
9506         def[0] = NULLCHAR;
9507     }
9508     return def;
9509 }
9510
9511 /* Save the current game to the given file */
9512 int
9513 SaveGameToFile(filename, append)
9514      char *filename;
9515      int append;
9516 {
9517     FILE *f;
9518     char buf[MSG_SIZ];
9519
9520     if (strcmp(filename, "-") == 0) {
9521         return SaveGame(stdout, 0, NULL);
9522     } else {
9523         f = fopen(filename, append ? "a" : "w");
9524         if (f == NULL) {
9525             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
9526             DisplayError(buf, errno);
9527             return FALSE;
9528         } else {
9529             return SaveGame(f, 0, NULL);
9530         }
9531     }
9532 }
9533
9534 char *
9535 SavePart(str)
9536      char *str;
9537 {
9538     static char buf[MSG_SIZ];
9539     char *p;
9540
9541     p = strchr(str, ' ');
9542     if (p == NULL) return str;
9543     strncpy(buf, str, p - str);
9544     buf[p - str] = NULLCHAR;
9545     return buf;
9546 }
9547
9548 #define PGN_MAX_LINE 75
9549
9550 #define PGN_SIDE_WHITE  0
9551 #define PGN_SIDE_BLACK  1
9552
9553 /* [AS] */
9554 static int FindFirstMoveOutOfBook( int side )
9555 {
9556     int result = -1;
9557
9558     if( backwardMostMove == 0 && ! startedFromSetupPosition) {
9559         int index = backwardMostMove;
9560         int has_book_hit = 0;
9561
9562         if( (index % 2) != side ) {
9563             index++;
9564         }
9565
9566         while( index < forwardMostMove ) {
9567             /* Check to see if engine is in book */
9568             int depth = pvInfoList[index].depth;
9569             int score = pvInfoList[index].score;
9570             int in_book = 0;
9571
9572             if( depth <= 2 ) {
9573                 in_book = 1;
9574             }
9575             else if( score == 0 && depth == 63 ) {
9576                 in_book = 1; /* Zappa */
9577             }
9578             else if( score == 2 && depth == 99 ) {
9579                 in_book = 1; /* Abrok */
9580             }
9581
9582             has_book_hit += in_book;
9583
9584             if( ! in_book ) {
9585                 result = index;
9586
9587                 break;
9588             }
9589
9590             index += 2;
9591         }
9592     }
9593
9594     return result;
9595 }
9596
9597 /* [AS] */
9598 void GetOutOfBookInfo( char * buf )
9599 {
9600     int oob[2];
9601     int i;
9602     int offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
9603
9604     oob[0] = FindFirstMoveOutOfBook( PGN_SIDE_WHITE );
9605     oob[1] = FindFirstMoveOutOfBook( PGN_SIDE_BLACK );
9606
9607     *buf = '\0';
9608
9609     if( oob[0] >= 0 || oob[1] >= 0 ) {
9610         for( i=0; i<2; i++ ) {
9611             int idx = oob[i];
9612
9613             if( idx >= 0 ) {
9614                 if( i > 0 && oob[0] >= 0 ) {
9615                     strcat( buf, "   " );
9616                 }
9617
9618                 sprintf( buf+strlen(buf), "%d%s. ", (idx - offset)/2 + 1, idx & 1 ? ".." : "" );
9619                 sprintf( buf+strlen(buf), "%s%.2f",
9620                     pvInfoList[idx].score >= 0 ? "+" : "",
9621                     pvInfoList[idx].score / 100.0 );
9622             }
9623         }
9624     }
9625 }
9626
9627 /* Save game in PGN style and close the file */
9628 int
9629 SaveGamePGN(f)
9630      FILE *f;
9631 {
9632     int i, offset, linelen, newblock;
9633     time_t tm;
9634 //    char *movetext;
9635     char numtext[32];
9636     int movelen, numlen, blank;
9637     char move_buffer[100]; /* [AS] Buffer for move+PV info */
9638
9639     offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
9640
9641     tm = time((time_t *) NULL);
9642
9643     PrintPGNTags(f, &gameInfo);
9644
9645     if (backwardMostMove > 0 || startedFromSetupPosition) {
9646         char *fen = PositionToFEN(backwardMostMove, NULL);
9647         fprintf(f, "[FEN \"%s\"]\n[SetUp \"1\"]\n", fen);
9648         fprintf(f, "\n{--------------\n");
9649         PrintPosition(f, backwardMostMove);
9650         fprintf(f, "--------------}\n");
9651         free(fen);
9652     }
9653     else {
9654         /* [AS] Out of book annotation */
9655         if( appData.saveOutOfBookInfo ) {
9656             char buf[64];
9657
9658             GetOutOfBookInfo( buf );
9659
9660             if( buf[0] != '\0' ) {
9661                 fprintf( f, "[%s \"%s\"]\n", PGN_OUT_OF_BOOK, buf );
9662             }
9663         }
9664
9665         fprintf(f, "\n");
9666     }
9667
9668     i = backwardMostMove;
9669     linelen = 0;
9670     newblock = TRUE;
9671
9672     while (i < forwardMostMove) {
9673         /* Print comments preceding this move */
9674         if (commentList[i] != NULL) {
9675             if (linelen > 0) fprintf(f, "\n");
9676             fprintf(f, "{\n%s}\n", commentList[i]);
9677             linelen = 0;
9678             newblock = TRUE;
9679         }
9680
9681         /* Format move number */
9682         if ((i % 2) == 0) {
9683             sprintf(numtext, "%d.", (i - offset)/2 + 1);
9684         } else {
9685             if (newblock) {
9686                 sprintf(numtext, "%d...", (i - offset)/2 + 1);
9687             } else {
9688                 numtext[0] = NULLCHAR;
9689             }
9690         }
9691         numlen = strlen(numtext);
9692         newblock = FALSE;
9693
9694         /* Print move number */
9695         blank = linelen > 0 && numlen > 0;
9696         if (linelen + (blank ? 1 : 0) + numlen > PGN_MAX_LINE) {
9697             fprintf(f, "\n");
9698             linelen = 0;
9699             blank = 0;
9700         }
9701         if (blank) {
9702             fprintf(f, " ");
9703             linelen++;
9704         }
9705         fprintf(f, numtext);
9706         linelen += numlen;
9707
9708         /* Get move */
9709         strcpy(move_buffer, SavePart(parseList[i])); // [HGM] pgn: print move via buffer, so it can be edited
9710         movelen = strlen(move_buffer); /* [HGM] pgn: line-break point before move */
9711 #if 0
9712         // SavePart already does this!
9713         if( i >= 0 && appData.saveExtendedInfoInPGN && pvInfoList[i].depth > 0 ) {
9714                 int p = movelen - 1;
9715                 if(move_buffer[p] == ' ') p--;
9716                 if(move_buffer[p] == ')') { // [HGM] pgn: strip off ICS time if we have extended info
9717                     while(p && move_buffer[--p] != '(');
9718                     if(p && move_buffer[p-1] == ' ') move_buffer[movelen=p-1] = 0;
9719                 }
9720         }
9721 #endif
9722         /* Print move */
9723         blank = linelen > 0 && movelen > 0;
9724         if (linelen + (blank ? 1 : 0) + movelen > PGN_MAX_LINE) {
9725             fprintf(f, "\n");
9726             linelen = 0;
9727             blank = 0;
9728         }
9729         if (blank) {
9730             fprintf(f, " ");
9731             linelen++;
9732         }
9733         fprintf(f, move_buffer);
9734         linelen += movelen;
9735
9736         /* [AS] Add PV info if present */
9737         if( i >= 0 && appData.saveExtendedInfoInPGN && pvInfoList[i].depth > 0 ) {
9738             /* [HGM] add time */
9739             char buf[MSG_SIZ]; int seconds = 0;
9740
9741 #if 1
9742             if(i >= backwardMostMove) {
9743                 if(WhiteOnMove(i))
9744                         seconds = timeRemaining[0][i] - timeRemaining[0][i+1]
9745                                   + GetTimeQuota(i/2) / (1000*WhitePlayer()->timeOdds);
9746                 else
9747                         seconds = timeRemaining[1][i] - timeRemaining[1][i+1]
9748                                   + GetTimeQuota(i/2) / (1000*WhitePlayer()->other->timeOdds);
9749             }
9750             seconds = (seconds+50)/100; // deci-seconds, rounded to nearest
9751 #else
9752             seconds = (pvInfoList[i].time + 5)/10; // [HGM] PVtime: use engine time
9753 #endif
9754
9755             if( seconds <= 0) buf[0] = 0; else
9756             if( seconds < 30 ) sprintf(buf, " %3.1f%c", seconds/10., 0); else {
9757                 seconds = (seconds + 4)/10; // round to full seconds
9758                 if( seconds < 60 ) sprintf(buf, " %d%c", seconds, 0); else
9759                                    sprintf(buf, " %d:%02d%c", seconds/60, seconds%60, 0);
9760             }
9761
9762             sprintf( move_buffer, "{%s%.2f/%d%s}",
9763                 pvInfoList[i].score >= 0 ? "+" : "",
9764                 pvInfoList[i].score / 100.0,
9765                 pvInfoList[i].depth,
9766                 buf );
9767
9768             movelen = strlen(move_buffer); /* [HGM] pgn: line-break point after move */
9769
9770             /* Print score/depth */
9771             blank = linelen > 0 && movelen > 0;
9772             if (linelen + (blank ? 1 : 0) + movelen > PGN_MAX_LINE) {
9773                 fprintf(f, "\n");
9774                 linelen = 0;
9775                 blank = 0;
9776             }
9777             if (blank) {
9778                 fprintf(f, " ");
9779                 linelen++;
9780             }
9781             fprintf(f, move_buffer);
9782             linelen += movelen;
9783         }
9784
9785         i++;
9786     }
9787
9788     /* Start a new line */
9789     if (linelen > 0) fprintf(f, "\n");
9790
9791     /* Print comments after last move */
9792     if (commentList[i] != NULL) {
9793         fprintf(f, "{\n%s}\n", commentList[i]);
9794     }
9795
9796     /* Print result */
9797     if (gameInfo.resultDetails != NULL &&
9798         gameInfo.resultDetails[0] != NULLCHAR) {
9799         fprintf(f, "{%s} %s\n\n", gameInfo.resultDetails,
9800                 PGNResult(gameInfo.result));
9801     } else {
9802         fprintf(f, "%s\n\n", PGNResult(gameInfo.result));
9803     }
9804
9805     fclose(f);
9806     lastSavedGame = GameCheckSum(); // [HGM] save: remember ID of last saved game to prevent double saving
9807     return TRUE;
9808 }
9809
9810 /* Save game in old style and close the file */
9811 int
9812 SaveGameOldStyle(f)
9813      FILE *f;
9814 {
9815     int i, offset;
9816     time_t tm;
9817
9818     tm = time((time_t *) NULL);
9819
9820     fprintf(f, "# %s game file -- %s", programName, ctime(&tm));
9821     PrintOpponents(f);
9822
9823     if (backwardMostMove > 0 || startedFromSetupPosition) {
9824         fprintf(f, "\n[--------------\n");
9825         PrintPosition(f, backwardMostMove);
9826         fprintf(f, "--------------]\n");
9827     } else {
9828         fprintf(f, "\n");
9829     }
9830
9831     i = backwardMostMove;
9832     offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
9833
9834     while (i < forwardMostMove) {
9835         if (commentList[i] != NULL) {
9836             fprintf(f, "[%s]\n", commentList[i]);
9837         }
9838
9839         if ((i % 2) == 1) {
9840             fprintf(f, "%d. ...  %s\n", (i - offset)/2 + 1, parseList[i]);
9841             i++;
9842         } else {
9843             fprintf(f, "%d. %s  ", (i - offset)/2 + 1, parseList[i]);
9844             i++;
9845             if (commentList[i] != NULL) {
9846                 fprintf(f, "\n");
9847                 continue;
9848             }
9849             if (i >= forwardMostMove) {
9850                 fprintf(f, "\n");
9851                 break;
9852             }
9853             fprintf(f, "%s\n", parseList[i]);
9854             i++;
9855         }
9856     }
9857
9858     if (commentList[i] != NULL) {
9859         fprintf(f, "[%s]\n", commentList[i]);
9860     }
9861
9862     /* This isn't really the old style, but it's close enough */
9863     if (gameInfo.resultDetails != NULL &&
9864         gameInfo.resultDetails[0] != NULLCHAR) {
9865         fprintf(f, "%s (%s)\n\n", PGNResult(gameInfo.result),
9866                 gameInfo.resultDetails);
9867     } else {
9868         fprintf(f, "%s\n\n", PGNResult(gameInfo.result));
9869     }
9870
9871     fclose(f);
9872     return TRUE;
9873 }
9874
9875 /* Save the current game to open file f and close the file */
9876 int
9877 SaveGame(f, dummy, dummy2)
9878      FILE *f;
9879      int dummy;
9880      char *dummy2;
9881 {
9882     if (gameMode == EditPosition) EditPositionDone();
9883     lastSavedGame = GameCheckSum(); // [HGM] save: remember ID of last saved game to prevent double saving
9884     if (appData.oldSaveStyle)
9885       return SaveGameOldStyle(f);
9886     else
9887       return SaveGamePGN(f);
9888 }
9889
9890 /* Save the current position to the given file */
9891 int
9892 SavePositionToFile(filename)
9893      char *filename;
9894 {
9895     FILE *f;
9896     char buf[MSG_SIZ];
9897
9898     if (strcmp(filename, "-") == 0) {
9899         return SavePosition(stdout, 0, NULL);
9900     } else {
9901         f = fopen(filename, "a");
9902         if (f == NULL) {
9903             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
9904             DisplayError(buf, errno);
9905             return FALSE;
9906         } else {
9907             SavePosition(f, 0, NULL);
9908             return TRUE;
9909         }
9910     }
9911 }
9912
9913 /* Save the current position to the given open file and close the file */
9914 int
9915 SavePosition(f, dummy, dummy2)
9916      FILE *f;
9917      int dummy;
9918      char *dummy2;
9919 {
9920     time_t tm;
9921     char *fen;
9922
9923     if (appData.oldSaveStyle) {
9924         tm = time((time_t *) NULL);
9925
9926         fprintf(f, "# %s position file -- %s", programName, ctime(&tm));
9927         PrintOpponents(f);
9928         fprintf(f, "[--------------\n");
9929         PrintPosition(f, currentMove);
9930         fprintf(f, "--------------]\n");
9931     } else {
9932         fen = PositionToFEN(currentMove, NULL);
9933         fprintf(f, "%s\n", fen);
9934         free(fen);
9935     }
9936     fclose(f);
9937     return TRUE;
9938 }
9939
9940 void
9941 ReloadCmailMsgEvent(unregister)
9942      int unregister;
9943 {
9944 #if !WIN32
9945     static char *inFilename = NULL;
9946     static char *outFilename;
9947     int i;
9948     struct stat inbuf, outbuf;
9949     int status;
9950
9951     /* Any registered moves are unregistered if unregister is set, */
9952     /* i.e. invoked by the signal handler */
9953     if (unregister) {
9954         for (i = 0; i < CMAIL_MAX_GAMES; i ++) {
9955             cmailMoveRegistered[i] = FALSE;
9956             if (cmailCommentList[i] != NULL) {
9957                 free(cmailCommentList[i]);
9958                 cmailCommentList[i] = NULL;
9959             }
9960         }
9961         nCmailMovesRegistered = 0;
9962     }
9963
9964     for (i = 0; i < CMAIL_MAX_GAMES; i ++) {
9965         cmailResult[i] = CMAIL_NOT_RESULT;
9966     }
9967     nCmailResults = 0;
9968
9969     if (inFilename == NULL) {
9970         /* Because the filenames are static they only get malloced once  */
9971         /* and they never get freed                                      */
9972         inFilename = (char *) malloc(strlen(appData.cmailGameName) + 9);
9973         sprintf(inFilename, "%s.game.in", appData.cmailGameName);
9974
9975         outFilename = (char *) malloc(strlen(appData.cmailGameName) + 5);
9976         sprintf(outFilename, "%s.out", appData.cmailGameName);
9977     }
9978
9979     status = stat(outFilename, &outbuf);
9980     if (status < 0) {
9981         cmailMailedMove = FALSE;
9982     } else {
9983         status = stat(inFilename, &inbuf);
9984         cmailMailedMove = (inbuf.st_mtime < outbuf.st_mtime);
9985     }
9986
9987     /* LoadGameFromFile(CMAIL_MAX_GAMES) with cmailMsgLoaded == TRUE
9988        counts the games, notes how each one terminated, etc.
9989
9990        It would be nice to remove this kludge and instead gather all
9991        the information while building the game list.  (And to keep it
9992        in the game list nodes instead of having a bunch of fixed-size
9993        parallel arrays.)  Note this will require getting each game's
9994        termination from the PGN tags, as the game list builder does
9995        not process the game moves.  --mann
9996        */
9997     cmailMsgLoaded = TRUE;
9998     LoadGameFromFile(inFilename, CMAIL_MAX_GAMES, "", FALSE);
9999
10000     /* Load first game in the file or popup game menu */
10001     LoadGameFromFile(inFilename, 0, appData.cmailGameName, TRUE);
10002
10003 #endif /* !WIN32 */
10004     return;
10005 }
10006
10007 int
10008 RegisterMove()
10009 {
10010     FILE *f;
10011     char string[MSG_SIZ];
10012
10013     if (   cmailMailedMove
10014         || (cmailResult[lastLoadGameNumber - 1] == CMAIL_OLD_RESULT)) {
10015         return TRUE;            /* Allow free viewing  */
10016     }
10017
10018     /* Unregister move to ensure that we don't leave RegisterMove        */
10019     /* with the move registered when the conditions for registering no   */
10020     /* longer hold                                                       */
10021     if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
10022         cmailMoveRegistered[lastLoadGameNumber - 1] = FALSE;
10023         nCmailMovesRegistered --;
10024
10025         if (cmailCommentList[lastLoadGameNumber - 1] != NULL)
10026           {
10027               free(cmailCommentList[lastLoadGameNumber - 1]);
10028               cmailCommentList[lastLoadGameNumber - 1] = NULL;
10029           }
10030     }
10031
10032     if (cmailOldMove == -1) {
10033         DisplayError(_("You have edited the game history.\nUse Reload Same Game and make your move again."), 0);
10034         return FALSE;
10035     }
10036
10037     if (currentMove > cmailOldMove + 1) {
10038         DisplayError(_("You have entered too many moves.\nBack up to the correct position and try again."), 0);
10039         return FALSE;
10040     }
10041
10042     if (currentMove < cmailOldMove) {
10043         DisplayError(_("Displayed position is not current.\nStep forward to the correct position and try again."), 0);
10044         return FALSE;
10045     }
10046
10047     if (forwardMostMove > currentMove) {
10048         /* Silently truncate extra moves */
10049         TruncateGame();
10050     }
10051
10052     if (   (currentMove == cmailOldMove + 1)
10053         || (   (currentMove == cmailOldMove)
10054             && (   (cmailMoveType[lastLoadGameNumber - 1] == CMAIL_ACCEPT)
10055                 || (cmailMoveType[lastLoadGameNumber - 1] == CMAIL_RESIGN)))) {
10056         if (gameInfo.result != GameUnfinished) {
10057             cmailResult[lastLoadGameNumber - 1] = CMAIL_NEW_RESULT;
10058         }
10059
10060         if (commentList[currentMove] != NULL) {
10061             cmailCommentList[lastLoadGameNumber - 1]
10062               = StrSave(commentList[currentMove]);
10063         }
10064         strcpy(cmailMove[lastLoadGameNumber - 1], moveList[currentMove - 1]);
10065
10066         if (appData.debugMode)
10067           fprintf(debugFP, "Saving %s for game %d\n",
10068                   cmailMove[lastLoadGameNumber - 1], lastLoadGameNumber);
10069
10070         sprintf(string,
10071                 "%s.game.out.%d", appData.cmailGameName, lastLoadGameNumber);
10072
10073         f = fopen(string, "w");
10074         if (appData.oldSaveStyle) {
10075             SaveGameOldStyle(f); /* also closes the file */
10076
10077             sprintf(string, "%s.pos.out", appData.cmailGameName);
10078             f = fopen(string, "w");
10079             SavePosition(f, 0, NULL); /* also closes the file */
10080         } else {
10081             fprintf(f, "{--------------\n");
10082             PrintPosition(f, currentMove);
10083             fprintf(f, "--------------}\n\n");
10084
10085             SaveGame(f, 0, NULL); /* also closes the file*/
10086         }
10087
10088         cmailMoveRegistered[lastLoadGameNumber - 1] = TRUE;
10089         nCmailMovesRegistered ++;
10090     } else if (nCmailGames == 1) {
10091         DisplayError(_("You have not made a move yet"), 0);
10092         return FALSE;
10093     }
10094
10095     return TRUE;
10096 }
10097
10098 void
10099 MailMoveEvent()
10100 {
10101 #if !WIN32
10102     static char *partCommandString = "cmail -xv%s -remail -game %s 2>&1";
10103     FILE *commandOutput;
10104     char buffer[MSG_SIZ], msg[MSG_SIZ], string[MSG_SIZ];
10105     int nBytes = 0;             /*  Suppress warnings on uninitialized variables    */
10106     int nBuffers;
10107     int i;
10108     int archived;
10109     char *arcDir;
10110
10111     if (! cmailMsgLoaded) {
10112         DisplayError(_("The cmail message is not loaded.\nUse Reload CMail Message and make your move again."), 0);
10113         return;
10114     }
10115
10116     if (nCmailGames == nCmailResults) {
10117         DisplayError(_("No unfinished games"), 0);
10118         return;
10119     }
10120
10121 #if CMAIL_PROHIBIT_REMAIL
10122     if (cmailMailedMove) {
10123         sprintf(msg, _("You have already mailed a move.\nWait until a move arrives from your opponent.\nTo resend the same move, type\n\"cmail -remail -game %s\"\non the command line."), appData.cmailGameName);
10124         DisplayError(msg, 0);
10125         return;
10126     }
10127 #endif
10128
10129     if (! (cmailMailedMove || RegisterMove())) return;
10130
10131     if (   cmailMailedMove
10132         || (nCmailMovesRegistered + nCmailResults == nCmailGames)) {
10133         sprintf(string, partCommandString,
10134                 appData.debugMode ? " -v" : "", appData.cmailGameName);
10135         commandOutput = popen(string, "r");
10136
10137         if (commandOutput == NULL) {
10138             DisplayError(_("Failed to invoke cmail"), 0);
10139         } else {
10140             for (nBuffers = 0; (! feof(commandOutput)); nBuffers ++) {
10141                 nBytes = fread(buffer, 1, MSG_SIZ - 1, commandOutput);
10142             }
10143             if (nBuffers > 1) {
10144                 (void) memcpy(msg, buffer + nBytes, MSG_SIZ - nBytes - 1);
10145                 (void) memcpy(msg + MSG_SIZ - nBytes - 1, buffer, nBytes);
10146                 nBytes = MSG_SIZ - 1;
10147             } else {
10148                 (void) memcpy(msg, buffer, nBytes);
10149             }
10150             *(msg + nBytes) = '\0'; /* \0 for end-of-string*/
10151
10152             if(StrStr(msg, "Mailed cmail message to ") != NULL) {
10153                 cmailMailedMove = TRUE; /* Prevent >1 moves    */
10154
10155                 archived = TRUE;
10156                 for (i = 0; i < nCmailGames; i ++) {
10157                     if (cmailResult[i] == CMAIL_NOT_RESULT) {
10158                         archived = FALSE;
10159                     }
10160                 }
10161                 if (   archived
10162                     && (   (arcDir = (char *) getenv("CMAIL_ARCDIR"))
10163                         != NULL)) {
10164                     sprintf(buffer, "%s/%s.%s.archive",
10165                             arcDir,
10166                             appData.cmailGameName,
10167                             gameInfo.date);
10168                     LoadGameFromFile(buffer, 1, buffer, FALSE);
10169                     cmailMsgLoaded = FALSE;
10170                 }
10171             }
10172
10173             DisplayInformation(msg);
10174             pclose(commandOutput);
10175         }
10176     } else {
10177         if ((*cmailMsg) != '\0') {
10178             DisplayInformation(cmailMsg);
10179         }
10180     }
10181
10182     return;
10183 #endif /* !WIN32 */
10184 }
10185
10186 char *
10187 CmailMsg()
10188 {
10189 #if WIN32
10190     return NULL;
10191 #else
10192     int  prependComma = 0;
10193     char number[5];
10194     char string[MSG_SIZ];       /* Space for game-list */
10195     int  i;
10196
10197     if (!cmailMsgLoaded) return "";
10198
10199     if (cmailMailedMove) {
10200         sprintf(cmailMsg, _("Waiting for reply from opponent\n"));
10201     } else {
10202         /* Create a list of games left */
10203         sprintf(string, "[");
10204         for (i = 0; i < nCmailGames; i ++) {
10205             if (! (   cmailMoveRegistered[i]
10206                    || (cmailResult[i] == CMAIL_OLD_RESULT))) {
10207                 if (prependComma) {
10208                     sprintf(number, ",%d", i + 1);
10209                 } else {
10210                     sprintf(number, "%d", i + 1);
10211                     prependComma = 1;
10212                 }
10213
10214                 strcat(string, number);
10215             }
10216         }
10217         strcat(string, "]");
10218
10219         if (nCmailMovesRegistered + nCmailResults == 0) {
10220             switch (nCmailGames) {
10221               case 1:
10222                 sprintf(cmailMsg,
10223                         _("Still need to make move for game\n"));
10224                 break;
10225
10226               case 2:
10227                 sprintf(cmailMsg,
10228                         _("Still need to make moves for both games\n"));
10229                 break;
10230
10231               default:
10232                 sprintf(cmailMsg,
10233                         _("Still need to make moves for all %d games\n"),
10234                         nCmailGames);
10235                 break;
10236             }
10237         } else {
10238             switch (nCmailGames - nCmailMovesRegistered - nCmailResults) {
10239               case 1:
10240                 sprintf(cmailMsg,
10241                         _("Still need to make a move for game %s\n"),
10242                         string);
10243                 break;
10244
10245               case 0:
10246                 if (nCmailResults == nCmailGames) {
10247                     sprintf(cmailMsg, _("No unfinished games\n"));
10248                 } else {
10249                     sprintf(cmailMsg, _("Ready to send mail\n"));
10250                 }
10251                 break;
10252
10253               default:
10254                 sprintf(cmailMsg,
10255                         _("Still need to make moves for games %s\n"),
10256                         string);
10257             }
10258         }
10259     }
10260     return cmailMsg;
10261 #endif /* WIN32 */
10262 }
10263
10264 void
10265 ResetGameEvent()
10266 {
10267     if (gameMode == Training)
10268       SetTrainingModeOff();
10269
10270     Reset(TRUE, TRUE);
10271     cmailMsgLoaded = FALSE;
10272     if (appData.icsActive) {
10273       SendToICS(ics_prefix);
10274       SendToICS("refresh\n");
10275     }
10276 }
10277
10278 void
10279 ExitEvent(status)
10280      int status;
10281 {
10282     exiting++;
10283     if (exiting > 2) {
10284       /* Give up on clean exit */
10285       exit(status);
10286     }
10287     if (exiting > 1) {
10288       /* Keep trying for clean exit */
10289       return;
10290     }
10291
10292     if (appData.icsActive && appData.colorize) Colorize(ColorNone, FALSE);
10293
10294     if (telnetISR != NULL) {
10295       RemoveInputSource(telnetISR);
10296     }
10297     if (icsPR != NoProc) {
10298       DestroyChildProcess(icsPR, TRUE);
10299     }
10300 #if 0
10301     /* Save game if resource set and not already saved by GameEnds() */
10302     if ((gameInfo.resultDetails == NULL || errorExitFlag )
10303                              && forwardMostMove > 0) {
10304       if (*appData.saveGameFile != NULLCHAR) {
10305         SaveGameToFile(appData.saveGameFile, TRUE);
10306       } else if (appData.autoSaveGames) {
10307         AutoSaveGame();
10308       }
10309       if (*appData.savePositionFile != NULLCHAR) {
10310         SavePositionToFile(appData.savePositionFile);
10311       }
10312     }
10313     GameEnds((ChessMove) 0, NULL, GE_PLAYER);
10314 #else
10315     /* [HGM] crash: leave writing PGN and position entirely to GameEnds() */
10316     GameEnds(gameInfo.result, gameInfo.resultDetails==NULL ? "xboard exit" : gameInfo.resultDetails, GE_PLAYER);
10317 #endif
10318     /* [HGM] crash: the above GameEnds() is a dud if another one was running */
10319     /* make sure this other one finishes before killing it!                  */
10320     if(endingGame) { int count = 0;
10321         if(appData.debugMode) fprintf(debugFP, "ExitEvent() during GameEnds(), wait\n");
10322         while(endingGame && count++ < 10) DoSleep(1);
10323         if(appData.debugMode && endingGame) fprintf(debugFP, "GameEnds() seems stuck, proceed exiting\n");
10324     }
10325
10326     /* Kill off chess programs */
10327     if (first.pr != NoProc) {
10328         ExitAnalyzeMode();
10329
10330         DoSleep( appData.delayBeforeQuit );
10331         SendToProgram("quit\n", &first);
10332         DoSleep( appData.delayAfterQuit );
10333         DestroyChildProcess(first.pr, 10 /* [AS] first.useSigterm */ );
10334     }
10335     if (second.pr != NoProc) {
10336         DoSleep( appData.delayBeforeQuit );
10337         SendToProgram("quit\n", &second);
10338         DoSleep( appData.delayAfterQuit );
10339         DestroyChildProcess(second.pr, 10 /* [AS] second.useSigterm */ );
10340     }
10341     if (first.isr != NULL) {
10342         RemoveInputSource(first.isr);
10343     }
10344     if (second.isr != NULL) {
10345         RemoveInputSource(second.isr);
10346     }
10347
10348     ShutDownFrontEnd();
10349     exit(status);
10350 }
10351
10352 void
10353 PauseEvent()
10354 {
10355     if (appData.debugMode)
10356         fprintf(debugFP, "PauseEvent(): pausing %d\n", pausing);
10357     if (pausing) {
10358         pausing = FALSE;
10359         ModeHighlight();
10360         if (gameMode == MachinePlaysWhite ||
10361             gameMode == MachinePlaysBlack) {
10362             StartClocks();
10363         } else {
10364             DisplayBothClocks();
10365         }
10366         if (gameMode == PlayFromGameFile) {
10367             if (appData.timeDelay >= 0)
10368                 AutoPlayGameLoop();
10369         } else if (gameMode == IcsExamining && pauseExamInvalid) {
10370             Reset(FALSE, TRUE);
10371             SendToICS(ics_prefix);
10372             SendToICS("refresh\n");
10373         } else if (currentMove < forwardMostMove) {
10374             ForwardInner(forwardMostMove);
10375         }
10376         pauseExamInvalid = FALSE;
10377     } else {
10378         switch (gameMode) {
10379           default:
10380             return;
10381           case IcsExamining:
10382             pauseExamForwardMostMove = forwardMostMove;
10383             pauseExamInvalid = FALSE;
10384             /* fall through */
10385           case IcsObserving:
10386           case IcsPlayingWhite:
10387           case IcsPlayingBlack:
10388             pausing = TRUE;
10389             ModeHighlight();
10390             return;
10391           case PlayFromGameFile:
10392             (void) StopLoadGameTimer();
10393             pausing = TRUE;
10394             ModeHighlight();
10395             break;
10396           case BeginningOfGame:
10397             if (appData.icsActive) return;
10398             /* else fall through */
10399           case MachinePlaysWhite:
10400           case MachinePlaysBlack:
10401           case TwoMachinesPlay:
10402             if (forwardMostMove == 0)
10403               return;           /* don't pause if no one has moved */
10404             if ((gameMode == MachinePlaysWhite &&
10405                  !WhiteOnMove(forwardMostMove)) ||
10406                 (gameMode == MachinePlaysBlack &&
10407                  WhiteOnMove(forwardMostMove))) {
10408                 StopClocks();
10409             }
10410             pausing = TRUE;
10411             ModeHighlight();
10412             break;
10413         }
10414     }
10415 }
10416
10417 void
10418 EditCommentEvent()
10419 {
10420     char title[MSG_SIZ];
10421
10422     if (currentMove < 1 || parseList[currentMove - 1][0] == NULLCHAR) {
10423         strcpy(title, _("Edit comment"));
10424     } else {
10425         sprintf(title, _("Edit comment on %d.%s%s"), (currentMove - 1) / 2 + 1,
10426                 WhiteOnMove(currentMove - 1) ? " " : ".. ",
10427                 parseList[currentMove - 1]);
10428     }
10429
10430     EditCommentPopUp(currentMove, title, commentList[currentMove]);
10431 }
10432
10433
10434 void
10435 EditTagsEvent()
10436 {
10437     char *tags = PGNTags(&gameInfo);
10438     EditTagsPopUp(tags);
10439     free(tags);
10440 }
10441
10442 void
10443 AnalyzeModeEvent()
10444 {
10445     if (appData.noChessProgram || gameMode == AnalyzeMode)
10446       return;
10447
10448     if (gameMode != AnalyzeFile) {
10449         if (!appData.icsEngineAnalyze) {
10450                EditGameEvent();
10451                if (gameMode != EditGame) return;
10452         }
10453         ResurrectChessProgram();
10454         SendToProgram("analyze\n", &first);
10455         first.analyzing = TRUE;
10456         /*first.maybeThinking = TRUE;*/
10457         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
10458         AnalysisPopUp(_("Analysis"),
10459                       _("Starting analysis mode...\nIf this message stays up, your chess program does not support analysis."));
10460     }
10461     if (!appData.icsEngineAnalyze) gameMode = AnalyzeMode;
10462     pausing = FALSE;
10463     ModeHighlight();
10464     SetGameInfo();
10465
10466     StartAnalysisClock();
10467     GetTimeMark(&lastNodeCountTime);
10468     lastNodeCount = 0;
10469 }
10470
10471 void
10472 AnalyzeFileEvent()
10473 {
10474     if (appData.noChessProgram || gameMode == AnalyzeFile)
10475       return;
10476
10477     if (gameMode != AnalyzeMode) {
10478         EditGameEvent();
10479         if (gameMode != EditGame) return;
10480         ResurrectChessProgram();
10481         SendToProgram("analyze\n", &first);
10482         first.analyzing = TRUE;
10483         /*first.maybeThinking = TRUE;*/
10484         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
10485         AnalysisPopUp(_("Analysis"),
10486                       _("Starting analysis mode...\nIf this message stays up, your chess program does not support analysis."));
10487     }
10488     gameMode = AnalyzeFile;
10489     pausing = FALSE;
10490     ModeHighlight();
10491     SetGameInfo();
10492
10493     StartAnalysisClock();
10494     GetTimeMark(&lastNodeCountTime);
10495     lastNodeCount = 0;
10496 }
10497
10498 void
10499 MachineWhiteEvent()
10500 {
10501     char buf[MSG_SIZ];
10502     char *bookHit = NULL;
10503
10504     if (appData.noChessProgram || (gameMode == MachinePlaysWhite))
10505       return;
10506
10507
10508     if (gameMode == PlayFromGameFile ||
10509         gameMode == TwoMachinesPlay  ||
10510         gameMode == Training         ||
10511         gameMode == AnalyzeMode      ||
10512         gameMode == EndOfGame)
10513         EditGameEvent();
10514
10515     if (gameMode == EditPosition)
10516         EditPositionDone();
10517
10518     if (!WhiteOnMove(currentMove)) {
10519         DisplayError(_("It is not White's turn"), 0);
10520         return;
10521     }
10522
10523     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile)
10524       ExitAnalyzeMode();
10525
10526     if (gameMode == EditGame || gameMode == AnalyzeMode ||
10527         gameMode == AnalyzeFile)
10528         TruncateGame();
10529
10530     ResurrectChessProgram();    /* in case it isn't running */
10531     if(gameMode == BeginningOfGame) { /* [HGM] time odds: to get right odds in human mode */
10532         gameMode = MachinePlaysWhite;
10533         ResetClocks();
10534     } else
10535     gameMode = MachinePlaysWhite;
10536     pausing = FALSE;
10537     ModeHighlight();
10538     SetGameInfo();
10539     sprintf(buf, "%s vs. %s", gameInfo.white, gameInfo.black);
10540     DisplayTitle(buf);
10541     if (first.sendName) {
10542       sprintf(buf, "name %s\n", gameInfo.black);
10543       SendToProgram(buf, &first);
10544     }
10545     if (first.sendTime) {
10546       if (first.useColors) {
10547         SendToProgram("black\n", &first); /*gnu kludge*/
10548       }
10549       SendTimeRemaining(&first, TRUE);
10550     }
10551     if (first.useColors) {
10552       SendToProgram("white\n", &first); // [HGM] book: send 'go' separately
10553     }
10554     bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: send go or retrieve book move
10555     SetMachineThinkingEnables();
10556     first.maybeThinking = TRUE;
10557     StartClocks();
10558     firstMove = FALSE;
10559
10560     if (appData.autoFlipView && !flipView) {
10561       flipView = !flipView;
10562       DrawPosition(FALSE, NULL);
10563       DisplayBothClocks();       // [HGM] logo: clocks might have to be exchanged;
10564     }
10565
10566     if(bookHit) { // [HGM] book: simulate book reply
10567         static char bookMove[MSG_SIZ]; // a bit generous?
10568
10569         programStats.nodes = programStats.depth = programStats.time =
10570         programStats.score = programStats.got_only_move = 0;
10571         sprintf(programStats.movelist, "%s (xbook)", bookHit);
10572
10573         strcpy(bookMove, "move ");
10574         strcat(bookMove, bookHit);
10575         HandleMachineMove(bookMove, &first);
10576     }
10577 }
10578
10579 void
10580 MachineBlackEvent()
10581 {
10582     char buf[MSG_SIZ];
10583    char *bookHit = NULL;
10584
10585     if (appData.noChessProgram || (gameMode == MachinePlaysBlack))
10586         return;
10587
10588
10589     if (gameMode == PlayFromGameFile ||
10590         gameMode == TwoMachinesPlay  ||
10591         gameMode == Training         ||
10592         gameMode == AnalyzeMode      ||
10593         gameMode == EndOfGame)
10594         EditGameEvent();
10595
10596     if (gameMode == EditPosition)
10597         EditPositionDone();
10598
10599     if (WhiteOnMove(currentMove)) {
10600         DisplayError(_("It is not Black's turn"), 0);
10601         return;
10602     }
10603
10604     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile)
10605       ExitAnalyzeMode();
10606
10607     if (gameMode == EditGame || gameMode == AnalyzeMode ||
10608         gameMode == AnalyzeFile)
10609         TruncateGame();
10610
10611     ResurrectChessProgram();    /* in case it isn't running */
10612     gameMode = MachinePlaysBlack;
10613     pausing = FALSE;
10614     ModeHighlight();
10615     SetGameInfo();
10616     sprintf(buf, "%s vs. %s", gameInfo.white, gameInfo.black);
10617     DisplayTitle(buf);
10618     if (first.sendName) {
10619       sprintf(buf, "name %s\n", gameInfo.white);
10620       SendToProgram(buf, &first);
10621     }
10622     if (first.sendTime) {
10623       if (first.useColors) {
10624         SendToProgram("white\n", &first); /*gnu kludge*/
10625       }
10626       SendTimeRemaining(&first, FALSE);
10627     }
10628     if (first.useColors) {
10629       SendToProgram("black\n", &first); // [HGM] book: 'go' sent separately
10630     }
10631     bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: send go or retrieve book move
10632     SetMachineThinkingEnables();
10633     first.maybeThinking = TRUE;
10634     StartClocks();
10635
10636     if (appData.autoFlipView && flipView) {
10637       flipView = !flipView;
10638       DrawPosition(FALSE, NULL);
10639       DisplayBothClocks();       // [HGM] logo: clocks might have to be exchanged;
10640     }
10641     if(bookHit) { // [HGM] book: simulate book reply
10642         static char bookMove[MSG_SIZ]; // a bit generous?
10643
10644         programStats.nodes = programStats.depth = programStats.time =
10645         programStats.score = programStats.got_only_move = 0;
10646         sprintf(programStats.movelist, "%s (xbook)", bookHit);
10647
10648         strcpy(bookMove, "move ");
10649         strcat(bookMove, bookHit);
10650         HandleMachineMove(bookMove, &first);
10651     }
10652 }
10653
10654
10655 void
10656 DisplayTwoMachinesTitle()
10657 {
10658     char buf[MSG_SIZ];
10659     if (appData.matchGames > 0) {
10660         if (first.twoMachinesColor[0] == 'w') {
10661             sprintf(buf, "%s vs. %s (%d-%d-%d)",
10662                     gameInfo.white, gameInfo.black,
10663                     first.matchWins, second.matchWins,
10664                     matchGame - 1 - (first.matchWins + second.matchWins));
10665         } else {
10666             sprintf(buf, "%s vs. %s (%d-%d-%d)",
10667                     gameInfo.white, gameInfo.black,
10668                     second.matchWins, first.matchWins,
10669                     matchGame - 1 - (first.matchWins + second.matchWins));
10670         }
10671     } else {
10672         sprintf(buf, "%s vs. %s", gameInfo.white, gameInfo.black);
10673     }
10674     DisplayTitle(buf);
10675 }
10676
10677 void
10678 TwoMachinesEvent P((void))
10679 {
10680     int i;
10681     char buf[MSG_SIZ];
10682     ChessProgramState *onmove;
10683     char *bookHit = NULL;
10684
10685     if (appData.noChessProgram) return;
10686
10687     switch (gameMode) {
10688       case TwoMachinesPlay:
10689         return;
10690       case MachinePlaysWhite:
10691       case MachinePlaysBlack:
10692         if (WhiteOnMove(forwardMostMove) == (gameMode == MachinePlaysWhite)) {
10693             DisplayError(_("Wait until your turn,\nor select Move Now"), 0);
10694             return;
10695         }
10696         /* fall through */
10697       case BeginningOfGame:
10698       case PlayFromGameFile:
10699       case EndOfGame:
10700         EditGameEvent();
10701         if (gameMode != EditGame) return;
10702         break;
10703       case EditPosition:
10704         EditPositionDone();
10705         break;
10706       case AnalyzeMode:
10707       case AnalyzeFile:
10708         ExitAnalyzeMode();
10709         break;
10710       case EditGame:
10711       default:
10712         break;
10713     }
10714
10715     forwardMostMove = currentMove;
10716     ResurrectChessProgram();    /* in case first program isn't running */
10717
10718     if (second.pr == NULL) {
10719         StartChessProgram(&second);
10720         if (second.protocolVersion == 1) {
10721           TwoMachinesEventIfReady();
10722         } else {
10723           /* kludge: allow timeout for initial "feature" command */
10724           FreezeUI();
10725           DisplayMessage("", _("Starting second chess program"));
10726           ScheduleDelayedEvent(TwoMachinesEventIfReady, FEATURE_TIMEOUT);
10727         }
10728         return;
10729     }
10730     DisplayMessage("", "");
10731     InitChessProgram(&second, FALSE);
10732     SendToProgram("force\n", &second);
10733     if (startedFromSetupPosition) {
10734         SendBoard(&second, backwardMostMove);
10735     if (appData.debugMode) {
10736         fprintf(debugFP, "Two Machines\n");
10737     }
10738     }
10739     for (i = backwardMostMove; i < forwardMostMove; i++) {
10740         SendMoveToProgram(i, &second);
10741     }
10742
10743     gameMode = TwoMachinesPlay;
10744     pausing = FALSE;
10745     ModeHighlight();
10746     SetGameInfo();
10747     DisplayTwoMachinesTitle();
10748     firstMove = TRUE;
10749     if ((first.twoMachinesColor[0] == 'w') == WhiteOnMove(forwardMostMove)) {
10750         onmove = &first;
10751     } else {
10752         onmove = &second;
10753     }
10754
10755     SendToProgram(first.computerString, &first);
10756     if (first.sendName) {
10757       sprintf(buf, "name %s\n", second.tidy);
10758       SendToProgram(buf, &first);
10759     }
10760     SendToProgram(second.computerString, &second);
10761     if (second.sendName) {
10762       sprintf(buf, "name %s\n", first.tidy);
10763       SendToProgram(buf, &second);
10764     }
10765
10766     ResetClocks();
10767     if (!first.sendTime || !second.sendTime) {
10768         timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
10769         timeRemaining[1][forwardMostMove] = blackTimeRemaining;
10770     }
10771     if (onmove->sendTime) {
10772       if (onmove->useColors) {
10773         SendToProgram(onmove->other->twoMachinesColor, onmove); /*gnu kludge*/
10774       }
10775       SendTimeRemaining(onmove, WhiteOnMove(forwardMostMove));
10776     }
10777     if (onmove->useColors) {
10778       SendToProgram(onmove->twoMachinesColor, onmove);
10779     }
10780     bookHit = SendMoveToBookUser(forwardMostMove-1, onmove, TRUE); // [HGM] book: send go or retrieve book move
10781 //    SendToProgram("go\n", onmove);
10782     onmove->maybeThinking = TRUE;
10783     SetMachineThinkingEnables();
10784
10785     StartClocks();
10786
10787     if(bookHit) { // [HGM] book: simulate book reply
10788         static char bookMove[MSG_SIZ]; // a bit generous?
10789
10790         programStats.nodes = programStats.depth = programStats.time =
10791         programStats.score = programStats.got_only_move = 0;
10792         sprintf(programStats.movelist, "%s (xbook)", bookHit);
10793
10794         strcpy(bookMove, "move ");
10795         strcat(bookMove, bookHit);
10796         HandleMachineMove(bookMove, &first);
10797     }
10798 }
10799
10800 void
10801 TrainingEvent()
10802 {
10803     if (gameMode == Training) {
10804       SetTrainingModeOff();
10805       gameMode = PlayFromGameFile;
10806       DisplayMessage("", _("Training mode off"));
10807     } else {
10808       gameMode = Training;
10809       animateTraining = appData.animate;
10810
10811       /* make sure we are not already at the end of the game */
10812       if (currentMove < forwardMostMove) {
10813         SetTrainingModeOn();
10814         DisplayMessage("", _("Training mode on"));
10815       } else {
10816         gameMode = PlayFromGameFile;
10817         DisplayError(_("Already at end of game"), 0);
10818       }
10819     }
10820     ModeHighlight();
10821 }
10822
10823 void
10824 IcsClientEvent()
10825 {
10826     if (!appData.icsActive) return;
10827     switch (gameMode) {
10828       case IcsPlayingWhite:
10829       case IcsPlayingBlack:
10830       case IcsObserving:
10831       case IcsIdle:
10832       case BeginningOfGame:
10833       case IcsExamining:
10834         return;
10835
10836       case EditGame:
10837         break;
10838
10839       case EditPosition:
10840         EditPositionDone();
10841         break;
10842
10843       case AnalyzeMode:
10844       case AnalyzeFile:
10845         ExitAnalyzeMode();
10846         break;
10847
10848       default:
10849         EditGameEvent();
10850         break;
10851     }
10852
10853     gameMode = IcsIdle;
10854     ModeHighlight();
10855     return;
10856 }
10857
10858
10859 void
10860 EditGameEvent()
10861 {
10862     int i;
10863
10864     switch (gameMode) {
10865       case Training:
10866         SetTrainingModeOff();
10867         break;
10868       case MachinePlaysWhite:
10869       case MachinePlaysBlack:
10870       case BeginningOfGame:
10871         SendToProgram("force\n", &first);
10872         SetUserThinkingEnables();
10873         break;
10874       case PlayFromGameFile:
10875         (void) StopLoadGameTimer();
10876         if (gameFileFP != NULL) {
10877             gameFileFP = NULL;
10878         }
10879         break;
10880       case EditPosition:
10881         EditPositionDone();
10882         break;
10883       case AnalyzeMode:
10884       case AnalyzeFile:
10885         ExitAnalyzeMode();
10886         SendToProgram("force\n", &first);
10887         break;
10888       case TwoMachinesPlay:
10889         GameEnds((ChessMove) 0, NULL, GE_PLAYER);
10890         ResurrectChessProgram();
10891         SetUserThinkingEnables();
10892         break;
10893       case EndOfGame:
10894         ResurrectChessProgram();
10895         break;
10896       case IcsPlayingBlack:
10897       case IcsPlayingWhite:
10898         DisplayError(_("Warning: You are still playing a game"), 0);
10899         break;
10900       case IcsObserving:
10901         DisplayError(_("Warning: You are still observing a game"), 0);
10902         break;
10903       case IcsExamining:
10904         DisplayError(_("Warning: You are still examining a game"), 0);
10905         break;
10906       case IcsIdle:
10907         break;
10908       case EditGame:
10909       default:
10910         return;
10911     }
10912
10913     pausing = FALSE;
10914     StopClocks();
10915     first.offeredDraw = second.offeredDraw = 0;
10916
10917     if (gameMode == PlayFromGameFile) {
10918         whiteTimeRemaining = timeRemaining[0][currentMove];
10919         blackTimeRemaining = timeRemaining[1][currentMove];
10920         DisplayTitle("");
10921     }
10922
10923     if (gameMode == MachinePlaysWhite ||
10924         gameMode == MachinePlaysBlack ||
10925         gameMode == TwoMachinesPlay ||
10926         gameMode == EndOfGame) {
10927         i = forwardMostMove;
10928         while (i > currentMove) {
10929             SendToProgram("undo\n", &first);
10930             i--;
10931         }
10932         whiteTimeRemaining = timeRemaining[0][currentMove];
10933         blackTimeRemaining = timeRemaining[1][currentMove];
10934         DisplayBothClocks();
10935         if (whiteFlag || blackFlag) {
10936             whiteFlag = blackFlag = 0;
10937         }
10938         DisplayTitle("");
10939     }
10940
10941     gameMode = EditGame;
10942     ModeHighlight();
10943     SetGameInfo();
10944 }
10945
10946
10947 void
10948 EditPositionEvent()
10949 {
10950     if (gameMode == EditPosition) {
10951         EditGameEvent();
10952         return;
10953     }
10954
10955     EditGameEvent();
10956     if (gameMode != EditGame) return;
10957
10958     gameMode = EditPosition;
10959     ModeHighlight();
10960     SetGameInfo();
10961     if (currentMove > 0)
10962       CopyBoard(boards[0], boards[currentMove]);
10963
10964     blackPlaysFirst = !WhiteOnMove(currentMove);
10965     ResetClocks();
10966     currentMove = forwardMostMove = backwardMostMove = 0;
10967     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
10968     DisplayMove(-1);
10969 }
10970
10971 void
10972 ExitAnalyzeMode()
10973 {
10974     /* [DM] icsEngineAnalyze - possible call from other functions */
10975     if (appData.icsEngineAnalyze) {
10976         appData.icsEngineAnalyze = FALSE;
10977
10978         DisplayMessage("",_("Close ICS engine analyze..."));
10979     }
10980     if (first.analysisSupport && first.analyzing) {
10981       SendToProgram("exit\n", &first);
10982       first.analyzing = FALSE;
10983     }
10984     AnalysisPopDown();
10985     thinkOutput[0] = NULLCHAR;
10986 }
10987
10988 void
10989 EditPositionDone()
10990 {
10991     int king = gameInfo.variant == VariantKnightmate ? WhiteUnicorn : WhiteKing;
10992
10993     startedFromSetupPosition = TRUE;
10994     InitChessProgram(&first, FALSE);
10995     castlingRights[0][2] = castlingRights[0][5] = BOARD_WIDTH>>1;
10996     if(boards[0][0][BOARD_WIDTH>>1] == king) {
10997         castlingRights[0][1] = boards[0][0][BOARD_LEFT] == WhiteRook ? 0 : -1;
10998         castlingRights[0][0] = boards[0][0][BOARD_RGHT-1] == WhiteRook ? BOARD_RGHT-1 : -1;
10999     } else castlingRights[0][2] = -1;
11000     if(boards[0][BOARD_HEIGHT-1][BOARD_WIDTH>>1] == WHITE_TO_BLACK king) {
11001         castlingRights[0][4] = boards[0][BOARD_HEIGHT-1][BOARD_LEFT] == BlackRook ? 0 : -1;
11002         castlingRights[0][3] = boards[0][BOARD_HEIGHT-1][BOARD_RGHT-1] == BlackRook ? BOARD_RGHT-1 : -1;
11003     } else castlingRights[0][5] = -1;
11004     SendToProgram("force\n", &first);
11005     if (blackPlaysFirst) {
11006         strcpy(moveList[0], "");
11007         strcpy(parseList[0], "");
11008         currentMove = forwardMostMove = backwardMostMove = 1;
11009         CopyBoard(boards[1], boards[0]);
11010         /* [HGM] copy rights as well, as this code is also used after pasting a FEN */
11011         { int i;
11012           epStatus[1] = epStatus[0];
11013           for(i=0; i<nrCastlingRights; i++) castlingRights[1][i] = castlingRights[0][i];
11014         }
11015     } else {
11016         currentMove = forwardMostMove = backwardMostMove = 0;
11017     }
11018     SendBoard(&first, forwardMostMove);
11019     if (appData.debugMode) {
11020         fprintf(debugFP, "EditPosDone\n");
11021     }
11022     DisplayTitle("");
11023     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
11024     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
11025     gameMode = EditGame;
11026     ModeHighlight();
11027     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
11028     ClearHighlights(); /* [AS] */
11029 }
11030
11031 /* Pause for `ms' milliseconds */
11032 /* !! Ugh, this is a kludge. Fix it sometime. --tpm */
11033 void
11034 TimeDelay(ms)
11035      long ms;
11036 {
11037     TimeMark m1, m2;
11038
11039     GetTimeMark(&m1);
11040     do {
11041         GetTimeMark(&m2);
11042     } while (SubtractTimeMarks(&m2, &m1) < ms);
11043 }
11044
11045 /* !! Ugh, this is a kludge. Fix it sometime. --tpm */
11046 void
11047 SendMultiLineToICS(buf)
11048      char *buf;
11049 {
11050     char temp[MSG_SIZ+1], *p;
11051     int len;
11052
11053     len = strlen(buf);
11054     if (len > MSG_SIZ)
11055       len = MSG_SIZ;
11056
11057     strncpy(temp, buf, len);
11058     temp[len] = 0;
11059
11060     p = temp;
11061     while (*p) {
11062         if (*p == '\n' || *p == '\r')
11063           *p = ' ';
11064         ++p;
11065     }
11066
11067     strcat(temp, "\n");
11068     SendToICS(temp);
11069     SendToPlayer(temp, strlen(temp));
11070 }
11071
11072 void
11073 SetWhiteToPlayEvent()
11074 {
11075     if (gameMode == EditPosition) {
11076         blackPlaysFirst = FALSE;
11077         DisplayBothClocks();    /* works because currentMove is 0 */
11078     } else if (gameMode == IcsExamining) {
11079         SendToICS(ics_prefix);
11080         SendToICS("tomove white\n");
11081     }
11082 }
11083
11084 void
11085 SetBlackToPlayEvent()
11086 {
11087     if (gameMode == EditPosition) {
11088         blackPlaysFirst = TRUE;
11089         currentMove = 1;        /* kludge */
11090         DisplayBothClocks();
11091         currentMove = 0;
11092     } else if (gameMode == IcsExamining) {
11093         SendToICS(ics_prefix);
11094         SendToICS("tomove black\n");
11095     }
11096 }
11097
11098 void
11099 EditPositionMenuEvent(selection, x, y)
11100      ChessSquare selection;
11101      int x, y;
11102 {
11103     char buf[MSG_SIZ];
11104     ChessSquare piece = boards[0][y][x];
11105
11106     if (gameMode != EditPosition && gameMode != IcsExamining) return;
11107
11108     switch (selection) {
11109       case ClearBoard:
11110         if (gameMode == IcsExamining && ics_type == ICS_FICS) {
11111             SendToICS(ics_prefix);
11112             SendToICS("bsetup clear\n");
11113         } else if (gameMode == IcsExamining && ics_type == ICS_ICC) {
11114             SendToICS(ics_prefix);
11115             SendToICS("clearboard\n");
11116         } else {
11117             for (x = 0; x < BOARD_WIDTH; x++) { ChessSquare p = EmptySquare;
11118                 if(x == BOARD_LEFT-1 || x == BOARD_RGHT) p = (ChessSquare) 0; /* [HGM] holdings */
11119                 for (y = 0; y < BOARD_HEIGHT; y++) {
11120                     if (gameMode == IcsExamining) {
11121                         if (boards[currentMove][y][x] != EmptySquare) {
11122                             sprintf(buf, "%sx@%c%c\n", ics_prefix,
11123                                     AAA + x, ONE + y);
11124                             SendToICS(buf);
11125                         }
11126                     } else {
11127                         boards[0][y][x] = p;
11128                     }
11129                 }
11130             }
11131         }
11132         if (gameMode == EditPosition) {
11133             DrawPosition(FALSE, boards[0]);
11134         }
11135         break;
11136
11137       case WhitePlay:
11138         SetWhiteToPlayEvent();
11139         break;
11140
11141       case BlackPlay:
11142         SetBlackToPlayEvent();
11143         break;
11144
11145       case EmptySquare:
11146         if (gameMode == IcsExamining) {
11147             sprintf(buf, "%sx@%c%c\n", ics_prefix, AAA + x, ONE + y);
11148             SendToICS(buf);
11149         } else {
11150             boards[0][y][x] = EmptySquare;
11151             DrawPosition(FALSE, boards[0]);
11152         }
11153         break;
11154
11155       case PromotePiece:
11156         if(piece >= (int)WhitePawn && piece < (int)WhiteMan ||
11157            piece >= (int)BlackPawn && piece < (int)BlackMan   ) {
11158             selection = (ChessSquare) (PROMOTED piece);
11159         } else if(piece == EmptySquare) selection = WhiteSilver;
11160         else selection = (ChessSquare)((int)piece - 1);
11161         goto defaultlabel;
11162
11163       case DemotePiece:
11164         if(piece > (int)WhiteMan && piece <= (int)WhiteKing ||
11165            piece > (int)BlackMan && piece <= (int)BlackKing   ) {
11166             selection = (ChessSquare) (DEMOTED piece);
11167         } else if(piece == EmptySquare) selection = BlackSilver;
11168         else selection = (ChessSquare)((int)piece + 1);
11169         goto defaultlabel;
11170
11171       case WhiteQueen:
11172       case BlackQueen:
11173         if(gameInfo.variant == VariantShatranj ||
11174            gameInfo.variant == VariantXiangqi  ||
11175            gameInfo.variant == VariantCourier    )
11176             selection = (ChessSquare)((int)selection - (int)WhiteQueen + (int)WhiteFerz);
11177         goto defaultlabel;
11178
11179       case WhiteKing:
11180       case BlackKing:
11181         if(gameInfo.variant == VariantXiangqi)
11182             selection = (ChessSquare)((int)selection - (int)WhiteKing + (int)WhiteWazir);
11183         if(gameInfo.variant == VariantKnightmate)
11184             selection = (ChessSquare)((int)selection - (int)WhiteKing + (int)WhiteUnicorn);
11185       default:
11186         defaultlabel:
11187         if (gameMode == IcsExamining) {
11188             sprintf(buf, "%s%c@%c%c\n", ics_prefix,
11189                     PieceToChar(selection), AAA + x, ONE + y);
11190             SendToICS(buf);
11191         } else {
11192             boards[0][y][x] = selection;
11193             DrawPosition(FALSE, boards[0]);
11194         }
11195         break;
11196     }
11197 }
11198
11199
11200 void
11201 DropMenuEvent(selection, x, y)
11202      ChessSquare selection;
11203      int x, y;
11204 {
11205     ChessMove moveType;
11206
11207     switch (gameMode) {
11208       case IcsPlayingWhite:
11209       case MachinePlaysBlack:
11210         if (!WhiteOnMove(currentMove)) {
11211             DisplayMoveError(_("It is Black's turn"));
11212             return;
11213         }
11214         moveType = WhiteDrop;
11215         break;
11216       case IcsPlayingBlack:
11217       case MachinePlaysWhite:
11218         if (WhiteOnMove(currentMove)) {
11219             DisplayMoveError(_("It is White's turn"));
11220             return;
11221         }
11222         moveType = BlackDrop;
11223         break;
11224       case EditGame:
11225         moveType = WhiteOnMove(currentMove) ? WhiteDrop : BlackDrop;
11226         break;
11227       default:
11228         return;
11229     }
11230
11231     if (moveType == BlackDrop && selection < BlackPawn) {
11232       selection = (ChessSquare) ((int) selection
11233                                  + (int) BlackPawn - (int) WhitePawn);
11234     }
11235     if (boards[currentMove][y][x] != EmptySquare) {
11236         DisplayMoveError(_("That square is occupied"));
11237         return;
11238     }
11239
11240     FinishMove(moveType, (int) selection, DROP_RANK, x, y, NULLCHAR);
11241 }
11242
11243 void
11244 AcceptEvent()
11245 {
11246     /* Accept a pending offer of any kind from opponent */
11247
11248     if (appData.icsActive) {
11249         SendToICS(ics_prefix);
11250         SendToICS("accept\n");
11251     } else if (cmailMsgLoaded) {
11252         if (currentMove == cmailOldMove &&
11253             commentList[cmailOldMove] != NULL &&
11254             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
11255                    "Black offers a draw" : "White offers a draw")) {
11256             TruncateGame();
11257             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
11258             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_ACCEPT;
11259         } else {
11260             DisplayError(_("There is no pending offer on this move"), 0);
11261             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
11262         }
11263     } else {
11264         /* Not used for offers from chess program */
11265     }
11266 }
11267
11268 void
11269 DeclineEvent()
11270 {
11271     /* Decline a pending offer of any kind from opponent */
11272
11273     if (appData.icsActive) {
11274         SendToICS(ics_prefix);
11275         SendToICS("decline\n");
11276     } else if (cmailMsgLoaded) {
11277         if (currentMove == cmailOldMove &&
11278             commentList[cmailOldMove] != NULL &&
11279             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
11280                    "Black offers a draw" : "White offers a draw")) {
11281 #ifdef NOTDEF
11282             AppendComment(cmailOldMove, "Draw declined");
11283             DisplayComment(cmailOldMove - 1, "Draw declined");
11284 #endif /*NOTDEF*/
11285         } else {
11286             DisplayError(_("There is no pending offer on this move"), 0);
11287         }
11288     } else {
11289         /* Not used for offers from chess program */
11290     }
11291 }
11292
11293 void
11294 RematchEvent()
11295 {
11296     /* Issue ICS rematch command */
11297     if (appData.icsActive) {
11298         SendToICS(ics_prefix);
11299         SendToICS("rematch\n");
11300     }
11301 }
11302
11303 void
11304 CallFlagEvent()
11305 {
11306     /* Call your opponent's flag (claim a win on time) */
11307     if (appData.icsActive) {
11308         SendToICS(ics_prefix);
11309         SendToICS("flag\n");
11310     } else {
11311         switch (gameMode) {
11312           default:
11313             return;
11314           case MachinePlaysWhite:
11315             if (whiteFlag) {
11316                 if (blackFlag)
11317                   GameEnds(GameIsDrawn, "Both players ran out of time",
11318                            GE_PLAYER);
11319                 else
11320                   GameEnds(BlackWins, "Black wins on time", GE_PLAYER);
11321             } else {
11322                 DisplayError(_("Your opponent is not out of time"), 0);
11323             }
11324             break;
11325           case MachinePlaysBlack:
11326             if (blackFlag) {
11327                 if (whiteFlag)
11328                   GameEnds(GameIsDrawn, "Both players ran out of time",
11329                            GE_PLAYER);
11330                 else
11331                   GameEnds(WhiteWins, "White wins on time", GE_PLAYER);
11332             } else {
11333                 DisplayError(_("Your opponent is not out of time"), 0);
11334             }
11335             break;
11336         }
11337     }
11338 }
11339
11340 void
11341 DrawEvent()
11342 {
11343     /* Offer draw or accept pending draw offer from opponent */
11344
11345     if (appData.icsActive) {
11346         /* Note: tournament rules require draw offers to be
11347            made after you make your move but before you punch
11348            your clock.  Currently ICS doesn't let you do that;
11349            instead, you immediately punch your clock after making
11350            a move, but you can offer a draw at any time. */
11351
11352         SendToICS(ics_prefix);
11353         SendToICS("draw\n");
11354     } else if (cmailMsgLoaded) {
11355         if (currentMove == cmailOldMove &&
11356             commentList[cmailOldMove] != NULL &&
11357             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
11358                    "Black offers a draw" : "White offers a draw")) {
11359             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
11360             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_ACCEPT;
11361         } else if (currentMove == cmailOldMove + 1) {
11362             char *offer = WhiteOnMove(cmailOldMove) ?
11363               "White offers a draw" : "Black offers a draw";
11364             AppendComment(currentMove, offer);
11365             DisplayComment(currentMove - 1, offer);
11366             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_DRAW;
11367         } else {
11368             DisplayError(_("You must make your move before offering a draw"), 0);
11369             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
11370         }
11371     } else if (first.offeredDraw) {
11372         GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
11373     } else {
11374         if (first.sendDrawOffers) {
11375             SendToProgram("draw\n", &first);
11376             userOfferedDraw = TRUE;
11377         }
11378     }
11379 }
11380
11381 void
11382 AdjournEvent()
11383 {
11384     /* Offer Adjourn or accept pending Adjourn offer from opponent */
11385
11386     if (appData.icsActive) {
11387         SendToICS(ics_prefix);
11388         SendToICS("adjourn\n");
11389     } else {
11390         /* Currently GNU Chess doesn't offer or accept Adjourns */
11391     }
11392 }
11393
11394
11395 void
11396 AbortEvent()
11397 {
11398     /* Offer Abort or accept pending Abort offer from opponent */
11399
11400     if (appData.icsActive) {
11401         SendToICS(ics_prefix);
11402         SendToICS("abort\n");
11403     } else {
11404         GameEnds(GameUnfinished, "Game aborted", GE_PLAYER);
11405     }
11406 }
11407
11408 void
11409 ResignEvent()
11410 {
11411     /* Resign.  You can do this even if it's not your turn. */
11412
11413     if (appData.icsActive) {
11414         SendToICS(ics_prefix);
11415         SendToICS("resign\n");
11416     } else {
11417         switch (gameMode) {
11418           case MachinePlaysWhite:
11419             GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
11420             break;
11421           case MachinePlaysBlack:
11422             GameEnds(BlackWins, "White resigns", GE_PLAYER);
11423             break;
11424           case EditGame:
11425             if (cmailMsgLoaded) {
11426                 TruncateGame();
11427                 if (WhiteOnMove(cmailOldMove)) {
11428                     GameEnds(BlackWins, "White resigns", GE_PLAYER);
11429                 } else {
11430                     GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
11431                 }
11432                 cmailMoveType[lastLoadGameNumber - 1] = CMAIL_RESIGN;
11433             }
11434             break;
11435           default:
11436             break;
11437         }
11438     }
11439 }
11440
11441
11442 void
11443 StopObservingEvent()
11444 {
11445     /* Stop observing current games */
11446     SendToICS(ics_prefix);
11447     SendToICS("unobserve\n");
11448 }
11449
11450 void
11451 StopExaminingEvent()
11452 {
11453     /* Stop observing current game */
11454     SendToICS(ics_prefix);
11455     SendToICS("unexamine\n");
11456 }
11457
11458 void
11459 ForwardInner(target)
11460      int target;
11461 {
11462     int limit;
11463
11464     if (appData.debugMode)
11465         fprintf(debugFP, "ForwardInner(%d), current %d, forward %d\n",
11466                 target, currentMove, forwardMostMove);
11467
11468     if (gameMode == EditPosition)
11469       return;
11470
11471     if (gameMode == PlayFromGameFile && !pausing)
11472       PauseEvent();
11473
11474     if (gameMode == IcsExamining && pausing)
11475       limit = pauseExamForwardMostMove;
11476     else
11477       limit = forwardMostMove;
11478
11479     if (target > limit) target = limit;
11480
11481     if (target > 0 && moveList[target - 1][0]) {
11482         int fromX, fromY, toX, toY;
11483         toX = moveList[target - 1][2] - AAA;
11484         toY = moveList[target - 1][3] - ONE;
11485         if (moveList[target - 1][1] == '@') {
11486             if (appData.highlightLastMove) {
11487                 SetHighlights(-1, -1, toX, toY);
11488             }
11489         } else {
11490             fromX = moveList[target - 1][0] - AAA;
11491             fromY = moveList[target - 1][1] - ONE;
11492             if (target == currentMove + 1) {
11493                 AnimateMove(boards[currentMove], fromX, fromY, toX, toY);
11494             }
11495             if (appData.highlightLastMove) {
11496                 SetHighlights(fromX, fromY, toX, toY);
11497             }
11498         }
11499     }
11500     if (gameMode == EditGame || gameMode == AnalyzeMode ||
11501         gameMode == Training || gameMode == PlayFromGameFile ||
11502         gameMode == AnalyzeFile) {
11503         while (currentMove < target) {
11504             SendMoveToProgram(currentMove++, &first);
11505         }
11506     } else {
11507         currentMove = target;
11508     }
11509
11510     if (gameMode == EditGame || gameMode == EndOfGame) {
11511         whiteTimeRemaining = timeRemaining[0][currentMove];
11512         blackTimeRemaining = timeRemaining[1][currentMove];
11513     }
11514     DisplayBothClocks();
11515     DisplayMove(currentMove - 1);
11516     DrawPosition(FALSE, boards[currentMove]);
11517     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
11518     if ( !matchMode && gameMode != Training) { // [HGM] PV info: routine tests if empty
11519         DisplayComment(currentMove - 1, commentList[currentMove]);
11520     }
11521 }
11522
11523
11524 void
11525 ForwardEvent()
11526 {
11527     if (gameMode == IcsExamining && !pausing) {
11528         SendToICS(ics_prefix);
11529         SendToICS("forward\n");
11530     } else {
11531         ForwardInner(currentMove + 1);
11532     }
11533 }
11534
11535 void
11536 ToEndEvent()
11537 {
11538     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
11539         /* to optimze, we temporarily turn off analysis mode while we feed
11540          * the remaining moves to the engine. Otherwise we get analysis output
11541          * after each move.
11542          */
11543         if (first.analysisSupport) {
11544           SendToProgram("exit\nforce\n", &first);
11545           first.analyzing = FALSE;
11546         }
11547     }
11548
11549     if (gameMode == IcsExamining && !pausing) {
11550         SendToICS(ics_prefix);
11551         SendToICS("forward 999999\n");
11552     } else {
11553         ForwardInner(forwardMostMove);
11554     }
11555
11556     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
11557         /* we have fed all the moves, so reactivate analysis mode */
11558         SendToProgram("analyze\n", &first);
11559         first.analyzing = TRUE;
11560         /*first.maybeThinking = TRUE;*/
11561         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
11562     }
11563 }
11564
11565 void
11566 BackwardInner(target)
11567      int target;
11568 {
11569     int full_redraw = TRUE; /* [AS] Was FALSE, had to change it! */
11570
11571     if (appData.debugMode)
11572         fprintf(debugFP, "BackwardInner(%d), current %d, forward %d\n",
11573                 target, currentMove, forwardMostMove);
11574
11575     if (gameMode == EditPosition) return;
11576     if (currentMove <= backwardMostMove) {
11577         ClearHighlights();
11578         DrawPosition(full_redraw, boards[currentMove]);
11579         return;
11580     }
11581     if (gameMode == PlayFromGameFile && !pausing)
11582       PauseEvent();
11583
11584     if (moveList[target][0]) {
11585         int fromX, fromY, toX, toY;
11586         toX = moveList[target][2] - AAA;
11587         toY = moveList[target][3] - ONE;
11588         if (moveList[target][1] == '@') {
11589             if (appData.highlightLastMove) {
11590                 SetHighlights(-1, -1, toX, toY);
11591             }
11592         } else {
11593             fromX = moveList[target][0] - AAA;
11594             fromY = moveList[target][1] - ONE;
11595             if (target == currentMove - 1) {
11596                 AnimateMove(boards[currentMove], toX, toY, fromX, fromY);
11597             }
11598             if (appData.highlightLastMove) {
11599                 SetHighlights(fromX, fromY, toX, toY);
11600             }
11601         }
11602     }
11603     if (gameMode == EditGame || gameMode==AnalyzeMode ||
11604         gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
11605         while (currentMove > target) {
11606             SendToProgram("undo\n", &first);
11607             currentMove--;
11608         }
11609     } else {
11610         currentMove = target;
11611     }
11612
11613     if (gameMode == EditGame || gameMode == EndOfGame) {
11614         whiteTimeRemaining = timeRemaining[0][currentMove];
11615         blackTimeRemaining = timeRemaining[1][currentMove];
11616     }
11617     DisplayBothClocks();
11618     DisplayMove(currentMove - 1);
11619     DrawPosition(full_redraw, boards[currentMove]);
11620     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
11621     // [HGM] PV info: routine tests if comment empty
11622     DisplayComment(currentMove - 1, commentList[currentMove]);
11623 }
11624
11625 void
11626 BackwardEvent()
11627 {
11628     if (gameMode == IcsExamining && !pausing) {
11629         SendToICS(ics_prefix);
11630         SendToICS("backward\n");
11631     } else {
11632         BackwardInner(currentMove - 1);
11633     }
11634 }
11635
11636 void
11637 ToStartEvent()
11638 {
11639     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
11640         /* to optimze, we temporarily turn off analysis mode while we undo
11641          * all the moves. Otherwise we get analysis output after each undo.
11642          */
11643         if (first.analysisSupport) {
11644           SendToProgram("exit\nforce\n", &first);
11645           first.analyzing = FALSE;
11646         }
11647     }
11648
11649     if (gameMode == IcsExamining && !pausing) {
11650         SendToICS(ics_prefix);
11651         SendToICS("backward 999999\n");
11652     } else {
11653         BackwardInner(backwardMostMove);
11654     }
11655
11656     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
11657         /* we have fed all the moves, so reactivate analysis mode */
11658         SendToProgram("analyze\n", &first);
11659         first.analyzing = TRUE;
11660         /*first.maybeThinking = TRUE;*/
11661         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
11662     }
11663 }
11664
11665 void
11666 ToNrEvent(int to)
11667 {
11668   if (gameMode == PlayFromGameFile && !pausing) PauseEvent();
11669   if (to >= forwardMostMove) to = forwardMostMove;
11670   if (to <= backwardMostMove) to = backwardMostMove;
11671   if (to < currentMove) {
11672     BackwardInner(to);
11673   } else {
11674     ForwardInner(to);
11675   }
11676 }
11677
11678 void
11679 RevertEvent()
11680 {
11681     if (gameMode != IcsExamining) {
11682         DisplayError(_("You are not examining a game"), 0);
11683         return;
11684     }
11685     if (pausing) {
11686         DisplayError(_("You can't revert while pausing"), 0);
11687         return;
11688     }
11689     SendToICS(ics_prefix);
11690     SendToICS("revert\n");
11691 }
11692
11693 void
11694 RetractMoveEvent()
11695 {
11696     switch (gameMode) {
11697       case MachinePlaysWhite:
11698       case MachinePlaysBlack:
11699         if (WhiteOnMove(forwardMostMove) == (gameMode == MachinePlaysWhite)) {
11700             DisplayError(_("Wait until your turn,\nor select Move Now"), 0);
11701             return;
11702         }
11703         if (forwardMostMove < 2) return;
11704         currentMove = forwardMostMove = forwardMostMove - 2;
11705         whiteTimeRemaining = timeRemaining[0][currentMove];
11706         blackTimeRemaining = timeRemaining[1][currentMove];
11707         DisplayBothClocks();
11708         DisplayMove(currentMove - 1);
11709         ClearHighlights();/*!! could figure this out*/
11710         DrawPosition(TRUE, boards[currentMove]); /* [AS] Changed to full redraw! */
11711         SendToProgram("remove\n", &first);
11712         /*first.maybeThinking = TRUE;*/ /* GNU Chess does not ponder here */
11713         break;
11714
11715       case BeginningOfGame:
11716       default:
11717         break;
11718
11719       case IcsPlayingWhite:
11720       case IcsPlayingBlack:
11721         if (WhiteOnMove(forwardMostMove) == (gameMode == IcsPlayingWhite)) {
11722             SendToICS(ics_prefix);
11723             SendToICS("takeback 2\n");
11724         } else {
11725             SendToICS(ics_prefix);
11726             SendToICS("takeback 1\n");
11727         }
11728         break;
11729     }
11730 }
11731
11732 void
11733 MoveNowEvent()
11734 {
11735     ChessProgramState *cps;
11736
11737     switch (gameMode) {
11738       case MachinePlaysWhite:
11739         if (!WhiteOnMove(forwardMostMove)) {
11740             DisplayError(_("It is your turn"), 0);
11741             return;
11742         }
11743         cps = &first;
11744         break;
11745       case MachinePlaysBlack:
11746         if (WhiteOnMove(forwardMostMove)) {
11747             DisplayError(_("It is your turn"), 0);
11748             return;
11749         }
11750         cps = &first;
11751         break;
11752       case TwoMachinesPlay:
11753         if (WhiteOnMove(forwardMostMove) ==
11754             (first.twoMachinesColor[0] == 'w')) {
11755             cps = &first;
11756         } else {
11757             cps = &second;
11758         }
11759         break;
11760       case BeginningOfGame:
11761       default:
11762         return;
11763     }
11764     SendToProgram("?\n", cps);
11765 }
11766
11767 void
11768 TruncateGameEvent()
11769 {
11770     EditGameEvent();
11771     if (gameMode != EditGame) return;
11772     TruncateGame();
11773 }
11774
11775 void
11776 TruncateGame()
11777 {
11778     if (forwardMostMove > currentMove) {
11779         if (gameInfo.resultDetails != NULL) {
11780             free(gameInfo.resultDetails);
11781             gameInfo.resultDetails = NULL;
11782             gameInfo.result = GameUnfinished;
11783         }
11784         forwardMostMove = currentMove;
11785         HistorySet(parseList, backwardMostMove, forwardMostMove,
11786                    currentMove-1);
11787     }
11788 }
11789
11790 void
11791 HintEvent()
11792 {
11793     if (appData.noChessProgram) return;
11794     switch (gameMode) {
11795       case MachinePlaysWhite:
11796         if (WhiteOnMove(forwardMostMove)) {
11797             DisplayError(_("Wait until your turn"), 0);
11798             return;
11799         }
11800         break;
11801       case BeginningOfGame:
11802       case MachinePlaysBlack:
11803         if (!WhiteOnMove(forwardMostMove)) {
11804             DisplayError(_("Wait until your turn"), 0);
11805             return;
11806         }
11807         break;
11808       default:
11809         DisplayError(_("No hint available"), 0);
11810         return;
11811     }
11812     SendToProgram("hint\n", &first);
11813     hintRequested = TRUE;
11814 }
11815
11816 void
11817 BookEvent()
11818 {
11819     if (appData.noChessProgram) return;
11820     switch (gameMode) {
11821       case MachinePlaysWhite:
11822         if (WhiteOnMove(forwardMostMove)) {
11823             DisplayError(_("Wait until your turn"), 0);
11824             return;
11825         }
11826         break;
11827       case BeginningOfGame:
11828       case MachinePlaysBlack:
11829         if (!WhiteOnMove(forwardMostMove)) {
11830             DisplayError(_("Wait until your turn"), 0);
11831             return;
11832         }
11833         break;
11834       case EditPosition:
11835         EditPositionDone();
11836         break;
11837       case TwoMachinesPlay:
11838         return;
11839       default:
11840         break;
11841     }
11842     SendToProgram("bk\n", &first);
11843     bookOutput[0] = NULLCHAR;
11844     bookRequested = TRUE;
11845 }
11846
11847 void
11848 AboutGameEvent()
11849 {
11850     char *tags = PGNTags(&gameInfo);
11851     TagsPopUp(tags, CmailMsg());
11852     free(tags);
11853 }
11854
11855 /* end button procedures */
11856
11857 void
11858 PrintPosition(fp, move)
11859      FILE *fp;
11860      int move;
11861 {
11862     int i, j;
11863
11864     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
11865         for (j = BOARD_LEFT; j < BOARD_RGHT; j++) {
11866             char c = PieceToChar(boards[move][i][j]);
11867             fputc(c == 'x' ? '.' : c, fp);
11868             fputc(j == BOARD_RGHT - 1 ? '\n' : ' ', fp);
11869         }
11870     }
11871     if ((gameMode == EditPosition) ? !blackPlaysFirst : (move % 2 == 0))
11872       fprintf(fp, "white to play\n");
11873     else
11874       fprintf(fp, "black to play\n");
11875 }
11876
11877 void
11878 PrintOpponents(fp)
11879      FILE *fp;
11880 {
11881     if (gameInfo.white != NULL) {
11882         fprintf(fp, "\t%s vs. %s\n", gameInfo.white, gameInfo.black);
11883     } else {
11884         fprintf(fp, "\n");
11885     }
11886 }
11887
11888 /* Find last component of program's own name, using some heuristics */
11889 void
11890 TidyProgramName(prog, host, buf)
11891      char *prog, *host, buf[MSG_SIZ];
11892 {
11893     char *p, *q;
11894     int local = (strcmp(host, "localhost") == 0);
11895     while (!local && (p = strchr(prog, ';')) != NULL) {
11896         p++;
11897         while (*p == ' ') p++;
11898         prog = p;
11899     }
11900     if (*prog == '"' || *prog == '\'') {
11901         q = strchr(prog + 1, *prog);
11902     } else {
11903         q = strchr(prog, ' ');
11904     }
11905     if (q == NULL) q = prog + strlen(prog);
11906     p = q;
11907     while (p >= prog && *p != '/' && *p != '\\') p--;
11908     p++;
11909     if(p == prog && *p == '"') p++;
11910     if (q - p >= 4 && StrCaseCmp(q - 4, ".exe") == 0) q -= 4;
11911     memcpy(buf, p, q - p);
11912     buf[q - p] = NULLCHAR;
11913     if (!local) {
11914         strcat(buf, "@");
11915         strcat(buf, host);
11916     }
11917 }
11918
11919 char *
11920 TimeControlTagValue()
11921 {
11922     char buf[MSG_SIZ];
11923     if (!appData.clockMode) {
11924         strcpy(buf, "-");
11925     } else if (movesPerSession > 0) {
11926         sprintf(buf, "%d/%ld", movesPerSession, timeControl/1000);
11927     } else if (timeIncrement == 0) {
11928         sprintf(buf, "%ld", timeControl/1000);
11929     } else {
11930         sprintf(buf, "%ld+%ld", timeControl/1000, timeIncrement/1000);
11931     }
11932     return StrSave(buf);
11933 }
11934
11935 void
11936 SetGameInfo()
11937 {
11938     /* This routine is used only for certain modes */
11939     VariantClass v = gameInfo.variant;
11940     ClearGameInfo(&gameInfo);
11941     gameInfo.variant = v;
11942
11943     switch (gameMode) {
11944       case MachinePlaysWhite:
11945         gameInfo.event = StrSave( appData.pgnEventHeader );
11946         gameInfo.site = StrSave(HostName());
11947         gameInfo.date = PGNDate();
11948         gameInfo.round = StrSave("-");
11949         gameInfo.white = StrSave(first.tidy);
11950         gameInfo.black = StrSave(UserName());
11951         gameInfo.timeControl = TimeControlTagValue();
11952         break;
11953
11954       case MachinePlaysBlack:
11955         gameInfo.event = StrSave( appData.pgnEventHeader );
11956         gameInfo.site = StrSave(HostName());
11957         gameInfo.date = PGNDate();
11958         gameInfo.round = StrSave("-");
11959         gameInfo.white = StrSave(UserName());
11960         gameInfo.black = StrSave(first.tidy);
11961         gameInfo.timeControl = TimeControlTagValue();
11962         break;
11963
11964       case TwoMachinesPlay:
11965         gameInfo.event = StrSave( appData.pgnEventHeader );
11966         gameInfo.site = StrSave(HostName());
11967         gameInfo.date = PGNDate();
11968         if (matchGame > 0) {
11969             char buf[MSG_SIZ];
11970             sprintf(buf, "%d", matchGame);
11971             gameInfo.round = StrSave(buf);
11972         } else {
11973             gameInfo.round = StrSave("-");
11974         }
11975         if (first.twoMachinesColor[0] == 'w') {
11976             gameInfo.white = StrSave(first.tidy);
11977             gameInfo.black = StrSave(second.tidy);
11978         } else {
11979             gameInfo.white = StrSave(second.tidy);
11980             gameInfo.black = StrSave(first.tidy);
11981         }
11982         gameInfo.timeControl = TimeControlTagValue();
11983         break;
11984
11985       case EditGame:
11986         gameInfo.event = StrSave("Edited game");
11987         gameInfo.site = StrSave(HostName());
11988         gameInfo.date = PGNDate();
11989         gameInfo.round = StrSave("-");
11990         gameInfo.white = StrSave("-");
11991         gameInfo.black = StrSave("-");
11992         break;
11993
11994       case EditPosition:
11995         gameInfo.event = StrSave("Edited position");
11996         gameInfo.site = StrSave(HostName());
11997         gameInfo.date = PGNDate();
11998         gameInfo.round = StrSave("-");
11999         gameInfo.white = StrSave("-");
12000         gameInfo.black = StrSave("-");
12001         break;
12002
12003       case IcsPlayingWhite:
12004       case IcsPlayingBlack:
12005       case IcsObserving:
12006       case IcsExamining:
12007         break;
12008
12009       case PlayFromGameFile:
12010         gameInfo.event = StrSave("Game from non-PGN file");
12011         gameInfo.site = StrSave(HostName());
12012         gameInfo.date = PGNDate();
12013         gameInfo.round = StrSave("-");
12014         gameInfo.white = StrSave("?");
12015         gameInfo.black = StrSave("?");
12016         break;
12017
12018       default:
12019         break;
12020     }
12021 }
12022
12023 void
12024 ReplaceComment(index, text)
12025      int index;
12026      char *text;
12027 {
12028     int len;
12029
12030     while (*text == '\n') text++;
12031     len = strlen(text);
12032     while (len > 0 && text[len - 1] == '\n') len--;
12033
12034     if (commentList[index] != NULL)
12035       free(commentList[index]);
12036
12037     if (len == 0) {
12038         commentList[index] = NULL;
12039         return;
12040     }
12041     commentList[index] = (char *) malloc(len + 2);
12042     strncpy(commentList[index], text, len);
12043     commentList[index][len] = '\n';
12044     commentList[index][len + 1] = NULLCHAR;
12045 }
12046
12047 void
12048 CrushCRs(text)
12049      char *text;
12050 {
12051   char *p = text;
12052   char *q = text;
12053   char ch;
12054
12055   do {
12056     ch = *p++;
12057     if (ch == '\r') continue;
12058     *q++ = ch;
12059   } while (ch != '\0');
12060 }
12061
12062 void
12063 AppendComment(index, text)
12064      int index;
12065      char *text;
12066 {
12067     int oldlen, len;
12068     char *old;
12069
12070     text = GetInfoFromComment( index, text ); /* [HGM] PV time: strip PV info from comment */
12071
12072     CrushCRs(text);
12073     while (*text == '\n') text++;
12074     len = strlen(text);
12075     while (len > 0 && text[len - 1] == '\n') len--;
12076
12077     if (len == 0) return;
12078
12079     if (commentList[index] != NULL) {
12080         old = commentList[index];
12081         oldlen = strlen(old);
12082         commentList[index] = (char *) malloc(oldlen + len + 2);
12083         strcpy(commentList[index], old);
12084         free(old);
12085         strncpy(&commentList[index][oldlen], text, len);
12086         commentList[index][oldlen + len] = '\n';
12087         commentList[index][oldlen + len + 1] = NULLCHAR;
12088     } else {
12089         commentList[index] = (char *) malloc(len + 2);
12090         strncpy(commentList[index], text, len);
12091         commentList[index][len] = '\n';
12092         commentList[index][len + 1] = NULLCHAR;
12093     }
12094 }
12095
12096 static char * FindStr( char * text, char * sub_text )
12097 {
12098     char * result = strstr( text, sub_text );
12099
12100     if( result != NULL ) {
12101         result += strlen( sub_text );
12102     }
12103
12104     return result;
12105 }
12106
12107 /* [AS] Try to extract PV info from PGN comment */
12108 /* [HGM] PV time: and then remove it, to prevent it appearing twice */
12109 char *GetInfoFromComment( int index, char * text )
12110 {
12111     char * sep = text;
12112
12113     if( text != NULL && index > 0 ) {
12114         int score = 0;
12115         int depth = 0;
12116         int time = -1, sec = 0, deci;
12117         char * s_eval = FindStr( text, "[%eval " );
12118         char * s_emt = FindStr( text, "[%emt " );
12119
12120         if( s_eval != NULL || s_emt != NULL ) {
12121             /* New style */
12122             char delim;
12123
12124             if( s_eval != NULL ) {
12125                 if( sscanf( s_eval, "%d,%d%c", &score, &depth, &delim ) != 3 ) {
12126                     return text;
12127                 }
12128
12129                 if( delim != ']' ) {
12130                     return text;
12131                 }
12132             }
12133
12134             if( s_emt != NULL ) {
12135             }
12136         }
12137         else {
12138             /* We expect something like: [+|-]nnn.nn/dd */
12139             int score_lo = 0;
12140
12141             sep = strchr( text, '/' );
12142             if( sep == NULL || sep < (text+4) ) {
12143                 return text;
12144             }
12145
12146             time = -1; sec = -1; deci = -1;
12147             if( sscanf( text, "%d.%d/%d %d:%d", &score, &score_lo, &depth, &time, &sec ) != 5 &&
12148                 sscanf( text, "%d.%d/%d %d.%d", &score, &score_lo, &depth, &time, &deci ) != 5 &&
12149                 sscanf( text, "%d.%d/%d %d", &score, &score_lo, &depth, &time ) != 4 &&
12150                 sscanf( text, "%d.%d/%d", &score, &score_lo, &depth ) != 3   ) {
12151                 return text;
12152             }
12153
12154             if( score_lo < 0 || score_lo >= 100 ) {
12155                 return text;
12156             }
12157
12158             if(sec >= 0) time = 600*time + 10*sec; else
12159             if(deci >= 0) time = 10*time + deci; else time *= 10; // deci-sec
12160
12161             score = score >= 0 ? score*100 + score_lo : score*100 - score_lo;
12162
12163             /* [HGM] PV time: now locate end of PV info */
12164             while( *++sep >= '0' && *sep <= '9'); // strip depth
12165             if(time >= 0)
12166             while( *++sep >= '0' && *sep <= '9'); // strip time
12167             if(sec >= 0)
12168             while( *++sep >= '0' && *sep <= '9'); // strip seconds
12169             if(deci >= 0)
12170             while( *++sep >= '0' && *sep <= '9'); // strip fractional seconds
12171             while(*sep == ' ') sep++;
12172         }
12173
12174         if( depth <= 0 ) {
12175             return text;
12176         }
12177
12178         if( time < 0 ) {
12179             time = -1;
12180         }
12181
12182         pvInfoList[index-1].depth = depth;
12183         pvInfoList[index-1].score = score;
12184         pvInfoList[index-1].time  = 10*time; // centi-sec
12185     }
12186     return sep;
12187 }
12188
12189 void
12190 SendToProgram(message, cps)
12191      char *message;
12192      ChessProgramState *cps;
12193 {
12194     int count, outCount, error;
12195     char buf[MSG_SIZ];
12196
12197     if (cps->pr == NULL) return;
12198     Attention(cps);
12199
12200     if (appData.debugMode) {
12201         TimeMark now;
12202         GetTimeMark(&now);
12203         fprintf(debugFP, "%ld >%-6s: %s",
12204                 SubtractTimeMarks(&now, &programStartTime),
12205                 cps->which, message);
12206     }
12207
12208     count = strlen(message);
12209     outCount = OutputToProcess(cps->pr, message, count, &error);
12210     if (outCount < count && !exiting
12211                          && !endingGame) { /* [HGM] crash: to not hang GameEnds() writing to deceased engines */
12212         sprintf(buf, _("Error writing to %s chess program"), cps->which);
12213         if(gameInfo.resultDetails==NULL) { /* [HGM] crash: if game in progress, give reason for abort */
12214             if(epStatus[forwardMostMove] <= EP_DRAWS) {
12215                 gameInfo.result = GameIsDrawn; /* [HGM] accept exit as draw claim */
12216                 sprintf(buf, "%s program exits in draw position (%s)", cps->which, cps->program);
12217             } else {
12218                 gameInfo.result = cps->twoMachinesColor[0]=='w' ? BlackWins : WhiteWins;
12219             }
12220             gameInfo.resultDetails = buf;
12221         }
12222         DisplayFatalError(buf, error, 1);
12223     }
12224 }
12225
12226 void
12227 ReceiveFromProgram(isr, closure, message, count, error)
12228      InputSourceRef isr;
12229      VOIDSTAR closure;
12230      char *message;
12231      int count;
12232      int error;
12233 {
12234     char *end_str;
12235     char buf[MSG_SIZ];
12236     ChessProgramState *cps = (ChessProgramState *)closure;
12237
12238     if (isr != cps->isr) return; /* Killed intentionally */
12239     if (count <= 0) {
12240         if (count == 0) {
12241             sprintf(buf,
12242                     _("Error: %s chess program (%s) exited unexpectedly"),
12243                     cps->which, cps->program);
12244         if(gameInfo.resultDetails==NULL) { /* [HGM] crash: if game in progress, give reason for abort */
12245                 if(epStatus[forwardMostMove] <= EP_DRAWS) {
12246                     gameInfo.result = GameIsDrawn; /* [HGM] accept exit as draw claim */
12247                     sprintf(buf, _("%s program exits in draw position (%s)"), cps->which, cps->program);
12248                 } else {
12249                     gameInfo.result = cps->twoMachinesColor[0]=='w' ? BlackWins : WhiteWins;
12250                 }
12251                 gameInfo.resultDetails = buf;
12252             }
12253             RemoveInputSource(cps->isr);
12254             DisplayFatalError(buf, 0, 1);
12255         } else {
12256             sprintf(buf,
12257                     _("Error reading from %s chess program (%s)"),
12258                     cps->which, cps->program);
12259             RemoveInputSource(cps->isr);
12260
12261             /* [AS] Program is misbehaving badly... kill it */
12262             if( count == -2 ) {
12263                 DestroyChildProcess( cps->pr, 9 );
12264                 cps->pr = NoProc;
12265             }
12266
12267             DisplayFatalError(buf, error, 1);
12268         }
12269         return;
12270     }
12271
12272     if ((end_str = strchr(message, '\r')) != NULL)
12273       *end_str = NULLCHAR;
12274     if ((end_str = strchr(message, '\n')) != NULL)
12275       *end_str = NULLCHAR;
12276
12277     if (appData.debugMode) {
12278         TimeMark now; int print = 1;
12279         char *quote = ""; char c; int i;
12280
12281         if(appData.engineComments != 1) { /* [HGM] debug: decide if protocol-violating output is written */
12282                 char start = message[0];
12283                 if(start >='A' && start <= 'Z') start += 'a' - 'A'; // be tolerant to capitalizing
12284                 if(sscanf(message, "%d%c%d%d%d", &i, &c, &i, &i, &i) != 5 &&
12285                    sscanf(message, "move %c", &c)!=1  && sscanf(message, "offer%c", &c)!=1 &&
12286                    sscanf(message, "resign%c", &c)!=1 && sscanf(message, "feature %c", &c)!=1 &&
12287                    sscanf(message, "error %c", &c)!=1 && sscanf(message, "illegal %c", &c)!=1 &&
12288                    sscanf(message, "tell%c", &c)!=1   && sscanf(message, "0-1 %c", &c)!=1 &&
12289                    sscanf(message, "1-0 %c", &c)!=1   && sscanf(message, "1/2-1/2 %c", &c)!=1 &&
12290                    sscanf(message, "pong %c", &c)!=1   && start != '#')
12291                         { quote = "# "; print = (appData.engineComments == 2); }
12292                 message[0] = start; // restore original message
12293         }
12294         if(print) {
12295                 GetTimeMark(&now);
12296                 fprintf(debugFP, "%ld <%-6s: %s%s\n",
12297                         SubtractTimeMarks(&now, &programStartTime), cps->which,
12298                         quote,
12299                         message);
12300         }
12301     }
12302
12303     /* [DM] if icsEngineAnalyze is active we block all whisper and kibitz output, because nobody want to see this */
12304     if (appData.icsEngineAnalyze) {
12305         if (strstr(message, "whisper") != NULL ||
12306              strstr(message, "kibitz") != NULL ||
12307             strstr(message, "tellics") != NULL) return;
12308     }
12309
12310     HandleMachineMove(message, cps);
12311 }
12312
12313
12314 void
12315 SendTimeControl(cps, mps, tc, inc, sd, st)
12316      ChessProgramState *cps;
12317      int mps, inc, sd, st;
12318      long tc;
12319 {
12320     char buf[MSG_SIZ];
12321     int seconds;
12322
12323     if( timeControl_2 > 0 ) {
12324         if( (gameMode == MachinePlaysBlack) || (gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b') ) {
12325             tc = timeControl_2;
12326         }
12327     }
12328     tc  /= cps->timeOdds; /* [HGM] time odds: apply before telling engine */
12329     inc /= cps->timeOdds;
12330     st  /= cps->timeOdds;
12331
12332     seconds = (tc / 1000) % 60; /* [HGM] displaced to after applying odds */
12333
12334     if (st > 0) {
12335       /* Set exact time per move, normally using st command */
12336       if (cps->stKludge) {
12337         /* GNU Chess 4 has no st command; uses level in a nonstandard way */
12338         seconds = st % 60;
12339         if (seconds == 0) {
12340           sprintf(buf, "level 1 %d\n", st/60);
12341         } else {
12342           sprintf(buf, "level 1 %d:%02d\n", st/60, seconds);
12343         }
12344       } else {
12345         sprintf(buf, "st %d\n", st);
12346       }
12347     } else {
12348       /* Set conventional or incremental time control, using level command */
12349       if (seconds == 0) {
12350         /* Note old gnuchess bug -- minutes:seconds used to not work.
12351            Fixed in later versions, but still avoid :seconds
12352            when seconds is 0. */
12353         sprintf(buf, "level %d %ld %d\n", mps, tc/60000, inc/1000);
12354       } else {
12355         sprintf(buf, "level %d %ld:%02d %d\n", mps, tc/60000,
12356                 seconds, inc/1000);
12357       }
12358     }
12359     SendToProgram(buf, cps);
12360
12361     /* Orthoganally (except for GNU Chess 4), limit time to st seconds */
12362     /* Orthogonally, limit search to given depth */
12363     if (sd > 0) {
12364       if (cps->sdKludge) {
12365         sprintf(buf, "depth\n%d\n", sd);
12366       } else {
12367         sprintf(buf, "sd %d\n", sd);
12368       }
12369       SendToProgram(buf, cps);
12370     }
12371
12372     if(cps->nps > 0) { /* [HGM] nps */
12373         if(cps->supportsNPS == FALSE) cps->nps = -1; // don't use if engine explicitly says not supported!
12374         else {
12375                 sprintf(buf, "nps %d\n", cps->nps);
12376               SendToProgram(buf, cps);
12377         }
12378     }
12379 }
12380
12381 ChessProgramState *WhitePlayer()
12382 /* [HGM] return pointer to 'first' or 'second', depending on who plays white */
12383 {
12384     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b' ||
12385        gameMode == BeginningOfGame || gameMode == MachinePlaysBlack)
12386         return &second;
12387     return &first;
12388 }
12389
12390 void
12391 SendTimeRemaining(cps, machineWhite)
12392      ChessProgramState *cps;
12393      int /*boolean*/ machineWhite;
12394 {
12395     char message[MSG_SIZ];
12396     long time, otime;
12397
12398     /* Note: this routine must be called when the clocks are stopped
12399        or when they have *just* been set or switched; otherwise
12400        it will be off by the time since the current tick started.
12401     */
12402     if (machineWhite) {
12403         time = whiteTimeRemaining / 10;
12404         otime = blackTimeRemaining / 10;
12405     } else {
12406         time = blackTimeRemaining / 10;
12407         otime = whiteTimeRemaining / 10;
12408     }
12409     /* [HGM] translate opponent's time by time-odds factor */
12410     otime = (otime * cps->other->timeOdds) / cps->timeOdds;
12411     if (appData.debugMode) {
12412         fprintf(debugFP, "time odds: %d %d \n", cps->timeOdds, cps->other->timeOdds);
12413     }
12414
12415     if (time <= 0) time = 1;
12416     if (otime <= 0) otime = 1;
12417
12418     sprintf(message, "time %ld\n", time);
12419     SendToProgram(message, cps);
12420
12421     sprintf(message, "otim %ld\n", otime);
12422     SendToProgram(message, cps);
12423 }
12424
12425 int
12426 BoolFeature(p, name, loc, cps)
12427      char **p;
12428      char *name;
12429      int *loc;
12430      ChessProgramState *cps;
12431 {
12432   char buf[MSG_SIZ];
12433   int len = strlen(name);
12434   int val;
12435   if (strncmp((*p), name, len) == 0 && (*p)[len] == '=') {
12436     (*p) += len + 1;
12437     sscanf(*p, "%d", &val);
12438     *loc = (val != 0);
12439     while (**p && **p != ' ') (*p)++;
12440     sprintf(buf, "accepted %s\n", name);
12441     SendToProgram(buf, cps);
12442     return TRUE;
12443   }
12444   return FALSE;
12445 }
12446
12447 int
12448 IntFeature(p, name, loc, cps)
12449      char **p;
12450      char *name;
12451      int *loc;
12452      ChessProgramState *cps;
12453 {
12454   char buf[MSG_SIZ];
12455   int len = strlen(name);
12456   if (strncmp((*p), name, len) == 0 && (*p)[len] == '=') {
12457     (*p) += len + 1;
12458     sscanf(*p, "%d", loc);
12459     while (**p && **p != ' ') (*p)++;
12460     sprintf(buf, "accepted %s\n", name);
12461     SendToProgram(buf, cps);
12462     return TRUE;
12463   }
12464   return FALSE;
12465 }
12466
12467 int
12468 StringFeature(p, name, loc, cps)
12469      char **p;
12470      char *name;
12471      char loc[];
12472      ChessProgramState *cps;
12473 {
12474   char buf[MSG_SIZ];
12475   int len = strlen(name);
12476   if (strncmp((*p), name, len) == 0
12477       && (*p)[len] == '=' && (*p)[len+1] == '\"') {
12478     (*p) += len + 2;
12479     sscanf(*p, "%[^\"]", loc);
12480     while (**p && **p != '\"') (*p)++;
12481     if (**p == '\"') (*p)++;
12482     sprintf(buf, "accepted %s\n", name);
12483     SendToProgram(buf, cps);
12484     return TRUE;
12485   }
12486   return FALSE;
12487 }
12488
12489 int
12490 ParseOption(Option *opt, ChessProgramState *cps)
12491 // [HGM] options: process the string that defines an engine option, and determine
12492 // name, type, default value, and allowed value range
12493 {
12494         char *p, *q, buf[MSG_SIZ];
12495         int n, min = (-1)<<31, max = 1<<31, def;
12496
12497         if(p = strstr(opt->name, " -spin ")) {
12498             if((n = sscanf(p, " -spin %d %d %d", &def, &min, &max)) < 3 ) return FALSE;
12499             if(max < min) max = min; // enforce consistency
12500             if(def < min) def = min;
12501             if(def > max) def = max;
12502             opt->value = def;
12503             opt->min = min;
12504             opt->max = max;
12505             opt->type = Spin;
12506         } else if((p = strstr(opt->name, " -slider "))) {
12507             // for now -slider is a synonym for -spin, to already provide compatibility with future polyglots
12508             if((n = sscanf(p, " -slider %d %d %d", &def, &min, &max)) < 3 ) return FALSE;
12509             if(max < min) max = min; // enforce consistency
12510             if(def < min) def = min;
12511             if(def > max) def = max;
12512             opt->value = def;
12513             opt->min = min;
12514             opt->max = max;
12515             opt->type = Spin; // Slider;
12516         } else if((p = strstr(opt->name, " -string "))) {
12517             opt->textValue = p+9;
12518             opt->type = TextBox;
12519         } else if((p = strstr(opt->name, " -file "))) {
12520             // for now -file is a synonym for -string, to already provide compatibility with future polyglots
12521             opt->textValue = p+7;
12522             opt->type = TextBox; // FileName;
12523         } else if((p = strstr(opt->name, " -path "))) {
12524             // for now -file is a synonym for -string, to already provide compatibility with future polyglots
12525             opt->textValue = p+7;
12526             opt->type = TextBox; // PathName;
12527         } else if(p = strstr(opt->name, " -check ")) {
12528             if(sscanf(p, " -check %d", &def) < 1) return FALSE;
12529             opt->value = (def != 0);
12530             opt->type = CheckBox;
12531         } else if(p = strstr(opt->name, " -combo ")) {
12532             opt->textValue = (char*) (&cps->comboList[cps->comboCnt]); // cheat with pointer type
12533             cps->comboList[cps->comboCnt++] = q = p+8; // holds possible choices
12534             if(*q == '*') cps->comboList[cps->comboCnt-1]++;
12535             opt->value = n = 0;
12536             while(q = StrStr(q, " /// ")) {
12537                 n++; *q = 0;    // count choices, and null-terminate each of them
12538                 q += 5;
12539                 if(*q == '*') { // remember default, which is marked with * prefix
12540                     q++;
12541                     opt->value = n;
12542                 }
12543                 cps->comboList[cps->comboCnt++] = q;
12544             }
12545             cps->comboList[cps->comboCnt++] = NULL;
12546             opt->max = n + 1;
12547             opt->type = ComboBox;
12548         } else if(p = strstr(opt->name, " -button")) {
12549             opt->type = Button;
12550         } else if(p = strstr(opt->name, " -save")) {
12551             opt->type = SaveButton;
12552         } else return FALSE;
12553         *p = 0; // terminate option name
12554         // now look if the command-line options define a setting for this engine option.
12555         if(cps->optionSettings && cps->optionSettings[0])
12556             p = strstr(cps->optionSettings, opt->name); else p = NULL;
12557         if(p && (p == cps->optionSettings || p[-1] == ',')) {
12558                 sprintf(buf, "option %s", p);
12559                 if(p = strstr(buf, ",")) *p = 0;
12560                 strcat(buf, "\n");
12561                 SendToProgram(buf, cps);
12562         }
12563         return TRUE;
12564 }
12565
12566 void
12567 FeatureDone(cps, val)
12568      ChessProgramState* cps;
12569      int val;
12570 {
12571   DelayedEventCallback cb = GetDelayedEvent();
12572   if ((cb == InitBackEnd3 && cps == &first) ||
12573       (cb == TwoMachinesEventIfReady && cps == &second)) {
12574     CancelDelayedEvent();
12575     ScheduleDelayedEvent(cb, val ? 1 : 3600000);
12576   }
12577   cps->initDone = val;
12578 }
12579
12580 /* Parse feature command from engine */
12581 void
12582 ParseFeatures(args, cps)
12583      char* args;
12584      ChessProgramState *cps;
12585 {
12586   char *p = args;
12587   char *q;
12588   int val;
12589   char buf[MSG_SIZ];
12590
12591   for (;;) {
12592     while (*p == ' ') p++;
12593     if (*p == NULLCHAR) return;
12594
12595     if (BoolFeature(&p, "setboard", &cps->useSetboard, cps)) continue;
12596     if (BoolFeature(&p, "time", &cps->sendTime, cps)) continue;
12597     if (BoolFeature(&p, "draw", &cps->sendDrawOffers, cps)) continue;
12598     if (BoolFeature(&p, "sigint", &cps->useSigint, cps)) continue;
12599     if (BoolFeature(&p, "sigterm", &cps->useSigterm, cps)) continue;
12600     if (BoolFeature(&p, "reuse", &val, cps)) {
12601       /* Engine can disable reuse, but can't enable it if user said no */
12602       if (!val) cps->reuse = FALSE;
12603       continue;
12604     }
12605     if (BoolFeature(&p, "analyze", &cps->analysisSupport, cps)) continue;
12606     if (StringFeature(&p, "myname", &cps->tidy, cps)) {
12607       if (gameMode == TwoMachinesPlay) {
12608         DisplayTwoMachinesTitle();
12609       } else {
12610         DisplayTitle("");
12611       }
12612       continue;
12613     }
12614     if (StringFeature(&p, "variants", &cps->variants, cps)) continue;
12615     if (BoolFeature(&p, "san", &cps->useSAN, cps)) continue;
12616     if (BoolFeature(&p, "ping", &cps->usePing, cps)) continue;
12617     if (BoolFeature(&p, "playother", &cps->usePlayother, cps)) continue;
12618     if (BoolFeature(&p, "colors", &cps->useColors, cps)) continue;
12619     if (BoolFeature(&p, "usermove", &cps->useUsermove, cps)) continue;
12620     if (BoolFeature(&p, "ics", &cps->sendICS, cps)) continue;
12621     if (BoolFeature(&p, "name", &cps->sendName, cps)) continue;
12622     if (BoolFeature(&p, "pause", &val, cps)) continue; /* unused at present */
12623     if (IntFeature(&p, "done", &val, cps)) {
12624       FeatureDone(cps, val);
12625       continue;
12626     }
12627     /* Added by Tord: */
12628     if (BoolFeature(&p, "fen960", &cps->useFEN960, cps)) continue;
12629     if (BoolFeature(&p, "oocastle", &cps->useOOCastle, cps)) continue;
12630     /* End of additions by Tord */
12631
12632     /* [HGM] added features: */
12633     if (BoolFeature(&p, "debug", &cps->debug, cps)) continue;
12634     if (BoolFeature(&p, "nps", &cps->supportsNPS, cps)) continue;
12635     if (IntFeature(&p, "level", &cps->maxNrOfSessions, cps)) continue;
12636     if (BoolFeature(&p, "memory", &cps->memSize, cps)) continue;
12637     if (BoolFeature(&p, "smp", &cps->maxCores, cps)) continue;
12638     if (StringFeature(&p, "egt", &cps->egtFormats, cps)) continue;
12639     if (StringFeature(&p, "option", &(cps->option[cps->nrOptions].name), cps)) {
12640         if(!ParseOption(&(cps->option[cps->nrOptions++]), cps)) { // [HGM] options: add option feature
12641             sprintf(buf, "rejected option %s\n", cps->option[--cps->nrOptions].name);
12642             SendToProgram(buf, cps);
12643             continue;
12644         }
12645         if(cps->nrOptions >= MAX_OPTIONS) {
12646             cps->nrOptions--;
12647             sprintf(buf, "%s engine has too many options\n", cps->which);
12648             DisplayError(buf, 0);
12649         }
12650         continue;
12651     }
12652     if (BoolFeature(&p, "smp", &cps->maxCores, cps)) continue;
12653     /* End of additions by HGM */
12654
12655     /* unknown feature: complain and skip */
12656     q = p;
12657     while (*q && *q != '=') q++;
12658     sprintf(buf, "rejected %.*s\n", q-p, p);
12659     SendToProgram(buf, cps);
12660     p = q;
12661     if (*p == '=') {
12662       p++;
12663       if (*p == '\"') {
12664         p++;
12665         while (*p && *p != '\"') p++;
12666         if (*p == '\"') p++;
12667       } else {
12668         while (*p && *p != ' ') p++;
12669       }
12670     }
12671   }
12672
12673 }
12674
12675 void
12676 PeriodicUpdatesEvent(newState)
12677      int newState;
12678 {
12679     if (newState == appData.periodicUpdates)
12680       return;
12681
12682     appData.periodicUpdates=newState;
12683
12684     /* Display type changes, so update it now */
12685     DisplayAnalysis();
12686
12687     /* Get the ball rolling again... */
12688     if (newState) {
12689         AnalysisPeriodicEvent(1);
12690         StartAnalysisClock();
12691     }
12692 }
12693
12694 void
12695 PonderNextMoveEvent(newState)
12696      int newState;
12697 {
12698     if (newState == appData.ponderNextMove) return;
12699     if (gameMode == EditPosition) EditPositionDone();
12700     if (newState) {
12701         SendToProgram("hard\n", &first);
12702         if (gameMode == TwoMachinesPlay) {
12703             SendToProgram("hard\n", &second);
12704         }
12705     } else {
12706         SendToProgram("easy\n", &first);
12707         thinkOutput[0] = NULLCHAR;
12708         if (gameMode == TwoMachinesPlay) {
12709             SendToProgram("easy\n", &second);
12710         }
12711     }
12712     appData.ponderNextMove = newState;
12713 }
12714
12715 void
12716 NewSettingEvent(option, command, value)
12717      char *command;
12718      int option, value;
12719 {
12720     char buf[MSG_SIZ];
12721
12722     if (gameMode == EditPosition) EditPositionDone();
12723     sprintf(buf, "%s%s %d\n", (option ? "option ": ""), command, value);
12724     SendToProgram(buf, &first);
12725     if (gameMode == TwoMachinesPlay) {
12726         SendToProgram(buf, &second);
12727     }
12728 }
12729
12730 void
12731 ShowThinkingEvent()
12732 // [HGM] thinking: this routine is now also called from "Options -> Engine..." popup
12733 {
12734     static int oldState = 2; // kludge alert! Neither true nor fals, so first time oldState is always updated
12735     int newState = appData.showThinking
12736         // [HGM] thinking: other features now need thinking output as well
12737         || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp();
12738
12739     if (oldState == newState) return;
12740     oldState = newState;
12741     if (gameMode == EditPosition) EditPositionDone();
12742     if (oldState) {
12743         SendToProgram("post\n", &first);
12744         if (gameMode == TwoMachinesPlay) {
12745             SendToProgram("post\n", &second);
12746         }
12747     } else {
12748         SendToProgram("nopost\n", &first);
12749         thinkOutput[0] = NULLCHAR;
12750         if (gameMode == TwoMachinesPlay) {
12751             SendToProgram("nopost\n", &second);
12752         }
12753     }
12754 //    appData.showThinking = newState; // [HGM] thinking: responsible option should already have be changed when calling this routine!
12755 }
12756
12757 void
12758 AskQuestionEvent(title, question, replyPrefix, which)
12759      char *title; char *question; char *replyPrefix; char *which;
12760 {
12761   ProcRef pr = (which[0] == '1') ? first.pr : second.pr;
12762   if (pr == NoProc) return;
12763   AskQuestion(title, question, replyPrefix, pr);
12764 }
12765
12766 void
12767 DisplayMove(moveNumber)
12768      int moveNumber;
12769 {
12770     char message[MSG_SIZ];
12771     char res[MSG_SIZ];
12772     char cpThinkOutput[MSG_SIZ];
12773
12774     if(appData.noGUI) return; // [HGM] fast: suppress display of moves
12775
12776     if (moveNumber == forwardMostMove - 1 ||
12777         gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
12778
12779         safeStrCpy(cpThinkOutput, thinkOutput, sizeof(cpThinkOutput));
12780
12781         if (strchr(cpThinkOutput, '\n')) {
12782             *strchr(cpThinkOutput, '\n') = NULLCHAR;
12783         }
12784     } else {
12785         *cpThinkOutput = NULLCHAR;
12786     }
12787
12788     /* [AS] Hide thinking from human user */
12789     if( appData.hideThinkingFromHuman && gameMode != TwoMachinesPlay ) {
12790         *cpThinkOutput = NULLCHAR;
12791         if( thinkOutput[0] != NULLCHAR ) {
12792             int i;
12793
12794             for( i=0; i<=hiddenThinkOutputState; i++ ) {
12795                 cpThinkOutput[i] = '.';
12796             }
12797             cpThinkOutput[i] = NULLCHAR;
12798             hiddenThinkOutputState = (hiddenThinkOutputState + 1) % 3;
12799         }
12800     }
12801
12802     if (moveNumber == forwardMostMove - 1 &&
12803         gameInfo.resultDetails != NULL) {
12804         if (gameInfo.resultDetails[0] == NULLCHAR) {
12805             sprintf(res, " %s", PGNResult(gameInfo.result));
12806         } else {
12807             sprintf(res, " {%s} %s",
12808                     gameInfo.resultDetails, PGNResult(gameInfo.result));
12809         }
12810     } else {
12811         res[0] = NULLCHAR;
12812     }
12813
12814     if (moveNumber < 0 || parseList[moveNumber][0] == NULLCHAR) {
12815         DisplayMessage(res, cpThinkOutput);
12816     } else {
12817         sprintf(message, "%d.%s%s%s", moveNumber / 2 + 1,
12818                 WhiteOnMove(moveNumber) ? " " : ".. ",
12819                 parseList[moveNumber], res);
12820         DisplayMessage(message, cpThinkOutput);
12821     }
12822 }
12823
12824 void
12825 DisplayAnalysisText(text)
12826      char *text;
12827 {
12828     char buf[MSG_SIZ];
12829
12830     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile
12831                || appData.icsEngineAnalyze) {
12832         sprintf(buf, "Analysis (%s)", first.tidy);
12833         AnalysisPopUp(buf, text);
12834     }
12835 }
12836
12837 static int
12838 only_one_move(str)
12839      char *str;
12840 {
12841     while (*str && isspace(*str)) ++str;
12842     while (*str && !isspace(*str)) ++str;
12843     if (!*str) return 1;
12844     while (*str && isspace(*str)) ++str;
12845     if (!*str) return 1;
12846     return 0;
12847 }
12848
12849 void
12850 DisplayAnalysis()
12851 {
12852     char buf[MSG_SIZ];
12853     char lst[MSG_SIZ / 2];
12854     double nps;
12855     static char *xtra[] = { "", " (--)", " (++)" };
12856     int h, m, s, cs;
12857
12858     if (programStats.time == 0) {
12859         programStats.time = 1;
12860     }
12861
12862     if (programStats.got_only_move) {
12863         safeStrCpy(buf, programStats.movelist, sizeof(buf));
12864     } else {
12865         safeStrCpy( lst, programStats.movelist, sizeof(lst));
12866
12867         nps = (u64ToDouble(programStats.nodes) /
12868              ((double)programStats.time /100.0));
12869
12870         cs = programStats.time % 100;
12871         s = programStats.time / 100;
12872         h = (s / (60*60));
12873         s = s - h*60*60;
12874         m = (s/60);
12875         s = s - m*60;
12876
12877         if (programStats.moves_left > 0 && appData.periodicUpdates) {
12878           if (programStats.move_name[0] != NULLCHAR) {
12879             sprintf(buf, "depth=%d %d/%d(%s) %+.2f %s%s\nNodes: " u64Display " NPS: %d\nTime: %02d:%02d:%02d.%02d",
12880                     programStats.depth,
12881                     programStats.nr_moves-programStats.moves_left,
12882                     programStats.nr_moves, programStats.move_name,
12883                     ((float)programStats.score)/100.0, lst,
12884                     only_one_move(lst)?
12885                     xtra[programStats.got_fail] : "",
12886                     (u64)programStats.nodes, (int)nps, h, m, s, cs);
12887           } else {
12888             sprintf(buf, "depth=%d %d/%d %+.2f %s%s\nNodes: " u64Display " NPS: %d\nTime: %02d:%02d:%02d.%02d",
12889                     programStats.depth,
12890                     programStats.nr_moves-programStats.moves_left,
12891                     programStats.nr_moves, ((float)programStats.score)/100.0,
12892                     lst,
12893                     only_one_move(lst)?
12894                     xtra[programStats.got_fail] : "",
12895                     (u64)programStats.nodes, (int)nps, h, m, s, cs);
12896           }
12897         } else {
12898             sprintf(buf, "depth=%d %+.2f %s%s\nNodes: " u64Display " NPS: %d\nTime: %02d:%02d:%02d.%02d",
12899                     programStats.depth,
12900                     ((float)programStats.score)/100.0,
12901                     lst,
12902                     only_one_move(lst)?
12903                     xtra[programStats.got_fail] : "",
12904                     (u64)programStats.nodes, (int)nps, h, m, s, cs);
12905         }
12906     }
12907     DisplayAnalysisText(buf);
12908 }
12909
12910 void
12911 DisplayComment(moveNumber, text)
12912      int moveNumber;
12913      char *text;
12914 {
12915     char title[MSG_SIZ];
12916     char buf[8000]; // comment can be long!
12917     int score, depth;
12918
12919     if( appData.autoDisplayComment ) {
12920         if (moveNumber < 0 || parseList[moveNumber][0] == NULLCHAR) {
12921             strcpy(title, "Comment");
12922         } else {
12923             sprintf(title, "Comment on %d.%s%s", moveNumber / 2 + 1,
12924                     WhiteOnMove(moveNumber) ? " " : ".. ",
12925                     parseList[moveNumber]);
12926         }
12927         // [HGM] PV info: display PV info together with (or as) comment
12928         if(moveNumber >= 0 && (depth = pvInfoList[moveNumber].depth) > 0) {
12929             if(text == NULL) text = "";
12930             score = pvInfoList[moveNumber].score;
12931             sprintf(buf, "%s%.2f/%d %d\n%s", score>0 ? "+" : "", score/100.,
12932                               depth, (pvInfoList[moveNumber].time+50)/100, text);
12933             text = buf;
12934         }
12935     } else title[0] = 0;
12936
12937     if (text != NULL)
12938         CommentPopUp(title, text);
12939 }
12940
12941 /* This routine sends a ^C interrupt to gnuchess, to awaken it if it
12942  * might be busy thinking or pondering.  It can be omitted if your
12943  * gnuchess is configured to stop thinking immediately on any user
12944  * input.  However, that gnuchess feature depends on the FIONREAD
12945  * ioctl, which does not work properly on some flavors of Unix.
12946  */
12947 void
12948 Attention(cps)
12949      ChessProgramState *cps;
12950 {
12951 #if ATTENTION
12952     if (!cps->useSigint) return;
12953     if (appData.noChessProgram || (cps->pr == NoProc)) return;
12954     switch (gameMode) {
12955       case MachinePlaysWhite:
12956       case MachinePlaysBlack:
12957       case TwoMachinesPlay:
12958       case IcsPlayingWhite:
12959       case IcsPlayingBlack:
12960       case AnalyzeMode:
12961       case AnalyzeFile:
12962         /* Skip if we know it isn't thinking */
12963         if (!cps->maybeThinking) return;
12964         if (appData.debugMode)
12965           fprintf(debugFP, "Interrupting %s\n", cps->which);
12966         InterruptChildProcess(cps->pr);
12967         cps->maybeThinking = FALSE;
12968         break;
12969       default:
12970         break;
12971     }
12972 #endif /*ATTENTION*/
12973 }
12974
12975 int
12976 CheckFlags()
12977 {
12978     if (whiteTimeRemaining <= 0) {
12979         if (!whiteFlag) {
12980             whiteFlag = TRUE;
12981             if (appData.icsActive) {
12982                 if (appData.autoCallFlag &&
12983                     gameMode == IcsPlayingBlack && !blackFlag) {
12984                   SendToICS(ics_prefix);
12985                   SendToICS("flag\n");
12986                 }
12987             } else {
12988                 if (blackFlag) {
12989                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Both flags fell"));
12990                 } else {
12991                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("White's flag fell"));
12992                     if (appData.autoCallFlag) {
12993                         GameEnds(BlackWins, "Black wins on time", GE_XBOARD);
12994                         return TRUE;
12995                     }
12996                 }
12997             }
12998         }
12999     }
13000     if (blackTimeRemaining <= 0) {
13001         if (!blackFlag) {
13002             blackFlag = TRUE;
13003             if (appData.icsActive) {
13004                 if (appData.autoCallFlag &&
13005                     gameMode == IcsPlayingWhite && !whiteFlag) {
13006                   SendToICS(ics_prefix);
13007                   SendToICS("flag\n");
13008                 }
13009             } else {
13010                 if (whiteFlag) {
13011                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Both flags fell"));
13012                 } else {
13013                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Black's flag fell"));
13014                     if (appData.autoCallFlag) {
13015                         GameEnds(WhiteWins, "White wins on time", GE_XBOARD);
13016                         return TRUE;
13017                     }
13018                 }
13019             }
13020         }
13021     }
13022     return FALSE;
13023 }
13024
13025 void
13026 CheckTimeControl()
13027 {
13028     if (!appData.clockMode || appData.icsActive ||
13029         gameMode == PlayFromGameFile || forwardMostMove == 0) return;
13030
13031     /*
13032      * add time to clocks when time control is achieved ([HGM] now also used for increment)
13033      */
13034     if ( !WhiteOnMove(forwardMostMove) )
13035         /* White made time control */
13036         whiteTimeRemaining += GetTimeQuota((forwardMostMove-1)/2)
13037         /* [HGM] time odds: correct new time quota for time odds! */
13038                                             / WhitePlayer()->timeOdds;
13039       else
13040         /* Black made time control */
13041         blackTimeRemaining += GetTimeQuota((forwardMostMove-1)/2)
13042                                             / WhitePlayer()->other->timeOdds;
13043 }
13044
13045 void
13046 DisplayBothClocks()
13047 {
13048     int wom = gameMode == EditPosition ?
13049       !blackPlaysFirst : WhiteOnMove(currentMove);
13050     DisplayWhiteClock(whiteTimeRemaining, wom);
13051     DisplayBlackClock(blackTimeRemaining, !wom);
13052 }
13053
13054
13055 /* Timekeeping seems to be a portability nightmare.  I think everyone
13056    has ftime(), but I'm really not sure, so I'm including some ifdefs
13057    to use other calls if you don't.  Clocks will be less accurate if
13058    you have neither ftime nor gettimeofday.
13059 */
13060
13061 /* VS 2008 requires the #include outside of the function */
13062 #if !HAVE_GETTIMEOFDAY && HAVE_FTIME
13063 #include <sys/timeb.h>
13064 #endif
13065
13066 /* Get the current time as a TimeMark */
13067 void
13068 GetTimeMark(tm)
13069      TimeMark *tm;
13070 {
13071 #if HAVE_GETTIMEOFDAY
13072
13073     struct timeval timeVal;
13074     struct timezone timeZone;
13075
13076     gettimeofday(&timeVal, &timeZone);
13077     tm->sec = (long) timeVal.tv_sec;
13078     tm->ms = (int) (timeVal.tv_usec / 1000L);
13079
13080 #else /*!HAVE_GETTIMEOFDAY*/
13081 #if HAVE_FTIME
13082
13083 // include <sys/timeb.h> / moved to just above start of function
13084     struct timeb timeB;
13085
13086     ftime(&timeB);
13087     tm->sec = (long) timeB.time;
13088     tm->ms = (int) timeB.millitm;
13089
13090 #else /*!HAVE_FTIME && !HAVE_GETTIMEOFDAY*/
13091     tm->sec = (long) time(NULL);
13092     tm->ms = 0;
13093 #endif
13094 #endif
13095 }
13096
13097 /* Return the difference in milliseconds between two
13098    time marks.  We assume the difference will fit in a long!
13099 */
13100 long
13101 SubtractTimeMarks(tm2, tm1)
13102      TimeMark *tm2, *tm1;
13103 {
13104     return 1000L*(tm2->sec - tm1->sec) +
13105            (long) (tm2->ms - tm1->ms);
13106 }
13107
13108
13109 /*
13110  * Code to manage the game clocks.
13111  *
13112  * In tournament play, black starts the clock and then white makes a move.
13113  * We give the human user a slight advantage if he is playing white---the
13114  * clocks don't run until he makes his first move, so it takes zero time.
13115  * Also, we don't account for network lag, so we could get out of sync
13116  * with GNU Chess's clock -- but then, referees are always right.
13117  */
13118
13119 static TimeMark tickStartTM;
13120 static long intendedTickLength;
13121
13122 long
13123 NextTickLength(timeRemaining)
13124      long timeRemaining;
13125 {
13126     long nominalTickLength, nextTickLength;
13127
13128     if (timeRemaining > 0L && timeRemaining <= 10000L)
13129       nominalTickLength = 100L;
13130     else
13131       nominalTickLength = 1000L;
13132     nextTickLength = timeRemaining % nominalTickLength;
13133     if (nextTickLength <= 0) nextTickLength += nominalTickLength;
13134
13135     return nextTickLength;
13136 }
13137
13138 /* Adjust clock one minute up or down */
13139 void
13140 AdjustClock(Boolean which, int dir)
13141 {
13142     if(which) blackTimeRemaining += 60000*dir;
13143     else      whiteTimeRemaining += 60000*dir;
13144     DisplayBothClocks();
13145 }
13146
13147 /* Stop clocks and reset to a fresh time control */
13148 void
13149 ResetClocks()
13150 {
13151     (void) StopClockTimer();
13152     if (appData.icsActive) {
13153         whiteTimeRemaining = blackTimeRemaining = 0;
13154     } else { /* [HGM] correct new time quote for time odds */
13155         whiteTimeRemaining = GetTimeQuota(-1) / WhitePlayer()->timeOdds;
13156         blackTimeRemaining = GetTimeQuota(-1) / WhitePlayer()->other->timeOdds;
13157     }
13158     if (whiteFlag || blackFlag) {
13159         DisplayTitle("");
13160         whiteFlag = blackFlag = FALSE;
13161     }
13162     DisplayBothClocks();
13163 }
13164
13165 #define FUDGE 25 /* 25ms = 1/40 sec; should be plenty even for 50 Hz clocks */
13166
13167 /* Decrement running clock by amount of time that has passed */
13168 void
13169 DecrementClocks()
13170 {
13171     long timeRemaining;
13172     long lastTickLength, fudge;
13173     TimeMark now;
13174
13175     if (!appData.clockMode) return;
13176     if (gameMode==AnalyzeMode || gameMode == AnalyzeFile) return;
13177
13178     GetTimeMark(&now);
13179
13180     lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
13181
13182     /* Fudge if we woke up a little too soon */
13183     fudge = intendedTickLength - lastTickLength;
13184     if (fudge < 0 || fudge > FUDGE) fudge = 0;
13185
13186     if (WhiteOnMove(forwardMostMove)) {
13187         if(whiteNPS >= 0) lastTickLength = 0;
13188         timeRemaining = whiteTimeRemaining -= lastTickLength;
13189         DisplayWhiteClock(whiteTimeRemaining - fudge,
13190                           WhiteOnMove(currentMove));
13191     } else {
13192         if(blackNPS >= 0) lastTickLength = 0;
13193         timeRemaining = blackTimeRemaining -= lastTickLength;
13194         DisplayBlackClock(blackTimeRemaining - fudge,
13195                           !WhiteOnMove(currentMove));
13196     }
13197
13198     if (CheckFlags()) return;
13199
13200     tickStartTM = now;
13201     intendedTickLength = NextTickLength(timeRemaining - fudge) + fudge;
13202     StartClockTimer(intendedTickLength);
13203
13204     /* if the time remaining has fallen below the alarm threshold, sound the
13205      * alarm. if the alarm has sounded and (due to a takeback or time control
13206      * with increment) the time remaining has increased to a level above the
13207      * threshold, reset the alarm so it can sound again.
13208      */
13209
13210     if (appData.icsActive && appData.icsAlarm) {
13211
13212         /* make sure we are dealing with the user's clock */
13213         if (!( ((gameMode == IcsPlayingWhite) && WhiteOnMove(currentMove)) ||
13214                ((gameMode == IcsPlayingBlack) && !WhiteOnMove(currentMove))
13215            )) return;
13216
13217         if (alarmSounded && (timeRemaining > appData.icsAlarmTime)) {
13218             alarmSounded = FALSE;
13219         } else if (!alarmSounded && (timeRemaining <= appData.icsAlarmTime)) {
13220             PlayAlarmSound();
13221             alarmSounded = TRUE;
13222         }
13223     }
13224 }
13225
13226
13227 /* A player has just moved, so stop the previously running
13228    clock and (if in clock mode) start the other one.
13229    We redisplay both clocks in case we're in ICS mode, because
13230    ICS gives us an update to both clocks after every move.
13231    Note that this routine is called *after* forwardMostMove
13232    is updated, so the last fractional tick must be subtracted
13233    from the color that is *not* on move now.
13234 */
13235 void
13236 SwitchClocks()
13237 {
13238     long lastTickLength;
13239     TimeMark now;
13240     int flagged = FALSE;
13241
13242     GetTimeMark(&now);
13243
13244     if (StopClockTimer() && appData.clockMode) {
13245         lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
13246         if (WhiteOnMove(forwardMostMove)) {
13247             if(blackNPS >= 0) lastTickLength = 0;
13248             blackTimeRemaining -= lastTickLength;
13249            /* [HGM] PGNtime: save time for PGN file if engine did not give it */
13250 //         if(pvInfoList[forwardMostMove-1].time == -1)
13251                  pvInfoList[forwardMostMove-1].time =               // use GUI time
13252                       (timeRemaining[1][forwardMostMove-1] - blackTimeRemaining)/10;
13253         } else {
13254            if(whiteNPS >= 0) lastTickLength = 0;
13255            whiteTimeRemaining -= lastTickLength;
13256            /* [HGM] PGNtime: save time for PGN file if engine did not give it */
13257 //         if(pvInfoList[forwardMostMove-1].time == -1)
13258                  pvInfoList[forwardMostMove-1].time =
13259                       (timeRemaining[0][forwardMostMove-1] - whiteTimeRemaining)/10;
13260         }
13261         flagged = CheckFlags();
13262     }
13263     CheckTimeControl();
13264
13265     if (flagged || !appData.clockMode) return;
13266
13267     switch (gameMode) {
13268       case MachinePlaysBlack:
13269       case MachinePlaysWhite:
13270       case BeginningOfGame:
13271         if (pausing) return;
13272         break;
13273
13274       case EditGame:
13275       case PlayFromGameFile:
13276       case IcsExamining:
13277         return;
13278
13279       default:
13280         break;
13281     }
13282
13283     tickStartTM = now;
13284     intendedTickLength = NextTickLength(WhiteOnMove(forwardMostMove) ?
13285       whiteTimeRemaining : blackTimeRemaining);
13286     StartClockTimer(intendedTickLength);
13287 }
13288
13289
13290 /* Stop both clocks */
13291 void
13292 StopClocks()
13293 {
13294     long lastTickLength;
13295     TimeMark now;
13296
13297     if (!StopClockTimer()) return;
13298     if (!appData.clockMode) return;
13299
13300     GetTimeMark(&now);
13301
13302     lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
13303     if (WhiteOnMove(forwardMostMove)) {
13304         if(whiteNPS >= 0) lastTickLength = 0;
13305         whiteTimeRemaining -= lastTickLength;
13306         DisplayWhiteClock(whiteTimeRemaining, WhiteOnMove(currentMove));
13307     } else {
13308         if(blackNPS >= 0) lastTickLength = 0;
13309         blackTimeRemaining -= lastTickLength;
13310         DisplayBlackClock(blackTimeRemaining, !WhiteOnMove(currentMove));
13311     }
13312     CheckFlags();
13313 }
13314
13315 /* Start clock of player on move.  Time may have been reset, so
13316    if clock is already running, stop and restart it. */
13317 void
13318 StartClocks()
13319 {
13320     (void) StopClockTimer(); /* in case it was running already */
13321     DisplayBothClocks();
13322     if (CheckFlags()) return;
13323
13324     if (!appData.clockMode) return;
13325     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) return;
13326
13327     GetTimeMark(&tickStartTM);
13328     intendedTickLength = NextTickLength(WhiteOnMove(forwardMostMove) ?
13329       whiteTimeRemaining : blackTimeRemaining);
13330
13331    /* [HGM] nps: figure out nps factors, by determining which engine plays white and/or black once and for all */
13332     whiteNPS = blackNPS = -1;
13333     if(gameMode == MachinePlaysWhite || gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'w'
13334        || appData.zippyPlay && gameMode == IcsPlayingBlack) // first (perhaps only) engine has white
13335         whiteNPS = first.nps;
13336     if(gameMode == MachinePlaysBlack || gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b'
13337        || appData.zippyPlay && gameMode == IcsPlayingWhite) // first (perhaps only) engine has black
13338         blackNPS = first.nps;
13339     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b') // second only used in Two-Machines mode
13340         whiteNPS = second.nps;
13341     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'w')
13342         blackNPS = second.nps;
13343     if(appData.debugMode) fprintf(debugFP, "nps: w=%d, b=%d\n", whiteNPS, blackNPS);
13344
13345     StartClockTimer(intendedTickLength);
13346 }
13347
13348 char *
13349 TimeString(ms)
13350      long ms;
13351 {
13352     long second, minute, hour, day;
13353     char *sign = "";
13354     static char buf[32];
13355
13356     if (ms > 0 && ms <= 9900) {
13357       /* convert milliseconds to tenths, rounding up */
13358       double tenths = floor( ((double)(ms + 99L)) / 100.00 );
13359
13360       sprintf(buf, " %03.1f ", tenths/10.0);
13361       return buf;
13362     }
13363
13364     /* convert milliseconds to seconds, rounding up */
13365     /* use floating point to avoid strangeness of integer division
13366        with negative dividends on many machines */
13367     second = (long) floor(((double) (ms + 999L)) / 1000.0);
13368
13369     if (second < 0) {
13370         sign = "-";
13371         second = -second;
13372     }
13373
13374     day = second / (60 * 60 * 24);
13375     second = second % (60 * 60 * 24);
13376     hour = second / (60 * 60);
13377     second = second % (60 * 60);
13378     minute = second / 60;
13379     second = second % 60;
13380
13381     if (day > 0)
13382       sprintf(buf, " %s%ld:%02ld:%02ld:%02ld ",
13383               sign, day, hour, minute, second);
13384     else if (hour > 0)
13385       sprintf(buf, " %s%ld:%02ld:%02ld ", sign, hour, minute, second);
13386     else
13387       sprintf(buf, " %s%2ld:%02ld ", sign, minute, second);
13388
13389     return buf;
13390 }
13391
13392
13393 /*
13394  * This is necessary because some C libraries aren't ANSI C compliant yet.
13395  */
13396 char *
13397 StrStr(string, match)
13398      char *string, *match;
13399 {
13400     int i, length;
13401
13402     length = strlen(match);
13403
13404     for (i = strlen(string) - length; i >= 0; i--, string++)
13405       if (!strncmp(match, string, length))
13406         return string;
13407
13408     return NULL;
13409 }
13410
13411 char *
13412 StrCaseStr(string, match)
13413      char *string, *match;
13414 {
13415     int i, j, length;
13416
13417     length = strlen(match);
13418
13419     for (i = strlen(string) - length; i >= 0; i--, string++) {
13420         for (j = 0; j < length; j++) {
13421             if (ToLower(match[j]) != ToLower(string[j]))
13422               break;
13423         }
13424         if (j == length) return string;
13425     }
13426
13427     return NULL;
13428 }
13429
13430 #ifndef _amigados
13431 int
13432 StrCaseCmp(s1, s2)
13433      char *s1, *s2;
13434 {
13435     char c1, c2;
13436
13437     for (;;) {
13438         c1 = ToLower(*s1++);
13439         c2 = ToLower(*s2++);
13440         if (c1 > c2) return 1;
13441         if (c1 < c2) return -1;
13442         if (c1 == NULLCHAR) return 0;
13443     }
13444 }
13445
13446
13447 int
13448 ToLower(c)
13449      int c;
13450 {
13451     return isupper(c) ? tolower(c) : c;
13452 }
13453
13454
13455 int
13456 ToUpper(c)
13457      int c;
13458 {
13459     return islower(c) ? toupper(c) : c;
13460 }
13461 #endif /* !_amigados    */
13462
13463 char *
13464 StrSave(s)
13465      char *s;
13466 {
13467     char *ret;
13468
13469     if ((ret = (char *) malloc(strlen(s) + 1))) {
13470         strcpy(ret, s);
13471     }
13472     return ret;
13473 }
13474
13475 char *
13476 StrSavePtr(s, savePtr)
13477      char *s, **savePtr;
13478 {
13479     if (*savePtr) {
13480         free(*savePtr);
13481     }
13482     if ((*savePtr = (char *) malloc(strlen(s) + 1))) {
13483         strcpy(*savePtr, s);
13484     }
13485     return(*savePtr);
13486 }
13487
13488 char *
13489 PGNDate()
13490 {
13491     time_t clock;
13492     struct tm *tm;
13493     char buf[MSG_SIZ];
13494
13495     clock = time((time_t *)NULL);
13496     tm = localtime(&clock);
13497     sprintf(buf, "%04d.%02d.%02d",
13498             tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday);
13499     return StrSave(buf);
13500 }
13501
13502
13503 char *
13504 PositionToFEN(move, overrideCastling)
13505      int move;
13506      char *overrideCastling;
13507 {
13508     int i, j, fromX, fromY, toX, toY;
13509     int whiteToPlay;
13510     char buf[128];
13511     char *p, *q;
13512     int emptycount;
13513     ChessSquare piece;
13514
13515     whiteToPlay = (gameMode == EditPosition) ?
13516       !blackPlaysFirst : (move % 2 == 0);
13517     p = buf;
13518
13519     /* Piece placement data */
13520     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
13521         emptycount = 0;
13522         for (j = BOARD_LEFT; j < BOARD_RGHT; j++) {
13523             if (boards[move][i][j] == EmptySquare) {
13524                 emptycount++;
13525             } else { ChessSquare piece = boards[move][i][j];
13526                 if (emptycount > 0) {
13527                     if(emptycount<10) /* [HGM] can be >= 10 */
13528                         *p++ = '0' + emptycount;
13529                     else { *p++ = '0' + emptycount/10; *p++ = '0' + emptycount%10; }
13530                     emptycount = 0;
13531                 }
13532                 if(PieceToChar(piece) == '+') {
13533                     /* [HGM] write promoted pieces as '+<unpromoted>' (Shogi) */
13534                     *p++ = '+';
13535                     piece = (ChessSquare)(DEMOTED piece);
13536                 }
13537                 *p++ = PieceToChar(piece);
13538                 if(p[-1] == '~') {
13539                     /* [HGM] flag promoted pieces as '<promoted>~' (Crazyhouse) */
13540                     p[-1] = PieceToChar((ChessSquare)(DEMOTED piece));
13541                     *p++ = '~';
13542                 }
13543             }
13544         }
13545         if (emptycount > 0) {
13546             if(emptycount<10) /* [HGM] can be >= 10 */
13547                 *p++ = '0' + emptycount;
13548             else { *p++ = '0' + emptycount/10; *p++ = '0' + emptycount%10; }
13549             emptycount = 0;
13550         }
13551         *p++ = '/';
13552     }
13553     *(p - 1) = ' ';
13554
13555     /* [HGM] print Crazyhouse or Shogi holdings */
13556     if( gameInfo.holdingsWidth ) {
13557         *(p-1) = '['; /* if we wanted to support BFEN, this could be '/' */
13558         q = p;
13559         for(i=0; i<gameInfo.holdingsSize; i++) { /* white holdings */
13560             piece = boards[move][i][BOARD_WIDTH-1];
13561             if( piece != EmptySquare )
13562               for(j=0; j<(int) boards[move][i][BOARD_WIDTH-2]; j++)
13563                   *p++ = PieceToChar(piece);
13564         }
13565         for(i=0; i<gameInfo.holdingsSize; i++) { /* black holdings */
13566             piece = boards[move][BOARD_HEIGHT-i-1][0];
13567             if( piece != EmptySquare )
13568               for(j=0; j<(int) boards[move][BOARD_HEIGHT-i-1][1]; j++)
13569                   *p++ = PieceToChar(piece);
13570         }
13571
13572         if( q == p ) *p++ = '-';
13573         *p++ = ']';
13574         *p++ = ' ';
13575     }
13576
13577     /* Active color */
13578     *p++ = whiteToPlay ? 'w' : 'b';
13579     *p++ = ' ';
13580
13581   if(q = overrideCastling) { // [HGM] FRC: override castling & e.p fields for non-compliant engines
13582     while(*p++ = *q++); if(q != overrideCastling+1) p[-1] = ' ';
13583   } else {
13584   if(nrCastlingRights) {
13585      q = p;
13586      if(gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom) {
13587        /* [HGM] write directly from rights */
13588            if(castlingRights[move][2] >= 0 &&
13589               castlingRights[move][0] >= 0   )
13590                 *p++ = castlingRights[move][0] + AAA + 'A' - 'a';
13591            if(castlingRights[move][2] >= 0 &&
13592               castlingRights[move][1] >= 0   )
13593                 *p++ = castlingRights[move][1] + AAA + 'A' - 'a';
13594            if(castlingRights[move][5] >= 0 &&
13595               castlingRights[move][3] >= 0   )
13596                 *p++ = castlingRights[move][3] + AAA;
13597            if(castlingRights[move][5] >= 0 &&
13598               castlingRights[move][4] >= 0   )
13599                 *p++ = castlingRights[move][4] + AAA;
13600      } else {
13601
13602         /* [HGM] write true castling rights */
13603         if( nrCastlingRights == 6 ) {
13604             if(castlingRights[move][0] == BOARD_RGHT-1 &&
13605                castlingRights[move][2] >= 0  ) *p++ = 'K';
13606             if(castlingRights[move][1] == BOARD_LEFT &&
13607                castlingRights[move][2] >= 0  ) *p++ = 'Q';
13608             if(castlingRights[move][3] == BOARD_RGHT-1 &&
13609                castlingRights[move][5] >= 0  ) *p++ = 'k';
13610             if(castlingRights[move][4] == BOARD_LEFT &&
13611                castlingRights[move][5] >= 0  ) *p++ = 'q';
13612         }
13613      }
13614      if (q == p) *p++ = '-'; /* No castling rights */
13615      *p++ = ' ';
13616   }
13617
13618   if(gameInfo.variant != VariantShogi    && gameInfo.variant != VariantXiangqi &&
13619      gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier ) {
13620     /* En passant target square */
13621     if (move > backwardMostMove) {
13622         fromX = moveList[move - 1][0] - AAA;
13623         fromY = moveList[move - 1][1] - ONE;
13624         toX = moveList[move - 1][2] - AAA;
13625         toY = moveList[move - 1][3] - ONE;
13626         if (fromY == (whiteToPlay ? BOARD_HEIGHT-2 : 1) &&
13627             toY == (whiteToPlay ? BOARD_HEIGHT-4 : 3) &&
13628             boards[move][toY][toX] == (whiteToPlay ? BlackPawn : WhitePawn) &&
13629             fromX == toX) {
13630             /* 2-square pawn move just happened */
13631             *p++ = toX + AAA;
13632             *p++ = whiteToPlay ? '6'+BOARD_HEIGHT-8 : '3';
13633         } else {
13634             *p++ = '-';
13635         }
13636     } else {
13637         *p++ = '-';
13638     }
13639     *p++ = ' ';
13640   }
13641   }
13642
13643     /* [HGM] find reversible plies */
13644     {   int i = 0, j=move;
13645
13646         if (appData.debugMode) { int k;
13647             fprintf(debugFP, "write FEN 50-move: %d %d %d\n", initialRulePlies, forwardMostMove, backwardMostMove);
13648             for(k=backwardMostMove; k<=forwardMostMove; k++)
13649                 fprintf(debugFP, "e%d. p=%d\n", k, epStatus[k]);
13650
13651         }
13652
13653         while(j > backwardMostMove && epStatus[j] <= EP_NONE) j--,i++;
13654         if( j == backwardMostMove ) i += initialRulePlies;
13655         sprintf(p, "%d ", i);
13656         p += i>=100 ? 4 : i >= 10 ? 3 : 2;
13657     }
13658     /* Fullmove number */
13659     sprintf(p, "%d", (move / 2) + 1);
13660
13661     return StrSave(buf);
13662 }
13663
13664 Boolean
13665 ParseFEN(board, blackPlaysFirst, fen)
13666     Board board;
13667      int *blackPlaysFirst;
13668      char *fen;
13669 {
13670     int i, j;
13671     char *p;
13672     int emptycount;
13673     ChessSquare piece;
13674
13675     p = fen;
13676
13677     /* [HGM] by default clear Crazyhouse holdings, if present */
13678     if(gameInfo.holdingsWidth) {
13679        for(i=0; i<BOARD_HEIGHT; i++) {
13680            board[i][0]             = EmptySquare; /* black holdings */
13681            board[i][BOARD_WIDTH-1] = EmptySquare; /* white holdings */
13682            board[i][1]             = (ChessSquare) 0; /* black counts */
13683            board[i][BOARD_WIDTH-2] = (ChessSquare) 0; /* white counts */
13684        }
13685     }
13686
13687     /* Piece placement data */
13688     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
13689         j = 0;
13690         for (;;) {
13691             if (*p == '/' || *p == ' ' || (*p == '[' && i == 0) ) {
13692                 if (*p == '/') p++;
13693                 emptycount = gameInfo.boardWidth - j;
13694                 while (emptycount--)
13695                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
13696                 break;
13697 #if(BOARD_SIZE >= 10)
13698             } else if(*p=='x' || *p=='X') { /* [HGM] X means 10 */
13699                 p++; emptycount=10;
13700                 if (j + emptycount > gameInfo.boardWidth) return FALSE;
13701                 while (emptycount--)
13702                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
13703 #endif
13704             } else if (isdigit(*p)) {
13705                 emptycount = *p++ - '0';
13706                 while(isdigit(*p)) emptycount = 10*emptycount + *p++ - '0'; /* [HGM] allow > 9 */
13707                 if (j + emptycount > gameInfo.boardWidth) return FALSE;
13708                 while (emptycount--)
13709                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
13710             } else if (*p == '+' || isalpha(*p)) {
13711                 if (j >= gameInfo.boardWidth) return FALSE;
13712                 if(*p=='+') {
13713                     piece = CharToPiece(*++p);
13714                     if(piece == EmptySquare) return FALSE; /* unknown piece */
13715                     piece = (ChessSquare) (PROMOTED piece ); p++;
13716                     if(PieceToChar(piece) != '+') return FALSE; /* unpromotable piece */
13717                 } else piece = CharToPiece(*p++);
13718
13719                 if(piece==EmptySquare) return FALSE; /* unknown piece */
13720                 if(*p == '~') { /* [HGM] make it a promoted piece for Crazyhouse */
13721                     piece = (ChessSquare) (PROMOTED piece);
13722                     if(PieceToChar(piece) != '~') return FALSE; /* cannot be a promoted piece */
13723                     p++;
13724                 }
13725                 board[i][(j++)+gameInfo.holdingsWidth] = piece;
13726             } else {
13727                 return FALSE;
13728             }
13729         }
13730     }
13731     while (*p == '/' || *p == ' ') p++;
13732
13733     /* [HGM] look for Crazyhouse holdings here */
13734     while(*p==' ') p++;
13735     if( gameInfo.holdingsWidth && p[-1] == '/' || *p == '[') {
13736         if(*p == '[') p++;
13737         if(*p == '-' ) *p++; /* empty holdings */ else {
13738             if( !gameInfo.holdingsWidth ) return FALSE; /* no room to put holdings! */
13739             /* if we would allow FEN reading to set board size, we would   */
13740             /* have to add holdings and shift the board read so far here   */
13741             while( (piece = CharToPiece(*p) ) != EmptySquare ) {
13742                 *p++;
13743                 if((int) piece >= (int) BlackPawn ) {
13744                     i = (int)piece - (int)BlackPawn;
13745                     i = PieceToNumber((ChessSquare)i);
13746                     if( i >= gameInfo.holdingsSize ) return FALSE;
13747                     board[BOARD_HEIGHT-1-i][0] = piece; /* black holdings */
13748                     board[BOARD_HEIGHT-1-i][1]++;       /* black counts   */
13749                 } else {
13750                     i = (int)piece - (int)WhitePawn;
13751                     i = PieceToNumber((ChessSquare)i);
13752                     if( i >= gameInfo.holdingsSize ) return FALSE;
13753                     board[i][BOARD_WIDTH-1] = piece;    /* white holdings */
13754                     board[i][BOARD_WIDTH-2]++;          /* black holdings */
13755                 }
13756             }
13757         }
13758         if(*p == ']') *p++;
13759     }
13760
13761     while(*p == ' ') p++;
13762
13763     /* Active color */
13764     switch (*p++) {
13765       case 'w':
13766         *blackPlaysFirst = FALSE;
13767         break;
13768       case 'b':
13769         *blackPlaysFirst = TRUE;
13770         break;
13771       default:
13772         return FALSE;
13773     }
13774
13775     /* [HGM] We NO LONGER ignore the rest of the FEN notation */
13776     /* return the extra info in global variiables             */
13777
13778     /* set defaults in case FEN is incomplete */
13779     FENepStatus = EP_UNKNOWN;
13780     for(i=0; i<nrCastlingRights; i++ ) {
13781         FENcastlingRights[i] =
13782             gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom ? -1 : initialRights[i];
13783     }   /* assume possible unless obviously impossible */
13784     if(initialRights[0]>=0 && board[castlingRank[0]][initialRights[0]] != WhiteRook) FENcastlingRights[0] = -1;
13785     if(initialRights[1]>=0 && board[castlingRank[1]][initialRights[1]] != WhiteRook) FENcastlingRights[1] = -1;
13786     if(initialRights[2]>=0 && board[castlingRank[2]][initialRights[2]] != WhiteKing) FENcastlingRights[2] = -1;
13787     if(initialRights[3]>=0 && board[castlingRank[3]][initialRights[3]] != BlackRook) FENcastlingRights[3] = -1;
13788     if(initialRights[4]>=0 && board[castlingRank[4]][initialRights[4]] != BlackRook) FENcastlingRights[4] = -1;
13789     if(initialRights[5]>=0 && board[castlingRank[5]][initialRights[5]] != BlackKing) FENcastlingRights[5] = -1;
13790     FENrulePlies = 0;
13791
13792     while(*p==' ') p++;
13793     if(nrCastlingRights) {
13794       if(*p=='K' || *p=='Q' || *p=='k' || *p=='q' || *p=='-') {
13795           /* castling indicator present, so default becomes no castlings */
13796           for(i=0; i<nrCastlingRights; i++ ) {
13797                  FENcastlingRights[i] = -1;
13798           }
13799       }
13800       while(*p=='K' || *p=='Q' || *p=='k' || *p=='q' || *p=='-' ||
13801              (gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom) &&
13802              ( *p >= 'a' && *p < 'a' + gameInfo.boardWidth) ||
13803              ( *p >= 'A' && *p < 'A' + gameInfo.boardWidth)   ) {
13804         char c = *p++; int whiteKingFile=-1, blackKingFile=-1;
13805
13806         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) {
13807             if(board[BOARD_HEIGHT-1][i] == BlackKing) blackKingFile = i;
13808             if(board[0             ][i] == WhiteKing) whiteKingFile = i;
13809         }
13810         switch(c) {
13811           case'K':
13812               for(i=BOARD_RGHT-1; board[0][i]!=WhiteRook && i>whiteKingFile; i--);
13813               FENcastlingRights[0] = i != whiteKingFile ? i : -1;
13814               FENcastlingRights[2] = whiteKingFile;
13815               break;
13816           case'Q':
13817               for(i=BOARD_LEFT; board[0][i]!=WhiteRook && i<whiteKingFile; i++);
13818               FENcastlingRights[1] = i != whiteKingFile ? i : -1;
13819               FENcastlingRights[2] = whiteKingFile;
13820               break;
13821           case'k':
13822               for(i=BOARD_RGHT-1; board[BOARD_HEIGHT-1][i]!=BlackRook && i>blackKingFile; i--);
13823               FENcastlingRights[3] = i != blackKingFile ? i : -1;
13824               FENcastlingRights[5] = blackKingFile;
13825               break;
13826           case'q':
13827               for(i=BOARD_LEFT; board[BOARD_HEIGHT-1][i]!=BlackRook && i<blackKingFile; i++);
13828               FENcastlingRights[4] = i != blackKingFile ? i : -1;
13829               FENcastlingRights[5] = blackKingFile;
13830           case '-':
13831               break;
13832           default: /* FRC castlings */
13833               if(c >= 'a') { /* black rights */
13834                   for(i=BOARD_LEFT; i<BOARD_RGHT; i++)
13835                     if(board[BOARD_HEIGHT-1][i] == BlackKing) break;
13836                   if(i == BOARD_RGHT) break;
13837                   FENcastlingRights[5] = i;
13838                   c -= AAA;
13839                   if(board[BOARD_HEIGHT-1][c] <  BlackPawn ||
13840                      board[BOARD_HEIGHT-1][c] >= BlackKing   ) break;
13841                   if(c > i)
13842                       FENcastlingRights[3] = c;
13843                   else
13844                       FENcastlingRights[4] = c;
13845               } else { /* white rights */
13846                   for(i=BOARD_LEFT; i<BOARD_RGHT; i++)
13847                     if(board[0][i] == WhiteKing) break;
13848                   if(i == BOARD_RGHT) break;
13849                   FENcastlingRights[2] = i;
13850                   c -= AAA - 'a' + 'A';
13851                   if(board[0][c] >= WhiteKing) break;
13852                   if(c > i)
13853                       FENcastlingRights[0] = c;
13854                   else
13855                       FENcastlingRights[1] = c;
13856               }
13857         }
13858       }
13859     if (appData.debugMode) {
13860         fprintf(debugFP, "FEN castling rights:");
13861         for(i=0; i<nrCastlingRights; i++)
13862         fprintf(debugFP, " %d", FENcastlingRights[i]);
13863         fprintf(debugFP, "\n");
13864     }
13865
13866       while(*p==' ') p++;
13867     }
13868
13869     /* read e.p. field in games that know e.p. capture */
13870     if(gameInfo.variant != VariantShogi    && gameInfo.variant != VariantXiangqi &&
13871        gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier ) {
13872       if(*p=='-') {
13873         p++; FENepStatus = EP_NONE;
13874       } else {
13875          char c = *p++ - AAA;
13876
13877          if(c < BOARD_LEFT || c >= BOARD_RGHT) return TRUE;
13878          if(*p >= '0' && *p <='9') *p++;
13879          FENepStatus = c;
13880       }
13881     }
13882
13883
13884     if(sscanf(p, "%d", &i) == 1) {
13885         FENrulePlies = i; /* 50-move ply counter */
13886         /* (The move number is still ignored)    */
13887     }
13888
13889     return TRUE;
13890 }
13891
13892 void
13893 EditPositionPasteFEN(char *fen)
13894 {
13895   if (fen != NULL) {
13896     Board initial_position;
13897
13898     if (!ParseFEN(initial_position, &blackPlaysFirst, fen)) {
13899       DisplayError(_("Bad FEN position in clipboard"), 0);
13900       return ;
13901     } else {
13902       int savedBlackPlaysFirst = blackPlaysFirst;
13903       EditPositionEvent();
13904       blackPlaysFirst = savedBlackPlaysFirst;
13905       CopyBoard(boards[0], initial_position);
13906           /* [HGM] copy FEN attributes as well */
13907           {   int i;
13908               initialRulePlies = FENrulePlies;
13909               epStatus[0] = FENepStatus;
13910               for( i=0; i<nrCastlingRights; i++ )
13911                   castlingRights[0][i] = FENcastlingRights[i];
13912           }
13913       EditPositionDone();
13914       DisplayBothClocks();
13915       DrawPosition(FALSE, boards[currentMove]);
13916     }
13917   }
13918 }