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, 2010, 2011, 2012, 2013, 2014, 2015 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     int flock(int f, int code);
  59 #   define LOCK_EX 2
  60 #   define SLASH '\\'
  61
  62 #   ifdef ARC_64BIT
  63 #       define EGBB_NAME "egbbdll64.dll"
  64 #   else
  65 #       define EGBB_NAME "egbbdll.dll"
  66 #   endif
  67
  68 #else
  69
  70 #   include <sys/file.h>
  71 #   define SLASH '/'
  72
  73 #   include <dlfcn.h>
  74 #   ifdef ARC_64BIT
  75 #       define EGBB_NAME "egbbso64.so"
  76 #   else
  77 #       define EGBB_NAME "egbbso.so"
  78 #   endif
  79     // kludge to allow Windows code in back-end by converting it to corresponding Linux code
  80 #   define CDECL
  81 #   define HMODULE void *
  82 #   define LoadLibrary(x) dlopen(x, RTLD_LAZY)
  83 #   define GetProcAddress dlsym
  84
  85 #endif
  86
  87 #include "config.h"
  88
  89 #include <assert.h>
  90 #include <stdio.h>
  91 #include <ctype.h>
  92 #include <errno.h>
  93 #include <sys/types.h>
  94 #include <sys/stat.h>
  95 #include <math.h>
  96 #include <ctype.h>
  97
  98 #if STDC_HEADERS
  99 # include <stdlib.h>
 100 # include <string.h>
 101 # include <stdarg.h>
 102 #else /* not STDC_HEADERS */
 103 # if HAVE_STRING_H
 104 #  include <string.h>
 105 # else /* not HAVE_STRING_H */
 106 #  include <strings.h>
 107 # endif /* not HAVE_STRING_H */
 108 #endif /* not STDC_HEADERS */
 109
 110 #if HAVE_SYS_FCNTL_H
 111 # include <sys/fcntl.h>
 112 #else /* not HAVE_SYS_FCNTL_H */
 113 # if HAVE_FCNTL_H
 114 #  include <fcntl.h>
 115 # endif /* HAVE_FCNTL_H */
 116 #endif /* not HAVE_SYS_FCNTL_H */
 117
 118 #if TIME_WITH_SYS_TIME
 119 # include <sys/time.h>
 120 # include <time.h>
 121 #else
 122 # if HAVE_SYS_TIME_H
 123 #  include <sys/time.h>
 124 # else
 125 #  include <time.h>
 126 # endif
 127 #endif
 128
 129 #if defined(_amigados) && !defined(__GNUC__)
 130 struct timezone {
 131     int tz_minuteswest;
 132     int tz_dsttime;
 133 };
 134 extern int gettimeofday(struct timeval *, struct timezone *);
 135 #endif
 136
 137 #if HAVE_UNISTD_H
 138 # include <unistd.h>
 139 #endif
 140
 141 #include "common.h"
 142 #include "frontend.h"
 143 #include "backend.h"
 144 #include "parser.h"
 145 #include "moves.h"
 146 #if ZIPPY
 147 # include "zippy.h"
 148 #endif
 149 #include "backendz.h"
 150 #include "evalgraph.h"
 151 #include "engineoutput.h"
 152 #include "gettext.h"
 153
 154 #ifdef ENABLE_NLS
 155 # define _(s) gettext (s)
 156 # define N_(s) gettext_noop (s)
 157 # define T_(s) gettext(s)
 158 #else
 159 # ifdef WIN32
 160 #   define _(s) T_(s)
 161 #   define N_(s) s
 162 # else
 163 #   define _(s) (s)
 164 #   define N_(s) s
 165 #   define T_(s) s
 166 # endif
 167 #endif
 168
 169
 170 int establish P((void));
 171 void read_from_player P((InputSourceRef isr, VOIDSTAR closure,
 172                          char *buf, int count, int error));
 173 void read_from_ics P((InputSourceRef isr, VOIDSTAR closure,
 174                       char *buf, int count, int error));
 175 void SendToICS P((char *s));
 176 void SendToICSDelayed P((char *s, long msdelay));
 177 void SendMoveToICS P((ChessMove moveType, int fromX, int fromY, int toX, int toY, char promoChar));
 178 void HandleMachineMove P((char *message, ChessProgramState *cps));
 179 int AutoPlayOneMove P((void));
 180 int LoadGameOneMove P((ChessMove readAhead));
 181 int LoadGameFromFile P((char *filename, int n, char *title, int useList));
 182 int LoadPositionFromFile P((char *filename, int n, char *title));
 183 int SavePositionToFile P((char *filename));
 184 void MakeMove P((int fromX, int fromY, int toX, int toY, int promoChar));
 185 void ShowMove P((int fromX, int fromY, int toX, int toY));
 186 int FinishMove P((ChessMove moveType, int fromX, int fromY, int toX, int toY,
 187                    /*char*/int promoChar));
 188 void BackwardInner P((int target));
 189 void ForwardInner P((int target));
 190 int Adjudicate P((ChessProgramState *cps));
 191 void GameEnds P((ChessMove result, char *resultDetails, int whosays));
 192 void EditPositionDone P((Boolean fakeRights));
 193 void PrintOpponents P((FILE *fp));
 194 void PrintPosition P((FILE *fp, int move));
 195 void StartChessProgram P((ChessProgramState *cps));
 196 void SendToProgram P((char *message, ChessProgramState *cps));
 197 void SendMoveToProgram P((int moveNum, ChessProgramState *cps));
 198 void ReceiveFromProgram P((InputSourceRef isr, VOIDSTAR closure,
 199                            char *buf, int count, int error));
 200 void SendTimeControl P((ChessProgramState *cps,
 201                         int mps, long tc, int inc, int sd, int st));
 202 char *TimeControlTagValue P((void));
 203 void Attention P((ChessProgramState *cps));
 204 void FeedMovesToProgram P((ChessProgramState *cps, int upto));
 205 int ResurrectChessProgram P((void));
 206 void DisplayComment P((int moveNumber, char *text));
 207 void DisplayMove P((int moveNumber));
 208
 209 void ParseGameHistory P((char *game));
 210 void ParseBoard12 P((char *string));
 211 void KeepAlive P((void));
 212 void StartClocks P((void));
 213 void SwitchClocks P((int nr));
 214 void StopClocks P((void));
 215 void ResetClocks P((void));
 216 char *PGNDate P((void));
 217 void SetGameInfo P((void));
 218 int RegisterMove P((void));
 219 void MakeRegisteredMove P((void));
 220 void TruncateGame P((void));
 221 int looking_at P((char *, int *, char *));
 222 void CopyPlayerNameIntoFileName P((char **, char *));
 223 char *SavePart P((char *));
 224 int SaveGameOldStyle P((FILE *));
 225 int SaveGamePGN P((FILE *));
 226 int CheckFlags P((void));
 227 long NextTickLength P((long));
 228 void CheckTimeControl P((void));
 229 void show_bytes P((FILE *, char *, int));
 230 int string_to_rating P((char *str));
 231 void ParseFeatures P((char* args, ChessProgramState *cps));
 232 void InitBackEnd3 P((void));
 233 void FeatureDone P((ChessProgramState* cps, int val));
 234 void InitChessProgram P((ChessProgramState *cps, int setup));
 235 void OutputKibitz(int window, char *text);
 236 int PerpetualChase(int first, int last);
 237 int EngineOutputIsUp();
 238 void InitDrawingSizes(int x, int y);
 239 void NextMatchGame P((void));
 240 int NextTourneyGame P((int nr, int *swap));
 241 int Pairing P((int nr, int nPlayers, int *w, int *b, int *sync));
 242 FILE *WriteTourneyFile P((char *results, FILE *f));
 243 void DisplayTwoMachinesTitle P(());
 244 static void ExcludeClick P((int index));
 245 void ToggleSecond P((void));
 246 void PauseEngine P((ChessProgramState *cps));
 247 static int NonStandardBoardSize P((VariantClass v, int w, int h, int s));
 248
 249 #ifdef WIN32
 250        extern void ConsoleCreate();
 251 #endif
 252
 253 ChessProgramState *WhitePlayer();
 254 int VerifyDisplayMode P(());
 255
 256 char *GetInfoFromComment( int, char * ); // [HGM] PV time: returns stripped comment
 257 void InitEngineUCI( const char * iniDir, ChessProgramState * cps ); // [HGM] moved here from winboard.c
 258 char *ProbeBook P((int moveNr, char *book)); // [HGM] book: returns a book move
 259 char *SendMoveToBookUser P((int nr, ChessProgramState *cps, int initial)); // [HGM] book
 260 void ics_update_width P((int new_width));
 261 extern char installDir[MSG_SIZ];
 262 VariantClass startVariant; /* [HGM] nicks: initial variant */
 263 Boolean abortMatch;
 264
 265 extern int tinyLayout, smallLayout;
 266 ChessProgramStats programStats;
 267 char lastPV[2][2*MSG_SIZ]; /* [HGM] pv: last PV in thinking output of each engine */
 268 int endPV = -1;
 269 static int exiting = 0; /* [HGM] moved to top */
 270 static int setboardSpoiledMachineBlack = 0 /*, errorExitFlag = 0*/;
 271 int startedFromPositionFile = FALSE; Board filePosition;       /* [HGM] loadPos */
 272 Board partnerBoard;     /* [HGM] bughouse: for peeking at partner game          */
 273 int partnerHighlight[2];
 274 Boolean partnerBoardValid = 0;
 275 char partnerStatus[MSG_SIZ];
 276 Boolean partnerUp;
 277 Boolean originalFlip;
 278 Boolean twoBoards = 0;
 279 char endingGame = 0;    /* [HGM] crash: flag to prevent recursion of GameEnds() */
 280 int whiteNPS, blackNPS; /* [HGM] nps: for easily making clocks aware of NPS     */
 281 VariantClass currentlyInitializedVariant; /* [HGM] variantswitch */
 282 int lastIndex = 0;      /* [HGM] autoinc: last game/position used in match mode */
 283 Boolean connectionAlive;/* [HGM] alive: ICS connection status from probing      */
 284 int opponentKibitzes;
 285 int lastSavedGame; /* [HGM] save: ID of game */
 286 char chatPartner[MAX_CHAT][MSG_SIZ]; /* [HGM] chat: list of chatting partners */
 287 extern int chatCount;
 288 int chattingPartner;
 289 char marker[BOARD_RANKS][BOARD_FILES]; /* [HGM] marks for target squares */
 290 char legal[BOARD_RANKS][BOARD_FILES];  /* [HGM] legal target squares */
 291 char lastMsg[MSG_SIZ];
 292 char lastTalker[MSG_SIZ];
 293 ChessSquare pieceSweep = EmptySquare;
 294 ChessSquare promoSweep = EmptySquare, defaultPromoChoice;
 295 int promoDefaultAltered;
 296 int keepInfo = 0; /* [HGM] to protect PGN tags in auto-step game analysis */
 297 static int initPing = -1;
 298 int border;       /* [HGM] width of board rim, needed to size seek graph  */
 299 char bestMove[MSG_SIZ];
 300 int solvingTime, totalTime;
 301
 302 /* States for ics_getting_history */
 303 #define H_FALSE 0
 304 #define H_REQUESTED 1
 305 #define H_GOT_REQ_HEADER 2
 306 #define H_GOT_UNREQ_HEADER 3
 307 #define H_GETTING_MOVES 4
 308 #define H_GOT_UNWANTED_HEADER 5
 309
 310 /* whosays values for GameEnds */
 311 #define GE_ICS 0
 312 #define GE_ENGINE 1
 313 #define GE_PLAYER 2
 314 #define GE_FILE 3
 315 #define GE_XBOARD 4
 316 #define GE_ENGINE1 5
 317 #define GE_ENGINE2 6
 318
 319 /* Maximum number of games in a cmail message */
 320 #define CMAIL_MAX_GAMES 20
 321
 322 /* Different types of move when calling RegisterMove */
 323 #define CMAIL_MOVE   0
 324 #define CMAIL_RESIGN 1
 325 #define CMAIL_DRAW   2
 326 #define CMAIL_ACCEPT 3
 327
 328 /* Different types of result to remember for each game */
 329 #define CMAIL_NOT_RESULT 0
 330 #define CMAIL_OLD_RESULT 1
 331 #define CMAIL_NEW_RESULT 2
 332
 333 /* Telnet protocol constants */
 334 #define TN_WILL 0373
 335 #define TN_WONT 0374
 336 #define TN_DO   0375
 337 #define TN_DONT 0376
 338 #define TN_IAC  0377
 339 #define TN_ECHO 0001
 340 #define TN_SGA  0003
 341 #define TN_PORT 23
 342
 343 char*
 344 safeStrCpy (char *dst, const char *src, size_t count)
 345 { // [HGM] made safe
 346   int i;
 347   assert( dst != NULL );
 348   assert( src != NULL );
 349   assert( count > 0 );
 350
 351   for(i=0; i<count; i++) if((dst[i] = src[i]) == NULLCHAR) break;
 352   if(  i == count && dst[count-1] != NULLCHAR)
 353     {
 354       dst[ count-1 ] = '\0'; // make sure incomplete copy still null-terminated
 355       if(appData.debugMode)
 356         fprintf(debugFP, "safeStrCpy: copying %s into %s didn't work, not enough space %d\n",src,dst, (int)count);
 357     }
 358
 359   return dst;
 360 }
 361
 362 /* Some compiler can't cast u64 to double
 363  * This function do the job for us:
 364
 365  * We use the highest bit for cast, this only
 366  * works if the highest bit is not
 367  * in use (This should not happen)
 368  *
 369  * We used this for all compiler
 370  */
 371 double
 372 u64ToDouble (u64 value)
 373 {
 374   double r;
 375   u64 tmp = value & u64Const(0x7fffffffffffffff);
 376   r = (double)(s64)tmp;
 377   if (value & u64Const(0x8000000000000000))
 378        r +=  9.2233720368547758080e18; /* 2^63 */
 379  return r;
 380 }
 381
 382 /* Fake up flags for now, as we aren't keeping track of castling
 383    availability yet. [HGM] Change of logic: the flag now only
 384    indicates the type of castlings allowed by the rule of the game.
 385    The actual rights themselves are maintained in the array
 386    castlingRights, as part of the game history, and are not probed
 387    by this function.
 388  */
 389 int
 390 PosFlags (index)
 391 {
 392   int flags = F_ALL_CASTLE_OK;
 393   if ((index % 2) == 0) flags |= F_WHITE_ON_MOVE;
 394   switch (gameInfo.variant) {
 395   case VariantSuicide:
 396     flags &= ~F_ALL_CASTLE_OK;
 397   case VariantGiveaway:         // [HGM] moved this case label one down: seems Giveaway does have castling on ICC!
 398     flags |= F_IGNORE_CHECK;
 399   case VariantLosers:
 400     flags |= F_MANDATORY_CAPTURE; //[HGM] losers: sets flag so TestLegality rejects non-capts if capts exist
 401     break;
 402   case VariantAtomic:
 403     flags |= F_IGNORE_CHECK | F_ATOMIC_CAPTURE;
 404     break;
 405   case VariantKriegspiel:
 406     flags |= F_KRIEGSPIEL_CAPTURE;
 407     break;
 408   case VariantCapaRandom:
 409   case VariantFischeRandom:
 410     flags |= F_FRC_TYPE_CASTLING; /* [HGM] enable this through flag */
 411   case VariantNoCastle:
 412   case VariantShatranj:
 413   case VariantCourier:
 414   case VariantMakruk:
 415   case VariantASEAN:
 416   case VariantGrand:
 417     flags &= ~F_ALL_CASTLE_OK;
 418     break;
 419   case VariantChu:
 420   case VariantChuChess:
 421   case VariantLion:
 422     flags |= F_NULL_MOVE;
 423     break;
 424   default:
 425     break;
 426   }
 427   if(appData.fischerCastling) flags |= F_FRC_TYPE_CASTLING, flags &= ~F_ALL_CASTLE_OK; // [HGM] fischer
 428   return flags;
 429 }
 430
 431 FILE *gameFileFP, *debugFP, *serverFP;
 432 char *currentDebugFile; // [HGM] debug split: to remember name
 433
 434 /*
 435     [AS] Note: sometimes, the sscanf() function is used to parse the input
 436     into a fixed-size buffer. Because of this, we must be prepared to
 437     receive strings as long as the size of the input buffer, which is currently
 438     set to 4K for Windows and 8K for the rest.
 439     So, we must either allocate sufficiently large buffers here, or
 440     reduce the size of the input buffer in the input reading part.
 441 */
 442
 443 char cmailMove[CMAIL_MAX_GAMES][MOVE_LEN], cmailMsg[MSG_SIZ];
 444 char bookOutput[MSG_SIZ*10], thinkOutput[MSG_SIZ*10], lastHint[MSG_SIZ];
 445 char thinkOutput1[MSG_SIZ*10];
 446
 447 ChessProgramState first, second, pairing;
 448
 449 /* premove variables */
 450 int premoveToX = 0;
 451 int premoveToY = 0;
 452 int premoveFromX = 0;
 453 int premoveFromY = 0;
 454 int premovePromoChar = 0;
 455 int gotPremove = 0;
 456 Boolean alarmSounded;
 457 /* end premove variables */
 458
 459 char *ics_prefix = "$";
 460 enum ICS_TYPE ics_type = ICS_GENERIC;
 461
 462 int currentMove = 0, forwardMostMove = 0, backwardMostMove = 0;
 463 int pauseExamForwardMostMove = 0;
 464 int nCmailGames = 0, nCmailResults = 0, nCmailMovesRegistered = 0;
 465 int cmailMoveRegistered[CMAIL_MAX_GAMES], cmailResult[CMAIL_MAX_GAMES];
 466 int cmailMsgLoaded = FALSE, cmailMailedMove = FALSE;
 467 int cmailOldMove = -1, firstMove = TRUE, flipView = FALSE;
 468 int blackPlaysFirst = FALSE, startedFromSetupPosition = FALSE;
 469 int searchTime = 0, pausing = FALSE, pauseExamInvalid = FALSE;
 470 int whiteFlag = FALSE, blackFlag = FALSE;
 471 int userOfferedDraw = FALSE;
 472 int ics_user_moved = 0, ics_gamenum = -1, ics_getting_history = H_FALSE;
 473 int matchMode = FALSE, hintRequested = FALSE, bookRequested = FALSE;
 474 int cmailMoveType[CMAIL_MAX_GAMES];
 475 long ics_clock_paused = 0;
 476 ProcRef icsPR = NoProc, cmailPR = NoProc;
 477 InputSourceRef telnetISR = NULL, fromUserISR = NULL, cmailISR = NULL;
 478 GameMode gameMode = BeginningOfGame;
 479 char moveList[MAX_MOVES][MOVE_LEN], parseList[MAX_MOVES][MOVE_LEN * 2];
 480 char *commentList[MAX_MOVES], *cmailCommentList[CMAIL_MAX_GAMES];
 481 ChessProgramStats_Move pvInfoList[MAX_MOVES]; /* [AS] Info about engine thinking */
 482 int hiddenThinkOutputState = 0; /* [AS] */
 483 int adjudicateLossThreshold = 0; /* [AS] Automatic adjudication */
 484 int adjudicateLossPlies = 6;
 485 char white_holding[64], black_holding[64];
 486 TimeMark lastNodeCountTime;
 487 long lastNodeCount=0;
 488 int shiftKey, controlKey; // [HGM] set by mouse handler
 489
 490 int have_sent_ICS_logon = 0;
 491 int movesPerSession;
 492 int suddenDeath, whiteStartMove, blackStartMove; /* [HGM] for implementation of 'any per time' sessions, as in first part of byoyomi TC */
 493 long whiteTimeRemaining, blackTimeRemaining, timeControl, timeIncrement, lastWhite, lastBlack, activePartnerTime;
 494 Boolean adjustedClock;
 495 long timeControl_2; /* [AS] Allow separate time controls */
 496 char *fullTimeControlString = NULL, *nextSession, *whiteTC, *blackTC, activePartner; /* [HGM] secondary TC: merge of MPS, TC and inc */
 497 long timeRemaining[2][MAX_MOVES];
 498 int matchGame = 0, nextGame = 0, roundNr = 0;
 499 Boolean waitingForGame = FALSE, startingEngine = FALSE;
 500 TimeMark programStartTime, pauseStart;
 501 char ics_handle[MSG_SIZ];
 502 int have_set_title = 0;
 503
 504 /* animateTraining preserves the state of appData.animate
 505  * when Training mode is activated. This allows the
 506  * response to be animated when appData.animate == TRUE and
 507  * appData.animateDragging == TRUE.
 508  */
 509 Boolean animateTraining;
 510
 511 GameInfo gameInfo;
 512
 513 AppData appData;
 514
 515 Board boards[MAX_MOVES];
 516 /* [HGM] Following 7 needed for accurate legality tests: */
 517 signed char  castlingRank[BOARD_FILES]; // and corresponding ranks
 518 signed char  initialRights[BOARD_FILES];
 519 int   nrCastlingRights; // For TwoKings, or to implement castling-unknown status
 520 int   initialRulePlies, FENrulePlies;
 521 FILE  *serverMoves = NULL; // next two for broadcasting (/serverMoves option)
 522 int loadFlag = 0;
 523 Boolean shuffleOpenings;
 524 int mute; // mute all sounds
 525
 526 // [HGM] vari: next 12 to save and restore variations
 527 #define MAX_VARIATIONS 10
 528 int framePtr = MAX_MOVES-1; // points to free stack entry
 529 int storedGames = 0;
 530 int savedFirst[MAX_VARIATIONS];
 531 int savedLast[MAX_VARIATIONS];
 532 int savedFramePtr[MAX_VARIATIONS];
 533 char *savedDetails[MAX_VARIATIONS];
 534 ChessMove savedResult[MAX_VARIATIONS];
 535
 536 void PushTail P((int firstMove, int lastMove));
 537 Boolean PopTail P((Boolean annotate));
 538 void PushInner P((int firstMove, int lastMove));
 539 void PopInner P((Boolean annotate));
 540 void CleanupTail P((void));
 541
 542 ChessSquare  FIDEArray[2][BOARD_FILES] = {
 543     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 544         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 545     { BlackRook, BlackKnight, BlackBishop, BlackQueen,
 546         BlackKing, BlackBishop, BlackKnight, BlackRook }
 547 };
 548
 549 ChessSquare twoKingsArray[2][BOARD_FILES] = {
 550     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 551         WhiteKing, WhiteKing, WhiteKnight, WhiteRook },
 552     { BlackRook, BlackKnight, BlackBishop, BlackQueen,
 553         BlackKing, BlackKing, BlackKnight, BlackRook }
 554 };
 555
 556 ChessSquare  KnightmateArray[2][BOARD_FILES] = {
 557     { WhiteRook, WhiteMan, WhiteBishop, WhiteQueen,
 558         WhiteUnicorn, WhiteBishop, WhiteMan, WhiteRook },
 559     { BlackRook, BlackMan, BlackBishop, BlackQueen,
 560         BlackUnicorn, BlackBishop, BlackMan, BlackRook }
 561 };
 562
 563 ChessSquare SpartanArray[2][BOARD_FILES] = {
 564     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 565         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 566     { BlackAlfil, BlackMarshall, BlackKing, BlackDragon,
 567         BlackDragon, BlackKing, BlackAngel, BlackAlfil }
 568 };
 569
 570 ChessSquare fairyArray[2][BOARD_FILES] = { /* [HGM] Queen side differs from King side */
 571     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 572         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 573     { BlackCardinal, BlackAlfil, BlackMarshall, BlackAngel,
 574         BlackKing, BlackMarshall, BlackAlfil, BlackCardinal }
 575 };
 576
 577 ChessSquare ShatranjArray[2][BOARD_FILES] = { /* [HGM] (movGen knows about Shatranj Q and P) */
 578     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteKing,
 579         WhiteFerz, WhiteAlfil, WhiteKnight, WhiteRook },
 580     { BlackRook, BlackKnight, BlackAlfil, BlackKing,
 581         BlackFerz, BlackAlfil, BlackKnight, BlackRook }
 582 };
 583
 584 ChessSquare makrukArray[2][BOARD_FILES] = { /* [HGM] (movGen knows about Shatranj Q and P) */
 585     { WhiteRook, WhiteKnight, WhiteMan, WhiteKing,
 586         WhiteFerz, WhiteMan, WhiteKnight, WhiteRook },
 587     { BlackRook, BlackKnight, BlackMan, BlackFerz,
 588         BlackKing, BlackMan, BlackKnight, BlackRook }
 589 };
 590
 591 ChessSquare aseanArray[2][BOARD_FILES] = { /* [HGM] (movGen knows about Shatranj Q and P) */
 592     { WhiteRook, WhiteKnight, WhiteMan, WhiteFerz,
 593         WhiteKing, WhiteMan, WhiteKnight, WhiteRook },
 594     { BlackRook, BlackKnight, BlackMan, BlackFerz,
 595         BlackKing, BlackMan, BlackKnight, BlackRook }
 596 };
 597
 598 ChessSquare  lionArray[2][BOARD_FILES] = {
 599     { WhiteRook, WhiteLion, WhiteBishop, WhiteQueen,
 600         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 601     { BlackRook, BlackLion, BlackBishop, BlackQueen,
 602         BlackKing, BlackBishop, BlackKnight, BlackRook }
 603 };
 604
 605
 606 #if (BOARD_FILES>=10)
 607 ChessSquare ShogiArray[2][BOARD_FILES] = {
 608     { WhiteQueen, WhiteKnight, WhiteFerz, WhiteWazir,
 609         WhiteKing, WhiteWazir, WhiteFerz, WhiteKnight, WhiteQueen },
 610     { BlackQueen, BlackKnight, BlackFerz, BlackWazir,
 611         BlackKing, BlackWazir, BlackFerz, BlackKnight, BlackQueen }
 612 };
 613
 614 ChessSquare XiangqiArray[2][BOARD_FILES] = {
 615     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteFerz,
 616         WhiteWazir, WhiteFerz, WhiteAlfil, WhiteKnight, WhiteRook },
 617     { BlackRook, BlackKnight, BlackAlfil, BlackFerz,
 618         BlackWazir, BlackFerz, BlackAlfil, BlackKnight, BlackRook }
 619 };
 620
 621 ChessSquare CapablancaArray[2][BOARD_FILES] = {
 622     { WhiteRook, WhiteKnight, WhiteAngel, WhiteBishop, WhiteQueen,
 623         WhiteKing, WhiteBishop, WhiteMarshall, WhiteKnight, WhiteRook },
 624     { BlackRook, BlackKnight, BlackAngel, BlackBishop, BlackQueen,
 625         BlackKing, BlackBishop, BlackMarshall, BlackKnight, BlackRook }
 626 };
 627
 628 ChessSquare GreatArray[2][BOARD_FILES] = {
 629     { WhiteDragon, WhiteKnight, WhiteAlfil, WhiteGrasshopper, WhiteKing,
 630         WhiteSilver, WhiteCardinal, WhiteAlfil, WhiteKnight, WhiteDragon },
 631     { BlackDragon, BlackKnight, BlackAlfil, BlackGrasshopper, BlackKing,
 632         BlackSilver, BlackCardinal, BlackAlfil, BlackKnight, BlackDragon },
 633 };
 634
 635 ChessSquare JanusArray[2][BOARD_FILES] = {
 636     { WhiteRook, WhiteAngel, WhiteKnight, WhiteBishop, WhiteKing,
 637         WhiteQueen, WhiteBishop, WhiteKnight, WhiteAngel, WhiteRook },
 638     { BlackRook, BlackAngel, BlackKnight, BlackBishop, BlackKing,
 639         BlackQueen, BlackBishop, BlackKnight, BlackAngel, BlackRook }
 640 };
 641
 642 ChessSquare GrandArray[2][BOARD_FILES] = {
 643     { EmptySquare, WhiteKnight, WhiteBishop, WhiteQueen, WhiteKing,
 644         WhiteMarshall, WhiteAngel, WhiteBishop, WhiteKnight, EmptySquare },
 645     { EmptySquare, BlackKnight, BlackBishop, BlackQueen, BlackKing,
 646         BlackMarshall, BlackAngel, BlackBishop, BlackKnight, EmptySquare }
 647 };
 648
 649 ChessSquare ChuChessArray[2][BOARD_FILES] = {
 650     { WhiteMan, WhiteKnight, WhiteBishop, WhiteCardinal, WhiteLion,
 651         WhiteQueen, WhiteDragon, WhiteBishop, WhiteKnight, WhiteMan },
 652     { BlackMan, BlackKnight, BlackBishop, BlackDragon, BlackQueen,
 653         BlackLion, BlackCardinal, BlackBishop, BlackKnight, BlackMan }
 654 };
 655
 656 #ifdef GOTHIC
 657 ChessSquare GothicArray[2][BOARD_FILES] = {
 658     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen, WhiteMarshall,
 659         WhiteKing, WhiteAngel, WhiteBishop, WhiteKnight, WhiteRook },
 660     { BlackRook, BlackKnight, BlackBishop, BlackQueen, BlackMarshall,
 661         BlackKing, BlackAngel, BlackBishop, BlackKnight, BlackRook }
 662 };
 663 #else // !GOTHIC
 664 #define GothicArray CapablancaArray
 665 #endif // !GOTHIC
 666
 667 #ifdef FALCON
 668 ChessSquare FalconArray[2][BOARD_FILES] = {
 669     { WhiteRook, WhiteKnight, WhiteBishop, WhiteFalcon, WhiteQueen,
 670         WhiteKing, WhiteFalcon, WhiteBishop, WhiteKnight, WhiteRook },
 671     { BlackRook, BlackKnight, BlackBishop, BlackFalcon, BlackQueen,
 672         BlackKing, BlackFalcon, BlackBishop, BlackKnight, BlackRook }
 673 };
 674 #else // !FALCON
 675 #define FalconArray CapablancaArray
 676 #endif // !FALCON
 677
 678 #else // !(BOARD_FILES>=10)
 679 #define XiangqiPosition FIDEArray
 680 #define CapablancaArray FIDEArray
 681 #define GothicArray FIDEArray
 682 #define GreatArray FIDEArray
 683 #endif // !(BOARD_FILES>=10)
 684
 685 #if (BOARD_FILES>=12)
 686 ChessSquare CourierArray[2][BOARD_FILES] = {
 687     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteBishop, WhiteMan, WhiteKing,
 688         WhiteFerz, WhiteWazir, WhiteBishop, WhiteAlfil, WhiteKnight, WhiteRook },
 689     { BlackRook, BlackKnight, BlackAlfil, BlackBishop, BlackMan, BlackKing,
 690         BlackFerz, BlackWazir, BlackBishop, BlackAlfil, BlackKnight, BlackRook }
 691 };
 692 ChessSquare ChuArray[6][BOARD_FILES] = {
 693     { WhiteLance, WhiteUnicorn, WhiteMan, WhiteFerz, WhiteWazir, WhiteKing,
 694       WhiteAlfil, WhiteWazir, WhiteFerz, WhiteMan, WhiteUnicorn, WhiteLance },
 695     { BlackLance, BlackUnicorn, BlackMan, BlackFerz, BlackWazir, BlackAlfil,
 696       BlackKing, BlackWazir, BlackFerz, BlackMan, BlackUnicorn, BlackLance },
 697     { WhiteCannon, EmptySquare, WhiteBishop, EmptySquare, WhiteNightrider, WhiteMarshall,
 698       WhiteAngel, WhiteNightrider, EmptySquare, WhiteBishop, EmptySquare, WhiteCannon },
 699     { BlackCannon, EmptySquare, BlackBishop, EmptySquare, BlackNightrider, BlackAngel,
 700       BlackMarshall, BlackNightrider, EmptySquare, BlackBishop, EmptySquare, BlackCannon },
 701     { WhiteFalcon, WhiteSilver, WhiteRook, WhiteCardinal, WhiteDragon, WhiteLion,
 702       WhiteQueen, WhiteDragon, WhiteCardinal, WhiteRook, WhiteSilver, WhiteFalcon },
 703     { BlackFalcon, BlackSilver, BlackRook, BlackCardinal, BlackDragon, BlackQueen,
 704       BlackLion, BlackDragon, BlackCardinal, BlackRook, BlackSilver, BlackFalcon }
 705 };
 706 #else // !(BOARD_FILES>=12)
 707 #define CourierArray CapablancaArray
 708 #define ChuArray CapablancaArray
 709 #endif // !(BOARD_FILES>=12)
 710
 711
 712 Board initialPosition;
 713
 714
 715 /* Convert str to a rating. Checks for special cases of "----",
 716
 717    "++++", etc. Also strips ()'s */
 718 int
 719 string_to_rating (char *str)
 720 {
 721   while(*str && !isdigit(*str)) ++str;
 722   if (!*str)
 723     return 0;   /* One of the special "no rating" cases */
 724   else
 725     return atoi(str);
 726 }
 727
 728 void
 729 ClearProgramStats ()
 730 {
 731     /* Init programStats */
 732     programStats.movelist[0] = 0;
 733     programStats.depth = 0;
 734     programStats.nr_moves = 0;
 735     programStats.moves_left = 0;
 736     programStats.nodes = 0;
 737     programStats.time = -1;        // [HGM] PGNtime: make invalid to recognize engine output
 738     programStats.score = 0;
 739     programStats.got_only_move = 0;
 740     programStats.got_fail = 0;
 741     programStats.line_is_book = 0;
 742 }
 743
 744 void
 745 CommonEngineInit ()
 746 {   // [HGM] moved some code here from InitBackend1 that has to be done after both engines have contributed their settings
 747     if (appData.firstPlaysBlack) {
 748         first.twoMachinesColor = "black\n";
 749         second.twoMachinesColor = "white\n";
 750     } else {
 751         first.twoMachinesColor = "white\n";
 752         second.twoMachinesColor = "black\n";
 753     }
 754
 755     first.other = &second;
 756     second.other = &first;
 757
 758     { float norm = 1;
 759         if(appData.timeOddsMode) {
 760             norm = appData.timeOdds[0];
 761             if(norm > appData.timeOdds[1]) norm = appData.timeOdds[1];
 762         }
 763         first.timeOdds  = appData.timeOdds[0]/norm;
 764         second.timeOdds = appData.timeOdds[1]/norm;
 765     }
 766
 767     if(programVersion) free(programVersion);
 768     if (appData.noChessProgram) {
 769         programVersion = (char*) malloc(5 + strlen(PACKAGE_STRING));
 770         sprintf(programVersion, "%s", PACKAGE_STRING);
 771     } else {
 772       /* [HGM] tidy: use tidy name, in stead of full pathname (which was probably a bug due to / vs \ ) */
 773       programVersion = (char*) malloc(8 + strlen(PACKAGE_STRING) + strlen(first.tidy));
 774       sprintf(programVersion, "%s + %s", PACKAGE_STRING, first.tidy);
 775     }
 776 }
 777
 778 void
 779 UnloadEngine (ChessProgramState *cps)
 780 {
 781         /* Kill off first chess program */
 782         if (cps->isr != NULL)
 783           RemoveInputSource(cps->isr);
 784         cps->isr = NULL;
 785
 786         if (cps->pr != NoProc) {
 787             ExitAnalyzeMode();
 788             DoSleep( appData.delayBeforeQuit );
 789             SendToProgram("quit\n", cps);
 790             DestroyChildProcess(cps->pr, 4 + cps->useSigterm);
 791         }
 792         cps->pr = NoProc;
 793         if(appData.debugMode) fprintf(debugFP, "Unload %s\n", cps->which);
 794 }
 795
 796 void
 797 ClearOptions (ChessProgramState *cps)
 798 {
 799     int i;
 800     cps->nrOptions = cps->comboCnt = 0;
 801     for(i=0; i<MAX_OPTIONS; i++) {
 802         cps->option[i].min = cps->option[i].max = cps->option[i].value = 0;
 803         cps->option[i].textValue = 0;
 804     }
 805 }
 806
 807 char *engineNames[] = {
 808   /* TRANSLATORS: "first" is the first of possible two chess engines. It is inserted into strings
 809      such as "%s engine" / "%s chess program" / "%s machine" - all meaning the same thing */
 810 N_("first"),
 811   /* TRANSLATORS: "second" is the second of possible two chess engines. It is inserted into strings
 812      such as "%s engine" / "%s chess program" / "%s machine" - all meaning the same thing */
 813 N_("second")
 814 };
 815
 816 void
 817 InitEngine (ChessProgramState *cps, int n)
 818 {   // [HGM] all engine initialiation put in a function that does one engine
 819
 820     ClearOptions(cps);
 821
 822     cps->which = engineNames[n];
 823     cps->maybeThinking = FALSE;
 824     cps->pr = NoProc;
 825     cps->isr = NULL;
 826     cps->sendTime = 2;
 827     cps->sendDrawOffers = 1;
 828
 829     cps->program = appData.chessProgram[n];
 830     cps->host = appData.host[n];
 831     cps->dir = appData.directory[n];
 832     cps->initString = appData.engInitString[n];
 833     cps->computerString = appData.computerString[n];
 834     cps->useSigint  = TRUE;
 835     cps->useSigterm = TRUE;
 836     cps->reuse = appData.reuse[n];
 837     cps->nps = appData.NPS[n];   // [HGM] nps: copy nodes per second
 838     cps->useSetboard = FALSE;
 839     cps->useSAN = FALSE;
 840     cps->usePing = FALSE;
 841     cps->lastPing = 0;
 842     cps->lastPong = 0;
 843     cps->usePlayother = FALSE;
 844     cps->useColors = TRUE;
 845     cps->useUsermove = FALSE;
 846     cps->sendICS = FALSE;
 847     cps->sendName = appData.icsActive;
 848     cps->sdKludge = FALSE;
 849     cps->stKludge = FALSE;
 850     if(cps->tidy == NULL) cps->tidy = (char*) malloc(MSG_SIZ);
 851     TidyProgramName(cps->program, cps->host, cps->tidy);
 852     cps->matchWins = 0;
 853     ASSIGN(cps->variants, appData.noChessProgram ? "" : appData.variant);
 854     cps->analysisSupport = 2; /* detect */
 855     cps->analyzing = FALSE;
 856     cps->initDone = FALSE;
 857     cps->reload = FALSE;
 858     cps->pseudo = appData.pseudo[n];
 859
 860     /* New features added by Tord: */
 861     cps->useFEN960 = FALSE;
 862     cps->useOOCastle = TRUE;
 863     /* End of new features added by Tord. */
 864     cps->fenOverride  = appData.fenOverride[n];
 865
 866     /* [HGM] time odds: set factor for each machine */
 867     cps->timeOdds  = appData.timeOdds[n];
 868
 869     /* [HGM] secondary TC: how to handle sessions that do not fit in 'level'*/
 870     cps->accumulateTC = appData.accumulateTC[n];
 871     cps->maxNrOfSessions = 1;
 872
 873     /* [HGM] debug */
 874     cps->debug = FALSE;
 875
 876     cps->drawDepth = appData.drawDepth[n];
 877     cps->supportsNPS = UNKNOWN;
 878     cps->memSize = FALSE;
 879     cps->maxCores = FALSE;
 880     ASSIGN(cps->egtFormats, "");
 881
 882     /* [HGM] options */
 883     cps->optionSettings  = appData.engOptions[n];
 884
 885     cps->scoreIsAbsolute = appData.scoreIsAbsolute[n]; /* [AS] */
 886     cps->isUCI = appData.isUCI[n]; /* [AS] */
 887     cps->hasOwnBookUCI = appData.hasOwnBookUCI[n]; /* [AS] */
 888     cps->highlight = 0;
 889
 890     if (appData.protocolVersion[n] > PROTOVER
 891         || appData.protocolVersion[n] < 1)
 892       {
 893         char buf[MSG_SIZ];
 894         int len;
 895
 896         len = snprintf(buf, MSG_SIZ, _("protocol version %d not supported"),
 897                        appData.protocolVersion[n]);
 898         if( (len >= MSG_SIZ) && appData.debugMode )
 899           fprintf(debugFP, "InitBackEnd1: buffer truncated.\n");
 900
 901         DisplayFatalError(buf, 0, 2);
 902       }
 903     else
 904       {
 905         cps->protocolVersion = appData.protocolVersion[n];
 906       }
 907
 908     InitEngineUCI( installDir, cps );  // [HGM] moved here from winboard.c, to make available in xboard
 909     ParseFeatures(appData.featureDefaults, cps);
 910 }
 911
 912 ChessProgramState *savCps;
 913
 914 GameMode oldMode;
 915
 916 void
 917 LoadEngine ()
 918 {
 919     int i;
 920     if(WaitForEngine(savCps, LoadEngine)) return;
 921     CommonEngineInit(); // recalculate time odds
 922     if(gameInfo.variant != StringToVariant(appData.variant)) {
 923         // we changed variant when loading the engine; this forces us to reset
 924         Reset(TRUE, savCps != &first);
 925         oldMode = BeginningOfGame; // to prevent restoring old mode
 926     }
 927     InitChessProgram(savCps, FALSE);
 928     if(gameMode == EditGame) SendToProgram("force\n", savCps); // in EditGame mode engine must be in force mode
 929     DisplayMessage("", "");
 930     if (startedFromSetupPosition) SendBoard(savCps, backwardMostMove);
 931     for (i = backwardMostMove; i < currentMove; i++) SendMoveToProgram(i, savCps);
 932     ThawUI();
 933     SetGNUMode();
 934     if(oldMode == AnalyzeMode) AnalyzeModeEvent();
 935 }
 936
 937 void
 938 ReplaceEngine (ChessProgramState *cps, int n)
 939 {
 940     oldMode = gameMode; // remember mode, so it can be restored after loading sequence is complete
 941     keepInfo = 1;
 942     if(oldMode != BeginningOfGame) EditGameEvent();
 943     keepInfo = 0;
 944     UnloadEngine(cps);
 945     appData.noChessProgram = FALSE;
 946     appData.clockMode = TRUE;
 947     InitEngine(cps, n);
 948     UpdateLogos(TRUE);
 949     if(n) return; // only startup first engine immediately; second can wait
 950     savCps = cps; // parameter to LoadEngine passed as globals, to allow scheduled calling :-(
 951     LoadEngine();
 952 }
 953
 954 extern char *engineName, *engineDir, *engineChoice, *engineLine, *nickName, *params;
 955 extern Boolean isUCI, hasBook, storeVariant, v1, addToList, useNick;
 956
 957 static char resetOptions[] =
 958         "-reuse -firstIsUCI false -firstHasOwnBookUCI true -firstTimeOdds 1 "
 959         "-firstInitString \"" INIT_STRING "\" -firstComputerString \"" COMPUTER_STRING "\" "
 960         "-firstFeatures \"\" -firstLogo \"\" -firstAccumulateTC 1 -fd \".\" "
 961         "-firstOptions \"\" -firstNPS -1 -fn \"\" -firstScoreAbs false";
 962
 963 void
 964 FloatToFront(char **list, char *engineLine)
 965 {
 966     char buf[MSG_SIZ], tidy[MSG_SIZ], *p = buf, *q, *r = buf;
 967     int i=0;
 968     if(appData.recentEngines <= 0) return;
 969     TidyProgramName(engineLine, "localhost", tidy+1);
 970     tidy[0] = buf[0] = '\n'; strcat(tidy, "\n");
 971     strncpy(buf+1, *list, MSG_SIZ-50);
 972     if(p = strstr(buf, tidy)) { // tidy name appears in list
 973         q = strchr(++p, '\n'); if(q == NULL) return; // malformed, don't touch
 974         while(*p++ = *++q); // squeeze out
 975     }
 976     strcat(tidy, buf+1); // put list behind tidy name
 977     p = tidy + 1; while(q = strchr(p, '\n')) i++, r = p, p = q + 1; // count entries in new list
 978     if(i > appData.recentEngines) *r = NULLCHAR; // if maximum rached, strip off last
 979     ASSIGN(*list, tidy+1);
 980 }
 981
 982 char *insert, *wbOptions; // point in ChessProgramNames were we should insert new engine
 983
 984 void
 985 Load (ChessProgramState *cps, int i)
 986 {
 987     char *p, *q, buf[MSG_SIZ], command[MSG_SIZ], buf2[MSG_SIZ], buf3[MSG_SIZ], jar;
 988     if(engineLine && engineLine[0]) { // an engine was selected from the combo box
 989         snprintf(buf, MSG_SIZ, "-fcp %s", engineLine);
 990         SwapEngines(i); // kludge to parse -f* / -first* like it is -s* / -second*
 991         ParseArgsFromString(resetOptions); appData.pvSAN[0] = FALSE;
 992         FREE(appData.fenOverride[0]); appData.fenOverride[0] = NULL;
 993         appData.firstProtocolVersion = PROTOVER;
 994         ParseArgsFromString(buf);
 995         SwapEngines(i);
 996         ReplaceEngine(cps, i);
 997         FloatToFront(&appData.recentEngineList, engineLine);
 998         return;
 999     }
1000     p = engineName;
1001     while(q = strchr(p, SLASH)) p = q+1;
1002     if(*p== NULLCHAR) { DisplayError(_("You did not specify the engine executable"), 0); return; }
1003     if(engineDir[0] != NULLCHAR) {
1004         ASSIGN(appData.directory[i], engineDir); p = engineName;
1005     } else if(p != engineName) { // derive directory from engine path, when not given
1006         p[-1] = 0;
1007         ASSIGN(appData.directory[i], engineName);
1008         p[-1] = SLASH;
1009         if(SLASH == '/' && p - engineName > 1) *(p -= 2) = '.'; // for XBoard use ./exeName as command after split!
1010     } else { ASSIGN(appData.directory[i], "."); }
1011     jar = (strstr(p, ".jar") == p + strlen(p) - 4);
1012     if(params[0]) {
1013         if(strchr(p, ' ') && !strchr(p, '"')) snprintf(buf2, MSG_SIZ, "\"%s\"", p), p = buf2; // quote if it contains spaces
1014         snprintf(command, MSG_SIZ, "%s %s", p, params);
1015         p = command;
1016     }
1017     if(jar) { snprintf(buf3, MSG_SIZ, "java -jar %s", p); p = buf3; }
1018     ASSIGN(appData.chessProgram[i], p);
1019     appData.isUCI[i] = isUCI;
1020     appData.protocolVersion[i] = v1 ? 1 : PROTOVER;
1021     appData.hasOwnBookUCI[i] = hasBook;
1022     if(!nickName[0]) useNick = FALSE;
1023     if(useNick) ASSIGN(appData.pgnName[i], nickName);
1024     if(addToList) {
1025         int len;
1026         char quote;
1027         q = firstChessProgramNames;
1028         if(nickName[0]) snprintf(buf, MSG_SIZ, "\"%s\" -fcp ", nickName); else buf[0] = NULLCHAR;
1029         quote = strchr(p, '"') ? '\'' : '"'; // use single quotes around engine command if it contains double quotes
1030         snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), "%c%s%c -fd \"%s\"%s%s%s%s%s%s%s%s\n",
1031                         quote, p, quote, appData.directory[i],
1032                         useNick ? " -fn \"" : "",
1033                         useNick ? nickName : "",
1034                         useNick ? "\"" : "",
1035                         v1 ? " -firstProtocolVersion 1" : "",
1036                         hasBook ? "" : " -fNoOwnBookUCI",
1037                         isUCI ? (isUCI == TRUE ? " -fUCI" : gameInfo.variant == VariantShogi ? " -fUSI" : " -fUCCI") : "",
1038                         storeVariant ? " -variant " : "",
1039                         storeVariant ? VariantName(gameInfo.variant) : "");
1040         if(wbOptions && wbOptions[0]) snprintf(buf+strlen(buf)-1, MSG_SIZ-strlen(buf), " %s\n", wbOptions);
1041         firstChessProgramNames = malloc(len = strlen(q) + strlen(buf) + 1);
1042         if(insert != q) insert[-1] = NULLCHAR;
1043         snprintf(firstChessProgramNames, len, "%s\n%s%s", q, buf, insert);
1044         if(q)   free(q);
1045         FloatToFront(&appData.recentEngineList, buf);
1046     }
1047     ReplaceEngine(cps, i);
1048 }
1049
1050 void
1051 InitTimeControls ()
1052 {
1053     int matched, min, sec;
1054     /*
1055      * Parse timeControl resource
1056      */
1057     if (!ParseTimeControl(appData.timeControl, appData.timeIncrement,
1058                           appData.movesPerSession)) {
1059         char buf[MSG_SIZ];
1060         snprintf(buf, sizeof(buf), _("bad timeControl option %s"), appData.timeControl);
1061         DisplayFatalError(buf, 0, 2);
1062     }
1063
1064     /*
1065      * Parse searchTime resource
1066      */
1067     if (*appData.searchTime != NULLCHAR) {
1068         matched = sscanf(appData.searchTime, "%d:%d", &min, &sec);
1069         if (matched == 1) {
1070             searchTime = min * 60;
1071         } else if (matched == 2) {
1072             searchTime = min * 60 + sec;
1073         } else {
1074             char buf[MSG_SIZ];
1075             snprintf(buf, sizeof(buf), _("bad searchTime option %s"), appData.searchTime);
1076             DisplayFatalError(buf, 0, 2);
1077         }
1078     }
1079 }
1080
1081 void
1082 InitBackEnd1 ()
1083 {
1084
1085     ShowThinkingEvent(); // [HGM] thinking: make sure post/nopost state is set according to options
1086     startVariant = StringToVariant(appData.variant); // [HGM] nicks: remember original variant
1087
1088     GetTimeMark(&programStartTime);
1089     srandom((programStartTime.ms + 1000*programStartTime.sec)*0x1001001); // [HGM] book: makes sure random is unpredictabe to msec level
1090     appData.seedBase = random() + (random()<<15);
1091     pauseStart = programStartTime; pauseStart.sec -= 100; // [HGM] matchpause: fake a pause that has long since ended
1092
1093     ClearProgramStats();
1094     programStats.ok_to_send = 1;
1095     programStats.seen_stat = 0;
1096
1097     /*
1098      * Initialize game list
1099      */
1100     ListNew(&gameList);
1101
1102
1103     /*
1104      * Internet chess server status
1105      */
1106     if (appData.icsActive) {
1107         appData.matchMode = FALSE;
1108         appData.matchGames = 0;
1109 #if ZIPPY
1110         appData.noChessProgram = !appData.zippyPlay;
1111 #else
1112         appData.zippyPlay = FALSE;
1113         appData.zippyTalk = FALSE;
1114         appData.noChessProgram = TRUE;
1115 #endif
1116         if (*appData.icsHelper != NULLCHAR) {
1117             appData.useTelnet = TRUE;
1118             appData.telnetProgram = appData.icsHelper;
1119         }
1120     } else {
1121         appData.zippyTalk = appData.zippyPlay = FALSE;
1122     }
1123
1124     /* [AS] Initialize pv info list [HGM] and game state */
1125     {
1126         int i, j;
1127
1128         for( i=0; i<=framePtr; i++ ) {
1129             pvInfoList[i].depth = -1;
1130             boards[i][EP_STATUS] = EP_NONE;
1131             for( j=0; j<BOARD_FILES-2; j++ ) boards[i][CASTLING][j] = NoRights;
1132         }
1133     }
1134
1135     InitTimeControls();
1136
1137     /* [AS] Adjudication threshold */
1138     adjudicateLossThreshold = appData.adjudicateLossThreshold;
1139
1140     InitEngine(&first, 0);
1141     InitEngine(&second, 1);
1142     CommonEngineInit();
1143
1144     pairing.which = "pairing"; // pairing engine
1145     pairing.pr = NoProc;
1146     pairing.isr = NULL;
1147     pairing.program = appData.pairingEngine;
1148     pairing.host = "localhost";
1149     pairing.dir = ".";
1150
1151     if (appData.icsActive) {
1152         appData.clockMode = TRUE;  /* changes dynamically in ICS mode */
1153     } else if (appData.noChessProgram) { // [HGM] st: searchTime mode now also is clockMode
1154         appData.clockMode = FALSE;
1155         first.sendTime = second.sendTime = 0;
1156     }
1157
1158 #if ZIPPY
1159     /* Override some settings from environment variables, for backward
1160        compatibility.  Unfortunately it's not feasible to have the env
1161        vars just set defaults, at least in xboard.  Ugh.
1162     */
1163     if (appData.icsActive && (appData.zippyPlay || appData.zippyTalk)) {
1164       ZippyInit();
1165     }
1166 #endif
1167
1168     if (!appData.icsActive) {
1169       char buf[MSG_SIZ];
1170       int len;
1171
1172       /* Check for variants that are supported only in ICS mode,
1173          or not at all.  Some that are accepted here nevertheless
1174          have bugs; see comments below.
1175       */
1176       VariantClass variant = StringToVariant(appData.variant);
1177       switch (variant) {
1178       case VariantBughouse:     /* need four players and two boards */
1179       case VariantKriegspiel:   /* need to hide pieces and move details */
1180         /* case VariantFischeRandom: (Fabien: moved below) */
1181         len = snprintf(buf,MSG_SIZ, _("Variant %s supported only in ICS mode"), appData.variant);
1182         if( (len >= MSG_SIZ) && appData.debugMode )
1183           fprintf(debugFP, "InitBackEnd1: buffer truncated.\n");
1184
1185         DisplayFatalError(buf, 0, 2);
1186         return;
1187
1188       case VariantUnknown:
1189       case VariantLoadable:
1190       case Variant29:
1191       case Variant30:
1192       case Variant31:
1193       case Variant32:
1194       case Variant33:
1195       case Variant34:
1196       case Variant35:
1197       case Variant36:
1198       default:
1199         len = snprintf(buf, MSG_SIZ, _("Unknown variant name %s"), appData.variant);
1200         if( (len >= MSG_SIZ) && appData.debugMode )
1201           fprintf(debugFP, "InitBackEnd1: buffer truncated.\n");
1202
1203         DisplayFatalError(buf, 0, 2);
1204         return;
1205
1206       case VariantNormal:     /* definitely works! */
1207         if(strcmp(appData.variant, "normal") && !appData.noChessProgram) { // [HGM] hope this is an engine-defined variant
1208           safeStrCpy(engineVariant, appData.variant, MSG_SIZ);
1209           return;
1210         }
1211       case VariantXiangqi:    /* [HGM] repetition rules not implemented */
1212       case VariantFairy:      /* [HGM] TestLegality definitely off! */
1213       case VariantGothic:     /* [HGM] should work */
1214       case VariantCapablanca: /* [HGM] should work */
1215       case VariantCourier:    /* [HGM] initial forced moves not implemented */
1216       case VariantShogi:      /* [HGM] could still mate with pawn drop */
1217       case VariantChu:        /* [HGM] experimental */
1218       case VariantKnightmate: /* [HGM] should work */
1219       case VariantCylinder:   /* [HGM] untested */
1220       case VariantFalcon:     /* [HGM] untested */
1221       case VariantCrazyhouse: /* holdings not shown, ([HGM] fixed that!)
1222                                  offboard interposition not understood */
1223       case VariantWildCastle: /* pieces not automatically shuffled */
1224       case VariantNoCastle:   /* pieces not automatically shuffled */
1225       case VariantFischeRandom: /* [HGM] works and shuffles pieces */
1226       case VariantLosers:     /* should work except for win condition,
1227                                  and doesn't know captures are mandatory */
1228       case VariantSuicide:    /* should work except for win condition,
1229                                  and doesn't know captures are mandatory */
1230       case VariantGiveaway:   /* should work except for win condition,
1231                                  and doesn't know captures are mandatory */
1232       case VariantTwoKings:   /* should work */
1233       case VariantAtomic:     /* should work except for win condition */
1234       case Variant3Check:     /* should work except for win condition */
1235       case VariantShatranj:   /* should work except for all win conditions */
1236       case VariantMakruk:     /* should work except for draw countdown */
1237       case VariantASEAN :     /* should work except for draw countdown */
1238       case VariantBerolina:   /* might work if TestLegality is off */
1239       case VariantCapaRandom: /* should work */
1240       case VariantJanus:      /* should work */
1241       case VariantSuper:      /* experimental */
1242       case VariantGreat:      /* experimental, requires legality testing to be off */
1243       case VariantSChess:     /* S-Chess, should work */
1244       case VariantGrand:      /* should work */
1245       case VariantSpartan:    /* should work */
1246       case VariantLion:       /* should work */
1247       case VariantChuChess:   /* should work */
1248         break;
1249       }
1250     }
1251
1252 }
1253
1254 int
1255 NextIntegerFromString (char ** str, long * value)
1256 {
1257     int result = -1;
1258     char * s = *str;
1259
1260     while( *s == ' ' || *s == '\t' ) {
1261         s++;
1262     }
1263
1264     *value = 0;
1265
1266     if( *s >= '0' && *s <= '9' ) {
1267         while( *s >= '0' && *s <= '9' ) {
1268             *value = *value * 10 + (*s - '0');
1269             s++;
1270         }
1271
1272         result = 0;
1273     }
1274
1275     *str = s;
1276
1277     return result;
1278 }
1279
1280 int
1281 NextTimeControlFromString (char ** str, long * value)
1282 {
1283     long temp;
1284     int result = NextIntegerFromString( str, &temp );
1285
1286     if( result == 0 ) {
1287         *value = temp * 60; /* Minutes */
1288         if( **str == ':' ) {
1289             (*str)++;
1290             result = NextIntegerFromString( str, &temp );
1291             *value += temp; /* Seconds */
1292         }
1293     }
1294
1295     return result;
1296 }
1297
1298 int
1299 NextSessionFromString (char ** str, int *moves, long * tc, long *inc, int *incType)
1300 {   /* [HGM] routine added to read '+moves/time' for secondary time control. */
1301     int result = -1, type = 0; long temp, temp2;
1302
1303     if(**str != ':') return -1; // old params remain in force!
1304     (*str)++;
1305     if(**str == '*') type = *(*str)++, temp = 0; // sandclock TC
1306     if( NextIntegerFromString( str, &temp ) ) return -1;
1307     if(type) { *moves = 0; *tc = temp * 500; *inc = temp * 1000; *incType = '*'; return 0; }
1308
1309     if(**str != '/') {
1310         /* time only: incremental or sudden-death time control */
1311         if(**str == '+') { /* increment follows; read it */
1312             (*str)++;
1313             if(**str == '!') type = *(*str)++; // Bronstein TC
1314             if(result = NextIntegerFromString( str, &temp2)) return -1;
1315             *inc = temp2 * 1000;
1316             if(**str == '.') { // read fraction of increment
1317                 char *start = ++(*str);
1318                 if(result = NextIntegerFromString( str, &temp2)) return -1;
1319                 temp2 *= 1000;
1320                 while(start++ < *str) temp2 /= 10;
1321                 *inc += temp2;
1322             }
1323         } else *inc = 0;
1324         *moves = 0; *tc = temp * 1000; *incType = type;
1325         return 0;
1326     }
1327
1328     (*str)++; /* classical time control */
1329     result = NextIntegerFromString( str, &temp2); // NOTE: already converted to seconds by ParseTimeControl()
1330
1331     if(result == 0) {
1332         *moves = temp;
1333         *tc    = temp2 * 1000;
1334         *inc   = 0;
1335         *incType = type;
1336     }
1337     return result;
1338 }
1339
1340 int
1341 GetTimeQuota (int movenr, int lastUsed, char *tcString)
1342 {   /* [HGM] get time to add from the multi-session time-control string */
1343     int incType, moves=1; /* kludge to force reading of first session */
1344     long time, increment;
1345     char *s = tcString;
1346
1347     if(!s || !*s) return 0; // empty TC string means we ran out of the last sudden-death version
1348     do {
1349         if(moves) NextSessionFromString(&s, &moves, &time, &increment, &incType);
1350         nextSession = s; suddenDeath = moves == 0 && increment == 0;
1351         if(movenr == -1) return time;    /* last move before new session     */
1352         if(incType == '*') increment = 0; else // for sandclock, time is added while not thinking
1353         if(incType == '!' && lastUsed < increment) increment = lastUsed;
1354         if(!moves) return increment;     /* current session is incremental   */
1355         if(movenr >= 0) movenr -= moves; /* we already finished this session */
1356     } while(movenr >= -1);               /* try again for next session       */
1357
1358     return 0; // no new time quota on this move
1359 }
1360
1361 int
1362 ParseTimeControl (char *tc, float ti, int mps)
1363 {
1364   long tc1;
1365   long tc2;
1366   char buf[MSG_SIZ], buf2[MSG_SIZ], *mytc = tc;
1367   int min, sec=0;
1368
1369   if(ti >= 0 && !strchr(tc, '+') && !strchr(tc, '/') ) mps = 0;
1370   if(!strchr(tc, '+') && !strchr(tc, '/') && sscanf(tc, "%d:%d", &min, &sec) >= 1)
1371       sprintf(mytc=buf2, "%d", 60*min+sec); // convert 'classical' min:sec tc string to seconds
1372   if(ti > 0) {
1373
1374     if(mps)
1375       snprintf(buf, MSG_SIZ, ":%d/%s+%g", mps, mytc, ti);
1376     else
1377       snprintf(buf, MSG_SIZ, ":%s+%g", mytc, ti);
1378   } else {
1379     if(mps)
1380       snprintf(buf, MSG_SIZ, ":%d/%s", mps, mytc);
1381     else
1382       snprintf(buf, MSG_SIZ, ":%s", mytc);
1383   }
1384   fullTimeControlString = StrSave(buf); // this should now be in PGN format
1385
1386   if( NextTimeControlFromString( &tc, &tc1 ) != 0 ) {
1387     return FALSE;
1388   }
1389
1390   if( *tc == '/' ) {
1391     /* Parse second time control */
1392     tc++;
1393
1394     if( NextTimeControlFromString( &tc, &tc2 ) != 0 ) {
1395       return FALSE;
1396     }
1397
1398     if( tc2 == 0 ) {
1399       return FALSE;
1400     }
1401
1402     timeControl_2 = tc2 * 1000;
1403   }
1404   else {
1405     timeControl_2 = 0;
1406   }
1407
1408   if( tc1 == 0 ) {
1409     return FALSE;
1410   }
1411
1412   timeControl = tc1 * 1000;
1413
1414   if (ti >= 0) {
1415     timeIncrement = ti * 1000;  /* convert to ms */
1416     movesPerSession = 0;
1417   } else {
1418     timeIncrement = 0;
1419     movesPerSession = mps;
1420   }
1421   return TRUE;
1422 }
1423
1424 void
1425 InitBackEnd2 ()
1426 {
1427     if (appData.debugMode) {
1428 #    ifdef __GIT_VERSION
1429       fprintf(debugFP, "Version: %s (%s)\n", programVersion, __GIT_VERSION);
1430 #    else
1431       fprintf(debugFP, "Version: %s\n", programVersion);
1432 #    endif
1433     }
1434     ASSIGN(currentDebugFile, appData.nameOfDebugFile); // [HGM] debug split: remember initial name in use
1435
1436     set_cont_sequence(appData.wrapContSeq);
1437     if (appData.matchGames > 0) {
1438         appData.matchMode = TRUE;
1439     } else if (appData.matchMode) {
1440         appData.matchGames = 1;
1441     }
1442     if(appData.matchMode && appData.sameColorGames > 0) /* [HGM] alternate: overrule matchGames */
1443         appData.matchGames = appData.sameColorGames;
1444     if(appData.rewindIndex > 1) { /* [HGM] autoinc: rewind implies auto-increment and overrules given index */
1445         if(appData.loadPositionIndex >= 0) appData.loadPositionIndex = -1;
1446         if(appData.loadGameIndex >= 0) appData.loadGameIndex = -1;
1447     }
1448     Reset(TRUE, FALSE);
1449     if (appData.noChessProgram || first.protocolVersion == 1) {
1450       InitBackEnd3();
1451     } else {
1452       /* kludge: allow timeout for initial "feature" commands */
1453       FreezeUI();
1454       DisplayMessage("", _("Starting chess program"));
1455       ScheduleDelayedEvent(InitBackEnd3, FEATURE_TIMEOUT);
1456     }
1457 }
1458
1459 int
1460 CalculateIndex (int index, int gameNr)
1461 {   // [HGM] autoinc: absolute way to determine load index from game number (taking auto-inc and rewind into account)
1462     int res;
1463     if(index > 0) return index; // fixed nmber
1464     if(index == 0) return 1;
1465     res = (index == -1 ? gameNr : (gameNr-1)/2 + 1); // autoinc
1466     if(appData.rewindIndex > 0) res = (res-1) % appData.rewindIndex + 1; // rewind
1467     return res;
1468 }
1469
1470 int
1471 LoadGameOrPosition (int gameNr)
1472 {   // [HGM] taken out of MatchEvent and NextMatchGame (to combine it)
1473     if (*appData.loadGameFile != NULLCHAR) {
1474         if (!LoadGameFromFile(appData.loadGameFile,
1475                 CalculateIndex(appData.loadGameIndex, gameNr),
1476                               appData.loadGameFile, FALSE)) {
1477             DisplayFatalError(_("Bad game file"), 0, 1);
1478             return 0;
1479         }
1480     } else if (*appData.loadPositionFile != NULLCHAR) {
1481         if (!LoadPositionFromFile(appData.loadPositionFile,
1482                 CalculateIndex(appData.loadPositionIndex, gameNr),
1483                                   appData.loadPositionFile)) {
1484             DisplayFatalError(_("Bad position file"), 0, 1);
1485             return 0;
1486         }
1487     }
1488     return 1;
1489 }
1490
1491 void
1492 ReserveGame (int gameNr, char resChar)
1493 {
1494     FILE *tf = fopen(appData.tourneyFile, "r+");
1495     char *p, *q, c, buf[MSG_SIZ];
1496     if(tf == NULL) { nextGame = appData.matchGames + 1; return; } // kludge to terminate match
1497     safeStrCpy(buf, lastMsg, MSG_SIZ);
1498     DisplayMessage(_("Pick new game"), "");
1499     flock(fileno(tf), LOCK_EX); // lock the tourney file while we are messing with it
1500     ParseArgsFromFile(tf);
1501     p = q = appData.results;
1502     if(appData.debugMode) {
1503       char *r = appData.participants;
1504       fprintf(debugFP, "results = '%s'\n", p);
1505       while(*r) fprintf(debugFP, *r >= ' ' ? "%c" : "\\%03o", *r), r++;
1506       fprintf(debugFP, "\n");
1507     }
1508     while(*q && *q != ' ') q++; // get first un-played game (could be beyond end!)
1509     nextGame = q - p;
1510     q = malloc(strlen(p) + 2); // could be arbitrary long, but allow to extend by one!
1511     safeStrCpy(q, p, strlen(p) + 2);
1512     if(gameNr >= 0) q[gameNr] = resChar; // replace '*' with result
1513     if(appData.debugMode) fprintf(debugFP, "pick next game from '%s': %d\n", q, nextGame);
1514     if(nextGame <= appData.matchGames && resChar != ' ' && !abortMatch) { // reserve next game if tourney not yet done
1515         if(q[nextGame] == NULLCHAR) q[nextGame+1] = NULLCHAR; // append one char
1516         q[nextGame] = '*';
1517     }
1518     fseek(tf, -(strlen(p)+4), SEEK_END);
1519     c = fgetc(tf);
1520     if(c != '"') // depending on DOS or Unix line endings we can be one off
1521          fseek(tf, -(strlen(p)+2), SEEK_END);
1522     else fseek(tf, -(strlen(p)+3), SEEK_END);
1523     fprintf(tf, "%s\"\n", q); fclose(tf); // update, and flush by closing
1524     DisplayMessage(buf, "");
1525     free(p); appData.results = q;
1526     if(nextGame <= appData.matchGames && resChar != ' ' && !abortMatch &&
1527        (gameNr < 0 || nextGame / appData.defaultMatchGames != gameNr / appData.defaultMatchGames)) {
1528       int round = appData.defaultMatchGames * appData.tourneyType;
1529       if(gameNr < 0 || appData.tourneyType < 1 ||  // gauntlet engine can always stay loaded as first engine
1530          appData.tourneyType > 1 && nextGame/round != gameNr/round) // in multi-gauntlet change only after round
1531         UnloadEngine(&first);  // next game belongs to other pairing;
1532         UnloadEngine(&second); // already unload the engines, so TwoMachinesEvent will load new ones.
1533     }
1534     if(appData.debugMode) fprintf(debugFP, "Reserved, next=%d, nr=%d\n", nextGame, gameNr);
1535 }
1536
1537 void
1538 MatchEvent (int mode)
1539 {       // [HGM] moved out of InitBackend3, to make it callable when match starts through menu
1540         int dummy;
1541         if(matchMode) { // already in match mode: switch it off
1542             abortMatch = TRUE;
1543             if(!appData.tourneyFile[0]) appData.matchGames = matchGame; // kludge to let match terminate after next game.
1544             return;
1545         }
1546 //      if(gameMode != BeginningOfGame) {
1547 //          DisplayError(_("You can only start a match from the initial position."), 0);
1548 //          return;
1549 //      }
1550         abortMatch = FALSE;
1551         if(mode == 2) appData.matchGames = appData.defaultMatchGames;
1552         /* Set up machine vs. machine match */
1553         nextGame = 0;
1554         NextTourneyGame(-1, &dummy); // sets appData.matchGames if this is tourney, to make sure ReserveGame knows it
1555         if(appData.tourneyFile[0]) {
1556             ReserveGame(-1, 0);
1557             if(nextGame > appData.matchGames) {
1558                 char buf[MSG_SIZ];
1559                 if(strchr(appData.results, '*') == NULL) {
1560                     FILE *f;
1561                     appData.tourneyCycles++;
1562                     if(f = WriteTourneyFile(appData.results, NULL)) { // make a tourney file with increased number of cycles
1563                         fclose(f);
1564                         NextTourneyGame(-1, &dummy);
1565                         ReserveGame(-1, 0);
1566                         if(nextGame <= appData.matchGames) {
1567                             DisplayNote(_("You restarted an already completed tourney.\nOne more cycle will now be added to it.\nGames commence in 10 sec."));
1568                             matchMode = mode;
1569                             ScheduleDelayedEvent(NextMatchGame, 10000);
1570                             return;
1571                         }
1572                     }
1573                 }
1574                 snprintf(buf, MSG_SIZ, _("All games in tourney '%s' are already played or playing"), appData.tourneyFile);
1575                 DisplayError(buf, 0);
1576                 appData.tourneyFile[0] = 0;
1577                 return;
1578             }
1579         } else
1580         if (appData.noChessProgram) {  // [HGM] in tourney engines are loaded automatically
1581             DisplayFatalError(_("Can't have a match with no chess programs"),
1582                               0, 2);
1583             return;
1584         }
1585         matchMode = mode;
1586         matchGame = roundNr = 1;
1587         first.matchWins = second.matchWins = 0; // [HGM] match: needed in later matches
1588         NextMatchGame();
1589 }
1590
1591 char *comboLine = NULL; // [HGM] recent: WinBoard's first-engine combobox line
1592
1593 void
1594 InitBackEnd3 P((void))
1595 {
1596     GameMode initialMode;
1597     char buf[MSG_SIZ];
1598     int err, len;
1599
1600     if(!appData.icsActive && !appData.noChessProgram && !appData.matchMode &&                         // mode involves only first engine
1601        !strcmp(appData.variant, "normal") &&                                                          // no explicit variant request
1602         appData.NrRanks == -1 && appData.NrFiles == -1 && appData.holdingsSize == -1 &&               // no size overrides requested
1603        !SupportedVariant(first.variants, VariantNormal, 8, 8, 0, first.protocolVersion, "") &&        // but 'normal' won't work with engine
1604        !SupportedVariant(first.variants, VariantFischeRandom, 8, 8, 0, first.protocolVersion, "") ) { // nor will Chess960
1605         char c, *q = first.variants, *p = strchr(q, ',');
1606         if(p) *p = NULLCHAR;
1607         if(StringToVariant(q) != VariantUnknown) { // the engine can play a recognized variant, however
1608             int w, h, s;
1609             if(sscanf(q, "%dx%d+%d_%c", &w, &h, &s, &c) == 4) // get size overrides the engine needs with it (if any)
1610                 appData.NrFiles = w, appData.NrRanks = h, appData.holdingsSize = s, q = strchr(q, '_') + 1;
1611             ASSIGN(appData.variant, q); // fake user requested the first variant played by the engine
1612             Reset(TRUE, FALSE);         // and re-initialize
1613         }
1614         if(p) *p = ',';
1615     }
1616
1617     InitChessProgram(&first, startedFromSetupPosition);
1618
1619     if(!appData.noChessProgram) {  /* [HGM] tidy: redo program version to use name from myname feature */
1620         free(programVersion);
1621         programVersion = (char*) malloc(8 + strlen(PACKAGE_STRING) + strlen(first.tidy));
1622         sprintf(programVersion, "%s + %s", PACKAGE_STRING, first.tidy);
1623         FloatToFront(&appData.recentEngineList, comboLine ? comboLine : appData.firstChessProgram);
1624     }
1625
1626     if (appData.icsActive) {
1627 #ifdef WIN32
1628         /* [DM] Make a console window if needed [HGM] merged ifs */
1629         ConsoleCreate();
1630 #endif
1631         err = establish();
1632         if (err != 0)
1633           {
1634             if (*appData.icsCommPort != NULLCHAR)
1635               len = snprintf(buf, MSG_SIZ, _("Could not open comm port %s"),
1636                              appData.icsCommPort);
1637             else
1638               len = snprintf(buf, MSG_SIZ, _("Could not connect to host %s, port %s"),
1639                         appData.icsHost, appData.icsPort);
1640
1641             if( (len >= MSG_SIZ) && appData.debugMode )
1642               fprintf(debugFP, "InitBackEnd3: buffer truncated.\n");
1643
1644             DisplayFatalError(buf, err, 1);
1645             return;
1646         }
1647         SetICSMode();
1648         telnetISR =
1649           AddInputSource(icsPR, FALSE, read_from_ics, &telnetISR);
1650         fromUserISR =
1651           AddInputSource(NoProc, FALSE, read_from_player, &fromUserISR);
1652         if(appData.keepAlive) // [HGM] alive: schedule sending of dummy 'date' command
1653             ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
1654     } else if (appData.noChessProgram) {
1655         SetNCPMode();
1656     } else {
1657         SetGNUMode();
1658     }
1659
1660     if (*appData.cmailGameName != NULLCHAR) {
1661         SetCmailMode();
1662         OpenLoopback(&cmailPR);
1663         cmailISR =
1664           AddInputSource(cmailPR, FALSE, CmailSigHandlerCallBack, &cmailISR);
1665     }
1666
1667     ThawUI();
1668     DisplayMessage("", "");
1669     if (StrCaseCmp(appData.initialMode, "") == 0) {
1670       initialMode = BeginningOfGame;
1671       if(!appData.icsActive && appData.noChessProgram) { // [HGM] could be fall-back
1672         gameMode = MachinePlaysBlack; // "Machine Black" might have been implicitly highlighted
1673         ModeHighlight(); // make sure XBoard knows it is highlighted, so it will un-highlight it
1674         gameMode = BeginningOfGame; // in case BeginningOfGame now means "Edit Position"
1675         ModeHighlight();
1676       }
1677     } else if (StrCaseCmp(appData.initialMode, "TwoMachines") == 0) {
1678       initialMode = TwoMachinesPlay;
1679     } else if (StrCaseCmp(appData.initialMode, "AnalyzeFile") == 0) {
1680       initialMode = AnalyzeFile;
1681     } else if (StrCaseCmp(appData.initialMode, "Analysis") == 0) {
1682       initialMode = AnalyzeMode;
1683     } else if (StrCaseCmp(appData.initialMode, "MachineWhite") == 0) {
1684       initialMode = MachinePlaysWhite;
1685     } else if (StrCaseCmp(appData.initialMode, "MachineBlack") == 0) {
1686       initialMode = MachinePlaysBlack;
1687     } else if (StrCaseCmp(appData.initialMode, "EditGame") == 0) {
1688       initialMode = EditGame;
1689     } else if (StrCaseCmp(appData.initialMode, "EditPosition") == 0) {
1690       initialMode = EditPosition;
1691     } else if (StrCaseCmp(appData.initialMode, "Training") == 0) {
1692       initialMode = Training;
1693     } else {
1694       len = snprintf(buf, MSG_SIZ, _("Unknown initialMode %s"), appData.initialMode);
1695       if( (len >= MSG_SIZ) && appData.debugMode )
1696         fprintf(debugFP, "InitBackEnd3: buffer truncated.\n");
1697
1698       DisplayFatalError(buf, 0, 2);
1699       return;
1700     }
1701
1702     if (appData.matchMode) {
1703         if(appData.tourneyFile[0]) { // start tourney from command line
1704             FILE *f;
1705             if(f = fopen(appData.tourneyFile, "r")) {
1706                 ParseArgsFromFile(f); // make sure tourney parmeters re known
1707                 fclose(f);
1708                 appData.clockMode = TRUE;
1709                 SetGNUMode();
1710             } else appData.tourneyFile[0] = NULLCHAR; // for now ignore bad tourney file
1711         }
1712         MatchEvent(TRUE);
1713     } else if (*appData.cmailGameName != NULLCHAR) {
1714         /* Set up cmail mode */
1715         ReloadCmailMsgEvent(TRUE);
1716     } else {
1717         /* Set up other modes */
1718         if (initialMode == AnalyzeFile) {
1719           if (*appData.loadGameFile == NULLCHAR) {
1720             DisplayFatalError(_("AnalyzeFile mode requires a game file"), 0, 1);
1721             return;
1722           }
1723         }
1724         if (*appData.loadGameFile != NULLCHAR) {
1725             (void) LoadGameFromFile(appData.loadGameFile,
1726                                     appData.loadGameIndex,
1727                                     appData.loadGameFile, TRUE);
1728         } else if (*appData.loadPositionFile != NULLCHAR) {
1729             (void) LoadPositionFromFile(appData.loadPositionFile,
1730                                         appData.loadPositionIndex,
1731                                         appData.loadPositionFile);
1732             /* [HGM] try to make self-starting even after FEN load */
1733             /* to allow automatic setup of fairy variants with wtm */
1734             if(initialMode == BeginningOfGame && !blackPlaysFirst) {
1735                 gameMode = BeginningOfGame;
1736                 setboardSpoiledMachineBlack = 1;
1737             }
1738             /* [HGM] loadPos: make that every new game uses the setup */
1739             /* from file as long as we do not switch variant          */
1740             if(!blackPlaysFirst) {
1741                 startedFromPositionFile = TRUE;
1742                 CopyBoard(filePosition, boards[0]);
1743             }
1744         }
1745         if (initialMode == AnalyzeMode) {
1746           if (appData.noChessProgram) {
1747             DisplayFatalError(_("Analysis mode requires a chess engine"), 0, 2);
1748             return;
1749           }
1750           if (appData.icsActive) {
1751             DisplayFatalError(_("Analysis mode does not work with ICS mode"),0,2);
1752             return;
1753           }
1754           AnalyzeModeEvent();
1755         } else if (initialMode == AnalyzeFile) {
1756           appData.showThinking = TRUE; // [HGM] thinking: moved out of ShowThinkingEvent
1757           ShowThinkingEvent();
1758           AnalyzeFileEvent();
1759           AnalysisPeriodicEvent(1);
1760         } else if (initialMode == MachinePlaysWhite) {
1761           if (appData.noChessProgram) {
1762             DisplayFatalError(_("MachineWhite mode requires a chess engine"),
1763                               0, 2);
1764             return;
1765           }
1766           if (appData.icsActive) {
1767             DisplayFatalError(_("MachineWhite mode does not work with ICS mode"),
1768                               0, 2);
1769             return;
1770           }
1771           MachineWhiteEvent();
1772         } else if (initialMode == MachinePlaysBlack) {
1773           if (appData.noChessProgram) {
1774             DisplayFatalError(_("MachineBlack mode requires a chess engine"),
1775                               0, 2);
1776             return;
1777           }
1778           if (appData.icsActive) {
1779             DisplayFatalError(_("MachineBlack mode does not work with ICS mode"),
1780                               0, 2);
1781             return;
1782           }
1783           MachineBlackEvent();
1784         } else if (initialMode == TwoMachinesPlay) {
1785           if (appData.noChessProgram) {
1786             DisplayFatalError(_("TwoMachines mode requires a chess engine"),
1787                               0, 2);
1788             return;
1789           }
1790           if (appData.icsActive) {
1791             DisplayFatalError(_("TwoMachines mode does not work with ICS mode"),
1792                               0, 2);
1793             return;
1794           }
1795           TwoMachinesEvent();
1796         } else if (initialMode == EditGame) {
1797           EditGameEvent();
1798         } else if (initialMode == EditPosition) {
1799           EditPositionEvent();
1800         } else if (initialMode == Training) {
1801           if (*appData.loadGameFile == NULLCHAR) {
1802             DisplayFatalError(_("Training mode requires a game file"), 0, 2);
1803             return;
1804           }
1805           TrainingEvent();
1806         }
1807     }
1808 }
1809
1810 void
1811 HistorySet (char movelist[][2*MOVE_LEN], int first, int last, int current)
1812 {
1813     DisplayBook(current+1);
1814
1815     MoveHistorySet( movelist, first, last, current, pvInfoList );
1816
1817     EvalGraphSet( first, last, current, pvInfoList );
1818
1819     MakeEngineOutputTitle();
1820 }
1821
1822 /*
1823  * Establish will establish a contact to a remote host.port.
1824  * Sets icsPR to a ProcRef for a process (or pseudo-process)
1825  *  used to talk to the host.
1826  * Returns 0 if okay, error code if not.
1827  */
1828 int
1829 establish ()
1830 {
1831     char buf[MSG_SIZ];
1832
1833     if (*appData.icsCommPort != NULLCHAR) {
1834         /* Talk to the host through a serial comm port */
1835         return OpenCommPort(appData.icsCommPort, &icsPR);
1836
1837     } else if (*appData.gateway != NULLCHAR) {
1838         if (*appData.remoteShell == NULLCHAR) {
1839             /* Use the rcmd protocol to run telnet program on a gateway host */
1840             snprintf(buf, sizeof(buf), "%s %s %s",
1841                     appData.telnetProgram, appData.icsHost, appData.icsPort);
1842             return OpenRcmd(appData.gateway, appData.remoteUser, buf, &icsPR);
1843
1844         } else {
1845             /* Use the rsh program to run telnet program on a gateway host */
1846             if (*appData.remoteUser == NULLCHAR) {
1847                 snprintf(buf, sizeof(buf), "%s %s %s %s %s", appData.remoteShell,
1848                         appData.gateway, appData.telnetProgram,
1849                         appData.icsHost, appData.icsPort);
1850             } else {
1851                 snprintf(buf, sizeof(buf), "%s %s -l %s %s %s %s",
1852                         appData.remoteShell, appData.gateway,
1853                         appData.remoteUser, appData.telnetProgram,
1854                         appData.icsHost, appData.icsPort);
1855             }
1856             return StartChildProcess(buf, "", &icsPR);
1857
1858         }
1859     } else if (appData.useTelnet) {
1860         return OpenTelnet(appData.icsHost, appData.icsPort, &icsPR);
1861
1862     } else {
1863         /* TCP socket interface differs somewhat between
1864            Unix and NT; handle details in the front end.
1865            */
1866         return OpenTCP(appData.icsHost, appData.icsPort, &icsPR);
1867     }
1868 }
1869
1870 void
1871 EscapeExpand (char *p, char *q)
1872 {       // [HGM] initstring: routine to shape up string arguments
1873         while(*p++ = *q++) if(p[-1] == '\\')
1874             switch(*q++) {
1875                 case 'n': p[-1] = '\n'; break;
1876                 case 'r': p[-1] = '\r'; break;
1877                 case 't': p[-1] = '\t'; break;
1878                 case '\\': p[-1] = '\\'; break;
1879                 case 0: *p = 0; return;
1880                 default: p[-1] = q[-1]; break;
1881             }
1882 }
1883
1884 void
1885 show_bytes (FILE *fp, char *buf, int count)
1886 {
1887     while (count--) {
1888         if (*buf < 040 || *(unsigned char *) buf > 0177) {
1889             fprintf(fp, "\\%03o", *buf & 0xff);
1890         } else {
1891             putc(*buf, fp);
1892         }
1893         buf++;
1894     }
1895     fflush(fp);
1896 }
1897
1898 /* Returns an errno value */
1899 int
1900 OutputMaybeTelnet (ProcRef pr, char *message, int count, int *outError)
1901 {
1902     char buf[8192], *p, *q, *buflim;
1903     int left, newcount, outcount;
1904
1905     if (*appData.icsCommPort != NULLCHAR || appData.useTelnet ||
1906         *appData.gateway != NULLCHAR) {
1907         if (appData.debugMode) {
1908             fprintf(debugFP, ">ICS: ");
1909             show_bytes(debugFP, message, count);
1910             fprintf(debugFP, "\n");
1911         }
1912         return OutputToProcess(pr, message, count, outError);
1913     }
1914
1915     buflim = &buf[sizeof(buf)-1]; /* allow 1 byte for expanding last char */
1916     p = message;
1917     q = buf;
1918     left = count;
1919     newcount = 0;
1920     while (left) {
1921         if (q >= buflim) {
1922             if (appData.debugMode) {
1923                 fprintf(debugFP, ">ICS: ");
1924                 show_bytes(debugFP, buf, newcount);
1925                 fprintf(debugFP, "\n");
1926             }
1927             outcount = OutputToProcess(pr, buf, newcount, outError);
1928             if (outcount < newcount) return -1; /* to be sure */
1929             q = buf;
1930             newcount = 0;
1931         }
1932         if (*p == '\n') {
1933             *q++ = '\r';
1934             newcount++;
1935         } else if (((unsigned char) *p) == TN_IAC) {
1936             *q++ = (char) TN_IAC;
1937             newcount ++;
1938         }
1939         *q++ = *p++;
1940         newcount++;
1941         left--;
1942     }
1943     if (appData.debugMode) {
1944         fprintf(debugFP, ">ICS: ");
1945         show_bytes(debugFP, buf, newcount);
1946         fprintf(debugFP, "\n");
1947     }
1948     outcount = OutputToProcess(pr, buf, newcount, outError);
1949     if (outcount < newcount) return -1; /* to be sure */
1950     return count;
1951 }
1952
1953 void
1954 read_from_player (InputSourceRef isr, VOIDSTAR closure, char *message, int count, int error)
1955 {
1956     int outError, outCount;
1957     static int gotEof = 0;
1958     static FILE *ini;
1959
1960     /* Pass data read from player on to ICS */
1961     if (count > 0) {
1962         gotEof = 0;
1963         outCount = OutputMaybeTelnet(icsPR, message, count, &outError);
1964         if (outCount < count) {
1965             DisplayFatalError(_("Error writing to ICS"), outError, 1);
1966         }
1967         if(have_sent_ICS_logon == 2) {
1968           if(ini = fopen(appData.icsLogon, "w")) { // save first two lines (presumably username & password) on init script file
1969             fprintf(ini, "%s", message);
1970             have_sent_ICS_logon = 3;
1971           } else
1972             have_sent_ICS_logon = 1;
1973         } else if(have_sent_ICS_logon == 3) {
1974             fprintf(ini, "%s", message);
1975             fclose(ini);
1976           have_sent_ICS_logon = 1;
1977         }
1978     } else if (count < 0) {
1979         RemoveInputSource(isr);
1980         DisplayFatalError(_("Error reading from keyboard"), error, 1);
1981     } else if (gotEof++ > 0) {
1982         RemoveInputSource(isr);
1983         DisplayFatalError(_("Got end of file from keyboard"), 0, 0);
1984     }
1985 }
1986
1987 void
1988 KeepAlive ()
1989 {   // [HGM] alive: periodically send dummy (date) command to ICS to prevent time-out
1990     if(!connectionAlive) DisplayFatalError("No response from ICS", 0, 1);
1991     connectionAlive = FALSE; // only sticks if no response to 'date' command.
1992     SendToICS("date\n");
1993     if(appData.keepAlive) ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
1994 }
1995
1996 /* added routine for printf style output to ics */
1997 void
1998 ics_printf (char *format, ...)
1999 {
2000     char buffer[MSG_SIZ];
2001     va_list args;
2002
2003     va_start(args, format);
2004     vsnprintf(buffer, sizeof(buffer), format, args);
2005     buffer[sizeof(buffer)-1] = '\0';
2006     SendToICS(buffer);
2007     va_end(args);
2008 }
2009
2010 void
2011 SendToICS (char *s)
2012 {
2013     int count, outCount, outError;
2014
2015     if (icsPR == NoProc) return;
2016
2017     count = strlen(s);
2018     outCount = OutputMaybeTelnet(icsPR, s, count, &outError);
2019     if (outCount < count) {
2020         DisplayFatalError(_("Error writing to ICS"), outError, 1);
2021     }
2022 }
2023
2024 /* This is used for sending logon scripts to the ICS. Sending
2025    without a delay causes problems when using timestamp on ICC
2026    (at least on my machine). */
2027 void
2028 SendToICSDelayed (char *s, long msdelay)
2029 {
2030     int count, outCount, outError;
2031
2032     if (icsPR == NoProc) return;
2033
2034     count = strlen(s);
2035     if (appData.debugMode) {
2036         fprintf(debugFP, ">ICS: ");
2037         show_bytes(debugFP, s, count);
2038         fprintf(debugFP, "\n");
2039     }
2040     outCount = OutputToProcessDelayed(icsPR, s, count, &outError,
2041                                       msdelay);
2042     if (outCount < count) {
2043         DisplayFatalError(_("Error writing to ICS"), outError, 1);
2044     }
2045 }
2046
2047
2048 /* Remove all highlighting escape sequences in s
2049    Also deletes any suffix starting with '('
2050    */
2051 char *
2052 StripHighlightAndTitle (char *s)
2053 {
2054     static char retbuf[MSG_SIZ];
2055     char *p = retbuf;
2056
2057     while (*s != NULLCHAR) {
2058         while (*s == '\033') {
2059             while (*s != NULLCHAR && !isalpha(*s)) s++;
2060             if (*s != NULLCHAR) s++;
2061         }
2062         while (*s != NULLCHAR && *s != '\033') {
2063             if (*s == '(' || *s == '[') {
2064                 *p = NULLCHAR;
2065                 return retbuf;
2066             }
2067             *p++ = *s++;
2068         }
2069     }
2070     *p = NULLCHAR;
2071     return retbuf;
2072 }
2073
2074 /* Remove all highlighting escape sequences in s */
2075 char *
2076 StripHighlight (char *s)
2077 {
2078     static char retbuf[MSG_SIZ];
2079     char *p = retbuf;
2080
2081     while (*s != NULLCHAR) {
2082         while (*s == '\033') {
2083             while (*s != NULLCHAR && !isalpha(*s)) s++;
2084             if (*s != NULLCHAR) s++;
2085         }
2086         while (*s != NULLCHAR && *s != '\033') {
2087             *p++ = *s++;
2088         }
2089     }
2090     *p = NULLCHAR;
2091     return retbuf;
2092 }
2093
2094 char engineVariant[MSG_SIZ];
2095 char *variantNames[] = VARIANT_NAMES;
2096 char *
2097 VariantName (VariantClass v)
2098 {
2099     if(v == VariantUnknown || *engineVariant) return engineVariant;
2100     return variantNames[v];
2101 }
2102
2103
2104 /* Identify a variant from the strings the chess servers use or the
2105    PGN Variant tag names we use. */
2106 VariantClass
2107 StringToVariant (char *e)
2108 {
2109     char *p;
2110     int wnum = -1;
2111     VariantClass v = VariantNormal;
2112     int i, found = FALSE;
2113     char buf[MSG_SIZ], c;
2114     int len;
2115
2116     if (!e) return v;
2117
2118     /* [HGM] skip over optional board-size prefixes */
2119     if( sscanf(e, "%dx%d_%c", &i, &i, &c) == 3 ||
2120         sscanf(e, "%dx%d+%d_%c", &i, &i, &i, &c) == 4 ) {
2121         while( *e++ != '_');
2122     }
2123
2124     if(StrCaseStr(e, "misc/")) { // [HGM] on FICS, misc/shogi is not shogi
2125         v = VariantNormal;
2126         found = TRUE;
2127     } else
2128     for (i=0; i<sizeof(variantNames)/sizeof(char*); i++) {
2129       if (p = StrCaseStr(e, variantNames[i])) {
2130         if(p && i >= VariantShogi && (p != e || isalpha(p[strlen(variantNames[i])]))) continue;
2131         v = (VariantClass) i;
2132         found = TRUE;
2133         break;
2134       }
2135     }
2136
2137     if (!found) {
2138       if ((StrCaseStr(e, "fischer") && StrCaseStr(e, "random"))
2139           || StrCaseStr(e, "wild/fr")
2140           || StrCaseStr(e, "frc") || StrCaseStr(e, "960")) {
2141         v = VariantFischeRandom;
2142       } else if ((i = 4, p = StrCaseStr(e, "wild")) ||
2143                  (i = 1, p = StrCaseStr(e, "w"))) {
2144         p += i;
2145         while (*p && (isspace(*p) || *p == '(' || *p == '/')) p++;
2146         if (isdigit(*p)) {
2147           wnum = atoi(p);
2148         } else {
2149           wnum = -1;
2150         }
2151         switch (wnum) {
2152         case 0: /* FICS only, actually */
2153         case 1:
2154           /* Castling legal even if K starts on d-file */
2155           v = VariantWildCastle;
2156           break;
2157         case 2:
2158         case 3:
2159         case 4:
2160           /* Castling illegal even if K & R happen to start in
2161              normal positions. */
2162           v = VariantNoCastle;
2163           break;
2164         case 5:
2165         case 7:
2166         case 8:
2167         case 10:
2168         case 11:
2169         case 12:
2170         case 13:
2171         case 14:
2172         case 15:
2173         case 18:
2174         case 19:
2175           /* Castling legal iff K & R start in normal positions */
2176           v = VariantNormal;
2177           break;
2178         case 6:
2179         case 20:
2180         case 21:
2181           /* Special wilds for position setup; unclear what to do here */
2182           v = VariantLoadable;
2183           break;
2184         case 9:
2185           /* Bizarre ICC game */
2186           v = VariantTwoKings;
2187           break;
2188         case 16:
2189           v = VariantKriegspiel;
2190           break;
2191         case 17:
2192           v = VariantLosers;
2193           break;
2194         case 22:
2195           v = VariantFischeRandom;
2196           break;
2197         case 23:
2198           v = VariantCrazyhouse;
2199           break;
2200         case 24:
2201           v = VariantBughouse;
2202           break;
2203         case 25:
2204           v = Variant3Check;
2205           break;
2206         case 26:
2207           /* Not quite the same as FICS suicide! */
2208           v = VariantGiveaway;
2209           break;
2210         case 27:
2211           v = VariantAtomic;
2212           break;
2213         case 28:
2214           v = VariantShatranj;
2215           break;
2216
2217         /* Temporary names for future ICC types.  The name *will* change in
2218            the next xboard/WinBoard release after ICC defines it. */
2219         case 29:
2220           v = Variant29;
2221           break;
2222         case 30:
2223           v = Variant30;
2224           break;
2225         case 31:
2226           v = Variant31;
2227           break;
2228         case 32:
2229           v = Variant32;
2230           break;
2231         case 33:
2232           v = Variant33;
2233           break;
2234         case 34:
2235           v = Variant34;
2236           break;
2237         case 35:
2238           v = Variant35;
2239           break;
2240         case 36:
2241           v = Variant36;
2242           break;
2243         case 37:
2244           v = VariantShogi;
2245           break;
2246         case 38:
2247           v = VariantXiangqi;
2248           break;
2249         case 39:
2250           v = VariantCourier;
2251           break;
2252         case 40:
2253           v = VariantGothic;
2254           break;
2255         case 41:
2256           v = VariantCapablanca;
2257           break;
2258         case 42:
2259           v = VariantKnightmate;
2260           break;
2261         case 43:
2262           v = VariantFairy;
2263           break;
2264         case 44:
2265           v = VariantCylinder;
2266           break;
2267         case 45:
2268           v = VariantFalcon;
2269           break;
2270         case 46:
2271           v = VariantCapaRandom;
2272           break;
2273         case 47:
2274           v = VariantBerolina;
2275           break;
2276         case 48:
2277           v = VariantJanus;
2278           break;
2279         case 49:
2280           v = VariantSuper;
2281           break;
2282         case 50:
2283           v = VariantGreat;
2284           break;
2285         case -1:
2286           /* Found "wild" or "w" in the string but no number;
2287              must assume it's normal chess. */
2288           v = VariantNormal;
2289           break;
2290         default:
2291           len = snprintf(buf, MSG_SIZ, _("Unknown wild type %d"), wnum);
2292           if( (len >= MSG_SIZ) && appData.debugMode )
2293             fprintf(debugFP, "StringToVariant: buffer truncated.\n");
2294
2295           DisplayError(buf, 0);
2296           v = VariantUnknown;
2297           break;
2298         }
2299       }
2300     }
2301     if (appData.debugMode) {
2302       fprintf(debugFP, "recognized '%s' (%d) as variant %s\n",
2303               e, wnum, VariantName(v));
2304     }
2305     return v;
2306 }
2307
2308 static int leftover_start = 0, leftover_len = 0;
2309 char star_match[STAR_MATCH_N][MSG_SIZ];
2310
2311 /* Test whether pattern is present at &buf[*index]; if so, return TRUE,
2312    advance *index beyond it, and set leftover_start to the new value of
2313    *index; else return FALSE.  If pattern contains the character '*', it
2314    matches any sequence of characters not containing '\r', '\n', or the
2315    character following the '*' (if any), and the matched sequence(s) are
2316    copied into star_match.
2317    */
2318 int
2319 looking_at ( char *buf, int *index, char *pattern)
2320 {
2321     char *bufp = &buf[*index], *patternp = pattern;
2322     int star_count = 0;
2323     char *matchp = star_match[0];
2324
2325     for (;;) {
2326         if (*patternp == NULLCHAR) {
2327             *index = leftover_start = bufp - buf;
2328             *matchp = NULLCHAR;
2329             return TRUE;
2330         }
2331         if (*bufp == NULLCHAR) return FALSE;
2332         if (*patternp == '*') {
2333             if (*bufp == *(patternp + 1)) {
2334                 *matchp = NULLCHAR;
2335                 matchp = star_match[++star_count];
2336                 patternp += 2;
2337                 bufp++;
2338                 continue;
2339             } else if (*bufp == '\n' || *bufp == '\r') {
2340                 patternp++;
2341                 if (*patternp == NULLCHAR)
2342                   continue;
2343                 else
2344                   return FALSE;
2345             } else {
2346                 *matchp++ = *bufp++;
2347                 continue;
2348             }
2349         }
2350         if (*patternp != *bufp) return FALSE;
2351         patternp++;
2352         bufp++;
2353     }
2354 }
2355
2356 void
2357 SendToPlayer (char *data, int length)
2358 {
2359     int error, outCount;
2360     outCount = OutputToProcess(NoProc, data, length, &error);
2361     if (outCount < length) {
2362         DisplayFatalError(_("Error writing to display"), error, 1);
2363     }
2364 }
2365
2366 void
2367 PackHolding (char packed[], char *holding)
2368 {
2369     char *p = holding;
2370     char *q = packed;
2371     int runlength = 0;
2372     int curr = 9999;
2373     do {
2374         if (*p == curr) {
2375             runlength++;
2376         } else {
2377             switch (runlength) {
2378               case 0:
2379                 break;
2380               case 1:
2381                 *q++ = curr;
2382                 break;
2383               case 2:
2384                 *q++ = curr;
2385                 *q++ = curr;
2386                 break;
2387               default:
2388                 sprintf(q, "%d", runlength);
2389                 while (*q) q++;
2390                 *q++ = curr;
2391                 break;
2392             }
2393             runlength = 1;
2394             curr = *p;
2395         }
2396     } while (*p++);
2397     *q = NULLCHAR;
2398 }
2399
2400 /* Telnet protocol requests from the front end */
2401 void
2402 TelnetRequest (unsigned char ddww, unsigned char option)
2403 {
2404     unsigned char msg[3];
2405     int outCount, outError;
2406
2407     if (*appData.icsCommPort != NULLCHAR || appData.useTelnet) return;
2408
2409     if (appData.debugMode) {
2410         char buf1[8], buf2[8], *ddwwStr, *optionStr;
2411         switch (ddww) {
2412           case TN_DO:
2413             ddwwStr = "DO";
2414             break;
2415           case TN_DONT:
2416             ddwwStr = "DONT";
2417             break;
2418           case TN_WILL:
2419             ddwwStr = "WILL";
2420             break;
2421           case TN_WONT:
2422             ddwwStr = "WONT";
2423             break;
2424           default:
2425             ddwwStr = buf1;
2426             snprintf(buf1,sizeof(buf1)/sizeof(buf1[0]), "%d", ddww);
2427             break;
2428         }
2429         switch (option) {
2430           case TN_ECHO:
2431             optionStr = "ECHO";
2432             break;
2433           default:
2434             optionStr = buf2;
2435             snprintf(buf2,sizeof(buf2)/sizeof(buf2[0]), "%d", option);
2436             break;
2437         }
2438         fprintf(debugFP, ">%s %s ", ddwwStr, optionStr);
2439     }
2440     msg[0] = TN_IAC;
2441     msg[1] = ddww;
2442     msg[2] = option;
2443     outCount = OutputToProcess(icsPR, (char *)msg, 3, &outError);
2444     if (outCount < 3) {
2445         DisplayFatalError(_("Error writing to ICS"), outError, 1);
2446     }
2447 }
2448
2449 void
2450 DoEcho ()
2451 {
2452     if (!appData.icsActive) return;
2453     TelnetRequest(TN_DO, TN_ECHO);
2454 }
2455
2456 void
2457 DontEcho ()
2458 {
2459     if (!appData.icsActive) return;
2460     TelnetRequest(TN_DONT, TN_ECHO);
2461 }
2462
2463 void
2464 CopyHoldings (Board board, char *holdings, ChessSquare lowestPiece)
2465 {
2466     /* put the holdings sent to us by the server on the board holdings area */
2467     int i, j, holdingsColumn, holdingsStartRow, direction, countsColumn;
2468     char p;
2469     ChessSquare piece;
2470
2471     if(gameInfo.holdingsWidth < 2)  return;
2472     if(gameInfo.variant != VariantBughouse && board[HOLDINGS_SET])
2473         return; // prevent overwriting by pre-board holdings
2474
2475     if( (int)lowestPiece >= BlackPawn ) {
2476         holdingsColumn = 0;
2477         countsColumn = 1;
2478         holdingsStartRow = BOARD_HEIGHT-1;
2479         direction = -1;
2480     } else {
2481         holdingsColumn = BOARD_WIDTH-1;
2482         countsColumn = BOARD_WIDTH-2;
2483         holdingsStartRow = 0;
2484         direction = 1;
2485     }
2486
2487     for(i=0; i<BOARD_HEIGHT; i++) { /* clear holdings */
2488         board[i][holdingsColumn] = EmptySquare;
2489         board[i][countsColumn]   = (ChessSquare) 0;
2490     }
2491     while( (p=*holdings++) != NULLCHAR ) {
2492         piece = CharToPiece( ToUpper(p) );
2493         if(piece == EmptySquare) continue;
2494         /*j = (int) piece - (int) WhitePawn;*/
2495         j = PieceToNumber(piece);
2496         if(j >= gameInfo.holdingsSize) continue; /* ignore pieces that do not fit */
2497         if(j < 0) continue;               /* should not happen */
2498         piece = (ChessSquare) ( (int)piece + (int)lowestPiece );
2499         board[holdingsStartRow+j*direction][holdingsColumn] = piece;
2500         board[holdingsStartRow+j*direction][countsColumn]++;
2501     }
2502 }
2503
2504
2505 void
2506 VariantSwitch (Board board, VariantClass newVariant)
2507 {
2508    int newHoldingsWidth, newWidth = 8, newHeight = 8, i, j;
2509    static Board oldBoard;
2510
2511    startedFromPositionFile = FALSE;
2512    if(gameInfo.variant == newVariant) return;
2513
2514    /* [HGM] This routine is called each time an assignment is made to
2515     * gameInfo.variant during a game, to make sure the board sizes
2516     * are set to match the new variant. If that means adding or deleting
2517     * holdings, we shift the playing board accordingly
2518     * This kludge is needed because in ICS observe mode, we get boards
2519     * of an ongoing game without knowing the variant, and learn about the
2520     * latter only later. This can be because of the move list we requested,
2521     * in which case the game history is refilled from the beginning anyway,
2522     * but also when receiving holdings of a crazyhouse game. In the latter
2523     * case we want to add those holdings to the already received position.
2524     */
2525
2526
2527    if (appData.debugMode) {
2528      fprintf(debugFP, "Switch board from %s to %s\n",
2529              VariantName(gameInfo.variant), VariantName(newVariant));
2530      setbuf(debugFP, NULL);
2531    }
2532    shuffleOpenings = 0;       /* [HGM] shuffle */
2533    gameInfo.holdingsSize = 5; /* [HGM] prepare holdings */
2534    switch(newVariant)
2535      {
2536      case VariantShogi:
2537        newWidth = 9;  newHeight = 9;
2538        gameInfo.holdingsSize = 7;
2539      case VariantBughouse:
2540      case VariantCrazyhouse:
2541        newHoldingsWidth = 2; break;
2542      case VariantGreat:
2543        newWidth = 10;
2544      case VariantSuper:
2545        newHoldingsWidth = 2;
2546        gameInfo.holdingsSize = 8;
2547        break;
2548      case VariantGothic:
2549      case VariantCapablanca:
2550      case VariantCapaRandom:
2551        newWidth = 10;
2552      default:
2553        newHoldingsWidth = gameInfo.holdingsSize = 0;
2554      };
2555
2556    if(newWidth  != gameInfo.boardWidth  ||
2557       newHeight != gameInfo.boardHeight ||
2558       newHoldingsWidth != gameInfo.holdingsWidth ) {
2559
2560      /* shift position to new playing area, if needed */
2561      if(newHoldingsWidth > gameInfo.holdingsWidth) {
2562        for(i=0; i<BOARD_HEIGHT; i++)
2563          for(j=BOARD_RGHT-1; j>=BOARD_LEFT; j--)
2564            board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
2565              board[i][j];
2566        for(i=0; i<newHeight; i++) {
2567          board[i][0] = board[i][newWidth+2*newHoldingsWidth-1] = EmptySquare;
2568          board[i][1] = board[i][newWidth+2*newHoldingsWidth-2] = (ChessSquare) 0;
2569        }
2570      } else if(newHoldingsWidth < gameInfo.holdingsWidth) {
2571        for(i=0; i<BOARD_HEIGHT; i++)
2572          for(j=BOARD_LEFT; j<BOARD_RGHT; j++)
2573            board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
2574              board[i][j];
2575      }
2576      board[HOLDINGS_SET] = 0;
2577      gameInfo.boardWidth  = newWidth;
2578      gameInfo.boardHeight = newHeight;
2579      gameInfo.holdingsWidth = newHoldingsWidth;
2580      gameInfo.variant = newVariant;
2581      InitDrawingSizes(-2, 0);
2582    } else gameInfo.variant = newVariant;
2583    CopyBoard(oldBoard, board);   // remember correctly formatted board
2584      InitPosition(FALSE);          /* this sets up board[0], but also other stuff        */
2585    DrawPosition(TRUE, currentMove ? boards[currentMove] : oldBoard);
2586 }
2587
2588 static int loggedOn = FALSE;
2589
2590 /*-- Game start info cache: --*/
2591 int gs_gamenum;
2592 char gs_kind[MSG_SIZ];
2593 static char player1Name[128] = "";
2594 static char player2Name[128] = "";
2595 static char cont_seq[] = "\n\\   ";
2596 static int player1Rating = -1;
2597 static int player2Rating = -1;
2598 /*----------------------------*/
2599
2600 ColorClass curColor = ColorNormal;
2601 int suppressKibitz = 0;
2602
2603 // [HGM] seekgraph
2604 Boolean soughtPending = FALSE;
2605 Boolean seekGraphUp;
2606 #define MAX_SEEK_ADS 200
2607 #define SQUARE 0x80
2608 char *seekAdList[MAX_SEEK_ADS];
2609 int ratingList[MAX_SEEK_ADS], xList[MAX_SEEK_ADS], yList[MAX_SEEK_ADS], seekNrList[MAX_SEEK_ADS], zList[MAX_SEEK_ADS];
2610 float tcList[MAX_SEEK_ADS];
2611 char colorList[MAX_SEEK_ADS];
2612 int nrOfSeekAds = 0;
2613 int minRating = 1010, maxRating = 2800;
2614 int hMargin = 10, vMargin = 20, h, w;
2615 extern int squareSize, lineGap;
2616
2617 void
2618 PlotSeekAd (int i)
2619 {
2620         int x, y, color = 0, r = ratingList[i]; float tc = tcList[i];
2621         xList[i] = yList[i] = -100; // outside graph, so cannot be clicked
2622         if(r < minRating+100 && r >=0 ) r = minRating+100;
2623         if(r > maxRating) r = maxRating;
2624         if(tc < 1.f) tc = 1.f;
2625         if(tc > 95.f) tc = 95.f;
2626         x = (w-hMargin-squareSize/8-7)* log(tc)/log(95.) + hMargin;
2627         y = ((double)r - minRating)/(maxRating - minRating)
2628             * (h-vMargin-squareSize/8-1) + vMargin;
2629         if(ratingList[i] < 0) y = vMargin + squareSize/4;
2630         if(strstr(seekAdList[i], " u ")) color = 1;
2631         if(!strstr(seekAdList[i], "lightning") && // for now all wilds same color
2632            !strstr(seekAdList[i], "bullet") &&
2633            !strstr(seekAdList[i], "blitz") &&
2634            !strstr(seekAdList[i], "standard") ) color = 2;
2635         if(strstr(seekAdList[i], "(C) ")) color |= SQUARE; // plot computer seeks as squares
2636         DrawSeekDot(xList[i]=x+3*(color&~SQUARE), yList[i]=h-1-y, colorList[i]=color);
2637 }
2638
2639 void
2640 PlotSingleSeekAd (int i)
2641 {
2642         PlotSeekAd(i);
2643 }
2644
2645 void
2646 AddAd (char *handle, char *rating, int base, int inc,  char rated, char *type, int nr, Boolean plot)
2647 {
2648         char buf[MSG_SIZ], *ext = "";
2649         VariantClass v = StringToVariant(type);
2650         if(strstr(type, "wild")) {
2651             ext = type + 4; // append wild number
2652             if(v == VariantFischeRandom) type = "chess960"; else
2653             if(v == VariantLoadable) type = "setup"; else
2654             type = VariantName(v);
2655         }
2656         snprintf(buf, MSG_SIZ, "%s (%s) %d %d %c %s%s", handle, rating, base, inc, rated, type, ext);
2657         if(nrOfSeekAds < MAX_SEEK_ADS-1) {
2658             if(seekAdList[nrOfSeekAds]) free(seekAdList[nrOfSeekAds]);
2659             ratingList[nrOfSeekAds] = -1; // for if seeker has no rating
2660             sscanf(rating, "%d", &ratingList[nrOfSeekAds]);
2661             tcList[nrOfSeekAds] = base + (2./3.)*inc;
2662             seekNrList[nrOfSeekAds] = nr;
2663             zList[nrOfSeekAds] = 0;
2664             seekAdList[nrOfSeekAds++] = StrSave(buf);
2665             if(plot) PlotSingleSeekAd(nrOfSeekAds-1);
2666         }
2667 }
2668
2669 void
2670 EraseSeekDot (int i)
2671 {
2672     int x = xList[i], y = yList[i], d=squareSize/4, k;
2673     DrawSeekBackground(x-squareSize/8, y-squareSize/8, x+squareSize/8+1, y+squareSize/8+1);
2674     if(x < hMargin+d) DrawSeekAxis(hMargin, y-squareSize/8, hMargin, y+squareSize/8+1);
2675     // now replot every dot that overlapped
2676     for(k=0; k<nrOfSeekAds; k++) if(k != i) {
2677         int xx = xList[k], yy = yList[k];
2678         if(xx <= x+d && xx > x-d && yy <= y+d && yy > y-d)
2679             DrawSeekDot(xx, yy, colorList[k]);
2680     }
2681 }
2682
2683 void
2684 RemoveSeekAd (int nr)
2685 {
2686         int i;
2687         for(i=0; i<nrOfSeekAds; i++) if(seekNrList[i] == nr) {
2688             EraseSeekDot(i);
2689             if(seekAdList[i]) free(seekAdList[i]);
2690             seekAdList[i] = seekAdList[--nrOfSeekAds];
2691             seekNrList[i] = seekNrList[nrOfSeekAds];
2692             ratingList[i] = ratingList[nrOfSeekAds];
2693             colorList[i]  = colorList[nrOfSeekAds];
2694             tcList[i] = tcList[nrOfSeekAds];
2695             xList[i]  = xList[nrOfSeekAds];
2696             yList[i]  = yList[nrOfSeekAds];
2697             zList[i]  = zList[nrOfSeekAds];
2698             seekAdList[nrOfSeekAds] = NULL;
2699             break;
2700         }
2701 }
2702
2703 Boolean
2704 MatchSoughtLine (char *line)
2705 {
2706     char handle[MSG_SIZ], rating[MSG_SIZ], type[MSG_SIZ];
2707     int nr, base, inc, u=0; char dummy;
2708
2709     if(sscanf(line, "%d %s %s %d %d rated %s", &nr, rating, handle, &base, &inc, type) == 6 ||
2710        sscanf(line, "%d %s %s %s %d %d rated %c", &nr, rating, handle, type, &base, &inc, &dummy) == 7 ||
2711        (u=1) &&
2712        (sscanf(line, "%d %s %s %d %d unrated %s", &nr, rating, handle, &base, &inc, type) == 6 ||
2713         sscanf(line, "%d %s %s %s %d %d unrated %c", &nr, rating, handle, type, &base, &inc, &dummy) == 7)  ) {
2714         // match: compact and save the line
2715         AddAd(handle, rating, base, inc, u ? 'u' : 'r', type, nr, FALSE);
2716         return TRUE;
2717     }
2718     return FALSE;
2719 }
2720
2721 int
2722 DrawSeekGraph ()
2723 {
2724     int i;
2725     if(!seekGraphUp) return FALSE;
2726     h = BOARD_HEIGHT * (squareSize + lineGap) + lineGap + 2*border;
2727     w = BOARD_WIDTH  * (squareSize + lineGap) + lineGap + 2*border;
2728
2729     DrawSeekBackground(0, 0, w, h);
2730     DrawSeekAxis(hMargin, h-1-vMargin, w-5, h-1-vMargin);
2731     DrawSeekAxis(hMargin, h-1-vMargin, hMargin, 5);
2732     for(i=0; i<4000; i+= 100) if(i>=minRating && i<maxRating) {
2733         int yy =((double)i - minRating)/(maxRating - minRating)*(h-vMargin-squareSize/8-1) + vMargin;
2734         yy = h-1-yy;
2735         DrawSeekAxis(hMargin-5, yy, hMargin+5*(i%500==0), yy); // rating ticks
2736         if(i%500 == 0) {
2737             char buf[MSG_SIZ];
2738             snprintf(buf, MSG_SIZ, "%d", i);
2739             DrawSeekText(buf, hMargin+squareSize/8+7, yy);
2740         }
2741     }
2742     DrawSeekText("unrated", hMargin+squareSize/8+7, h-1-vMargin-squareSize/4);
2743     for(i=1; i<100; i+=(i<10?1:5)) {
2744         int xx = (w-hMargin-squareSize/8-7)* log((double)i)/log(95.) + hMargin;
2745         DrawSeekAxis(xx, h-1-vMargin, xx, h-6-vMargin-3*(i%10==0)); // TC ticks
2746         if(i<=5 || (i>40 ? i%20 : i%10) == 0) {
2747             char buf[MSG_SIZ];
2748             snprintf(buf, MSG_SIZ, "%d", i);
2749             DrawSeekText(buf, xx-2-3*(i>9), h-1-vMargin/2);
2750         }
2751     }
2752     for(i=0; i<nrOfSeekAds; i++) PlotSeekAd(i);
2753     return TRUE;
2754 }
2755
2756 int
2757 SeekGraphClick (ClickType click, int x, int y, int moving)
2758 {
2759     static int lastDown = 0, displayed = 0, lastSecond;
2760     if(y < 0) return FALSE;
2761     if(!(appData.seekGraph && appData.icsActive && loggedOn &&
2762         (gameMode == BeginningOfGame || gameMode == IcsIdle))) {
2763         if(!seekGraphUp) return FALSE;
2764         seekGraphUp = FALSE; // seek graph is up when it shouldn't be: take it down
2765         DrawPosition(TRUE, NULL);
2766         return TRUE;
2767     }
2768     if(!seekGraphUp) { // initiate cration of seek graph by requesting seek-ad list
2769         if(click == Release || moving) return FALSE;
2770         nrOfSeekAds = 0;
2771         soughtPending = TRUE;
2772         SendToICS(ics_prefix);
2773         SendToICS("sought\n"); // should this be "sought all"?
2774     } else { // issue challenge based on clicked ad
2775         int dist = 10000; int i, closest = 0, second = 0;
2776         for(i=0; i<nrOfSeekAds; i++) {
2777             int d = (x-xList[i])*(x-xList[i]) +  (y-yList[i])*(y-yList[i]) + zList[i];
2778             if(d < dist) { dist = d; closest = i; }
2779             second += (d - zList[i] < 120); // count in-range ads
2780             if(click == Press && moving != 1 && zList[i]>0) zList[i] *= 0.8; // age priority
2781         }
2782         if(dist < 120) {
2783             char buf[MSG_SIZ];
2784             second = (second > 1);
2785             if(displayed != closest || second != lastSecond) {
2786                 DisplayMessage(second ? "!" : "", seekAdList[closest]);
2787                 lastSecond = second; displayed = closest;
2788             }
2789             if(click == Press) {
2790                 if(moving == 2) zList[closest] = 100; // right-click; push to back on press
2791                 lastDown = closest;
2792                 return TRUE;
2793             } // on press 'hit', only show info
2794             if(moving == 2) return TRUE; // ignore right up-clicks on dot
2795             snprintf(buf, MSG_SIZ, "play %d\n", seekNrList[closest]);
2796             SendToICS(ics_prefix);
2797             SendToICS(buf);
2798             return TRUE; // let incoming board of started game pop down the graph
2799         } else if(click == Release) { // release 'miss' is ignored
2800             zList[lastDown] = 100; // make future selection of the rejected ad more difficult
2801             if(moving == 2) { // right up-click
2802                 nrOfSeekAds = 0; // refresh graph
2803                 soughtPending = TRUE;
2804                 SendToICS(ics_prefix);
2805                 SendToICS("sought\n"); // should this be "sought all"?
2806             }
2807             return TRUE;
2808         } else if(moving) { if(displayed >= 0) DisplayMessage("", ""); displayed = -1; return TRUE; }
2809         // press miss or release hit 'pop down' seek graph
2810         seekGraphUp = FALSE;
2811         DrawPosition(TRUE, NULL);
2812     }
2813     return TRUE;
2814 }
2815
2816 void
2817 read_from_ics (InputSourceRef isr, VOIDSTAR closure, char *data, int count, int error)
2818 {
2819 #define BUF_SIZE (16*1024) /* overflowed at 8K with "inchannel 1" on FICS? */
2820 #define STARTED_NONE 0
2821 #define STARTED_MOVES 1
2822 #define STARTED_BOARD 2
2823 #define STARTED_OBSERVE 3
2824 #define STARTED_HOLDINGS 4
2825 #define STARTED_CHATTER 5
2826 #define STARTED_COMMENT 6
2827 #define STARTED_MOVES_NOHIDE 7
2828
2829     static int started = STARTED_NONE;
2830     static char parse[20000];
2831     static int parse_pos = 0;
2832     static char buf[BUF_SIZE + 1];
2833     static int firstTime = TRUE, intfSet = FALSE;
2834     static ColorClass prevColor = ColorNormal;
2835     static int savingComment = FALSE;
2836     static int cmatch = 0; // continuation sequence match
2837     char *bp;
2838     char str[MSG_SIZ];
2839     int i, oldi;
2840     int buf_len;
2841     int next_out;
2842     int tkind;
2843     int backup;    /* [DM] For zippy color lines */
2844     char *p;
2845     char talker[MSG_SIZ]; // [HGM] chat
2846     int channel, collective=0;
2847
2848     connectionAlive = TRUE; // [HGM] alive: I think, therefore I am...
2849
2850     if (appData.debugMode) {
2851       if (!error) {
2852         fprintf(debugFP, "<ICS: ");
2853         show_bytes(debugFP, data, count);
2854         fprintf(debugFP, "\n");
2855       }
2856     }
2857
2858     if (appData.debugMode) { int f = forwardMostMove;
2859         fprintf(debugFP, "ics input %d, castling = %d %d %d %d %d %d\n", f,
2860                 boards[f][CASTLING][0],boards[f][CASTLING][1],boards[f][CASTLING][2],
2861                 boards[f][CASTLING][3],boards[f][CASTLING][4],boards[f][CASTLING][5]);
2862     }
2863     if (count > 0) {
2864         /* If last read ended with a partial line that we couldn't parse,
2865            prepend it to the new read and try again. */
2866         if (leftover_len > 0) {
2867             for (i=0; i<leftover_len; i++)
2868               buf[i] = buf[leftover_start + i];
2869         }
2870
2871     /* copy new characters into the buffer */
2872     bp = buf + leftover_len;
2873     buf_len=leftover_len;
2874     for (i=0; i<count; i++)
2875     {
2876         // ignore these
2877         if (data[i] == '\r')
2878             continue;
2879
2880         // join lines split by ICS?
2881         if (!appData.noJoin)
2882         {
2883             /*
2884                 Joining just consists of finding matches against the
2885                 continuation sequence, and discarding that sequence
2886                 if found instead of copying it.  So, until a match
2887                 fails, there's nothing to do since it might be the
2888                 complete sequence, and thus, something we don't want
2889                 copied.
2890             */
2891             if (data[i] == cont_seq[cmatch])
2892             {
2893                 cmatch++;
2894                 if (cmatch == strlen(cont_seq))
2895                 {
2896                     cmatch = 0; // complete match.  just reset the counter
2897
2898                     /*
2899                         it's possible for the ICS to not include the space
2900                         at the end of the last word, making our [correct]
2901                         join operation fuse two separate words.  the server
2902                         does this when the space occurs at the width setting.
2903                     */
2904                     if (!buf_len || buf[buf_len-1] != ' ')
2905                     {
2906                         *bp++ = ' ';
2907                         buf_len++;
2908                     }
2909                 }
2910                 continue;
2911             }
2912             else if (cmatch)
2913             {
2914                 /*
2915                     match failed, so we have to copy what matched before
2916                     falling through and copying this character.  In reality,
2917                     this will only ever be just the newline character, but
2918                     it doesn't hurt to be precise.
2919                 */
2920                 strncpy(bp, cont_seq, cmatch);
2921                 bp += cmatch;
2922                 buf_len += cmatch;
2923                 cmatch = 0;
2924             }
2925         }
2926
2927         // copy this char
2928         *bp++ = data[i];
2929         buf_len++;
2930     }
2931
2932         buf[buf_len] = NULLCHAR;
2933 //      next_out = leftover_len; // [HGM] should we set this to 0, and not print it in advance?
2934         next_out = 0;
2935         leftover_start = 0;
2936
2937         i = 0;
2938         while (i < buf_len) {
2939             /* Deal with part of the TELNET option negotiation
2940                protocol.  We refuse to do anything beyond the
2941                defaults, except that we allow the WILL ECHO option,
2942                which ICS uses to turn off password echoing when we are
2943                directly connected to it.  We reject this option
2944                if localLineEditing mode is on (always on in xboard)
2945                and we are talking to port 23, which might be a real
2946                telnet server that will try to keep WILL ECHO on permanently.
2947              */
2948             if (buf_len - i >= 3 && (unsigned char) buf[i] == TN_IAC) {
2949                 static int remoteEchoOption = FALSE; /* telnet ECHO option */
2950                 unsigned char option;
2951                 oldi = i;
2952                 switch ((unsigned char) buf[++i]) {
2953                   case TN_WILL:
2954                     if (appData.debugMode)
2955                       fprintf(debugFP, "\n<WILL ");
2956                     switch (option = (unsigned char) buf[++i]) {
2957                       case TN_ECHO:
2958                         if (appData.debugMode)
2959                           fprintf(debugFP, "ECHO ");
2960                         /* Reply only if this is a change, according
2961                            to the protocol rules. */
2962                         if (remoteEchoOption) break;
2963                         if (appData.localLineEditing &&
2964                             atoi(appData.icsPort) == TN_PORT) {
2965                             TelnetRequest(TN_DONT, TN_ECHO);
2966                         } else {
2967                             EchoOff();
2968                             TelnetRequest(TN_DO, TN_ECHO);
2969                             remoteEchoOption = TRUE;
2970                         }
2971                         break;
2972                       default:
2973                         if (appData.debugMode)
2974                           fprintf(debugFP, "%d ", option);
2975                         /* Whatever this is, we don't want it. */
2976                         TelnetRequest(TN_DONT, option);
2977                         break;
2978                     }
2979                     break;
2980                   case TN_WONT:
2981                     if (appData.debugMode)
2982                       fprintf(debugFP, "\n<WONT ");
2983                     switch (option = (unsigned char) buf[++i]) {
2984                       case TN_ECHO:
2985                         if (appData.debugMode)
2986                           fprintf(debugFP, "ECHO ");
2987                         /* Reply only if this is a change, according
2988                            to the protocol rules. */
2989                         if (!remoteEchoOption) break;
2990                         EchoOn();
2991                         TelnetRequest(TN_DONT, TN_ECHO);
2992                         remoteEchoOption = FALSE;
2993                         break;
2994                       default:
2995                         if (appData.debugMode)
2996                           fprintf(debugFP, "%d ", (unsigned char) option);
2997                         /* Whatever this is, it must already be turned
2998                            off, because we never agree to turn on
2999                            anything non-default, so according to the
3000                            protocol rules, we don't reply. */
3001                         break;
3002                     }
3003                     break;
3004                   case TN_DO:
3005                     if (appData.debugMode)
3006                       fprintf(debugFP, "\n<DO ");
3007                     switch (option = (unsigned char) buf[++i]) {
3008                       default:
3009                         /* Whatever this is, we refuse to do it. */
3010                         if (appData.debugMode)
3011                           fprintf(debugFP, "%d ", option);
3012                         TelnetRequest(TN_WONT, option);
3013                         break;
3014                     }
3015                     break;
3016                   case TN_DONT:
3017                     if (appData.debugMode)
3018                       fprintf(debugFP, "\n<DONT ");
3019                     switch (option = (unsigned char) buf[++i]) {
3020                       default:
3021                         if (appData.debugMode)
3022                           fprintf(debugFP, "%d ", option);
3023                         /* Whatever this is, we are already not doing
3024                            it, because we never agree to do anything
3025                            non-default, so according to the protocol
3026                            rules, we don't reply. */
3027                         break;
3028                     }
3029                     break;
3030                   case TN_IAC:
3031                     if (appData.debugMode)
3032                       fprintf(debugFP, "\n<IAC ");
3033                     /* Doubled IAC; pass it through */
3034                     i--;
3035                     break;
3036                   default:
3037                     if (appData.debugMode)
3038                       fprintf(debugFP, "\n<%d ", (unsigned char) buf[i]);
3039                     /* Drop all other telnet commands on the floor */
3040                     break;
3041                 }
3042                 if (oldi > next_out)
3043                   SendToPlayer(&buf[next_out], oldi - next_out);
3044                 if (++i > next_out)
3045                   next_out = i;
3046                 continue;
3047             }
3048
3049             /* OK, this at least will *usually* work */
3050             if (!loggedOn && looking_at(buf, &i, "ics%")) {
3051                 loggedOn = TRUE;
3052             }
3053
3054             if (loggedOn && !intfSet) {
3055                 if (ics_type == ICS_ICC) {
3056                   snprintf(str, MSG_SIZ,
3057                           "/set-quietly interface %s\n/set-quietly style 12\n",
3058                           programVersion);
3059                   if(appData.seekGraph && appData.autoRefresh) // [HGM] seekgraph
3060                       strcat(str, "/set-2 51 1\n/set seek 1\n");
3061                 } else if (ics_type == ICS_CHESSNET) {
3062                   snprintf(str, MSG_SIZ, "/style 12\n");
3063                 } else {
3064                   safeStrCpy(str, "alias $ @\n$set interface ", sizeof(str)/sizeof(str[0]));
3065                   strcat(str, programVersion);
3066                   strcat(str, "\n$iset startpos 1\n$iset ms 1\n");
3067                   if(appData.seekGraph && appData.autoRefresh) // [HGM] seekgraph
3068                       strcat(str, "$iset seekremove 1\n$set seek 1\n");
3069 #ifdef WIN32
3070                   strcat(str, "$iset nohighlight 1\n");
3071 #endif
3072                   strcat(str, "$iset lock 1\n$style 12\n");
3073                 }
3074                 SendToICS(str);
3075                 NotifyFrontendLogin();
3076                 intfSet = TRUE;
3077             }
3078
3079             if (started == STARTED_COMMENT) {
3080                 /* Accumulate characters in comment */
3081                 parse[parse_pos++] = buf[i];
3082                 if (buf[i] == '\n') {
3083                     parse[parse_pos] = NULLCHAR;
3084                     if(chattingPartner>=0) {
3085                         char mess[MSG_SIZ];
3086                         snprintf(mess, MSG_SIZ, "%s%s", talker, parse);
3087                         OutputChatMessage(chattingPartner, mess);
3088                         if(collective == 1) { // broadcasted talk also goes to private chatbox of talker
3089                             int p;
3090                             talker[strlen(talker+1)-1] = NULLCHAR; // strip closing delimiter
3091                             for(p=0; p<MAX_CHAT; p++) if(!StrCaseCmp(talker+1, chatPartner[p])) {
3092                                 snprintf(mess, MSG_SIZ, "%s: %s", chatPartner[chattingPartner], parse);
3093                                 OutputChatMessage(p, mess);
3094                                 break;
3095                             }
3096                         }
3097                         chattingPartner = -1;
3098                         if(collective != 3) next_out = i+1; // [HGM] suppress printing in ICS window
3099                         collective = 0;
3100                     } else
3101                     if(!suppressKibitz) // [HGM] kibitz
3102                         AppendComment(forwardMostMove, StripHighlight(parse), TRUE);
3103                     else { // [HGM kibitz: divert memorized engine kibitz to engine-output window
3104                         int nrDigit = 0, nrAlph = 0, j;
3105                         if(parse_pos > MSG_SIZ - 30) // defuse unreasonably long input
3106                         { parse_pos = MSG_SIZ-30; parse[parse_pos - 1] = '\n'; }
3107                         parse[parse_pos] = NULLCHAR;
3108                         // try to be smart: if it does not look like search info, it should go to
3109                         // ICS interaction window after all, not to engine-output window.
3110                         for(j=0; j<parse_pos; j++) { // count letters and digits
3111                             nrDigit += (parse[j] >= '0' && parse[j] <= '9');
3112                             nrAlph  += (parse[j] >= 'a' && parse[j] <= 'z');
3113                             nrAlph  += (parse[j] >= 'A' && parse[j] <= 'Z');
3114                         }
3115                         if(nrAlph < 9*nrDigit) { // if more than 10% digit we assume search info
3116                             int depth=0; float score;
3117                             if(sscanf(parse, "!!! %f/%d", &score, &depth) == 2 && depth>0) {
3118                                 // [HGM] kibitz: save kibitzed opponent info for PGN and eval graph
3119                                 pvInfoList[forwardMostMove-1].depth = depth;
3120                                 pvInfoList[forwardMostMove-1].score = 100*score;
3121                             }
3122                             OutputKibitz(suppressKibitz, parse);
3123                         } else {
3124                             char tmp[MSG_SIZ];
3125                             if(gameMode == IcsObserving) // restore original ICS messages
3126                               /* TRANSLATORS: to 'kibitz' is to send a message to all players and the game observers */
3127                               snprintf(tmp, MSG_SIZ, "%s kibitzes: %s", star_match[0], parse);
3128                             else
3129                             /* TRANSLATORS: to 'kibitz' is to send a message to all players and the game observers */
3130                             snprintf(tmp, MSG_SIZ, _("your opponent kibitzes: %s"), parse);
3131                             SendToPlayer(tmp, strlen(tmp));
3132                         }
3133                         next_out = i+1; // [HGM] suppress printing in ICS window
3134                     }
3135                     started = STARTED_NONE;
3136                 } else {
3137                     /* Don't match patterns against characters in comment */
3138                     i++;
3139                     continue;
3140                 }
3141             }
3142             if (started == STARTED_CHATTER) {
3143                 if (buf[i] != '\n') {
3144                     /* Don't match patterns against characters in chatter */
3145                     i++;
3146                     continue;
3147                 }
3148                 started = STARTED_NONE;
3149                 if(suppressKibitz) next_out = i+1;
3150             }
3151
3152             /* Kludge to deal with rcmd protocol */
3153             if (firstTime && looking_at(buf, &i, "\001*")) {
3154                 DisplayFatalError(&buf[1], 0, 1);
3155                 continue;
3156             } else {
3157                 firstTime = FALSE;
3158             }
3159
3160             if (!loggedOn && looking_at(buf, &i, "chessclub.com")) {
3161                 ics_type = ICS_ICC;
3162                 ics_prefix = "/";
3163                 if (appData.debugMode)
3164                   fprintf(debugFP, "ics_type %d\n", ics_type);
3165                 continue;
3166             }
3167             if (!loggedOn && looking_at(buf, &i, "freechess.org")) {
3168                 ics_type = ICS_FICS;
3169                 ics_prefix = "$";
3170                 if (appData.debugMode)
3171                   fprintf(debugFP, "ics_type %d\n", ics_type);
3172                 continue;
3173             }
3174             if (!loggedOn && looking_at(buf, &i, "chess.net")) {
3175                 ics_type = ICS_CHESSNET;
3176                 ics_prefix = "/";
3177                 if (appData.debugMode)
3178                   fprintf(debugFP, "ics_type %d\n", ics_type);
3179                 continue;
3180             }
3181
3182             if (!loggedOn &&
3183                 (looking_at(buf, &i, "\"*\" is *a registered name") ||
3184                  looking_at(buf, &i, "Logging you in as \"*\"") ||
3185                  looking_at(buf, &i, "will be \"*\""))) {
3186               safeStrCpy(ics_handle, star_match[0], sizeof(ics_handle)/sizeof(ics_handle[0]));
3187               continue;
3188             }
3189
3190             if (loggedOn && !have_set_title && ics_handle[0] != NULLCHAR) {
3191               char buf[MSG_SIZ];
3192               snprintf(buf, sizeof(buf), "%s@%s", ics_handle, appData.icsHost);
3193               DisplayIcsInteractionTitle(buf);
3194               have_set_title = TRUE;
3195             }
3196
3197             /* skip finger notes */
3198             if (started == STARTED_NONE &&
3199                 ((buf[i] == ' ' && isdigit(buf[i+1])) ||
3200                  (buf[i] == '1' && buf[i+1] == '0')) &&
3201                 buf[i+2] == ':' && buf[i+3] == ' ') {
3202               started = STARTED_CHATTER;
3203               i += 3;
3204               continue;
3205             }
3206
3207             oldi = i;
3208             // [HGM] seekgraph: recognize sought lines and end-of-sought message
3209             if(appData.seekGraph) {
3210                 if(soughtPending && MatchSoughtLine(buf+i)) {
3211                     i = strstr(buf+i, "rated") - buf;
3212                     if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
3213                     next_out = leftover_start = i;
3214                     started = STARTED_CHATTER;
3215                     suppressKibitz = TRUE;
3216                     continue;
3217                 }
3218                 if((gameMode == IcsIdle || gameMode == BeginningOfGame)
3219                         && looking_at(buf, &i, "* ads displayed")) {
3220                     soughtPending = FALSE;
3221                     seekGraphUp = TRUE;
3222                     DrawSeekGraph();
3223                     continue;
3224                 }
3225                 if(appData.autoRefresh) {
3226                     if(looking_at(buf, &i, "* (*) seeking * * * * *\"play *\" to respond)\n")) {
3227                         int s = (ics_type == ICS_ICC); // ICC format differs
3228                         if(seekGraphUp)
3229                         AddAd(star_match[0], star_match[1], atoi(star_match[2+s]), atoi(star_match[3+s]),
3230                               star_match[4+s][0], star_match[5-3*s], atoi(star_match[7]), TRUE);
3231                         looking_at(buf, &i, "*% "); // eat prompt
3232                         if(oldi > 0 && buf[oldi-1] == '\n') oldi--; // suppress preceding LF, if any
3233                         if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
3234                         next_out = i; // suppress
3235                         continue;
3236                     }
3237                     if(looking_at(buf, &i, "\nAds removed: *\n") || looking_at(buf, &i, "\031(51 * *\031)")) {
3238                         char *p = star_match[0];
3239                         while(*p) {
3240                             if(seekGraphUp) RemoveSeekAd(atoi(p));
3241                             while(*p && *p++ != ' '); // next
3242                         }
3243                         looking_at(buf, &i, "*% "); // eat prompt
3244                         if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
3245                         next_out = i;
3246                         continue;
3247                     }
3248                 }
3249             }
3250
3251             /* skip formula vars */
3252             if (started == STARTED_NONE &&
3253                 buf[i] == 'f' && isdigit(buf[i+1]) && buf[i+2] == ':') {
3254               started = STARTED_CHATTER;
3255               i += 3;
3256               continue;
3257             }
3258
3259             // [HGM] kibitz: try to recognize opponent engine-score kibitzes, to divert them to engine-output window
3260             if (appData.autoKibitz && started == STARTED_NONE &&
3261                 !appData.icsEngineAnalyze &&                     // [HGM] [DM] ICS analyze
3262                 (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack || gameMode == IcsObserving)) {
3263                 if((looking_at(buf, &i, "\n* kibitzes: ") || looking_at(buf, &i, "\n* whispers: ") ||
3264                     looking_at(buf, &i, "* kibitzes: ") || looking_at(buf, &i, "* whispers: ")) &&
3265                    (StrStr(star_match[0], gameInfo.white) == star_match[0] ||
3266                     StrStr(star_match[0], gameInfo.black) == star_match[0]   )) { // kibitz of self or opponent
3267                         suppressKibitz = TRUE;
3268                         if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
3269                         next_out = i;
3270                         if((StrStr(star_match[0], gameInfo.white) == star_match[0]
3271                                 && (gameMode == IcsPlayingWhite)) ||
3272                            (StrStr(star_match[0], gameInfo.black) == star_match[0]
3273                                 && (gameMode == IcsPlayingBlack))   ) // opponent kibitz
3274                             started = STARTED_CHATTER; // own kibitz we simply discard
3275                         else {
3276                             started = STARTED_COMMENT; // make sure it will be collected in parse[]
3277                             parse_pos = 0; parse[0] = NULLCHAR;
3278                             savingComment = TRUE;
3279                             suppressKibitz = gameMode != IcsObserving ? 2 :
3280                                 (StrStr(star_match[0], gameInfo.white) == NULL) + 1;
3281                         }
3282                         continue;
3283                 } else
3284                 if((looking_at(buf, &i, "\nkibitzed to *\n") || looking_at(buf, &i, "kibitzed to *\n") ||
3285                     looking_at(buf, &i, "\n(kibitzed to *\n") || looking_at(buf, &i, "(kibitzed to *\n"))
3286                          && atoi(star_match[0])) {
3287                     // suppress the acknowledgements of our own autoKibitz
3288                     char *p;
3289                     if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
3290                     if(p = strchr(star_match[0], ' ')) p[1] = NULLCHAR; // clip off "players)" on FICS
3291                     SendToPlayer(star_match[0], strlen(star_match[0]));
3292                     if(looking_at(buf, &i, "*% ")) // eat prompt
3293                         suppressKibitz = FALSE;
3294                     next_out = i;
3295                     continue;
3296                 }
3297             } // [HGM] kibitz: end of patch
3298
3299             if(looking_at(buf, &i, "* rating adjustment: * --> *\n")) continue;
3300
3301             // [HGM] chat: intercept tells by users for which we have an open chat window
3302             channel = -1;
3303             if(started == STARTED_NONE && (looking_at(buf, &i, "* tells you:") || looking_at(buf, &i, "* says:") ||
3304                                            looking_at(buf, &i, "* whispers:") ||
3305                                            looking_at(buf, &i, "* kibitzes:") ||
3306                                            looking_at(buf, &i, "* shouts:") ||
3307                                            looking_at(buf, &i, "* c-shouts:") ||
3308                                            looking_at(buf, &i, "--> * ") ||
3309                                            looking_at(buf, &i, "*(*):") && (sscanf(star_match[1], "%d", &channel),1) ||
3310                                            looking_at(buf, &i, "*(*)(*):") && (sscanf(star_match[2], "%d", &channel),1) ||
3311                                            looking_at(buf, &i, "*(*)(*)(*):") && (sscanf(star_match[3], "%d", &channel),1) ||
3312                                            looking_at(buf, &i, "*(*)(*)(*)(*):") && sscanf(star_match[4], "%d", &channel) == 1 )) {
3313                 int p;
3314                 sscanf(star_match[0], "%[^(]", talker+1); // strip (C) or (U) off ICS handle
3315                 chattingPartner = -1; collective = 0;
3316
3317                 if(channel >= 0) // channel broadcast; look if there is a chatbox for this channel
3318                 for(p=0; p<MAX_CHAT; p++) {
3319                     collective = 1;
3320                     if(chatPartner[p][0] >= '0' && chatPartner[p][0] <= '9' && channel == atoi(chatPartner[p])) {
3321                     talker[0] = '['; strcat(talker, "] ");
3322                     Colorize((channel == 1 ? ColorChannel1 : ColorChannel), FALSE);
3323                     chattingPartner = p; break;
3324                     }
3325                 } else
3326                 if(buf[i-3] == 'e') // kibitz; look if there is a KIBITZ chatbox
3327                 for(p=0; p<MAX_CHAT; p++) {
3328                     collective = 1;
3329                     if(!strcmp("kibitzes", chatPartner[p])) {
3330                         talker[0] = '['; strcat(talker, "] ");
3331                         chattingPartner = p; break;
3332                     }
3333                 } else
3334                 if(buf[i-3] == 'r') // whisper; look if there is a WHISPER chatbox
3335                 for(p=0; p<MAX_CHAT; p++) {
3336                     collective = 1;
3337                     if(!strcmp("whispers", chatPartner[p])) {
3338                         talker[0] = '['; strcat(talker, "] ");
3339                         chattingPartner = p; break;
3340                     }
3341                 } else
3342                 if(buf[i-3] == 't' || buf[oldi+2] == '>') {// shout, c-shout or it; look if there is a 'shouts' chatbox
3343                   if(buf[i-8] == '-' && buf[i-3] == 't')
3344                   for(p=0; p<MAX_CHAT; p++) { // c-shout; check if dedicatesd c-shout box exists
3345                     collective = 1;
3346                     if(!strcmp("c-shouts", chatPartner[p])) {
3347                         talker[0] = '('; strcat(talker, ") "); Colorize(ColorSShout, FALSE);
3348                         chattingPartner = p; break;
3349                     }
3350                   }
3351                   if(chattingPartner < 0)
3352                   for(p=0; p<MAX_CHAT; p++) {
3353                     collective = 1;
3354                     if(!strcmp("shouts", chatPartner[p])) {
3355                         if(buf[oldi+2] == '>') { talker[0] = '<'; strcat(talker, "> "); Colorize(ColorShout, FALSE); }
3356                         else if(buf[i-8] == '-') { talker[0] = '('; strcat(talker, ") "); Colorize(ColorSShout, FALSE); }
3357                         else { talker[0] = '['; strcat(talker, "] "); Colorize(ColorShout, FALSE); }
3358                         chattingPartner = p; break;
3359                     }
3360                   }
3361                 }
3362                 if(chattingPartner<0) // if not, look if there is a chatbox for this indivdual
3363                 for(p=0; p<MAX_CHAT; p++) if(!StrCaseCmp(talker+1, chatPartner[p])) {
3364                     talker[0] = 0;
3365                     Colorize(ColorTell, FALSE);
3366                     if(collective) safeStrCpy(talker, "broadcasts: ", MSG_SIZ);
3367                     collective |= 2;
3368                     chattingPartner = p; break;
3369                 }
3370                 if(chattingPartner<0) i = oldi, safeStrCpy(lastTalker, talker+1, MSG_SIZ); else {
3371                     Colorize(curColor, TRUE); // undo the bogus colorations we just made to trigger the souds
3372                     started = STARTED_COMMENT;
3373                     parse_pos = 0; parse[0] = NULLCHAR;
3374                     savingComment = 3 + chattingPartner; // counts as TRUE
3375                     if(collective == 3) i = oldi; else {
3376                         suppressKibitz = TRUE;
3377                         if(oldi > 0 && buf[oldi-1] == '\n') oldi--;
3378                         if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
3379                         continue;
3380                     }
3381                 }
3382             } // [HGM] chat: end of patch
3383
3384           backup = i;
3385             if (appData.zippyTalk || appData.zippyPlay) {
3386                 /* [DM] Backup address for color zippy lines */
3387 #if ZIPPY
3388                if (loggedOn == TRUE)
3389                        if (ZippyControl(buf, &backup) || ZippyConverse(buf, &backup) ||
3390                           (appData.zippyPlay && ZippyMatch(buf, &backup)));
3391 #endif
3392             } // [DM] 'else { ' deleted
3393                 if (
3394                     /* Regular tells and says */
3395                     (tkind = 1, looking_at(buf, &i, "* tells you: ")) ||
3396                     looking_at(buf, &i, "* (your partner) tells you: ") ||
3397                     looking_at(buf, &i, "* says: ") ||
3398                     /* Don't color "message" or "messages" output */
3399                     (tkind = 5, looking_at(buf, &i, "*. * (*:*): ")) ||
3400                     looking_at(buf, &i, "*. * at *:*: ") ||
3401                     looking_at(buf, &i, "--* (*:*): ") ||
3402                     /* Message notifications (same color as tells) */
3403                     looking_at(buf, &i, "* has left a message ") ||
3404                     looking_at(buf, &i, "* just sent you a message:\n") ||
3405                     /* Whispers and kibitzes */
3406                     (tkind = 2, looking_at(buf, &i, "* whispers: ")) ||
3407                     looking_at(buf, &i, "* kibitzes: ") ||
3408                     /* Channel tells */
3409                     (tkind = 3, looking_at(buf, &i, "*(*: "))) {
3410
3411                   if (tkind == 1 && strchr(star_match[0], ':')) {
3412                       /* Avoid "tells you:" spoofs in channels */
3413                      tkind = 3;
3414                   }
3415                   if (star_match[0][0] == NULLCHAR ||
3416                       strchr(star_match[0], ' ') ||
3417                       (tkind == 3 && strchr(star_match[1], ' '))) {
3418                     /* Reject bogus matches */
3419                     i = oldi;
3420                   } else {
3421                     if (appData.colorize) {
3422                       if (oldi > next_out) {
3423                         SendToPlayer(&buf[next_out], oldi - next_out);
3424                         next_out = oldi;
3425                       }
3426                       switch (tkind) {
3427                       case 1:
3428                         Colorize(ColorTell, FALSE);
3429                         curColor = ColorTell;
3430                         break;
3431                       case 2:
3432                         Colorize(ColorKibitz, FALSE);
3433                         curColor = ColorKibitz;
3434                         break;
3435                       case 3:
3436                         p = strrchr(star_match[1], '(');
3437                         if (p == NULL) {
3438                           p = star_match[1];
3439                         } else {
3440                           p++;
3441                         }
3442                         if (atoi(p) == 1) {
3443                           Colorize(ColorChannel1, FALSE);
3444                           curColor = ColorChannel1;
3445                         } else {
3446                           Colorize(ColorChannel, FALSE);
3447                           curColor = ColorChannel;
3448                         }
3449                         break;
3450                       case 5:
3451                         curColor = ColorNormal;
3452                         break;
3453                       }
3454                     }
3455                     if (started == STARTED_NONE && appData.autoComment &&
3456                         (gameMode == IcsObserving ||
3457                          gameMode == IcsPlayingWhite ||
3458                          gameMode == IcsPlayingBlack)) {
3459                       parse_pos = i - oldi;
3460                       memcpy(parse, &buf[oldi], parse_pos);
3461                       parse[parse_pos] = NULLCHAR;
3462                       started = STARTED_COMMENT;
3463                       savingComment = TRUE;
3464                     } else if(collective != 3) {
3465                       started = STARTED_CHATTER;
3466                       savingComment = FALSE;
3467                     }
3468                     loggedOn = TRUE;
3469                     continue;
3470                   }
3471                 }
3472
3473                 if (looking_at(buf, &i, "* s-shouts: ") ||
3474                     looking_at(buf, &i, "* c-shouts: ")) {
3475                     if (appData.colorize) {
3476                         if (oldi > next_out) {
3477                             SendToPlayer(&buf[next_out], oldi - next_out);
3478                             next_out = oldi;
3479                         }
3480                         Colorize(ColorSShout, FALSE);
3481                         curColor = ColorSShout;
3482                     }
3483                     loggedOn = TRUE;
3484                     started = STARTED_CHATTER;
3485                     continue;
3486                 }
3487
3488                 if (looking_at(buf, &i, "--->")) {
3489                     loggedOn = TRUE;
3490                     continue;
3491                 }
3492
3493                 if (looking_at(buf, &i, "* shouts: ") ||
3494                     looking_at(buf, &i, "--> ")) {
3495                     if (appData.colorize) {
3496                         if (oldi > next_out) {
3497                             SendToPlayer(&buf[next_out], oldi - next_out);
3498                             next_out = oldi;
3499                         }
3500                         Colorize(ColorShout, FALSE);
3501                         curColor = ColorShout;
3502                     }
3503                     loggedOn = TRUE;
3504                     started = STARTED_CHATTER;
3505                     continue;
3506                 }
3507
3508                 if (looking_at( buf, &i, "Challenge:")) {
3509                     if (appData.colorize) {
3510                         if (oldi > next_out) {
3511                             SendToPlayer(&buf[next_out], oldi - next_out);
3512                             next_out = oldi;
3513                         }
3514                         Colorize(ColorChallenge, FALSE);
3515                         curColor = ColorChallenge;
3516                     }
3517                     loggedOn = TRUE;
3518                     continue;
3519                 }
3520
3521                 if (looking_at(buf, &i, "* offers you") ||
3522                     looking_at(buf, &i, "* offers to be") ||
3523                     looking_at(buf, &i, "* would like to") ||
3524                     looking_at(buf, &i, "* requests to") ||
3525                     looking_at(buf, &i, "Your opponent offers") ||
3526                     looking_at(buf, &i, "Your opponent requests")) {
3527
3528                     if (appData.colorize) {
3529                         if (oldi > next_out) {
3530                             SendToPlayer(&buf[next_out], oldi - next_out);
3531                             next_out = oldi;
3532                         }
3533                         Colorize(ColorRequest, FALSE);
3534                         curColor = ColorRequest;
3535                     }
3536                     continue;
3537                 }
3538
3539                 if (looking_at(buf, &i, "* (*) seeking")) {
3540                     if (appData.colorize) {
3541                         if (oldi > next_out) {
3542                             SendToPlayer(&buf[next_out], oldi - next_out);
3543                             next_out = oldi;
3544                         }
3545                         Colorize(ColorSeek, FALSE);
3546                         curColor = ColorSeek;
3547                     }
3548                     continue;
3549             }
3550
3551           if(i < backup) { i = backup; continue; } // [HGM] for if ZippyControl matches, but the colorie code doesn't
3552
3553             if (looking_at(buf, &i, "\\   ")) {
3554                 if (prevColor != ColorNormal) {
3555                     if (oldi > next_out) {
3556                         SendToPlayer(&buf[next_out], oldi - next_out);
3557                         next_out = oldi;
3558                     }
3559                     Colorize(prevColor, TRUE);
3560                     curColor = prevColor;
3561                 }
3562                 if (savingComment) {
3563                     parse_pos = i - oldi;
3564                     memcpy(parse, &buf[oldi], parse_pos);
3565                     parse[parse_pos] = NULLCHAR;
3566                     started = STARTED_COMMENT;
3567                     if(savingComment >= 3) // [HGM] chat: continuation of line for chat box
3568                         chattingPartner = savingComment - 3; // kludge to remember the box
3569                 } else {
3570                     started = STARTED_CHATTER;
3571                 }
3572                 continue;
3573             }
3574
3575             if (looking_at(buf, &i, "Black Strength :") ||
3576                 looking_at(buf, &i, "<<< style 10 board >>>") ||
3577                 looking_at(buf, &i, "<10>") ||
3578                 looking_at(buf, &i, "#@#")) {
3579                 /* Wrong board style */
3580                 loggedOn = TRUE;
3581                 SendToICS(ics_prefix);
3582                 SendToICS("set style 12\n");
3583                 SendToICS(ics_prefix);
3584                 SendToICS("refresh\n");
3585                 continue;
3586             }
3587
3588             if (looking_at(buf, &i, "login:")) {
3589               if (!have_sent_ICS_logon) {
3590                 if(ICSInitScript())
3591                   have_sent_ICS_logon = 1;
3592                 else // no init script was found
3593                   have_sent_ICS_logon = (appData.autoCreateLogon ? 2 : 1); // flag that we should capture username + password
3594               } else { // we have sent (or created) the InitScript, but apparently the ICS rejected it
3595                   have_sent_ICS_logon = (appData.autoCreateLogon ? 2 : 1); // request creation of a new script
3596               }
3597                 continue;
3598             }
3599
3600             if (ics_getting_history != H_GETTING_MOVES /*smpos kludge*/ &&
3601                 (looking_at(buf, &i, "\n<12> ") ||
3602                  looking_at(buf, &i, "<12> "))) {
3603                 loggedOn = TRUE;
3604                 if (oldi > next_out) {
3605                     SendToPlayer(&buf[next_out], oldi - next_out);
3606                 }
3607                 next_out = i;
3608                 started = STARTED_BOARD;
3609                 parse_pos = 0;
3610                 continue;
3611             }
3612
3613             if ((started == STARTED_NONE && looking_at(buf, &i, "\n<b1> ")) ||
3614                 looking_at(buf, &i, "<b1> ")) {
3615                 if (oldi > next_out) {
3616                     SendToPlayer(&buf[next_out], oldi - next_out);
3617                 }
3618                 next_out = i;
3619                 started = STARTED_HOLDINGS;
3620                 parse_pos = 0;
3621                 continue;
3622             }
3623
3624             if (looking_at(buf, &i, "* *vs. * *--- *")) {
3625                 loggedOn = TRUE;
3626                 /* Header for a move list -- first line */
3627
3628                 switch (ics_getting_history) {
3629                   case H_FALSE:
3630                     switch (gameMode) {
3631                       case IcsIdle:
3632                       case BeginningOfGame:
3633                         /* User typed "moves" or "oldmoves" while we
3634                            were idle.  Pretend we asked for these
3635                            moves and soak them up so user can step
3636                            through them and/or save them.
3637                            */
3638                         Reset(FALSE, TRUE);
3639                         gameMode = IcsObserving;
3640                         ModeHighlight();
3641                         ics_gamenum = -1;
3642                         ics_getting_history = H_GOT_UNREQ_HEADER;
3643                         break;
3644                       case EditGame: /*?*/
3645                       case EditPosition: /*?*/
3646                         /* Should above feature work in these modes too? */
3647                         /* For now it doesn't */
3648                         ics_getting_history = H_GOT_UNWANTED_HEADER;
3649                         break;
3650                       default:
3651                         ics_getting_history = H_GOT_UNWANTED_HEADER;
3652                         break;
3653                     }
3654                     break;
3655                   case H_REQUESTED:
3656                     /* Is this the right one? */
3657                     if (gameInfo.white && gameInfo.black &&
3658                         strcmp(gameInfo.white, star_match[0]) == 0 &&
3659                         strcmp(gameInfo.black, star_match[2]) == 0) {
3660                         /* All is well */
3661                         ics_getting_history = H_GOT_REQ_HEADER;
3662                     }
3663                     break;
3664                   case H_GOT_REQ_HEADER:
3665                   case H_GOT_UNREQ_HEADER:
3666                   case H_GOT_UNWANTED_HEADER:
3667                   case H_GETTING_MOVES:
3668                     /* Should not happen */
3669                     DisplayError(_("Error gathering move list: two headers"), 0);
3670                     ics_getting_history = H_FALSE;
3671                     break;
3672                 }
3673
3674                 /* Save player ratings into gameInfo if needed */
3675                 if ((ics_getting_history == H_GOT_REQ_HEADER ||
3676                      ics_getting_history == H_GOT_UNREQ_HEADER) &&
3677                     (gameInfo.whiteRating == -1 ||
3678                      gameInfo.blackRating == -1)) {
3679
3680                     gameInfo.whiteRating = string_to_rating(star_match[1]);
3681                     gameInfo.blackRating = string_to_rating(star_match[3]);
3682                     if (appData.debugMode)
3683                       fprintf(debugFP, "Ratings from header: W %d, B %d\n",
3684                               gameInfo.whiteRating, gameInfo.blackRating);
3685                 }
3686                 continue;
3687             }
3688
3689             if (looking_at(buf, &i,
3690               "* * match, initial time: * minute*, increment: * second")) {
3691                 /* Header for a move list -- second line */
3692                 /* Initial board will follow if this is a wild game */
3693                 if (gameInfo.event != NULL) free(gameInfo.event);
3694                 snprintf(str, MSG_SIZ, "ICS %s %s match", star_match[0], star_match[1]);
3695                 gameInfo.event = StrSave(str);
3696                 /* [HGM] we switched variant. Translate boards if needed. */
3697                 VariantSwitch(boards[currentMove], StringToVariant(gameInfo.event));
3698                 continue;
3699             }
3700
3701             if (looking_at(buf, &i, "Move  ")) {
3702                 /* Beginning of a move list */
3703                 switch (ics_getting_history) {
3704                   case H_FALSE:
3705                     /* Normally should not happen */
3706                     /* Maybe user hit reset while we were parsing */
3707                     break;
3708                   case H_REQUESTED:
3709                     /* Happens if we are ignoring a move list that is not
3710                      * the one we just requested.  Common if the user
3711                      * tries to observe two games without turning off
3712                      * getMoveList */
3713                     break;
3714                   case H_GETTING_MOVES:
3715                     /* Should not happen */
3716                     DisplayError(_("Error gathering move list: nested"), 0);
3717                     ics_getting_history = H_FALSE;
3718                     break;
3719                   case H_GOT_REQ_HEADER:
3720                     ics_getting_history = H_GETTING_MOVES;
3721                     started = STARTED_MOVES;
3722                     parse_pos = 0;
3723                     if (oldi > next_out) {
3724                         SendToPlayer(&buf[next_out], oldi - next_out);
3725                     }
3726                     break;
3727                   case H_GOT_UNREQ_HEADER:
3728                     ics_getting_history = H_GETTING_MOVES;
3729                     started = STARTED_MOVES_NOHIDE;
3730                     parse_pos = 0;
3731                     break;
3732                   case H_GOT_UNWANTED_HEADER:
3733                     ics_getting_history = H_FALSE;
3734                     break;
3735                 }
3736                 continue;
3737             }
3738
3739             if (looking_at(buf, &i, "% ") ||
3740                 ((started == STARTED_MOVES || started == STARTED_MOVES_NOHIDE)
3741                  && looking_at(buf, &i, "}*"))) { char *bookHit = NULL; // [HGM] book
3742                 if(soughtPending && nrOfSeekAds) { // [HGM] seekgraph: on ICC sought-list has no termination line
3743                     soughtPending = FALSE;
3744                     seekGraphUp = TRUE;
3745                     DrawSeekGraph();
3746                 }
3747                 if(suppressKibitz) next_out = i;
3748                 savingComment = FALSE;
3749                 suppressKibitz = 0;
3750                 switch (started) {
3751                   case STARTED_MOVES:
3752                   case STARTED_MOVES_NOHIDE:
3753                     memcpy(&parse[parse_pos], &buf[oldi], i - oldi);
3754                     parse[parse_pos + i - oldi] = NULLCHAR;
3755                     ParseGameHistory(parse);
3756 #if ZIPPY
3757                     if (appData.zippyPlay && first.initDone) {
3758                         FeedMovesToProgram(&first, forwardMostMove);
3759                         if (gameMode == IcsPlayingWhite) {
3760                             if (WhiteOnMove(forwardMostMove)) {
3761                                 if (first.sendTime) {
3762                                   if (first.useColors) {
3763                                     SendToProgram("black\n", &first);
3764                                   }
3765                                   SendTimeRemaining(&first, TRUE);
3766                                 }
3767                                 if (first.useColors) {
3768                                   SendToProgram("white\n", &first); // [HGM] book: made sending of "go\n" book dependent
3769                                 }
3770                                 bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: probe book for initial pos
3771                                 first.maybeThinking = TRUE;
3772                             } else {
3773                                 if (first.usePlayother) {
3774                                   if (first.sendTime) {
3775                                     SendTimeRemaining(&first, TRUE);
3776                                   }
3777                                   SendToProgram("playother\n", &first);
3778                                   firstMove = FALSE;
3779                                 } else {
3780                                   firstMove = TRUE;
3781                                 }
3782                             }
3783                         } else if (gameMode == IcsPlayingBlack) {
3784                             if (!WhiteOnMove(forwardMostMove)) {
3785                                 if (first.sendTime) {
3786                                   if (first.useColors) {
3787                                     SendToProgram("white\n", &first);
3788                                   }
3789                                   SendTimeRemaining(&first, FALSE);
3790                                 }
3791                                 if (first.useColors) {
3792                                   SendToProgram("black\n", &first);
3793                                 }
3794                                 bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE);
3795                                 first.maybeThinking = TRUE;
3796                             } else {
3797                                 if (first.usePlayother) {
3798                                   if (first.sendTime) {
3799                                     SendTimeRemaining(&first, FALSE);
3800                                   }
3801                                   SendToProgram("playother\n", &first);
3802                                   firstMove = FALSE;
3803                                 } else {
3804                                   firstMove = TRUE;
3805                                 }
3806                             }
3807                         }
3808                     }
3809 #endif
3810                     if (gameMode == IcsObserving && ics_gamenum == -1) {
3811                         /* Moves came from oldmoves or moves command
3812                            while we weren't doing anything else.
3813                            */
3814                         currentMove = forwardMostMove;
3815                         ClearHighlights();/*!!could figure this out*/
3816                         flipView = appData.flipView;
3817                         DrawPosition(TRUE, boards[currentMove]);
3818                         DisplayBothClocks();
3819                         snprintf(str, MSG_SIZ, "%s %s %s",
3820                                 gameInfo.white, _("vs."),  gameInfo.black);
3821                         DisplayTitle(str);
3822                         gameMode = IcsIdle;
3823                     } else {
3824                         /* Moves were history of an active game */
3825                         if (gameInfo.resultDetails != NULL) {
3826                             free(gameInfo.resultDetails);
3827                             gameInfo.resultDetails = NULL;
3828                         }
3829                     }
3830                     HistorySet(parseList, backwardMostMove,
3831                                forwardMostMove, currentMove-1);
3832                     DisplayMove(currentMove - 1);
3833                     if (started == STARTED_MOVES) next_out = i;
3834                     started = STARTED_NONE;
3835                     ics_getting_history = H_FALSE;
3836                     break;
3837
3838                   case STARTED_OBSERVE:
3839                     started = STARTED_NONE;
3840                     SendToICS(ics_prefix);
3841                     SendToICS("refresh\n");
3842                     break;
3843
3844                   default:
3845                     break;
3846                 }
3847                 if(bookHit) { // [HGM] book: simulate book reply
3848                     static char bookMove[MSG_SIZ]; // a bit generous?
3849
3850                     programStats.nodes = programStats.depth = programStats.time =
3851                     programStats.score = programStats.got_only_move = 0;
3852                     sprintf(programStats.movelist, "%s (xbook)", bookHit);
3853
3854                     safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
3855                     strcat(bookMove, bookHit);
3856                     HandleMachineMove(bookMove, &first);
3857                 }
3858                 continue;
3859             }
3860
3861             if ((started == STARTED_MOVES || started == STARTED_BOARD ||
3862                  started == STARTED_HOLDINGS ||
3863                  started == STARTED_MOVES_NOHIDE) && i >= leftover_len) {
3864                 /* Accumulate characters in move list or board */
3865                 parse[parse_pos++] = buf[i];
3866             }
3867
3868             /* Start of game messages.  Mostly we detect start of game
3869                when the first board image arrives.  On some versions
3870                of the ICS, though, we need to do a "refresh" after starting
3871                to observe in order to get the current board right away. */
3872             if (looking_at(buf, &i, "Adding game * to observation list")) {
3873                 started = STARTED_OBSERVE;
3874                 continue;
3875             }
3876
3877             /* Handle auto-observe */
3878             if (appData.autoObserve &&
3879                 (gameMode == IcsIdle || gameMode == BeginningOfGame) &&
3880                 looking_at(buf, &i, "Game notification: * (*) vs. * (*)")) {
3881                 char *player;
3882                 /* Choose the player that was highlighted, if any. */
3883                 if (star_match[0][0] == '\033' ||
3884                     star_match[1][0] != '\033') {
3885                     player = star_match[0];
3886                 } else {
3887                     player = star_match[2];
3888                 }
3889                 snprintf(str, MSG_SIZ, "%sobserve %s\n",
3890                         ics_prefix, StripHighlightAndTitle(player));
3891                 SendToICS(str);
3892
3893                 /* Save ratings from notify string */
3894                 safeStrCpy(player1Name, star_match[0], sizeof(player1Name)/sizeof(player1Name[0]));
3895                 player1Rating = string_to_rating(star_match[1]);
3896                 safeStrCpy(player2Name, star_match[2], sizeof(player2Name)/sizeof(player2Name[0]));
3897                 player2Rating = string_to_rating(star_match[3]);
3898
3899                 if (appData.debugMode)
3900                   fprintf(debugFP,
3901                           "Ratings from 'Game notification:' %s %d, %s %d\n",
3902                           player1Name, player1Rating,
3903                           player2Name, player2Rating);
3904
3905                 continue;
3906             }
3907
3908             /* Deal with automatic examine mode after a game,
3909                and with IcsObserving -> IcsExamining transition */
3910             if (looking_at(buf, &i, "Entering examine mode for game *") ||
3911                 looking_at(buf, &i, "has made you an examiner of game *")) {
3912
3913                 int gamenum = atoi(star_match[0]);
3914                 if ((gameMode == IcsIdle || gameMode == IcsObserving) &&
3915                     gamenum == ics_gamenum) {
3916                     /* We were already playing or observing this game;
3917                        no need to refetch history */
3918                     gameMode = IcsExamining;
3919                     if (pausing) {
3920                         pauseExamForwardMostMove = forwardMostMove;
3921                     } else if (currentMove < forwardMostMove) {
3922                         ForwardInner(forwardMostMove);
3923                     }
3924                 } else {
3925                     /* I don't think this case really can happen */
3926                     SendToICS(ics_prefix);
3927                     SendToICS("refresh\n");
3928                 }
3929                 continue;
3930             }
3931
3932             /* Error messages */
3933 //          if (ics_user_moved) {
3934             if (1) { // [HGM] old way ignored error after move type in; ics_user_moved is not set then!
3935                 if (looking_at(buf, &i, "Illegal move") ||
3936                     looking_at(buf, &i, "Not a legal move") ||
3937                     looking_at(buf, &i, "Your king is in check") ||
3938                     looking_at(buf, &i, "It isn't your turn") ||
3939                     looking_at(buf, &i, "It is not your move")) {
3940                     /* Illegal move */
3941                     if (ics_user_moved && forwardMostMove > backwardMostMove) { // only backup if we already moved
3942                         currentMove = forwardMostMove-1;
3943                         DisplayMove(currentMove - 1); /* before DMError */
3944                         DrawPosition(FALSE, boards[currentMove]);
3945                         SwitchClocks(forwardMostMove-1); // [HGM] race
3946                         DisplayBothClocks();
3947                     }
3948                     DisplayMoveError(_("Illegal move (rejected by ICS)")); // [HGM] but always relay error msg
3949                     ics_user_moved = 0;
3950                     continue;
3951                 }
3952             }
3953
3954             if (looking_at(buf, &i, "still have time") ||
3955                 looking_at(buf, &i, "not out of time") ||
3956                 looking_at(buf, &i, "either player is out of time") ||
3957                 looking_at(buf, &i, "has timeseal; checking")) {
3958                 /* We must have called his flag a little too soon */
3959                 whiteFlag = blackFlag = FALSE;
3960                 continue;
3961             }
3962
3963             if (looking_at(buf, &i, "added * seconds to") ||
3964                 looking_at(buf, &i, "seconds were added to")) {
3965                 /* Update the clocks */
3966                 SendToICS(ics_prefix);
3967                 SendToICS("refresh\n");
3968                 continue;
3969             }
3970
3971             if (!ics_clock_paused && looking_at(buf, &i, "clock paused")) {
3972                 ics_clock_paused = TRUE;
3973                 StopClocks();
3974                 continue;
3975             }
3976
3977             if (ics_clock_paused && looking_at(buf, &i, "clock resumed")) {
3978                 ics_clock_paused = FALSE;
3979                 StartClocks();
3980                 continue;
3981             }
3982
3983             /* Grab player ratings from the Creating: message.
3984                Note we have to check for the special case when
3985                the ICS inserts things like [white] or [black]. */
3986             if (looking_at(buf, &i, "Creating: * (*)* * (*)") ||
3987                 looking_at(buf, &i, "Creating: * (*) [*] * (*)")) {
3988                 /* star_matches:
3989                    0    player 1 name (not necessarily white)
3990                    1    player 1 rating
3991                    2    empty, white, or black (IGNORED)
3992                    3    player 2 name (not necessarily black)
3993                    4    player 2 rating
3994
3995                    The names/ratings are sorted out when the game
3996                    actually starts (below).
3997                 */
3998                 safeStrCpy(player1Name, StripHighlightAndTitle(star_match[0]), sizeof(player1Name)/sizeof(player1Name[0]));
3999                 player1Rating = string_to_rating(star_match[1]);
4000                 safeStrCpy(player2Name, StripHighlightAndTitle(star_match[3]), sizeof(player2Name)/sizeof(player2Name[0]));
4001                 player2Rating = string_to_rating(star_match[4]);
4002
4003                 if (appData.debugMode)
4004                   fprintf(debugFP,
4005                           "Ratings from 'Creating:' %s %d, %s %d\n",
4006                           player1Name, player1Rating,
4007                           player2Name, player2Rating);
4008
4009                 continue;
4010             }
4011
4012             /* Improved generic start/end-of-game messages */
4013             if ((tkind=0, looking_at(buf, &i, "{Game * (* vs. *) *}*")) ||
4014                 (tkind=1, looking_at(buf, &i, "{Game * (*(*) vs. *(*)) *}*"))){
4015                 /* If tkind == 0: */
4016                 /* star_match[0] is the game number */
4017                 /*           [1] is the white player's name */
4018                 /*           [2] is the black player's name */
4019                 /* For end-of-game: */
4020                 /*           [3] is the reason for the game end */
4021                 /*           [4] is a PGN end game-token, preceded by " " */
4022                 /* For start-of-game: */
4023                 /*           [3] begins with "Creating" or "Continuing" */
4024                 /*           [4] is " *" or empty (don't care). */
4025                 int gamenum = atoi(star_match[0]);
4026                 char *whitename, *blackname, *why, *endtoken;
4027                 ChessMove endtype = EndOfFile;
4028
4029                 if (tkind == 0) {
4030                   whitename = star_match[1];
4031                   blackname = star_match[2];
4032                   why = star_match[3];
4033                   endtoken = star_match[4];
4034                 } else {
4035                   whitename = star_match[1];
4036                   blackname = star_match[3];
4037                   why = star_match[5];
4038                   endtoken = star_match[6];
4039                 }
4040
4041                 /* Game start messages */
4042                 if (strncmp(why, "Creating ", 9) == 0 ||
4043                     strncmp(why, "Continuing ", 11) == 0) {
4044                     gs_gamenum = gamenum;
4045                     safeStrCpy(gs_kind, strchr(why, ' ') + 1,sizeof(gs_kind)/sizeof(gs_kind[0]));
4046                     if(ics_gamenum == -1) // [HGM] only if we are not already involved in a game (because gin=1 sends us such messages)
4047                     VariantSwitch(boards[currentMove], StringToVariant(gs_kind)); // [HGM] variantswitch: even before we get first board
4048 #if ZIPPY
4049                     if (appData.zippyPlay) {
4050                         ZippyGameStart(whitename, blackname);
4051                     }
4052 #endif /*ZIPPY*/
4053                     partnerBoardValid = FALSE; // [HGM] bughouse
4054                     continue;
4055                 }
4056
4057                 /* Game end messages */
4058                 if (gameMode == IcsIdle || gameMode == BeginningOfGame ||
4059                     ics_gamenum != gamenum) {
4060                     continue;
4061                 }
4062                 while (endtoken[0] == ' ') endtoken++;
4063                 switch (endtoken[0]) {
4064                   case '*':
4065                   default:
4066                     endtype = GameUnfinished;
4067                     break;
4068                   case '0':
4069                     endtype = BlackWins;
4070                     break;
4071                   case '1':
4072                     if (endtoken[1] == '/')
4073                       endtype = GameIsDrawn;
4074                     else
4075                       endtype = WhiteWins;
4076                     break;
4077                 }
4078                 GameEnds(endtype, why, GE_ICS);
4079 #if ZIPPY
4080                 if (appData.zippyPlay && first.initDone) {
4081                     ZippyGameEnd(endtype, why);
4082                     if (first.pr == NoProc) {
4083                       /* Start the next process early so that we'll
4084                          be ready for the next challenge */
4085                       StartChessProgram(&first);
4086                     }
4087                     /* Send "new" early, in case this command takes
4088                        a long time to finish, so that we'll be ready
4089                        for the next challenge. */
4090                     gameInfo.variant = VariantNormal; // [HGM] variantswitch: suppress sending of 'variant'
4091                     Reset(TRUE, TRUE);
4092                 }
4093 #endif /*ZIPPY*/
4094                 if(appData.bgObserve && partnerBoardValid) DrawPosition(TRUE, partnerBoard);
4095                 continue;
4096             }
4097
4098             if (looking_at(buf, &i, "Removing game * from observation") ||
4099                 looking_at(buf, &i, "no longer observing game *") ||
4100                 looking_at(buf, &i, "Game * (*) has no examiners")) {
4101                 if (gameMode == IcsObserving &&
4102                     atoi(star_match[0]) == ics_gamenum)
4103                   {
4104                       /* icsEngineAnalyze */
4105                       if (appData.icsEngineAnalyze) {
4106                             ExitAnalyzeMode();
4107                             ModeHighlight();
4108                       }
4109                       StopClocks();
4110                       gameMode = IcsIdle;
4111                       ics_gamenum = -1;
4112                       ics_user_moved = FALSE;
4113                   }
4114                 continue;
4115             }
4116
4117             if (looking_at(buf, &i, "no longer examining game *")) {
4118                 if (gameMode == IcsExamining &&
4119                     atoi(star_match[0]) == ics_gamenum)
4120                   {
4121                       gameMode = IcsIdle;
4122                       ics_gamenum = -1;
4123                       ics_user_moved = FALSE;
4124                   }
4125                 continue;
4126             }
4127
4128             /* Advance leftover_start past any newlines we find,
4129                so only partial lines can get reparsed */
4130             if (looking_at(buf, &i, "\n")) {
4131                 prevColor = curColor;
4132                 if (curColor != ColorNormal) {
4133                     if (oldi > next_out) {
4134                         SendToPlayer(&buf[next_out], oldi - next_out);
4135                         next_out = oldi;
4136                     }
4137                     Colorize(ColorNormal, FALSE);
4138                     curColor = ColorNormal;
4139                 }
4140                 if (started == STARTED_BOARD) {
4141                     started = STARTED_NONE;
4142                     parse[parse_pos] = NULLCHAR;
4143                     ParseBoard12(parse);
4144                     ics_user_moved = 0;
4145
4146                     /* Send premove here */
4147                     if (appData.premove) {
4148                       char str[MSG_SIZ];
4149                       if (currentMove == 0 &&
4150                           gameMode == IcsPlayingWhite &&
4151                           appData.premoveWhite) {
4152                         snprintf(str, MSG_SIZ, "%s\n", appData.premoveWhiteText);
4153                         if (appData.debugMode)
4154                           fprintf(debugFP, "Sending premove:\n");
4155                         SendToICS(str);
4156                       } else if (currentMove == 1 &&
4157                                  gameMode == IcsPlayingBlack &&
4158                                  appData.premoveBlack) {
4159                         snprintf(str, MSG_SIZ, "%s\n", appData.premoveBlackText);
4160                         if (appData.debugMode)
4161                           fprintf(debugFP, "Sending premove:\n");
4162                         SendToICS(str);
4163                       } else if (gotPremove) {
4164                         gotPremove = 0;
4165                         ClearPremoveHighlights();
4166                         if (appData.debugMode)
4167                           fprintf(debugFP, "Sending premove:\n");
4168                           UserMoveEvent(premoveFromX, premoveFromY,
4169                                         premoveToX, premoveToY,
4170                                         premovePromoChar);
4171                       }
4172                     }
4173
4174                     /* Usually suppress following prompt */
4175                     if (!(forwardMostMove == 0 && gameMode == IcsExamining)) {
4176                         while(looking_at(buf, &i, "\n")); // [HGM] skip empty lines
4177                         if (looking_at(buf, &i, "*% ")) {
4178                             savingComment = FALSE;
4179                             suppressKibitz = 0;
4180                         }
4181                     }
4182                     next_out = i;
4183                 } else if (started == STARTED_HOLDINGS) {
4184                     int gamenum;
4185                     char new_piece[MSG_SIZ];
4186                     started = STARTED_NONE;
4187                     parse[parse_pos] = NULLCHAR;
4188                     if (appData.debugMode)
4189                       fprintf(debugFP, "Parsing holdings: %s, currentMove = %d\n",
4190                                                         parse, currentMove);
4191                     if (sscanf(parse, " game %d", &gamenum) == 1) {
4192                       if(gamenum == ics_gamenum) { // [HGM] bughouse: old code if part of foreground game
4193                         if (gameInfo.variant == VariantNormal) {
4194                           /* [HGM] We seem to switch variant during a game!
4195                            * Presumably no holdings were displayed, so we have
4196                            * to move the position two files to the right to
4197                            * create room for them!
4198                            */
4199                           VariantClass newVariant;
4200                           switch(gameInfo.boardWidth) { // base guess on board width
4201                                 case 9:  newVariant = VariantShogi; break;
4202                                 case 10: newVariant = VariantGreat; break;
4203                                 default: newVariant = VariantCrazyhouse; break;
4204                           }
4205                           VariantSwitch(boards[currentMove], newVariant); /* temp guess */
4206                           /* Get a move list just to see the header, which
4207                              will tell us whether this is really bug or zh */
4208                           if (ics_getting_history == H_FALSE) {
4209                             ics_getting_history = H_REQUESTED;
4210                             snprintf(str, MSG_SIZ, "%smoves %d\n", ics_prefix, gamenum);
4211                             SendToICS(str);
4212                           }
4213                         }
4214                         new_piece[0] = NULLCHAR;
4215                         sscanf(parse, "game %d white [%s black [%s <- %s",
4216                                &gamenum, white_holding, black_holding,
4217                                new_piece);
4218                         white_holding[strlen(white_holding)-1] = NULLCHAR;
4219                         black_holding[strlen(black_holding)-1] = NULLCHAR;
4220                         /* [HGM] copy holdings to board holdings area */
4221                         CopyHoldings(boards[forwardMostMove], white_holding, WhitePawn);
4222                         CopyHoldings(boards[forwardMostMove], black_holding, BlackPawn);
4223                         boards[forwardMostMove][HOLDINGS_SET] = 1; // flag holdings as set
4224 #if ZIPPY
4225                         if (appData.zippyPlay && first.initDone) {
4226                             ZippyHoldings(white_holding, black_holding,
4227                                           new_piece);
4228                         }
4229 #endif /*ZIPPY*/
4230                         if (tinyLayout || smallLayout) {
4231                             char wh[16], bh[16];
4232                             PackHolding(wh, white_holding);
4233                             PackHolding(bh, black_holding);
4234                             snprintf(str, MSG_SIZ, "[%s-%s] %s-%s", wh, bh,
4235                                     gameInfo.white, gameInfo.black);
4236                         } else {
4237                           snprintf(str, MSG_SIZ, "%s [%s] %s %s [%s]",
4238                                     gameInfo.white, white_holding, _("vs."),
4239                                     gameInfo.black, black_holding);
4240                         }
4241                         if(!partnerUp) // [HGM] bughouse: when peeking at partner game we already know what he captured...
4242                         DrawPosition(FALSE, boards[currentMove]);
4243                         DisplayTitle(str);
4244                       } else if(appData.bgObserve) { // [HGM] bughouse: holdings of other game => background
4245                         sscanf(parse, "game %d white [%s black [%s <- %s",
4246                                &gamenum, white_holding, black_holding,
4247                                new_piece);
4248                         white_holding[strlen(white_holding)-1] = NULLCHAR;
4249                         black_holding[strlen(black_holding)-1] = NULLCHAR;
4250                         /* [HGM] copy holdings to partner-board holdings area */
4251                         CopyHoldings(partnerBoard, white_holding, WhitePawn);
4252                         CopyHoldings(partnerBoard, black_holding, BlackPawn);
4253                         if(twoBoards) { partnerUp = 1; flipView = !flipView; } // [HGM] dual: always draw
4254                         if(partnerUp) DrawPosition(FALSE, partnerBoard);
4255                         if(twoBoards) { partnerUp = 0; flipView = !flipView; }
4256                       }
4257                     }
4258                     /* Suppress following prompt */
4259                     if (looking_at(buf, &i, "*% ")) {
4260                         if(strchr(star_match[0], 7)) SendToPlayer("\007", 1); // Bell(); // FICS fuses bell for next board with prompt in zh captures
4261                         savingComment = FALSE;
4262                         suppressKibitz = 0;
4263                     }
4264                     next_out = i;
4265                 }
4266                 continue;
4267             }
4268
4269             i++;                /* skip unparsed character and loop back */
4270         }
4271
4272         if (started != STARTED_MOVES && started != STARTED_BOARD && !suppressKibitz && // [HGM] kibitz
4273 //          started != STARTED_HOLDINGS && i > next_out) { // [HGM] should we compare to leftover_start in stead of i?
4274 //          SendToPlayer(&buf[next_out], i - next_out);
4275             started != STARTED_HOLDINGS && leftover_start > next_out) {
4276             SendToPlayer(&buf[next_out], leftover_start - next_out);
4277             next_out = i;
4278         }
4279
4280         leftover_len = buf_len - leftover_start;
4281         /* if buffer ends with something we couldn't parse,
4282            reparse it after appending the next read */
4283
4284     } else if (count == 0) {
4285         RemoveInputSource(isr);
4286         DisplayFatalError(_("Connection closed by ICS"), 0, 0);
4287     } else {
4288         DisplayFatalError(_("Error reading from ICS"), error, 1);
4289     }
4290 }
4291
4292
4293 /* Board style 12 looks like this:
4294
4295    <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
4296
4297  * The "<12> " is stripped before it gets to this routine.  The two
4298  * trailing 0's (flip state and clock ticking) are later addition, and
4299  * some chess servers may not have them, or may have only the first.
4300  * Additional trailing fields may be added in the future.
4301  */
4302
4303 #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"
4304
4305 #define RELATION_OBSERVING_PLAYED    0
4306 #define RELATION_OBSERVING_STATIC   -2   /* examined, oldmoves, or smoves */
4307 #define RELATION_PLAYING_MYMOVE      1
4308 #define RELATION_PLAYING_NOTMYMOVE  -1
4309 #define RELATION_EXAMINING           2
4310 #define RELATION_ISOLATED_BOARD     -3
4311 #define RELATION_STARTING_POSITION  -4   /* FICS only */
4312
4313 void
4314 ParseBoard12 (char *string)
4315 {
4316 #if ZIPPY
4317     int i, takeback;
4318     char *bookHit = NULL; // [HGM] book
4319 #endif
4320     GameMode newGameMode;
4321     int gamenum, newGame, newMove, relation, basetime, increment, ics_flip = 0;
4322     int j, k, n, moveNum, white_stren, black_stren, white_time, black_time;
4323     int double_push, castle_ws, castle_wl, castle_bs, castle_bl, irrev_count;
4324     char to_play, board_chars[200];
4325     char move_str[MSG_SIZ], str[MSG_SIZ], elapsed_time[MSG_SIZ];
4326     char black[32], white[32];
4327     Board board;
4328     int prevMove = currentMove;
4329     int ticking = 2;
4330     ChessMove moveType;
4331     int fromX, fromY, toX, toY;
4332     char promoChar;
4333     int ranks=1, files=0; /* [HGM] ICS80: allow variable board size */
4334     Boolean weird = FALSE, reqFlag = FALSE;
4335
4336     fromX = fromY = toX = toY = -1;
4337
4338     newGame = FALSE;
4339
4340     if (appData.debugMode)
4341       fprintf(debugFP, "Parsing board: %s\n", string);
4342
4343     move_str[0] = NULLCHAR;
4344     elapsed_time[0] = NULLCHAR;
4345     {   /* [HGM] figure out how many ranks and files the board has, for ICS extension used by Capablanca server */
4346         int  i = 0, j;
4347         while(i < 199 && (string[i] != ' ' || string[i+2] != ' ')) {
4348             if(string[i] == ' ') { ranks++; files = 0; }
4349             else files++;
4350             if(!strchr(" -pnbrqkPNBRQK" , string[i])) weird = TRUE; // test for fairies
4351             i++;
4352         }
4353         for(j = 0; j <i; j++) board_chars[j] = string[j];
4354         board_chars[i] = '\0';
4355         string += i + 1;
4356     }
4357     n = sscanf(string, PATTERN, &to_play, &double_push,
4358                &castle_ws, &castle_wl, &castle_bs, &castle_bl, &irrev_count,
4359                &gamenum, white, black, &relation, &basetime, &increment,
4360                &white_stren, &black_stren, &white_time, &black_time,
4361                &moveNum, str, elapsed_time, move_str, &ics_flip,
4362                &ticking);
4363
4364     if (n < 21) {
4365         snprintf(str, MSG_SIZ, _("Failed to parse board string:\n\"%s\""), string);
4366         DisplayError(str, 0);
4367         return;
4368     }
4369
4370     /* Convert the move number to internal form */
4371     moveNum = (moveNum - 1) * 2;
4372     if (to_play == 'B') moveNum++;
4373     if (moveNum > framePtr) { // [HGM] vari: do not run into saved variations
4374       DisplayFatalError(_("Game too long; increase MAX_MOVES and recompile"),
4375                         0, 1);
4376       return;
4377     }
4378
4379     switch (relation) {
4380       case RELATION_OBSERVING_PLAYED:
4381       case RELATION_OBSERVING_STATIC:
4382         if (gamenum == -1) {
4383             /* Old ICC buglet */
4384             relation = RELATION_OBSERVING_STATIC;
4385         }
4386         newGameMode = IcsObserving;
4387         break;
4388       case RELATION_PLAYING_MYMOVE:
4389       case RELATION_PLAYING_NOTMYMOVE:
4390         newGameMode =
4391           ((relation == RELATION_PLAYING_MYMOVE) == (to_play == 'W')) ?
4392             IcsPlayingWhite : IcsPlayingBlack;
4393         soughtPending =FALSE; // [HGM] seekgraph: solve race condition
4394         break;
4395       case RELATION_EXAMINING:
4396         newGameMode = IcsExamining;
4397         break;
4398       case RELATION_ISOLATED_BOARD:
4399       default:
4400         /* Just display this board.  If user was doing something else,
4401            we will forget about it until the next board comes. */
4402         newGameMode = IcsIdle;
4403         break;
4404       case RELATION_STARTING_POSITION:
4405         newGameMode = gameMode;
4406         break;
4407     }
4408
4409     if((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack ||
4410         gameMode == IcsObserving && appData.dualBoard) // also allow use of second board for observing two games
4411          && newGameMode == IcsObserving && gamenum != ics_gamenum && appData.bgObserve) {
4412       // [HGM] bughouse: don't act on alien boards while we play. Just parse the board and save it */
4413       int fac = strchr(elapsed_time, '.') ? 1 : 1000;
4414       static int lastBgGame = -1;
4415       char *toSqr;
4416       for (k = 0; k < ranks; k++) {
4417         for (j = 0; j < files; j++)
4418           board[k][j+gameInfo.holdingsWidth] = CharToPiece(board_chars[(ranks-1-k)*(files+1) + j]);
4419         if(gameInfo.holdingsWidth > 1) {
4420              board[k][0] = board[k][BOARD_WIDTH-1] = EmptySquare;
4421              board[k][1] = board[k][BOARD_WIDTH-2] = (ChessSquare) 0;;
4422         }
4423       }
4424       CopyBoard(partnerBoard, board);
4425       if(toSqr = strchr(str, '/')) { // extract highlights from long move
4426         partnerBoard[EP_STATUS-3] = toSqr[1] - AAA; // kludge: hide highlighting info in board
4427         partnerBoard[EP_STATUS-4] = toSqr[2] - ONE;
4428       } else partnerBoard[EP_STATUS-4] = partnerBoard[EP_STATUS-3] = -1;
4429       if(toSqr = strchr(str, '-')) {
4430         partnerBoard[EP_STATUS-1] = toSqr[1] - AAA;
4431         partnerBoard[EP_STATUS-2] = toSqr[2] - ONE;
4432       } else partnerBoard[EP_STATUS-1] = partnerBoard[EP_STATUS-2] = -1;
4433       if(appData.dualBoard && !twoBoards) { twoBoards = 1; InitDrawingSizes(-2,0); }
4434       if(twoBoards) { partnerUp = 1; flipView = !flipView; } // [HGM] dual
4435       if(partnerUp) DrawPosition(FALSE, partnerBoard);
4436       if(twoBoards) {
4437           DisplayWhiteClock(white_time*fac, to_play == 'W');
4438           DisplayBlackClock(black_time*fac, to_play != 'W');
4439           activePartner = to_play;
4440           if(gamenum != lastBgGame) {
4441               char buf[MSG_SIZ];
4442               snprintf(buf, MSG_SIZ, "%s %s %s", white, _("vs."), black);
4443               DisplayTitle(buf);
4444           }
4445           lastBgGame = gamenum;
4446           activePartnerTime = to_play == 'W' ? white_time*fac : black_time*fac;
4447                       partnerUp = 0; flipView = !flipView; } // [HGM] dual
4448       snprintf(partnerStatus, MSG_SIZ,"W: %d:%02d B: %d:%02d (%d-%d) %c", white_time*fac/60000, (white_time*fac%60000)/1000,
4449                  (black_time*fac/60000), (black_time*fac%60000)/1000, white_stren, black_stren, to_play);
4450       if(!twoBoards) DisplayMessage(partnerStatus, "");
4451         partnerBoardValid = TRUE;
4452       return;
4453     }
4454
4455     if(appData.dualBoard && appData.bgObserve) {
4456         if((newGameMode == IcsPlayingWhite || newGameMode == IcsPlayingBlack) && moveNum == 1)
4457             SendToICS(ics_prefix), SendToICS("pobserve\n");
4458         else if(newGameMode == IcsObserving && (gameMode == BeginningOfGame || gameMode == IcsIdle)) {
4459             char buf[MSG_SIZ];
4460             snprintf(buf, MSG_SIZ, "%spobserve %s\n", ics_prefix, white);
4461             SendToICS(buf);
4462         }
4463     }
4464
4465     /* Modify behavior for initial board display on move listing
4466        of wild games.
4467        */
4468     switch (ics_getting_history) {
4469       case H_FALSE:
4470       case H_REQUESTED:
4471         break;
4472       case H_GOT_REQ_HEADER:
4473       case H_GOT_UNREQ_HEADER:
4474         /* This is the initial position of the current game */
4475         gamenum = ics_gamenum;
4476         moveNum = 0;            /* old ICS bug workaround */
4477         if (to_play == 'B') {
4478           startedFromSetupPosition = TRUE;
4479           blackPlaysFirst = TRUE;
4480           moveNum = 1;
4481           if (forwardMostMove == 0) forwardMostMove = 1;
4482           if (backwardMostMove == 0) backwardMostMove = 1;
4483           if (currentMove == 0) currentMove = 1;
4484         }
4485         newGameMode = gameMode;
4486         relation = RELATION_STARTING_POSITION; /* ICC needs this */
4487         break;
4488       case H_GOT_UNWANTED_HEADER:
4489         /* This is an initial board that we don't want */
4490         return;
4491       case H_GETTING_MOVES:
4492         /* Should not happen */
4493         DisplayError(_("Error gathering move list: extra board"), 0);
4494         ics_getting_history = H_FALSE;
4495         return;
4496     }
4497
4498    if (gameInfo.boardHeight != ranks || gameInfo.boardWidth != files ||
4499                                         move_str[1] == '@' && !gameInfo.holdingsWidth ||
4500                                         weird && (int)gameInfo.variant < (int)VariantShogi) {
4501      /* [HGM] We seem to have switched variant unexpectedly
4502       * Try to guess new variant from board size
4503       */
4504           VariantClass newVariant = VariantFairy; // if 8x8, but fairies present
4505           if(ranks == 8 && files == 10) newVariant = VariantCapablanca; else
4506           if(ranks == 10 && files == 9) newVariant = VariantXiangqi; else
4507           if(ranks == 8 && files == 12) newVariant = VariantCourier; else
4508           if(ranks == 9 && files == 9)  newVariant = VariantShogi; else
4509           if(ranks == 10 && files == 10) newVariant = VariantGrand; else
4510           if(!weird) newVariant = move_str[1] == '@' ? VariantCrazyhouse : VariantNormal;
4511           VariantSwitch(boards[currentMove], newVariant); /* temp guess */
4512           /* Get a move list just to see the header, which
4513              will tell us whether this is really bug or zh */
4514           if (ics_getting_history == H_FALSE) {
4515             ics_getting_history = H_REQUESTED; reqFlag = TRUE;
4516             snprintf(str, MSG_SIZ, "%smoves %d\n", ics_prefix, gamenum);
4517             SendToICS(str);
4518           }
4519     }
4520
4521     /* Take action if this is the first board of a new game, or of a
4522        different game than is currently being displayed.  */
4523     if (gamenum != ics_gamenum || newGameMode != gameMode ||
4524         relation == RELATION_ISOLATED_BOARD) {
4525
4526         /* Forget the old game and get the history (if any) of the new one */
4527         if (gameMode != BeginningOfGame) {
4528           Reset(TRUE, TRUE);
4529         }
4530         newGame = TRUE;
4531         if (appData.autoRaiseBoard) BoardToTop();
4532         prevMove = -3;
4533         if (gamenum == -1) {
4534             newGameMode = IcsIdle;
4535         } else if ((moveNum > 0 || newGameMode == IcsObserving) && newGameMode != IcsIdle &&
4536                    appData.getMoveList && !reqFlag) {
4537             /* Need to get game history */
4538             ics_getting_history = H_REQUESTED;
4539             snprintf(str, MSG_SIZ, "%smoves %d\n", ics_prefix, gamenum);
4540             SendToICS(str);
4541         }
4542
4543         /* Initially flip the board to have black on the bottom if playing
4544            black or if the ICS flip flag is set, but let the user change
4545            it with the Flip View button. */
4546         flipView = appData.autoFlipView ?
4547           (newGameMode == IcsPlayingBlack) || ics_flip :
4548           appData.flipView;
4549
4550         /* Done with values from previous mode; copy in new ones */
4551         gameMode = newGameMode;
4552         ModeHighlight();
4553         ics_gamenum = gamenum;
4554         if (gamenum == gs_gamenum) {
4555             int klen = strlen(gs_kind);
4556             if (gs_kind[klen - 1] == '.') gs_kind[klen - 1] = NULLCHAR;
4557             snprintf(str, MSG_SIZ, "ICS %s", gs_kind);
4558             gameInfo.event = StrSave(str);
4559         } else {
4560             gameInfo.event = StrSave("ICS game");
4561         }
4562         gameInfo.site = StrSave(appData.icsHost);
4563         gameInfo.date = PGNDate();
4564         gameInfo.round = StrSave("-");
4565         gameInfo.white = StrSave(white);
4566         gameInfo.black = StrSave(black);
4567         timeControl = basetime * 60 * 1000;
4568         timeControl_2 = 0;
4569         timeIncrement = increment * 1000;
4570         movesPerSession = 0;
4571         gameInfo.timeControl = TimeControlTagValue();
4572         VariantSwitch(boards[currentMove], StringToVariant(gameInfo.event) );
4573   if (appData.debugMode) {
4574     fprintf(debugFP, "ParseBoard says variant = '%s'\n", gameInfo.event);
4575     fprintf(debugFP, "recognized as %s\n", VariantName(gameInfo.variant));
4576     setbuf(debugFP, NULL);
4577   }
4578
4579         gameInfo.outOfBook = NULL;
4580
4581         /* Do we have the ratings? */
4582         if (strcmp(player1Name, white) == 0 &&
4583             strcmp(player2Name, black) == 0) {
4584             if (appData.debugMode)
4585               fprintf(debugFP, "Remembered ratings: W %d, B %d\n",
4586                       player1Rating, player2Rating);
4587             gameInfo.whiteRating = player1Rating;
4588             gameInfo.blackRating = player2Rating;
4589         } else if (strcmp(player2Name, white) == 0 &&
4590                    strcmp(player1Name, black) == 0) {
4591             if (appData.debugMode)
4592               fprintf(debugFP, "Remembered ratings: W %d, B %d\n",
4593                       player2Rating, player1Rating);
4594             gameInfo.whiteRating = player2Rating;
4595             gameInfo.blackRating = player1Rating;
4596         }
4597         player1Name[0] = player2Name[0] = NULLCHAR;
4598
4599         /* Silence shouts if requested */
4600         if (appData.quietPlay &&
4601             (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack)) {
4602             SendToICS(ics_prefix);
4603             SendToICS("set shout 0\n");
4604         }
4605     }
4606
4607     /* Deal with midgame name changes */
4608     if (!newGame) {
4609         if (!gameInfo.white || strcmp(gameInfo.white, white) != 0) {
4610             if (gameInfo.white) free(gameInfo.white);
4611             gameInfo.white = StrSave(white);
4612         }
4613         if (!gameInfo.black || strcmp(gameInfo.black, black) != 0) {
4614             if (gameInfo.black) free(gameInfo.black);
4615             gameInfo.black = StrSave(black);
4616         }
4617     }
4618
4619     /* Throw away game result if anything actually changes in examine mode */
4620     if (gameMode == IcsExamining && !newGame) {
4621         gameInfo.result = GameUnfinished;
4622         if (gameInfo.resultDetails != NULL) {
4623             free(gameInfo.resultDetails);
4624             gameInfo.resultDetails = NULL;
4625         }
4626     }
4627
4628     /* In pausing && IcsExamining mode, we ignore boards coming
4629        in if they are in a different variation than we are. */
4630     if (pauseExamInvalid) return;
4631     if (pausing && gameMode == IcsExamining) {
4632         if (moveNum <= pauseExamForwardMostMove) {
4633             pauseExamInvalid = TRUE;
4634             forwardMostMove = pauseExamForwardMostMove;
4635             return;
4636         }
4637     }
4638
4639   if (appData.debugMode) {
4640     fprintf(debugFP, "load %dx%d board\n", files, ranks);
4641   }
4642     /* Parse the board */
4643     for (k = 0; k < ranks; k++) {
4644       for (j = 0; j < files; j++)
4645         board[k][j+gameInfo.holdingsWidth] = CharToPiece(board_chars[(ranks-1-k)*(files+1) + j]);
4646       if(gameInfo.holdingsWidth > 1) {
4647            board[k][0] = board[k][BOARD_WIDTH-1] = EmptySquare;
4648            board[k][1] = board[k][BOARD_WIDTH-2] = (ChessSquare) 0;;
4649       }
4650     }
4651     if(moveNum==0 && gameInfo.variant == VariantSChess) {
4652       board[5][BOARD_RGHT+1] = WhiteAngel;
4653       board[6][BOARD_RGHT+1] = WhiteMarshall;
4654       board[1][0] = BlackMarshall;
4655       board[2][0] = BlackAngel;
4656       board[1][1] = board[2][1] = board[5][BOARD_RGHT] = board[6][BOARD_RGHT] = 1;
4657     }
4658     CopyBoard(boards[moveNum], board);
4659     boards[moveNum][HOLDINGS_SET] = 0; // [HGM] indicate holdings not set
4660     if (moveNum == 0) {
4661         startedFromSetupPosition =
4662           !CompareBoards(board, initialPosition);
4663         if(startedFromSetupPosition)
4664             initialRulePlies = irrev_count; /* [HGM] 50-move counter offset */
4665     }
4666
4667     /* [HGM] Set castling rights. Take the outermost Rooks,
4668        to make it also work for FRC opening positions. Note that board12
4669        is really defective for later FRC positions, as it has no way to
4670        indicate which Rook can castle if they are on the same side of King.
4671        For the initial position we grant rights to the outermost Rooks,
4672        and remember thos rights, and we then copy them on positions
4673        later in an FRC game. This means WB might not recognize castlings with
4674        Rooks that have moved back to their original position as illegal,
4675        but in ICS mode that is not its job anyway.
4676     */
4677     if(moveNum == 0 || gameInfo.variant != VariantFischeRandom)
4678     { int i, j; ChessSquare wKing = WhiteKing, bKing = BlackKing;
4679
4680         for(i=BOARD_LEFT, j=NoRights; i<BOARD_RGHT; i++)
4681             if(board[0][i] == WhiteRook) j = i;
4682         initialRights[0] = boards[moveNum][CASTLING][0] = (castle_ws == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
4683         for(i=BOARD_RGHT-1, j=NoRights; i>=BOARD_LEFT; i--)
4684             if(board[0][i] == WhiteRook) j = i;
4685         initialRights[1] = boards[moveNum][CASTLING][1] = (castle_wl == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
4686         for(i=BOARD_LEFT, j=NoRights; i<BOARD_RGHT; i++)
4687             if(board[BOARD_HEIGHT-1][i] == BlackRook) j = i;
4688         initialRights[3] = boards[moveNum][CASTLING][3] = (castle_bs == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
4689         for(i=BOARD_RGHT-1, j=NoRights; i>=BOARD_LEFT; i--)
4690             if(board[BOARD_HEIGHT-1][i] == BlackRook) j = i;
4691         initialRights[4] = boards[moveNum][CASTLING][4] = (castle_bl == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
4692
4693         boards[moveNum][CASTLING][2] = boards[moveNum][CASTLING][5] = NoRights;
4694         if(gameInfo.variant == VariantKnightmate) { wKing = WhiteUnicorn; bKing = BlackUnicorn; }
4695         for(k=BOARD_LEFT; k<BOARD_RGHT; k++)
4696             if(board[0][k] == wKing) initialRights[2] = boards[moveNum][CASTLING][2] = k;
4697         for(k=BOARD_LEFT; k<BOARD_RGHT; k++)
4698             if(board[BOARD_HEIGHT-1][k] == bKing)
4699                 initialRights[5] = boards[moveNum][CASTLING][5] = k;
4700         if(gameInfo.variant == VariantTwoKings) {
4701             // In TwoKings looking for a King does not work, so always give castling rights to a King on e1/e8
4702             if(board[0][4] == wKing) initialRights[2] = boards[moveNum][CASTLING][2] = 4;
4703             if(board[BOARD_HEIGHT-1][4] == bKing) initialRights[5] = boards[moveNum][CASTLING][5] = 4;
4704         }
4705     } else { int r;
4706         r = boards[moveNum][CASTLING][0] = initialRights[0];
4707         if(board[0][r] != WhiteRook) boards[moveNum][CASTLING][0] = NoRights;
4708         r = boards[moveNum][CASTLING][1] = initialRights[1];
4709         if(board[0][r] != WhiteRook) boards[moveNum][CASTLING][1] = NoRights;
4710         r = boards[moveNum][CASTLING][3] = initialRights[3];
4711         if(board[BOARD_HEIGHT-1][r] != BlackRook) boards[moveNum][CASTLING][3] = NoRights;
4712         r = boards[moveNum][CASTLING][4] = initialRights[4];
4713         if(board[BOARD_HEIGHT-1][r] != BlackRook) boards[moveNum][CASTLING][4] = NoRights;
4714         /* wildcastle kludge: always assume King has rights */
4715         r = boards[moveNum][CASTLING][2] = initialRights[2];
4716         r = boards[moveNum][CASTLING][5] = initialRights[5];
4717     }
4718     /* [HGM] e.p. rights. Assume that ICS sends file number here? */
4719     boards[moveNum][EP_STATUS] = EP_NONE;
4720     if(str[0] == 'P') boards[moveNum][EP_STATUS] = EP_PAWN_MOVE;
4721     if(strchr(move_str, 'x')) boards[moveNum][EP_STATUS] = EP_CAPTURE;
4722     if(double_push !=  -1) boards[moveNum][EP_STATUS] = double_push + BOARD_LEFT;
4723
4724
4725     if (ics_getting_history == H_GOT_REQ_HEADER ||
4726         ics_getting_history == H_GOT_UNREQ_HEADER) {
4727         /* This was an initial position from a move list, not
4728            the current position */
4729         return;
4730     }
4731
4732     /* Update currentMove and known move number limits */
4733     newMove = newGame || moveNum > forwardMostMove;
4734
4735     if (newGame) {
4736         forwardMostMove = backwardMostMove = currentMove = moveNum;
4737         if (gameMode == IcsExamining && moveNum == 0) {
4738           /* Workaround for ICS limitation: we are not told the wild
4739              type when starting to examine a game.  But if we ask for
4740              the move list, the move list header will tell us */
4741             ics_getting_history = H_REQUESTED;
4742             snprintf(str, MSG_SIZ, "%smoves %d\n", ics_prefix, gamenum);
4743             SendToICS(str);
4744         }
4745     } else if (moveNum == forwardMostMove + 1 || moveNum == forwardMostMove
4746                || (moveNum < forwardMostMove && moveNum >= backwardMostMove)) {
4747 #if ZIPPY
4748         /* [DM] If we found takebacks during icsEngineAnalyze try send to engine */
4749         /* [HGM] applied this also to an engine that is silently watching        */
4750         if (appData.zippyPlay && moveNum < forwardMostMove && first.initDone &&
4751             (gameMode == IcsObserving || gameMode == IcsExamining) &&
4752             gameInfo.variant == currentlyInitializedVariant) {
4753           takeback = forwardMostMove - moveNum;
4754           for (i = 0; i < takeback; i++) {
4755             if (appData.debugMode) fprintf(debugFP, "take back move\n");
4756             SendToProgram("undo\n", &first);
4757           }
4758         }
4759 #endif
4760
4761         forwardMostMove = moveNum;
4762         if (!pausing || currentMove > forwardMostMove)
4763           currentMove = forwardMostMove;
4764     } else {
4765         /* New part of history that is not contiguous with old part */
4766         if (pausing && gameMode == IcsExamining) {
4767             pauseExamInvalid = TRUE;
4768             forwardMostMove = pauseExamForwardMostMove;
4769             return;
4770         }
4771         if (gameMode == IcsExamining && moveNum > 0 && appData.getMoveList) {
4772 #if ZIPPY
4773             if(appData.zippyPlay && forwardMostMove > 0 && first.initDone) {
4774                 // [HGM] when we will receive the move list we now request, it will be
4775                 // fed to the engine from the first move on. So if the engine is not
4776                 // in the initial position now, bring it there.
4777                 InitChessProgram(&first, 0);
4778             }
4779 #endif
4780             ics_getting_history = H_REQUESTED;
4781             snprintf(str, MSG_SIZ, "%smoves %d\n", ics_prefix, gamenum);
4782             SendToICS(str);
4783         }
4784         forwardMostMove = backwardMostMove = currentMove = moveNum;
4785     }
4786
4787     /* Update the clocks */
4788     if (strchr(elapsed_time, '.')) {
4789       /* Time is in ms */
4790       timeRemaining[0][moveNum] = whiteTimeRemaining = white_time;
4791       timeRemaining[1][moveNum] = blackTimeRemaining = black_time;
4792     } else {
4793       /* Time is in seconds */
4794       timeRemaining[0][moveNum] = whiteTimeRemaining = white_time * 1000;
4795       timeRemaining[1][moveNum] = blackTimeRemaining = black_time * 1000;
4796     }
4797
4798
4799 #if ZIPPY
4800     if (appData.zippyPlay && newGame &&
4801         gameMode != IcsObserving && gameMode != IcsIdle &&
4802         gameMode != IcsExamining)
4803       ZippyFirstBoard(moveNum, basetime, increment);
4804 #endif
4805
4806     /* Put the move on the move list, first converting
4807        to canonical algebraic form. */
4808     if (moveNum > 0) {
4809   if (appData.debugMode) {
4810     int f = forwardMostMove;
4811     fprintf(debugFP, "parseboard %d, castling = %d %d %d %d %d %d\n", f,
4812             boards[f][CASTLING][0],boards[f][CASTLING][1],boards[f][CASTLING][2],
4813             boards[f][CASTLING][3],boards[f][CASTLING][4],boards[f][CASTLING][5]);
4814     fprintf(debugFP, "accepted move %s from ICS, parse it.\n", move_str);
4815     fprintf(debugFP, "moveNum = %d\n", moveNum);
4816     fprintf(debugFP, "board = %d-%d x %d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT);
4817     setbuf(debugFP, NULL);
4818   }
4819         if (moveNum <= backwardMostMove) {
4820             /* We don't know what the board looked like before
4821                this move.  Punt. */
4822           safeStrCpy(parseList[moveNum - 1], move_str, sizeof(parseList[moveNum - 1])/sizeof(parseList[moveNum - 1][0]));
4823             strcat(parseList[moveNum - 1], " ");
4824             strcat(parseList[moveNum - 1], elapsed_time);
4825             moveList[moveNum - 1][0] = NULLCHAR;
4826         } else if (strcmp(move_str, "none") == 0) {
4827             // [HGM] long SAN: swapped order; test for 'none' before parsing move
4828             /* Again, we don't know what the board looked like;
4829                this is really the start of the game. */
4830             parseList[moveNum - 1][0] = NULLCHAR;
4831             moveList[moveNum - 1][0] = NULLCHAR;
4832             backwardMostMove = moveNum;
4833             startedFromSetupPosition = TRUE;
4834             fromX = fromY = toX = toY = -1;
4835         } else {
4836           // [HGM] long SAN: if legality-testing is off, disambiguation might not work or give wrong move.
4837           //                 So we parse the long-algebraic move string in stead of the SAN move
4838           int valid; char buf[MSG_SIZ], *prom;
4839
4840           if(gameInfo.variant == VariantShogi && !strchr(move_str, '=') && !strchr(move_str, '@'))
4841                 strcat(move_str, "="); // if ICS does not say 'promote' on non-drop, we defer.
4842           // str looks something like "Q/a1-a2"; kill the slash
4843           if(str[1] == '/')
4844             snprintf(buf, MSG_SIZ,"%c%s", str[0], str+2);
4845           else  safeStrCpy(buf, str, sizeof(buf)/sizeof(buf[0])); // might be castling
4846           if((prom = strstr(move_str, "=")) && !strstr(buf, "="))
4847                 strcat(buf, prom); // long move lacks promo specification!
4848           if(!appData.testLegality && move_str[1] != '@') { // drops never ambiguous (parser chokes on long form!)
4849                 if(appData.debugMode)
4850                         fprintf(debugFP, "replaced ICS move '%s' by '%s'\n", move_str, buf);
4851                 safeStrCpy(move_str, buf, MSG_SIZ);
4852           }
4853           valid = ParseOneMove(move_str, moveNum - 1, &moveType,
4854                                 &fromX, &fromY, &toX, &toY, &promoChar)
4855                || ParseOneMove(buf, moveNum - 1, &moveType,
4856                                 &fromX, &fromY, &toX, &toY, &promoChar);
4857           // end of long SAN patch
4858           if (valid) {
4859             (void) CoordsToAlgebraic(boards[moveNum - 1],
4860                                      PosFlags(moveNum - 1),
4861                                      fromY, fromX, toY, toX, promoChar,
4862                                      parseList[moveNum-1]);
4863             switch (MateTest(boards[moveNum], PosFlags(moveNum)) ) {
4864               case MT_NONE:
4865               case MT_STALEMATE:
4866               default:
4867                 break;
4868               case MT_CHECK:
4869                 if(!IS_SHOGI(gameInfo.variant))
4870                     strcat(parseList[moveNum - 1], "+");
4871                 break;
4872               case MT_CHECKMATE:
4873               case MT_STAINMATE: // [HGM] xq: for notation stalemate that wins counts as checkmate
4874                 strcat(parseList[moveNum - 1], "#");
4875                 break;
4876             }
4877             strcat(parseList[moveNum - 1], " ");
4878             strcat(parseList[moveNum - 1], elapsed_time);
4879             /* currentMoveString is set as a side-effect of ParseOneMove */
4880             if(gameInfo.variant == VariantShogi && currentMoveString[4]) currentMoveString[4] = '^';
4881             safeStrCpy(moveList[moveNum - 1], currentMoveString, sizeof(moveList[moveNum - 1])/sizeof(moveList[moveNum - 1][0]));
4882             strcat(moveList[moveNum - 1], "\n");
4883
4884             if(gameInfo.holdingsWidth && !appData.disguise && gameInfo.variant != VariantSuper && gameInfo.variant != VariantGreat
4885                && gameInfo.variant != VariantGrand&& gameInfo.variant != VariantSChess) // inherit info that ICS does not give from previous board
4886               for(k=0; k<ranks; k++) for(j=BOARD_LEFT; j<BOARD_RGHT; j++) {
4887                 ChessSquare old, new = boards[moveNum][k][j];
4888                   if(fromY == DROP_RANK && k==toY && j==toX) continue; // dropped pieces always stand for themselves
4889                   old = (k==toY && j==toX) ? boards[moveNum-1][fromY][fromX] : boards[moveNum-1][k][j]; // trace back mover
4890                   if(old == new) continue;
4891                   if(old == PROMOTED new) boards[moveNum][k][j] = old; // prevent promoted pieces to revert to primordial ones
4892                   else if(new == WhiteWazir || new == BlackWazir) {
4893                       if(old < WhiteCannon || old >= BlackPawn && old < BlackCannon)
4894                            boards[moveNum][k][j] = PROMOTED old; // choose correct type of Gold in promotion
4895                       else boards[moveNum][k][j] = old; // preserve type of Gold
4896                   } else if((old == WhitePawn || old == BlackPawn) && new != EmptySquare) // Pawn promotions (but not e.p.capture!)
4897                       boards[moveNum][k][j] = PROMOTED new; // use non-primordial representation of chosen piece
4898               }
4899           } else {
4900             /* Move from ICS was illegal!?  Punt. */
4901             if (appData.debugMode) {
4902               fprintf(debugFP, "Illegal move from ICS '%s'\n", move_str);
4903               fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
4904             }
4905             safeStrCpy(parseList[moveNum - 1], move_str, sizeof(parseList[moveNum - 1])/sizeof(parseList[moveNum - 1][0]));
4906             strcat(parseList[moveNum - 1], " ");
4907             strcat(parseList[moveNum - 1], elapsed_time);
4908             moveList[moveNum - 1][0] = NULLCHAR;
4909             fromX = fromY = toX = toY = -1;
4910           }
4911         }
4912   if (appData.debugMode) {
4913     fprintf(debugFP, "Move parsed to '%s'\n", parseList[moveNum - 1]);
4914     setbuf(debugFP, NULL);
4915   }
4916
4917 #if ZIPPY
4918         /* Send move to chess program (BEFORE animating it). */
4919         if (appData.zippyPlay && !newGame && newMove &&
4920            (!appData.getMoveList || backwardMostMove == 0) && first.initDone) {
4921
4922             if ((gameMode == IcsPlayingWhite && WhiteOnMove(moveNum)) ||
4923                 (gameMode == IcsPlayingBlack && !WhiteOnMove(moveNum))) {
4924                 if (moveList[moveNum - 1][0] == NULLCHAR) {
4925                   snprintf(str, MSG_SIZ, _("Couldn't parse move \"%s\" from ICS"),
4926                             move_str);
4927                     DisplayError(str, 0);
4928                 } else {
4929                     if (first.sendTime) {
4930                         SendTimeRemaining(&first, gameMode == IcsPlayingWhite);
4931                     }
4932                     bookHit = SendMoveToBookUser(moveNum - 1, &first, FALSE); // [HGM] book
4933                     if (firstMove && !bookHit) {
4934                         firstMove = FALSE;
4935                         if (first.useColors) {
4936                           SendToProgram(gameMode == IcsPlayingWhite ?
4937                                         "white\ngo\n" :
4938                                         "black\ngo\n", &first);
4939                         } else {
4940                           SendToProgram("go\n", &first);
4941                         }
4942                         first.maybeThinking = TRUE;
4943                     }
4944                 }
4945             } else if (gameMode == IcsObserving || gameMode == IcsExamining) {
4946               if (moveList[moveNum - 1][0] == NULLCHAR) {
4947                 snprintf(str, MSG_SIZ, _("Couldn't parse move \"%s\" from ICS"), move_str);
4948                 DisplayError(str, 0);
4949               } else {
4950                 if(gameInfo.variant == currentlyInitializedVariant) // [HGM] refrain sending moves engine can't understand!
4951                 SendMoveToProgram(moveNum - 1, &first);
4952               }
4953             }
4954         }
4955 #endif
4956     }
4957
4958     if (moveNum > 0 && !gotPremove && !appData.noGUI) {
4959         /* If move comes from a remote source, animate it.  If it
4960            isn't remote, it will have already been animated. */
4961         if (!pausing && !ics_user_moved && prevMove == moveNum - 1) {
4962             AnimateMove(boards[moveNum - 1], fromX, fromY, toX, toY);
4963         }
4964         if (!pausing && appData.highlightLastMove) {
4965             SetHighlights(fromX, fromY, toX, toY);
4966         }
4967     }
4968
4969     /* Start the clocks */
4970     whiteFlag = blackFlag = FALSE;
4971     appData.clockMode = !(basetime == 0 && increment == 0);
4972     if (ticking == 0) {
4973       ics_clock_paused = TRUE;
4974       StopClocks();
4975     } else if (ticking == 1) {
4976       ics_clock_paused = FALSE;
4977     }
4978     if (gameMode == IcsIdle ||
4979         relation == RELATION_OBSERVING_STATIC ||
4980         relation == RELATION_EXAMINING ||
4981         ics_clock_paused)
4982       DisplayBothClocks();
4983     else
4984       StartClocks();
4985
4986     /* Display opponents and material strengths */
4987     if (gameInfo.variant != VariantBughouse &&
4988         gameInfo.variant != VariantCrazyhouse && !appData.noGUI) {
4989         if (tinyLayout || smallLayout) {
4990             if(gameInfo.variant == VariantNormal)
4991               snprintf(str, MSG_SIZ, "%s(%d) %s(%d) {%d %d}",
4992                     gameInfo.white, white_stren, gameInfo.black, black_stren,
4993                     basetime, increment);
4994             else
4995               snprintf(str, MSG_SIZ, "%s(%d) %s(%d) {%d %d w%d}",
4996                     gameInfo.white, white_stren, gameInfo.black, black_stren,
4997                     basetime, increment, (int) gameInfo.variant);
4998         } else {
4999             if(gameInfo.variant == VariantNormal)
5000               snprintf(str, MSG_SIZ, "%s (%d) %s %s (%d) {%d %d}",
5001                     gameInfo.white, white_stren, _("vs."), gameInfo.black, black_stren,
5002                     basetime, increment);
5003             else
5004               snprintf(str, MSG_SIZ, "%s (%d) %s %s (%d) {%d %d %s}",
5005                     gameInfo.white, white_stren, _("vs."), gameInfo.black, black_stren,
5006                     basetime, increment, VariantName(gameInfo.variant));
5007         }
5008         DisplayTitle(str);
5009   if (appData.debugMode) {
5010     fprintf(debugFP, "Display title '%s, gameInfo.variant = %d'\n", str, gameInfo.variant);
5011   }
5012     }
5013
5014
5015     /* Display the board */
5016     if (!pausing && !appData.noGUI) {
5017
5018       if (appData.premove)
5019           if (!gotPremove ||
5020              ((gameMode == IcsPlayingWhite) && (WhiteOnMove(currentMove))) ||
5021              ((gameMode == IcsPlayingBlack) && (!WhiteOnMove(currentMove))))
5022               ClearPremoveHighlights();
5023
5024       j = seekGraphUp; seekGraphUp = FALSE; // [HGM] seekgraph: when we draw a board, it overwrites the seek graph
5025         if(partnerUp) { flipView = originalFlip; partnerUp = FALSE; j = TRUE; } // [HGM] bughouse: restore view
5026       DrawPosition(j, boards[currentMove]);
5027
5028       DisplayMove(moveNum - 1);
5029       if (appData.ringBellAfterMoves && /*!ics_user_moved*/ // [HGM] use absolute method to recognize own move
5030             !((gameMode == IcsPlayingWhite) && (!WhiteOnMove(moveNum)) ||
5031               (gameMode == IcsPlayingBlack) &&  (WhiteOnMove(moveNum))   ) ) {
5032         if(newMove) RingBell(); else PlayIcsUnfinishedSound();
5033       }
5034     }
5035
5036     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
5037 #if ZIPPY
5038     if(bookHit) { // [HGM] book: simulate book reply
5039         static char bookMove[MSG_SIZ]; // a bit generous?
5040
5041         programStats.nodes = programStats.depth = programStats.time =
5042         programStats.score = programStats.got_only_move = 0;
5043         sprintf(programStats.movelist, "%s (xbook)", bookHit);
5044
5045         safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
5046         strcat(bookMove, bookHit);
5047         HandleMachineMove(bookMove, &first);
5048     }
5049 #endif
5050 }
5051
5052 void
5053 GetMoveListEvent ()
5054 {
5055     char buf[MSG_SIZ];
5056     if (appData.icsActive && gameMode != IcsIdle && ics_gamenum > 0) {
5057         ics_getting_history = H_REQUESTED;
5058         snprintf(buf, MSG_SIZ, "%smoves %d\n", ics_prefix, ics_gamenum);
5059         SendToICS(buf);
5060     }
5061 }
5062
5063 void
5064 SendToBoth (char *msg)
5065 {   // to make it easy to keep two engines in step in dual analysis
5066     SendToProgram(msg, &first);
5067     if(second.analyzing) SendToProgram(msg, &second);
5068 }
5069
5070 void
5071 AnalysisPeriodicEvent (int force)
5072 {
5073     if (((programStats.ok_to_send == 0 || programStats.line_is_book)
5074          && !force) || !appData.periodicUpdates)
5075       return;
5076
5077     /* Send . command to Crafty to collect stats */
5078     SendToBoth(".\n");
5079
5080     /* Don't send another until we get a response (this makes
5081        us stop sending to old Crafty's which don't understand
5082        the "." command (sending illegal cmds resets node count & time,
5083        which looks bad)) */
5084     programStats.ok_to_send = 0;
5085 }
5086
5087 void
5088 ics_update_width (int new_width)
5089 {
5090         ics_printf("set width %d\n", new_width);
5091 }
5092
5093 void
5094 SendMoveToProgram (int moveNum, ChessProgramState *cps)
5095 {
5096     char buf[MSG_SIZ];
5097
5098     if(moveList[moveNum][1] == '@' && moveList[moveNum][0] == '@') {
5099         if(gameInfo.variant == VariantLion || gameInfo.variant == VariantChuChess || gameInfo.variant == VariantChu) {
5100             sprintf(buf, "%s@@@@\n", cps->useUsermove ? "usermove " : "");
5101             SendToProgram(buf, cps);
5102             return;
5103         }
5104         // null move in variant where engine does not understand it (for analysis purposes)
5105         SendBoard(cps, moveNum + 1); // send position after move in stead.
5106         return;
5107     }
5108     if (cps->useUsermove) {
5109       SendToProgram("usermove ", cps);
5110     }
5111     if (cps->useSAN) {
5112       char *space;
5113       if ((space = strchr(parseList[moveNum], ' ')) != NULL) {
5114         int len = space - parseList[moveNum];
5115         memcpy(buf, parseList[moveNum], len);
5116         buf[len++] = '\n';
5117         buf[len] = NULLCHAR;
5118       } else {
5119         snprintf(buf, MSG_SIZ,"%s\n", parseList[moveNum]);
5120       }
5121       SendToProgram(buf, cps);
5122     } else {
5123       if(cps->alphaRank) { /* [HGM] shogi: temporarily convert to shogi coordinates before sending */
5124         AlphaRank(moveList[moveNum], 4);
5125         SendToProgram(moveList[moveNum], cps);
5126         AlphaRank(moveList[moveNum], 4); // and back
5127       } else
5128       /* Added by Tord: Send castle moves in "O-O" in FRC games if required by
5129        * the engine. It would be nice to have a better way to identify castle
5130        * moves here. */
5131       if(appData.fischerCastling && cps->useOOCastle) {
5132         int fromX = moveList[moveNum][0] - AAA;
5133         int fromY = moveList[moveNum][1] - ONE;
5134         int toX = moveList[moveNum][2] - AAA;
5135         int toY = moveList[moveNum][3] - ONE;
5136         if((boards[moveNum][fromY][fromX] == WhiteKing
5137             && boards[moveNum][toY][toX] == WhiteRook)
5138            || (boards[moveNum][fromY][fromX] == BlackKing
5139                && boards[moveNum][toY][toX] == BlackRook)) {
5140           if(toX > fromX) SendToProgram("O-O\n", cps);
5141           else SendToProgram("O-O-O\n", cps);
5142         }
5143         else SendToProgram(moveList[moveNum], cps);
5144       } else
5145       if(moveList[moveNum][4] == ';') { // [HGM] lion: move is double-step over intermediate square
5146         char *m = moveList[moveNum];
5147         if((boards[moveNum][m[6]-ONE][m[5]-AAA] < BlackPawn) == (boards[moveNum][m[1]-ONE][m[0]-AAA] < BlackPawn)) // move is kludge to indicate castling
5148           snprintf(buf, MSG_SIZ, "%c%d%c%d,%c%d%c%d\n", m[0], m[1] - '0', // convert to two moves
5149                                                m[2], m[3] - '0',
5150                                                m[5], m[6] - '0',
5151                                                m[2] + (m[0] > m[5] ? 1 : -1), m[3] - '0');
5152         else
5153           snprintf(buf, MSG_SIZ, "%c%d%c%d,%c%d%c%d\n", m[0], m[1] - '0', // convert to two moves
5154                                                m[5], m[6] - '0',
5155                                                m[5], m[6] - '0',
5156                                                m[2], m[3] - '0');
5157           SendToProgram(buf, cps);
5158       } else
5159       if(BOARD_HEIGHT > 10) { // [HGM] big: convert ranks to double-digit where needed
5160         if(moveList[moveNum][1] == '@' && (BOARD_HEIGHT < 16 || moveList[moveNum][0] <= 'Z')) { // drop move
5161           if(moveList[moveNum][0]== '@') snprintf(buf, MSG_SIZ, "@@@@\n"); else
5162           snprintf(buf, MSG_SIZ, "%c@%c%d%s", moveList[moveNum][0],
5163                                               moveList[moveNum][2], moveList[moveNum][3] - '0', moveList[moveNum]+4);
5164         } else
5165           snprintf(buf, MSG_SIZ, "%c%d%c%d%s", moveList[moveNum][0], moveList[moveNum][1] - '0',
5166                                                moveList[moveNum][2], moveList[moveNum][3] - '0', moveList[moveNum]+4);
5167         SendToProgram(buf, cps);
5168       }
5169       else SendToProgram(moveList[moveNum], cps);
5170       /* End of additions by Tord */
5171     }
5172
5173     /* [HGM] setting up the opening has brought engine in force mode! */
5174     /*       Send 'go' if we are in a mode where machine should play. */
5175     if( (moveNum == 0 && setboardSpoiledMachineBlack && cps == &first) &&
5176         (gameMode == TwoMachinesPlay   ||
5177 #if ZIPPY
5178          gameMode == IcsPlayingBlack     || gameMode == IcsPlayingWhite ||
5179 #endif
5180          gameMode == MachinePlaysBlack || gameMode == MachinePlaysWhite) ) {
5181         SendToProgram("go\n", cps);
5182   if (appData.debugMode) {
5183     fprintf(debugFP, "(extra)\n");
5184   }
5185     }
5186     setboardSpoiledMachineBlack = 0;
5187 }
5188
5189 void
5190 SendMoveToICS (ChessMove moveType, int fromX, int fromY, int toX, int toY, char promoChar)
5191 {
5192     char user_move[MSG_SIZ];
5193     char suffix[4];
5194
5195     if(gameInfo.variant == VariantSChess && promoChar) {
5196         snprintf(suffix, 4, "=%c", toX == BOARD_WIDTH<<1 ? ToUpper(promoChar) : ToLower(promoChar));
5197         if(moveType == NormalMove) moveType = WhitePromotion; // kludge to do gating
5198     } else suffix[0] = NULLCHAR;
5199
5200     switch (moveType) {
5201       default:
5202         snprintf(user_move, MSG_SIZ, _("say Internal error; bad moveType %d (%d,%d-%d,%d)"),
5203                 (int)moveType, fromX, fromY, toX, toY);
5204         DisplayError(user_move + strlen("say "), 0);
5205         break;
5206       case WhiteKingSideCastle:
5207       case BlackKingSideCastle:
5208       case WhiteQueenSideCastleWild:
5209       case BlackQueenSideCastleWild:
5210       /* PUSH Fabien */
5211       case WhiteHSideCastleFR:
5212       case BlackHSideCastleFR:
5213       /* POP Fabien */
5214         snprintf(user_move, MSG_SIZ, "o-o%s\n", suffix);
5215         break;
5216       case WhiteQueenSideCastle:
5217       case BlackQueenSideCastle:
5218       case WhiteKingSideCastleWild:
5219       case BlackKingSideCastleWild:
5220       /* PUSH Fabien */
5221       case WhiteASideCastleFR:
5222       case BlackASideCastleFR:
5223       /* POP Fabien */
5224         snprintf(user_move, MSG_SIZ, "o-o-o%s\n",suffix);
5225         break;
5226       case WhiteNonPromotion:
5227       case BlackNonPromotion:
5228         sprintf(user_move, "%c%c%c%c==\n", AAA + fromX, ONE + fromY, AAA + toX, ONE + toY);
5229         break;
5230       case WhitePromotion:
5231       case BlackPromotion:
5232         if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier ||
5233            gameInfo.variant == VariantMakruk)
5234           snprintf(user_move, MSG_SIZ, "%c%c%c%c=%c\n",
5235                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
5236                 PieceToChar(WhiteFerz));
5237         else if(gameInfo.variant == VariantGreat)
5238           snprintf(user_move, MSG_SIZ,"%c%c%c%c=%c\n",
5239                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
5240                 PieceToChar(WhiteMan));
5241         else
5242           snprintf(user_move, MSG_SIZ, "%c%c%c%c=%c\n",
5243                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
5244                 promoChar);
5245         break;
5246       case WhiteDrop:
5247       case BlackDrop:
5248       drop:
5249         snprintf(user_move, MSG_SIZ, "%c@%c%c\n",
5250                  ToUpper(PieceToChar((ChessSquare) fromX)),
5251                  AAA + toX, ONE + toY);
5252         break;
5253       case IllegalMove:  /* could be a variant we don't quite understand */
5254         if(fromY == DROP_RANK) goto drop; // We need 'IllegalDrop' move type?
5255       case NormalMove:
5256       case WhiteCapturesEnPassant:
5257       case BlackCapturesEnPassant:
5258         snprintf(user_move, MSG_SIZ,"%c%c%c%c\n",
5259                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY);
5260         break;
5261     }
5262     SendToICS(user_move);
5263     if(appData.keepAlive) // [HGM] alive: schedule sending of dummy 'date' command
5264         ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
5265 }
5266
5267 void
5268 UploadGameEvent ()
5269 {   // [HGM] upload: send entire stored game to ICS as long-algebraic moves.
5270     int i, last = forwardMostMove; // make sure ICS reply cannot pre-empt us by clearing fmm
5271     static char *castlingStrings[4] = { "none", "kside", "qside", "both" };
5272     if(gameMode == IcsObserving || gameMode == IcsPlayingBlack || gameMode == IcsPlayingWhite) {
5273       DisplayError(_("You cannot do this while you are playing or observing"), 0);
5274       return;
5275     }
5276     if(gameMode != IcsExamining) { // is this ever not the case?
5277         char buf[MSG_SIZ], *p, *fen, command[MSG_SIZ], bsetup = 0;
5278
5279         if(ics_type == ICS_ICC) { // on ICC match ourselves in applicable variant
5280           snprintf(command,MSG_SIZ, "match %s", ics_handle);
5281         } else { // on FICS we must first go to general examine mode
5282           safeStrCpy(command, "examine\nbsetup", sizeof(command)/sizeof(command[0])); // and specify variant within it with bsetups
5283         }
5284         if(gameInfo.variant != VariantNormal) {
5285             // try figure out wild number, as xboard names are not always valid on ICS
5286             for(i=1; i<=36; i++) {
5287               snprintf(buf, MSG_SIZ, "wild/%d", i);
5288                 if(StringToVariant(buf) == gameInfo.variant) break;
5289             }
5290             if(i<=36 && ics_type == ICS_ICC) snprintf(buf, MSG_SIZ,"%s w%d\n", command, i);
5291             else if(i == 22) snprintf(buf,MSG_SIZ, "%s fr\n", command);
5292             else snprintf(buf, MSG_SIZ,"%s %s\n", command, VariantName(gameInfo.variant));
5293         } else snprintf(buf, MSG_SIZ,"%s\n", ics_type == ICS_ICC ? command : "examine\n"); // match yourself or examine
5294         SendToICS(ics_prefix);
5295         SendToICS(buf);
5296         if(startedFromSetupPosition || backwardMostMove != 0) {
5297           fen = PositionToFEN(backwardMostMove, NULL, 1);
5298           if(ics_type == ICS_ICC) { // on ICC we can simply send a complete FEN to set everything
5299             snprintf(buf, MSG_SIZ,"loadfen %s\n", fen);
5300             SendToICS(buf);
5301           } else { // FICS: everything has to set by separate bsetup commands
5302             p = strchr(fen, ' '); p[0] = NULLCHAR; // cut after board
5303             snprintf(buf, MSG_SIZ,"bsetup fen %s\n", fen);
5304             SendToICS(buf);
5305             if(!WhiteOnMove(backwardMostMove)) {
5306                 SendToICS("bsetup tomove black\n");
5307             }
5308             i = (strchr(p+3, 'K') != NULL) + 2*(strchr(p+3, 'Q') != NULL);
5309             snprintf(buf, MSG_SIZ,"bsetup wcastle %s\n", castlingStrings[i]);
5310             SendToICS(buf);
5311             i = (strchr(p+3, 'k') != NULL) + 2*(strchr(p+3, 'q') != NULL);
5312             snprintf(buf, MSG_SIZ, "bsetup bcastle %s\n", castlingStrings[i]);
5313             SendToICS(buf);
5314             i = boards[backwardMostMove][EP_STATUS];
5315             if(i >= 0) { // set e.p.
5316               snprintf(buf, MSG_SIZ,"bsetup eppos %c\n", i+AAA);
5317                 SendToICS(buf);
5318             }
5319             bsetup++;
5320           }
5321         }
5322       if(bsetup || ics_type != ICS_ICC && gameInfo.variant != VariantNormal)
5323             SendToICS("bsetup done\n"); // switch to normal examining.
5324     }
5325     for(i = backwardMostMove; i<last; i++) {
5326         char buf[20];
5327         snprintf(buf, sizeof(buf)/sizeof(buf[0]),"%s\n", parseList[i]);
5328         if((*buf == 'b' || *buf == 'B') && buf[1] == 'x') { // work-around for stupid FICS bug, which thinks bxc3 can be a Bishop move
5329             int len = strlen(moveList[i]);
5330             snprintf(buf, sizeof(buf)/sizeof(buf[0]),"%s", moveList[i]); // use long algebraic
5331             if(!isdigit(buf[len-2])) snprintf(buf+len-2, 20-len, "=%c\n", ToUpper(buf[len-2])); // promotion must have '=' in ICS format
5332         }
5333         SendToICS(buf);
5334     }
5335     SendToICS(ics_prefix);
5336     SendToICS(ics_type == ICS_ICC ? "tag result Game in progress\n" : "commit\n");
5337 }
5338
5339 int killX = -1, killY = -1, kill2X = -1, kill2Y = -1; // [HGM] lion: used for passing e.p. capture square to MakeMove
5340 int legNr = 1;
5341
5342 void
5343 CoordsToComputerAlgebraic (int rf, int ff, int rt, int ft, char promoChar, char move[9])
5344 {
5345     if (rf == DROP_RANK) {
5346       if(ff == EmptySquare) sprintf(move, "@@@@\n"); else // [HGM] pass
5347       sprintf(move, "%c@%c%c\n",
5348                 ToUpper(PieceToChar((ChessSquare) ff)), AAA + ft, ONE + rt);
5349     } else {
5350         if (promoChar == 'x' || promoChar == NULLCHAR) {
5351           sprintf(move, "%c%c%c%c\n",
5352                     AAA + ff, ONE + rf, AAA + ft, ONE + rt);
5353           if(killX >= 0 && killY >= 0) {
5354             sprintf(move+4, ";%c%c\n", AAA + killX, ONE + killY);
5355             if(kill2X >= 0 && kill2Y >= 0) sprintf(move+7, "%c%c\n", AAA + killX, ONE + killY);
5356           }
5357         } else {
5358             sprintf(move, "%c%c%c%c%c\n",
5359                     AAA + ff, ONE + rf, AAA + ft, ONE + rt, promoChar);
5360         }
5361     }
5362 }
5363
5364 void
5365 ProcessICSInitScript (FILE *f)
5366 {
5367     char buf[MSG_SIZ];
5368
5369     while (fgets(buf, MSG_SIZ, f)) {
5370         SendToICSDelayed(buf,(long)appData.msLoginDelay);
5371     }
5372
5373     fclose(f);
5374 }
5375
5376
5377 static int lastX, lastY, lastLeftX, lastLeftY, selectFlag;
5378 int dragging;
5379 static ClickType lastClickType;
5380
5381 int
5382 Partner (ChessSquare *p)
5383 { // change piece into promotion partner if one shogi-promotes to the other
5384   int stride = gameInfo.variant == VariantChu ? 22 : 11;
5385   ChessSquare partner;
5386   partner = (*p/stride & 1 ? *p - stride : *p + stride);
5387   if(PieceToChar(*p) != '+' && PieceToChar(partner) != '+') return 0;
5388   *p = partner;
5389   return 1;
5390 }
5391
5392 void
5393 Sweep (int step)
5394 {
5395     ChessSquare king = WhiteKing, pawn = WhitePawn, last = promoSweep;
5396     static int toggleFlag;
5397     if(gameInfo.variant == VariantKnightmate) king = WhiteUnicorn;
5398     if(gameInfo.variant == VariantSuicide || gameInfo.variant == VariantGiveaway) king = EmptySquare;
5399     if(promoSweep >= BlackPawn) king = WHITE_TO_BLACK king, pawn = WHITE_TO_BLACK pawn;
5400     if(gameInfo.variant == VariantSpartan && pawn == BlackPawn) pawn = BlackLance, king = EmptySquare;
5401     if(fromY != BOARD_HEIGHT-2 && fromY != 1 && gameInfo.variant != VariantChuChess) pawn = EmptySquare;
5402     if(!step) toggleFlag = Partner(&last); // piece has shogi-promotion
5403     do {
5404         if(step && !(toggleFlag && Partner(&promoSweep))) promoSweep -= step;
5405         if(promoSweep == EmptySquare) promoSweep = BlackPawn; // wrap
5406         else if((int)promoSweep == -1) promoSweep = WhiteKing;
5407         else if(promoSweep == BlackPawn && step < 0 && !toggleFlag) promoSweep = WhitePawn;
5408         else if(promoSweep == WhiteKing && step > 0 && !toggleFlag) promoSweep = BlackKing;
5409         if(!step) step = -1;
5410     } while(PieceToChar(promoSweep) == '.' || PieceToChar(promoSweep) == '~' || promoSweep == pawn ||
5411             !toggleFlag && PieceToChar(promoSweep) == '+' || // skip promoted versions of other
5412             appData.testLegality && (promoSweep == king || gameInfo.variant != VariantChuChess &&
5413             (promoSweep == WhiteLion || promoSweep == BlackLion)));
5414     if(toX >= 0) {
5415         int victim = boards[currentMove][toY][toX];
5416         boards[currentMove][toY][toX] = promoSweep;
5417         DrawPosition(FALSE, boards[currentMove]);
5418         boards[currentMove][toY][toX] = victim;
5419     } else
5420     ChangeDragPiece(promoSweep);
5421 }
5422
5423 int
5424 PromoScroll (int x, int y)
5425 {
5426   int step = 0;
5427
5428   if(promoSweep == EmptySquare || !appData.sweepSelect) return FALSE;
5429   if(abs(x - lastX) < 25 && abs(y - lastY) < 25) return FALSE;
5430   if( y > lastY + 2 ) step = -1; else if(y < lastY - 2) step = 1;
5431   if(!step) return FALSE;
5432   lastX = x; lastY = y;
5433   if((promoSweep < BlackPawn) == flipView) step = -step;
5434   if(step > 0) selectFlag = 1;
5435   if(!selectFlag) Sweep(step);
5436   return FALSE;
5437 }
5438
5439 void
5440 NextPiece (int step)
5441 {
5442     ChessSquare piece = boards[currentMove][toY][toX];
5443     do {
5444         pieceSweep -= step;
5445         if(pieceSweep == EmptySquare) pieceSweep = WhitePawn; // wrap
5446         if((int)pieceSweep == -1) pieceSweep = BlackKing;
5447         if(!step) step = -1;
5448     } while(PieceToChar(pieceSweep) == '.');
5449     boards[currentMove][toY][toX] = pieceSweep;
5450     DrawPosition(FALSE, boards[currentMove]);
5451     boards[currentMove][toY][toX] = piece;
5452 }
5453 /* [HGM] Shogi move preprocessor: swap digits for letters, vice versa */
5454 void
5455 AlphaRank (char *move, int n)
5456 {
5457 //    char *p = move, c; int x, y;
5458
5459     if (appData.debugMode) {
5460         fprintf(debugFP, "alphaRank(%s,%d)\n", move, n);
5461     }
5462
5463     if(move[1]=='*' &&
5464        move[2]>='0' && move[2]<='9' &&
5465        move[3]>='a' && move[3]<='x'    ) {
5466         move[1] = '@';
5467         move[2] = BOARD_RGHT  -1 - (move[2]-'1') + AAA;
5468         move[3] = BOARD_HEIGHT-1 - (move[3]-'a') + ONE;
5469     } else
5470     if(move[0]>='0' && move[0]<='9' &&
5471        move[1]>='a' && move[1]<='x' &&
5472        move[2]>='0' && move[2]<='9' &&
5473        move[3]>='a' && move[3]<='x'    ) {
5474         /* input move, Shogi -> normal */
5475         move[0] = BOARD_RGHT  -1 - (move[0]-'1') + AAA;
5476         move[1] = BOARD_HEIGHT-1 - (move[1]-'a') + ONE;
5477         move[2] = BOARD_RGHT  -1 - (move[2]-'1') + AAA;
5478         move[3] = BOARD_HEIGHT-1 - (move[3]-'a') + ONE;
5479     } else
5480     if(move[1]=='@' &&
5481        move[3]>='0' && move[3]<='9' &&
5482        move[2]>='a' && move[2]<='x'    ) {
5483         move[1] = '*';
5484         move[2] = BOARD_RGHT - 1 - (move[2]-AAA) + '1';
5485         move[3] = BOARD_HEIGHT-1 - (move[3]-ONE) + 'a';
5486     } else
5487     if(
5488        move[0]>='a' && move[0]<='x' &&
5489        move[3]>='0' && move[3]<='9' &&
5490        move[2]>='a' && move[2]<='x'    ) {
5491          /* output move, normal -> Shogi */
5492         move[0] = BOARD_RGHT - 1 - (move[0]-AAA) + '1';
5493         move[1] = BOARD_HEIGHT-1 - (move[1]-ONE) + 'a';
5494         move[2] = BOARD_RGHT - 1 - (move[2]-AAA) + '1';
5495         move[3] = BOARD_HEIGHT-1 - (move[3]-ONE) + 'a';
5496         if(move[4] == PieceToChar(BlackQueen)) move[4] = '+';
5497     }
5498     if (appData.debugMode) {
5499         fprintf(debugFP, "   out = '%s'\n", move);
5500     }
5501 }
5502
5503 char yy_textstr[8000];
5504
5505 /* Parser for moves from gnuchess, ICS, or user typein box */
5506 Boolean
5507 ParseOneMove (char *move, int moveNum, ChessMove *moveType, int *fromX, int *fromY, int *toX, int *toY, char *promoChar)
5508 {
5509     *moveType = yylexstr(moveNum, move, yy_textstr, sizeof yy_textstr);
5510
5511     switch (*moveType) {
5512       case WhitePromotion:
5513       case BlackPromotion:
5514       case WhiteNonPromotion:
5515       case BlackNonPromotion:
5516       case NormalMove:
5517       case FirstLeg:
5518       case WhiteCapturesEnPassant:
5519       case BlackCapturesEnPassant:
5520       case WhiteKingSideCastle:
5521       case WhiteQueenSideCastle:
5522       case BlackKingSideCastle:
5523       case BlackQueenSideCastle:
5524       case WhiteKingSideCastleWild:
5525       case WhiteQueenSideCastleWild:
5526       case BlackKingSideCastleWild:
5527       case BlackQueenSideCastleWild:
5528       /* Code added by Tord: */
5529       case WhiteHSideCastleFR:
5530       case WhiteASideCastleFR:
5531       case BlackHSideCastleFR:
5532       case BlackASideCastleFR:
5533       /* End of code added by Tord */
5534       case IllegalMove:         /* bug or odd chess variant */
5535         if(currentMoveString[1] == '@') { // illegal drop
5536           *fromX = WhiteOnMove(moveNum) ?
5537             (int) CharToPiece(ToUpper(currentMoveString[0])) :
5538             (int) CharToPiece(ToLower(currentMoveString[0]));
5539           goto drop;
5540         }
5541         *fromX = currentMoveString[0] - AAA;
5542         *fromY = currentMoveString[1] - ONE;
5543         *toX = currentMoveString[2] - AAA;
5544         *toY = currentMoveString[3] - ONE;
5545         *promoChar = currentMoveString[4];
5546         if (*fromX < BOARD_LEFT || *fromX >= BOARD_RGHT || *fromY < 0 || *fromY >= BOARD_HEIGHT ||
5547             *toX < BOARD_LEFT || *toX >= BOARD_RGHT || *toY < 0 || *toY >= BOARD_HEIGHT) {
5548     if (appData.debugMode) {
5549         fprintf(debugFP, "Off-board move (%d,%d)-(%d,%d)%c, type = %d\n", *fromX, *fromY, *toX, *toY, *promoChar, *moveType);
5550     }
5551             *fromX = *fromY = *toX = *toY = 0;
5552             return FALSE;
5553         }
5554         if (appData.testLegality) {
5555           return (*moveType != IllegalMove);
5556         } else {
5557           return !(*fromX == *toX && *fromY == *toY && killX < 0) && boards[moveNum][*fromY][*fromX] != EmptySquare &&
5558                          // [HGM] lion: if this is a double move we are less critical
5559                         WhiteOnMove(moveNum) == (boards[moveNum][*fromY][*fromX] < BlackPawn);
5560         }
5561
5562       case WhiteDrop:
5563       case BlackDrop:
5564         *fromX = *moveType == WhiteDrop ?
5565           (int) CharToPiece(ToUpper(currentMoveString[0])) :
5566           (int) CharToPiece(ToLower(currentMoveString[0]));
5567       drop:
5568         *fromY = DROP_RANK;
5569         *toX = currentMoveString[2] - AAA;
5570         *toY = currentMoveString[3] - ONE;
5571         *promoChar = NULLCHAR;
5572         return TRUE;
5573
5574       case AmbiguousMove:
5575       case ImpossibleMove:
5576       case EndOfFile:
5577       case ElapsedTime:
5578       case Comment:
5579       case PGNTag:
5580       case NAG:
5581       case WhiteWins:
5582       case BlackWins:
5583       case GameIsDrawn:
5584       default:
5585     if (appData.debugMode) {
5586         fprintf(debugFP, "Impossible move %s, type = %d\n", currentMoveString, *moveType);
5587     }
5588         /* bug? */
5589         *fromX = *fromY = *toX = *toY = 0;
5590         *promoChar = NULLCHAR;
5591         return FALSE;
5592     }
5593 }
5594
5595 Boolean pushed = FALSE;
5596 char *lastParseAttempt;
5597
5598 void
5599 ParsePV (char *pv, Boolean storeComments, Boolean atEnd)
5600 { // Parse a string of PV moves, and append to current game, behind forwardMostMove
5601   int fromX, fromY, toX, toY; char promoChar;
5602   ChessMove moveType;
5603   Boolean valid;
5604   int nr = 0;
5605
5606   lastParseAttempt = pv; if(!*pv) return;    // turns out we crash when we parse an empty PV
5607   if ((gameMode == AnalyzeMode || gameMode == AnalyzeFile) && currentMove < forwardMostMove) {
5608     PushInner(currentMove, forwardMostMove); // [HGM] engine might not be thinking on forwardMost position!
5609     pushed = TRUE;
5610   }
5611   endPV = forwardMostMove;
5612   do {
5613     while(*pv == ' ' || *pv == '\n' || *pv == '\t') pv++; // must still read away whitespace
5614     if(nr == 0 && !storeComments && *pv == '(') pv++; // first (ponder) move can be in parentheses
5615     lastParseAttempt = pv;
5616     valid = ParseOneMove(pv, endPV, &moveType, &fromX, &fromY, &toX, &toY, &promoChar);
5617     if(!valid && nr == 0 &&
5618        ParseOneMove(pv, endPV-1, &moveType, &fromX, &fromY, &toX, &toY, &promoChar)){
5619         nr++; moveType = Comment; // First move has been played; kludge to make sure we continue
5620         // Hande case where played move is different from leading PV move
5621         CopyBoard(boards[endPV+1], boards[endPV-1]); // tentatively unplay last game move
5622         CopyBoard(boards[endPV+2], boards[endPV-1]); // and play first move of PV
5623         ApplyMove(fromX, fromY, toX, toY, promoChar, boards[endPV+2]);
5624         if(!CompareBoards(boards[endPV], boards[endPV+2])) {
5625           endPV += 2; // if position different, keep this
5626           moveList[endPV-1][0] = fromX + AAA;
5627           moveList[endPV-1][1] = fromY + ONE;
5628           moveList[endPV-1][2] = toX + AAA;
5629           moveList[endPV-1][3] = toY + ONE;
5630           parseList[endPV-1][0] = NULLCHAR;
5631           safeStrCpy(moveList[endPV-2], "_0_0", sizeof(moveList[endPV-2])/sizeof(moveList[endPV-2][0])); // suppress premove highlight on takeback move
5632         }
5633       }
5634     pv = strstr(pv, yy_textstr) + strlen(yy_textstr); // skip what we parsed
5635     if(nr == 0 && !storeComments && *pv == ')') pv++; // closing parenthesis of ponder move;
5636     if(moveType == Comment && storeComments) AppendComment(endPV, yy_textstr, FALSE);
5637     if(moveType == Comment || moveType == NAG || moveType == ElapsedTime) {
5638         valid++; // allow comments in PV
5639         continue;
5640     }
5641     nr++;
5642     if(endPV+1 > framePtr) break; // no space, truncate
5643     if(!valid) break;
5644     endPV++;
5645     CopyBoard(boards[endPV], boards[endPV-1]);
5646     ApplyMove(fromX, fromY, toX, toY, promoChar, boards[endPV]);
5647     CoordsToComputerAlgebraic(fromY, fromX, toY, toX, promoChar, moveList[endPV - 1]);
5648     strncat(moveList[endPV-1], "\n", MOVE_LEN);
5649     CoordsToAlgebraic(boards[endPV - 1],
5650                              PosFlags(endPV - 1),
5651                              fromY, fromX, toY, toX, promoChar,
5652                              parseList[endPV - 1]);
5653   } while(valid);
5654   if(atEnd == 2) return; // used hidden, for PV conversion
5655   currentMove = (atEnd || endPV == forwardMostMove) ? endPV : forwardMostMove + 1;
5656   if(currentMove == forwardMostMove) ClearPremoveHighlights(); else
5657   SetPremoveHighlights(moveList[currentMove-1][0]-AAA, moveList[currentMove-1][1]-ONE,
5658                        moveList[currentMove-1][2]-AAA, moveList[currentMove-1][3]-ONE);
5659   DrawPosition(TRUE, boards[currentMove]);
5660 }
5661
5662 int
5663 MultiPV (ChessProgramState *cps)
5664 {       // check if engine supports MultiPV, and if so, return the number of the option that sets it
5665         int i;
5666         for(i=0; i<cps->nrOptions; i++)
5667             if(!strcmp(cps->option[i].name, "MultiPV") && cps->option[i].type == Spin)
5668                 return i;
5669         return -1;
5670 }
5671
5672 Boolean extendGame; // signals to UnLoadPV() if walked part of PV has to be appended to game
5673
5674 Boolean
5675 LoadMultiPV (int x, int y, char *buf, int index, int *start, int *end, int pane)
5676 {
5677         int startPV, multi, lineStart, origIndex = index;
5678         char *p, buf2[MSG_SIZ];
5679         ChessProgramState *cps = (pane ? &second : &first);
5680
5681         if(index < 0 || index >= strlen(buf)) return FALSE; // sanity
5682         lastX = x; lastY = y;
5683         while(index > 0 && buf[index-1] != '\n') index--; // beginning of line
5684         lineStart = startPV = index;
5685         while(buf[index] != '\n') if(buf[index++] == '\t') startPV = index;
5686         if(index == startPV && (p = StrCaseStr(buf+index, "PV="))) startPV = p - buf + 3;
5687         index = startPV;
5688         do{ while(buf[index] && buf[index] != '\n') index++;
5689         } while(buf[index] == '\n' && buf[index+1] == '\\' && buf[index+2] == ' ' && index++); // join kibitzed PV continuation line
5690         buf[index] = 0;
5691         if(lineStart == 0 && gameMode == AnalyzeMode && (multi = MultiPV(cps)) >= 0) {
5692                 int n = cps->option[multi].value;
5693                 if(origIndex > 17 && origIndex < 24) { if(n>1) n--; } else if(origIndex > index - 6) n++;
5694                 snprintf(buf2, MSG_SIZ, "option MultiPV=%d\n", n);
5695                 if(cps->option[multi].value != n) SendToProgram(buf2, cps);
5696                 cps->option[multi].value = n;
5697                 *start = *end = 0;
5698                 return FALSE;
5699         } else if(strstr(buf+lineStart, "exclude:") == buf+lineStart) { // exclude moves clicked
5700                 ExcludeClick(origIndex - lineStart);
5701                 return FALSE;
5702         } else if(!strncmp(buf+lineStart, "dep\t", 4)) {                // column headers clicked
5703                 Collapse(origIndex - lineStart);
5704                 return FALSE;
5705         }
5706         ParsePV(buf+startPV, FALSE, gameMode != AnalyzeMode);
5707         *start = startPV; *end = index-1;
5708         extendGame = (gameMode == AnalyzeMode && appData.autoExtend && origIndex - startPV < 5);
5709         return TRUE;
5710 }
5711
5712 char *
5713 PvToSAN (char *pv)
5714 {
5715         static char buf[10*MSG_SIZ];
5716         int i, k=0, savedEnd=endPV, saveFMM = forwardMostMove;
5717         *buf = NULLCHAR;
5718         if(forwardMostMove < endPV) PushInner(forwardMostMove, endPV); // shelve PV of PV-walk
5719         ParsePV(pv, FALSE, 2); // this appends PV to game, suppressing any display of it
5720         for(i = forwardMostMove; i<endPV; i++){
5721             if(i&1) snprintf(buf+k, 10*MSG_SIZ-k, "%s ", parseList[i]);
5722             else    snprintf(buf+k, 10*MSG_SIZ-k, "%d. %s ", i/2 + 1, parseList[i]);
5723             k += strlen(buf+k);
5724         }
5725         snprintf(buf+k, 10*MSG_SIZ-k, "%s", lastParseAttempt); // if we ran into stuff that could not be parsed, print it verbatim
5726         if(pushed) { PopInner(0); pushed = FALSE; } // restore game continuation shelved by ParsePV
5727         if(forwardMostMove < savedEnd) { PopInner(0); forwardMostMove = saveFMM; } // PopInner would set fmm to endPV!
5728         endPV = savedEnd;
5729         return buf;
5730 }
5731
5732 Boolean
5733 LoadPV (int x, int y)
5734 { // called on right mouse click to load PV
5735   int which = gameMode == TwoMachinesPlay && (WhiteOnMove(forwardMostMove) == (second.twoMachinesColor[0] == 'w'));
5736   lastX = x; lastY = y;
5737   ParsePV(lastPV[which], FALSE, TRUE); // load the PV of the thinking engine in the boards array.
5738   extendGame = FALSE;
5739   return TRUE;
5740 }
5741
5742 void
5743 UnLoadPV ()
5744 {
5745   int oldFMM = forwardMostMove; // N.B.: this was currentMove before PV was loaded!
5746   if(endPV < 0) return;
5747   if(appData.autoCopyPV) CopyFENToClipboard();
5748   endPV = -1;
5749   if(extendGame && currentMove > forwardMostMove) {
5750         Boolean saveAnimate = appData.animate;
5751         if(pushed) {
5752             if(shiftKey && storedGames < MAX_VARIATIONS-2) { // wants to start variation, and there is space
5753                 if(storedGames == 1) GreyRevert(FALSE);      // we already pushed the tail, so just make it official
5754             } else storedGames--; // abandon shelved tail of original game
5755         }
5756         pushed = FALSE;
5757         forwardMostMove = currentMove;
5758         currentMove = oldFMM;
5759         appData.animate = FALSE;
5760         ToNrEvent(forwardMostMove);
5761         appData.animate = saveAnimate;
5762   }
5763   currentMove = forwardMostMove;
5764   if(pushed) { PopInner(0); pushed = FALSE; } // restore shelved game continuation
5765   ClearPremoveHighlights();
5766   DrawPosition(TRUE, boards[currentMove]);
5767 }
5768
5769 void
5770 MovePV (int x, int y, int h)
5771 { // step through PV based on mouse coordinates (called on mouse move)
5772   int margin = h>>3, step = 0, threshold = (pieceSweep == EmptySquare ? 10 : 15);
5773
5774   // we must somehow check if right button is still down (might be released off board!)
5775   if(endPV < 0 && pieceSweep == EmptySquare) return; // needed in XBoard because lastX/Y is shared :-(
5776   if(abs(x - lastX) < threshold && abs(y - lastY) < threshold) return;
5777   if( y > lastY + 2 ) step = -1; else if(y < lastY - 2) step = 1;
5778   if(!step) return;
5779   lastX = x; lastY = y;
5780
5781   if(pieceSweep != EmptySquare) { NextPiece(step); return; }
5782   if(endPV < 0) return;
5783   if(y < margin) step = 1; else
5784   if(y > h - margin) step = -1;
5785   if(currentMove + step > endPV || currentMove + step < forwardMostMove) step = 0;
5786   currentMove += step;
5787   if(currentMove == forwardMostMove) ClearPremoveHighlights(); else
5788   SetPremoveHighlights(moveList[currentMove-1][0]-AAA, moveList[currentMove-1][1]-ONE,
5789                        moveList[currentMove-1][2]-AAA, moveList[currentMove-1][3]-ONE);
5790   DrawPosition(FALSE, boards[currentMove]);
5791 }
5792
5793
5794 // [HGM] shuffle: a general way to suffle opening setups, applicable to arbitrary variants.
5795 // All positions will have equal probability, but the current method will not provide a unique
5796 // numbering scheme for arrays that contain 3 or more pieces of the same kind.
5797 #define DARK 1
5798 #define LITE 2
5799 #define ANY 3
5800
5801 int squaresLeft[4];
5802 int piecesLeft[(int)BlackPawn];
5803 int seed, nrOfShuffles;
5804
5805 void
5806 GetPositionNumber ()
5807 {       // sets global variable seed
5808         int i;
5809
5810         seed = appData.defaultFrcPosition;
5811         if(seed < 0) { // randomize based on time for negative FRC position numbers
5812                 for(i=0; i<50; i++) seed += random();
5813                 seed = random() ^ random() >> 8 ^ random() << 8;
5814                 if(seed<0) seed = -seed;
5815         }
5816 }
5817
5818 int
5819 put (Board board, int pieceType, int rank, int n, int shade)
5820 // put the piece on the (n-1)-th empty squares of the given shade
5821 {
5822         int i;
5823
5824         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) {
5825                 if( (((i-BOARD_LEFT)&1)+1) & shade && board[rank][i] == EmptySquare && n-- == 0) {
5826                         board[rank][i] = (ChessSquare) pieceType;
5827                         squaresLeft[((i-BOARD_LEFT)&1) + 1]--;
5828                         squaresLeft[ANY]--;
5829                         piecesLeft[pieceType]--;
5830                         return i;
5831                 }
5832         }
5833         return -1;
5834 }
5835
5836
5837 void
5838 AddOnePiece (Board board, int pieceType, int rank, int shade)
5839 // calculate where the next piece goes, (any empty square), and put it there
5840 {
5841         int i;
5842
5843         i = seed % squaresLeft[shade];
5844         nrOfShuffles *= squaresLeft[shade];
5845         seed /= squaresLeft[shade];
5846         put(board, pieceType, rank, i, shade);
5847 }
5848
5849 void
5850 AddTwoPieces (Board board, int pieceType, int rank)
5851 // calculate where the next 2 identical pieces go, (any empty square), and put it there
5852 {
5853         int i, n=squaresLeft[ANY], j=n-1, k;
5854
5855         k = n*(n-1)/2; // nr of possibilities, not counting permutations
5856         i = seed % k;  // pick one
5857         nrOfShuffles *= k;
5858         seed /= k;
5859         while(i >= j) i -= j--;
5860         j = n - 1 - j; i += j;
5861         put(board, pieceType, rank, j, ANY);
5862         put(board, pieceType, rank, i, ANY);
5863 }
5864
5865 void
5866 SetUpShuffle (Board board, int number)
5867 {
5868         int i, p, first=1;
5869
5870         GetPositionNumber(); nrOfShuffles = 1;
5871
5872         squaresLeft[DARK] = (BOARD_RGHT - BOARD_LEFT + 1)/2;
5873         squaresLeft[ANY]  = BOARD_RGHT - BOARD_LEFT;
5874         squaresLeft[LITE] = squaresLeft[ANY] - squaresLeft[DARK];
5875
5876         for(p = 0; p<=(int)WhiteKing; p++) piecesLeft[p] = 0;
5877
5878         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) { // count pieces and clear board
5879             p = (int) board[0][i];
5880             if(p < (int) BlackPawn) piecesLeft[p] ++;
5881             board[0][i] = EmptySquare;
5882         }
5883
5884         if(PosFlags(0) & F_ALL_CASTLE_OK) {
5885             // shuffles restricted to allow normal castling put KRR first
5886             if(piecesLeft[(int)WhiteKing]) // King goes rightish of middle
5887                 put(board, WhiteKing, 0, (gameInfo.boardWidth+1)/2, ANY);
5888             else if(piecesLeft[(int)WhiteUnicorn]) // in Knightmate Unicorn castles
5889                 put(board, WhiteUnicorn, 0, (gameInfo.boardWidth+1)/2, ANY);
5890             if(piecesLeft[(int)WhiteRook]) // First supply a Rook for K-side castling
5891                 put(board, WhiteRook, 0, gameInfo.boardWidth-2, ANY);
5892             if(piecesLeft[(int)WhiteRook]) // Then supply a Rook for Q-side castling
5893                 put(board, WhiteRook, 0, 0, ANY);
5894             // in variants with super-numerary Kings and Rooks, we leave these for the shuffle
5895         }
5896
5897         if(((BOARD_RGHT-BOARD_LEFT) & 1) == 0)
5898             // only for even boards make effort to put pairs of colorbound pieces on opposite colors
5899             for(p = (int) WhiteKing; p > (int) WhitePawn; p--) {
5900                 if(p != (int) WhiteBishop && p != (int) WhiteFerz && p != (int) WhiteAlfil) continue;
5901                 while(piecesLeft[p] >= 2) {
5902                     AddOnePiece(board, p, 0, LITE);
5903                     AddOnePiece(board, p, 0, DARK);
5904                 }
5905                 // Odd color-bound pieces are shuffled with the rest (to not run out of paired squares)
5906             }
5907
5908         for(p = (int) WhiteKing - 2; p > (int) WhitePawn; p--) {
5909             // Remaining pieces (non-colorbound, or odd color bound) can be put anywhere
5910             // but we leave King and Rooks for last, to possibly obey FRC restriction
5911             if(p == (int)WhiteRook) continue;
5912             while(piecesLeft[p] >= 2) AddTwoPieces(board, p, 0); // add in pairs, for not counting permutations
5913             if(piecesLeft[p]) AddOnePiece(board, p, 0, ANY);     // add the odd piece
5914         }
5915
5916         // now everything is placed, except perhaps King (Unicorn) and Rooks
5917
5918         if(PosFlags(0) & F_FRC_TYPE_CASTLING) {
5919             // Last King gets castling rights
5920             while(piecesLeft[(int)WhiteUnicorn]) {
5921                 i = put(board, WhiteUnicorn, 0, piecesLeft[(int)WhiteRook]/2, ANY);
5922                 initialRights[2]  = initialRights[5]  = board[CASTLING][2] = board[CASTLING][5] = i;
5923             }
5924
5925             while(piecesLeft[(int)WhiteKing]) {
5926                 i = put(board, WhiteKing, 0, piecesLeft[(int)WhiteRook]/2, ANY);
5927                 initialRights[2]  = initialRights[5]  = board[CASTLING][2] = board[CASTLING][5] = i;
5928             }
5929
5930
5931         } else {
5932             while(piecesLeft[(int)WhiteKing])    AddOnePiece(board, WhiteKing, 0, ANY);
5933             while(piecesLeft[(int)WhiteUnicorn]) AddOnePiece(board, WhiteUnicorn, 0, ANY);
5934         }
5935
5936         // Only Rooks can be left; simply place them all
5937         while(piecesLeft[(int)WhiteRook]) {
5938                 i = put(board, WhiteRook, 0, 0, ANY);
5939                 if(PosFlags(0) & F_FRC_TYPE_CASTLING) { // first and last Rook get FRC castling rights
5940                         if(first) {
5941                                 first=0;
5942                                 initialRights[1]  = initialRights[4]  = board[CASTLING][1] = board[CASTLING][4] = i;
5943                         }
5944                         initialRights[0]  = initialRights[3]  = board[CASTLING][0] = board[CASTLING][3] = i;
5945                 }
5946         }
5947         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) { // copy black from white
5948             board[BOARD_HEIGHT-1][i] =  (int) board[0][i] < BlackPawn ? WHITE_TO_BLACK board[0][i] : EmptySquare;
5949         }
5950
5951         if(number >= 0) appData.defaultFrcPosition %= nrOfShuffles; // normalize
5952 }
5953
5954 int
5955 ptclen (const char *s, char *escapes)
5956 {
5957     int n = 0;
5958     if(!*escapes) return strlen(s);
5959     while(*s) n += (*s != '/' && !strchr(escapes, *s)), s++;
5960     return n;
5961 }
5962
5963 int
5964 SetCharTableEsc (unsigned char *table, const char * map, char * escapes)
5965 /* [HGM] moved here from winboard.c because of its general usefulness */
5966 /*       Basically a safe strcpy that uses the last character as King */
5967 {
5968     int result = FALSE; int NrPieces, offs;
5969
5970     if( map != NULL && (NrPieces=ptclen(map, escapes)) <= (int) EmptySquare
5971                     && NrPieces >= 12 && !(NrPieces&1)) {
5972         int i, j = 0; /* [HGM] Accept even length from 12 to 88 */
5973
5974         for( i=0; i<(int) EmptySquare; i++ ) table[i] = '.';
5975         for( i=offs=0; i<NrPieces/2-1; i++ ) {
5976             char *p;
5977             if(map[j] == '/' && *escapes) offs = WhiteTokin - i, j++;
5978             table[i + offs] = map[j++];
5979             if(p = strchr(escapes, map[j])) j++, table[i + offs] += 64*(p - escapes + 1);
5980         }
5981         table[(int) WhiteKing]  = map[j++];
5982         for( i=offs=0; i<NrPieces/2-1; i++ ) {
5983             char *p;
5984             if(map[j] == '/' && *escapes) offs = WhiteTokin - i, j++;
5985             table[WHITE_TO_BLACK i + offs] = map[j++];
5986             if(p = strchr(escapes, map[j])) j++, table[WHITE_TO_BLACK i + offs] += 64*(p - escapes + 1);
5987         }
5988         table[(int) BlackKing]  = map[j++];
5989
5990         result = TRUE;
5991     }
5992
5993     return result;
5994 }
5995
5996 int
5997 SetCharTable (unsigned char *table, const char * map)
5998 {
5999     return SetCharTableEsc(table, map, "");
6000 }
6001
6002 void
6003 Prelude (Board board)
6004 {       // [HGM] superchess: random selection of exo-pieces
6005         int i, j, k; ChessSquare p;
6006         static ChessSquare exoPieces[4] = { WhiteAngel, WhiteMarshall, WhiteSilver, WhiteLance };
6007
6008         GetPositionNumber(); // use FRC position number
6009
6010         if(appData.pieceToCharTable != NULL) { // select pieces to participate from given char table
6011             SetCharTable(pieceToChar, appData.pieceToCharTable);
6012             for(i=(int)WhiteQueen+1, j=0; i<(int)WhiteKing && j<4; i++)
6013                 if(PieceToChar((ChessSquare)i) != '.') exoPieces[j++] = (ChessSquare) i;
6014         }
6015
6016         j = seed%4;                 seed /= 4;
6017         p = board[0][BOARD_LEFT+j];   board[0][BOARD_LEFT+j] = EmptySquare; k = PieceToNumber(p);
6018         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
6019         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
6020         j = seed%3 + (seed%3 >= j); seed /= 3;
6021         p = board[0][BOARD_LEFT+j];   board[0][BOARD_LEFT+j] = EmptySquare; k = PieceToNumber(p);
6022         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
6023         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
6024         j = seed%3;                 seed /= 3;
6025         p = board[0][BOARD_LEFT+j+5]; board[0][BOARD_LEFT+j+5] = EmptySquare; k = PieceToNumber(p);
6026         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
6027         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
6028         j = seed%2 + (seed%2 >= j); seed /= 2;
6029         p = board[0][BOARD_LEFT+j+5]; board[0][BOARD_LEFT+j+5] = EmptySquare; k = PieceToNumber(p);
6030         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
6031         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
6032         j = seed%4; seed /= 4; put(board, exoPieces[3],    0, j, ANY);
6033         j = seed%3; seed /= 3; put(board, exoPieces[2],   0, j, ANY);
6034         j = seed%2; seed /= 2; put(board, exoPieces[1], 0, j, ANY);
6035         put(board, exoPieces[0],    0, 0, ANY);
6036         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) board[BOARD_HEIGHT-1][i] = WHITE_TO_BLACK board[0][i];
6037 }
6038
6039 void
6040 InitPosition (int redraw)
6041 {
6042     ChessSquare (* pieces)[BOARD_FILES];
6043     int i, j, pawnRow=1, pieceRows=1, overrule,
6044     oldx = gameInfo.boardWidth,
6045     oldy = gameInfo.boardHeight,
6046     oldh = gameInfo.holdingsWidth;
6047     static int oldv;
6048
6049     if(appData.icsActive) shuffleOpenings = appData.fischerCastling = FALSE; // [HGM] shuffle: in ICS mode, only shuffle on ICS request
6050
6051     /* [AS] Initialize pv info list [HGM] and game status */
6052     {
6053         for( i=0; i<=framePtr; i++ ) { // [HGM] vari: spare saved variations
6054             pvInfoList[i].depth = 0;
6055             boards[i][EP_STATUS] = EP_NONE;
6056             for( j=0; j<BOARD_FILES-2; j++ ) boards[i][CASTLING][j] = NoRights;
6057         }
6058
6059         initialRulePlies = 0; /* 50-move counter start */
6060
6061         castlingRank[0] = castlingRank[1] = castlingRank[2] = 0;
6062         castlingRank[3] = castlingRank[4] = castlingRank[5] = BOARD_HEIGHT-1;
6063     }
6064
6065
6066     /* [HGM] logic here is completely changed. In stead of full positions */
6067     /* the initialized data only consist of the two backranks. The switch */
6068     /* selects which one we will use, which is than copied to the Board   */
6069     /* initialPosition, which for the rest is initialized by Pawns and    */
6070     /* empty squares. This initial position is then copied to boards[0],  */
6071     /* possibly after shuffling, so that it remains available.            */
6072
6073     gameInfo.holdingsWidth = 0; /* default board sizes */
6074     gameInfo.boardWidth    = 8;
6075     gameInfo.boardHeight   = 8;
6076     gameInfo.holdingsSize  = 0;
6077     nrCastlingRights = -1; /* [HGM] Kludge to indicate default should be used */
6078     for(i=0; i<BOARD_FILES-6; i++)
6079       initialPosition[CASTLING][i] = initialRights[i] = NoRights; /* but no rights yet */
6080     initialPosition[EP_STATUS] = EP_NONE;
6081     initialPosition[TOUCHED_W] = initialPosition[TOUCHED_B] = 0;
6082     SetCharTable(pieceToChar, "PNBRQ...........Kpnbrq...........k");
6083     if(startVariant == gameInfo.variant) // [HGM] nicks: enable nicknames in original variant
6084          SetCharTable(pieceNickName, appData.pieceNickNames);
6085     else SetCharTable(pieceNickName, "............");
6086     pieces = FIDEArray;
6087
6088     switch (gameInfo.variant) {
6089     case VariantFischeRandom:
6090       shuffleOpenings = TRUE;
6091       appData.fischerCastling = TRUE;
6092     default:
6093       break;
6094     case VariantShatranj:
6095       pieces = ShatranjArray;
6096       nrCastlingRights = 0;
6097       SetCharTable(pieceToChar, "PN.R.QB...Kpn.r.qb...k");
6098       break;
6099     case VariantMakruk:
6100       pieces = makrukArray;
6101       nrCastlingRights = 0;
6102       SetCharTable(pieceToChar, "PN.R.M....SKpn.r.m....sk");
6103       break;
6104     case VariantASEAN:
6105       pieces = aseanArray;
6106       nrCastlingRights = 0;
6107       SetCharTable(pieceToChar, "PN.R.Q....BKpn.r.q....bk");
6108       break;
6109     case VariantTwoKings:
6110       pieces = twoKingsArray;
6111       break;
6112     case VariantGrand:
6113       pieces = GrandArray;
6114       nrCastlingRights = 0;
6115       SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
6116       gameInfo.boardWidth = 10;
6117       gameInfo.boardHeight = 10;
6118       gameInfo.holdingsSize = 7;
6119       break;
6120     case VariantCapaRandom:
6121       shuffleOpenings = TRUE;
6122       appData.fischerCastling = TRUE;
6123     case VariantCapablanca:
6124       pieces = CapablancaArray;
6125       gameInfo.boardWidth = 10;
6126       SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
6127       break;
6128     case VariantGothic:
6129       pieces = GothicArray;
6130       gameInfo.boardWidth = 10;
6131       SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
6132       break;
6133     case VariantSChess:
6134       SetCharTable(pieceToChar, "PNBRQ..HEKpnbrq..hek");
6135       gameInfo.holdingsSize = 7;
6136       for(i=0; i<BOARD_FILES; i++) initialPosition[VIRGIN][i] = VIRGIN_W | VIRGIN_B;
6137       break;
6138     case VariantJanus:
6139       pieces = JanusArray;
6140       gameInfo.boardWidth = 10;
6141       SetCharTable(pieceToChar, "PNBRQ..JKpnbrq..jk");
6142       nrCastlingRights = 6;
6143         initialPosition[CASTLING][0] = initialRights[0] = BOARD_RGHT-1;
6144         initialPosition[CASTLING][1] = initialRights[1] = BOARD_LEFT;
6145         initialPosition[CASTLING][2] = initialRights[2] =(BOARD_WIDTH-1)>>1;
6146         initialPosition[CASTLING][3] = initialRights[3] = BOARD_RGHT-1;
6147         initialPosition[CASTLING][4] = initialRights[4] = BOARD_LEFT;
6148         initialPosition[CASTLING][5] = initialRights[5] =(BOARD_WIDTH-1)>>1;
6149       break;
6150     case VariantFalcon:
6151       pieces = FalconArray;
6152       gameInfo.boardWidth = 10;
6153       SetCharTable(pieceToChar, "PNBRQ............FKpnbrq............fk");
6154       break;
6155     case VariantXiangqi:
6156       pieces = XiangqiArray;
6157       gameInfo.boardWidth  = 9;
6158       gameInfo.boardHeight = 10;
6159       nrCastlingRights = 0;
6160       SetCharTable(pieceToChar, "PH.R.AE..K.C.ph.r.ae..k.c.");
6161       break;
6162     case VariantShogi:
6163       pieces = ShogiArray;
6164       gameInfo.boardWidth  = 9;
6165       gameInfo.boardHeight = 9;
6166       gameInfo.holdingsSize = 7;
6167       nrCastlingRights = 0;
6168       SetCharTable(pieceToChar, "PNBRLS...G.++++++Kpnbrls...g.++++++k");
6169       break;
6170     case VariantChu:
6171       pieces = ChuArray; pieceRows = 3;
6172       gameInfo.boardWidth  = 12;
6173       gameInfo.boardHeight = 12;
6174       nrCastlingRights = 0;
6175       SetCharTableEsc(pieceToChar, "P.BRQSEXOGCATHD.VMLIFN/+.++.++++++++++.+++++K"
6176                                    "p.brqsexogcathd.vmlifn/+.++.++++++++++.+++++k", SUFFIXES);
6177       break;
6178     case VariantCourier:
6179       pieces = CourierArray;
6180       gameInfo.boardWidth  = 12;
6181       nrCastlingRights = 0;
6182       SetCharTable(pieceToChar, "PNBR.FE..WMKpnbr.fe..wmk");
6183       break;
6184     case VariantKnightmate:
6185       pieces = KnightmateArray;
6186       SetCharTable(pieceToChar, "P.BRQ.....M.........K.p.brq.....m.........k.");
6187       break;
6188     case VariantSpartan:
6189       pieces = SpartanArray;
6190       SetCharTable(pieceToChar, "PNBRQ................K......lwg.....c...h..k");
6191       break;
6192     case VariantLion:
6193       pieces = lionArray;
6194       SetCharTable(pieceToChar, "PNBRQ................LKpnbrq................lk");
6195       break;
6196     case VariantChuChess:
6197       pieces = ChuChessArray;
6198       gameInfo.boardWidth = 10;
6199       gameInfo.boardHeight = 10;
6200       SetCharTable(pieceToChar, "PNBRQ.....M.+++......LKpnbrq.....m.+++......lk");
6201       break;
6202     case VariantFairy:
6203       pieces = fairyArray;
6204       SetCharTable(pieceToChar, "PNBRQFEACWMOHIJGDVLSUKpnbrqfeacwmohijgdvlsuk");
6205       break;
6206     case VariantGreat:
6207       pieces = GreatArray;
6208       gameInfo.boardWidth = 10;
6209       SetCharTable(pieceToChar, "PN....E...S..HWGMKpn....e...s..hwgmk");
6210       gameInfo.holdingsSize = 8;
6211       break;
6212     case VariantSuper:
6213       pieces = FIDEArray;
6214       SetCharTable(pieceToChar, "PNBRQ..SE.......V.AKpnbrq..se.......v.ak");
6215       gameInfo.holdingsSize = 8;
6216       startedFromSetupPosition = TRUE;
6217       break;
6218     case VariantCrazyhouse:
6219     case VariantBughouse:
6220       pieces = FIDEArray;
6221       SetCharTable(pieceToChar, "PNBRQ.......~~~~Kpnbrq.......~~~~k");
6222       gameInfo.holdingsSize = 5;
6223       break;
6224     case VariantWildCastle:
6225       pieces = FIDEArray;
6226       /* !!?shuffle with kings guaranteed to be on d or e file */
6227       shuffleOpenings = 1;
6228       break;
6229     case VariantNoCastle:
6230       pieces = FIDEArray;
6231       nrCastlingRights = 0;
6232       /* !!?unconstrained back-rank shuffle */
6233       shuffleOpenings = 1;
6234       break;
6235     }
6236
6237     overrule = 0;
6238     if(appData.NrFiles >= 0) {
6239         if(gameInfo.boardWidth != appData.NrFiles) overrule++;
6240         gameInfo.boardWidth = appData.NrFiles;
6241     }
6242     if(appData.NrRanks >= 0) {
6243         gameInfo.boardHeight = appData.NrRanks;
6244     }
6245     if(appData.holdingsSize >= 0) {
6246         i = appData.holdingsSize;
6247         if(i > gameInfo.boardHeight) i = gameInfo.boardHeight;
6248         gameInfo.holdingsSize = i;
6249     }
6250     if(gameInfo.holdingsSize) gameInfo.holdingsWidth = 2;
6251     if(BOARD_HEIGHT > BOARD_RANKS || BOARD_WIDTH > BOARD_FILES)
6252         DisplayFatalError(_("Recompile to support this BOARD_RANKS or BOARD_FILES!"), 0, 2);
6253
6254     pawnRow = gameInfo.boardHeight - 7; /* seems to work in all common variants */
6255     if(pawnRow < 1) pawnRow = 1;
6256     if(gameInfo.variant == VariantMakruk || gameInfo.variant == VariantASEAN ||
6257        gameInfo.variant == VariantGrand || gameInfo.variant == VariantChuChess) pawnRow = 2;
6258     if(gameInfo.variant == VariantChu) pawnRow = 3;
6259
6260     /* User pieceToChar list overrules defaults */
6261     if(appData.pieceToCharTable != NULL)
6262         SetCharTableEsc(pieceToChar, appData.pieceToCharTable, SUFFIXES);
6263
6264     for( j=0; j<BOARD_WIDTH; j++ ) { ChessSquare s = EmptySquare;
6265
6266         if(j==BOARD_LEFT-1 || j==BOARD_RGHT)
6267             s = (ChessSquare) 0; /* account holding counts in guard band */
6268         for( i=0; i<BOARD_HEIGHT; i++ )
6269             initialPosition[i][j] = s;
6270
6271         if(j < BOARD_LEFT || j >= BOARD_RGHT || overrule) continue;
6272         initialPosition[gameInfo.variant == VariantGrand || gameInfo.variant == VariantChuChess][j] = pieces[0][j-gameInfo.holdingsWidth];
6273         initialPosition[pawnRow][j] = WhitePawn;
6274         initialPosition[BOARD_HEIGHT-pawnRow-1][j] = gameInfo.variant == VariantSpartan ? BlackLance : BlackPawn;
6275         if(gameInfo.variant == VariantXiangqi) {
6276             if(j&1) {
6277                 initialPosition[pawnRow][j] =
6278                 initialPosition[BOARD_HEIGHT-pawnRow-1][j] = EmptySquare;
6279                 if(j==BOARD_LEFT+1 || j>=BOARD_RGHT-2) {
6280                    initialPosition[2][j] = WhiteCannon;
6281                    initialPosition[BOARD_HEIGHT-3][j] = BlackCannon;
6282                 }
6283             }
6284         }
6285         if(gameInfo.variant == VariantChu) {
6286              if(j == (BOARD_WIDTH-2)/3 || j == BOARD_WIDTH - (BOARD_WIDTH+1)/3)
6287                initialPosition[pawnRow+1][j] = WhiteCobra,
6288                initialPosition[BOARD_HEIGHT-pawnRow-2][j] = BlackCobra;
6289              for(i=1; i<pieceRows; i++) {
6290                initialPosition[i][j] = pieces[2*i][j-gameInfo.holdingsWidth];
6291                initialPosition[BOARD_HEIGHT-1-i][j] =  pieces[2*i+1][j-gameInfo.holdingsWidth];
6292              }
6293         }
6294         if(gameInfo.variant == VariantGrand || gameInfo.variant == VariantChuChess) {
6295             if(j==BOARD_LEFT || j>=BOARD_RGHT-1) {
6296                initialPosition[0][j] = WhiteRook;
6297                initialPosition[BOARD_HEIGHT-1][j] = BlackRook;
6298             }
6299         }
6300         initialPosition[BOARD_HEIGHT-1-(gameInfo.variant == VariantGrand || gameInfo.variant == VariantChuChess)][j] =  pieces[1][j-gameInfo.holdingsWidth];
6301     }
6302     if(gameInfo.variant == VariantChuChess) initialPosition[0][BOARD_WIDTH/2] = WhiteKing, initialPosition[BOARD_HEIGHT-1][BOARD_WIDTH/2-1] = BlackKing;
6303     if( (gameInfo.variant == VariantShogi) && !overrule ) {
6304
6305             j=BOARD_LEFT+1;
6306             initialPosition[1][j] = WhiteBishop;
6307             initialPosition[BOARD_HEIGHT-2][j] = BlackRook;
6308             j=BOARD_RGHT-2;
6309             initialPosition[1][j] = WhiteRook;
6310             initialPosition[BOARD_HEIGHT-2][j] = BlackBishop;
6311     }
6312
6313     if( nrCastlingRights == -1) {
6314         /* [HGM] Build normal castling rights (must be done after board sizing!) */
6315         /*       This sets default castling rights from none to normal corners   */
6316         /* Variants with other castling rights must set them themselves above    */
6317         nrCastlingRights = 6;
6318
6319         initialPosition[CASTLING][0] = initialRights[0] = BOARD_RGHT-1;
6320         initialPosition[CASTLING][1] = initialRights[1] = BOARD_LEFT;
6321         initialPosition[CASTLING][2] = initialRights[2] = BOARD_WIDTH>>1;
6322         initialPosition[CASTLING][3] = initialRights[3] = BOARD_RGHT-1;
6323         initialPosition[CASTLING][4] = initialRights[4] = BOARD_LEFT;
6324         initialPosition[CASTLING][5] = initialRights[5] = BOARD_WIDTH>>1;
6325      }
6326
6327      if(gameInfo.variant == VariantSuper) Prelude(initialPosition);
6328      if(gameInfo.variant == VariantGreat) { // promotion commoners
6329         initialPosition[PieceToNumber(WhiteMan)][BOARD_WIDTH-1] = WhiteMan;
6330         initialPosition[PieceToNumber(WhiteMan)][BOARD_WIDTH-2] = 9;
6331         initialPosition[BOARD_HEIGHT-1-PieceToNumber(WhiteMan)][0] = BlackMan;
6332         initialPosition[BOARD_HEIGHT-1-PieceToNumber(WhiteMan)][1] = 9;
6333      }
6334      if( gameInfo.variant == VariantSChess ) {
6335       initialPosition[1][0] = BlackMarshall;
6336       initialPosition[2][0] = BlackAngel;
6337       initialPosition[6][BOARD_WIDTH-1] = WhiteMarshall;
6338       initialPosition[5][BOARD_WIDTH-1] = WhiteAngel;
6339       initialPosition[1][1] = initialPosition[2][1] =
6340       initialPosition[6][BOARD_WIDTH-2] = initialPosition[5][BOARD_WIDTH-2] = 1;
6341      }
6342   if (appData.debugMode) {
6343     fprintf(debugFP, "shuffleOpenings = %d\n", shuffleOpenings);
6344   }
6345     if(shuffleOpenings) {
6346         SetUpShuffle(initialPosition, appData.defaultFrcPosition);
6347         startedFromSetupPosition = TRUE;
6348     }
6349     if(startedFromPositionFile) {
6350       /* [HGM] loadPos: use PositionFile for every new game */
6351       CopyBoard(initialPosition, filePosition);
6352       for(i=0; i<nrCastlingRights; i++)
6353           initialRights[i] = filePosition[CASTLING][i];
6354       startedFromSetupPosition = TRUE;
6355     }
6356
6357     CopyBoard(boards[0], initialPosition);
6358
6359     if(oldx != gameInfo.boardWidth ||
6360        oldy != gameInfo.boardHeight ||
6361        oldv != gameInfo.variant ||
6362        oldh != gameInfo.holdingsWidth
6363                                          )
6364             InitDrawingSizes(-2 ,0);
6365
6366     oldv = gameInfo.variant;
6367     if (redraw)
6368       DrawPosition(TRUE, boards[currentMove]);
6369 }
6370
6371 void
6372 SendBoard (ChessProgramState *cps, int moveNum)
6373 {
6374     char message[MSG_SIZ];
6375
6376     if (cps->useSetboard) {
6377       char* fen = PositionToFEN(moveNum, cps->fenOverride, 1);
6378       snprintf(message, MSG_SIZ,"setboard %s\n", fen);
6379       SendToProgram(message, cps);
6380       free(fen);
6381
6382     } else {
6383       ChessSquare *bp;
6384       int i, j, left=0, right=BOARD_WIDTH;
6385       /* Kludge to set black to move, avoiding the troublesome and now
6386        * deprecated "black" command.
6387        */
6388       if (!WhiteOnMove(moveNum)) // [HGM] but better a deprecated command than an illegal move...
6389         SendToProgram(boards[0][1][BOARD_LEFT] == WhitePawn ? "a2a3\n" : "black\n", cps);
6390
6391       if(!cps->extendedEdit) left = BOARD_LEFT, right = BOARD_RGHT; // only board proper
6392
6393       SendToProgram("edit\n", cps);
6394       SendToProgram("#\n", cps);
6395       for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
6396         bp = &boards[moveNum][i][left];
6397         for (j = left; j < right; j++, bp++) {
6398           if(j == BOARD_LEFT-1 || j == BOARD_RGHT) continue;
6399           if ((int) *bp < (int) BlackPawn) {
6400             if(j == BOARD_RGHT+1)
6401                  snprintf(message, MSG_SIZ, "%c@%d\n", PieceToChar(*bp), bp[-1]);
6402             else snprintf(message, MSG_SIZ, "%c%c%d\n", PieceToChar(*bp), AAA + j, ONE + i - '0');
6403             if(message[0] == '+' || message[0] == '~') {
6404               snprintf(message, MSG_SIZ,"%c%c%d+\n",
6405                         PieceToChar((ChessSquare)(DEMOTED *bp)),
6406                         AAA + j, ONE + i - '0');
6407             }
6408             if(cps->alphaRank) { /* [HGM] shogi: translate coords */
6409                 message[1] = BOARD_RGHT   - 1 - j + '1';
6410                 message[2] = BOARD_HEIGHT - 1 - i + 'a';
6411             }
6412             SendToProgram(message, cps);
6413           }
6414         }
6415       }
6416
6417       SendToProgram("c\n", cps);
6418       for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
6419         bp = &boards[moveNum][i][left];
6420         for (j = left; j < right; j++, bp++) {
6421           if(j == BOARD_LEFT-1 || j == BOARD_RGHT) continue;
6422           if (((int) *bp != (int) EmptySquare)
6423               && ((int) *bp >= (int) BlackPawn)) {
6424             if(j == BOARD_LEFT-2)
6425                  snprintf(message, MSG_SIZ, "%c@%d\n", ToUpper(PieceToChar(*bp)), bp[1]);
6426             else snprintf(message,MSG_SIZ, "%c%c%d\n", ToUpper(PieceToChar(*bp)),
6427                     AAA + j, ONE + i - '0');
6428             if(message[0] == '+' || message[0] == '~') {
6429               snprintf(message, MSG_SIZ,"%c%c%d+\n",
6430                         PieceToChar((ChessSquare)(DEMOTED *bp)),
6431                         AAA + j, ONE + i - '0');
6432             }
6433             if(cps->alphaRank) { /* [HGM] shogi: translate coords */
6434                 message[1] = BOARD_RGHT   - 1 - j + '1';
6435                 message[2] = BOARD_HEIGHT - 1 - i + 'a';
6436             }
6437             SendToProgram(message, cps);
6438           }
6439         }
6440       }
6441
6442       SendToProgram(".\n", cps);
6443     }
6444     setboardSpoiledMachineBlack = 0; /* [HGM] assume WB 4.2.7 already solves this after sending setboard */
6445 }
6446
6447 char exclusionHeader[MSG_SIZ];
6448 int exCnt, excludePtr;
6449 typedef struct { int ff, fr, tf, tr, pc, mark; } Exclusion;
6450 static Exclusion excluTab[200];
6451 static char excludeMap[(BOARD_RANKS*BOARD_FILES*BOARD_RANKS*BOARD_FILES+7)/8]; // [HGM] exclude: bitmap for excluced moves
6452
6453 static void
6454 WriteMap (int s)
6455 {
6456     int j;
6457     for(j=0; j<(BOARD_RANKS*BOARD_FILES*BOARD_RANKS*BOARD_FILES+7)/8; j++) excludeMap[j] = s;
6458     exclusionHeader[19] = s ? '-' : '+'; // update tail state
6459 }
6460
6461 static void
6462 ClearMap ()
6463 {
6464     safeStrCpy(exclusionHeader, "exclude: none best +tail                                          \n", MSG_SIZ);
6465     excludePtr = 24; exCnt = 0;
6466     WriteMap(0);
6467 }
6468
6469 static void
6470 UpdateExcludeHeader (int fromY, int fromX, int toY, int toX, char promoChar, char state)
6471 {   // search given move in table of header moves, to know where it is listed (and add if not there), and update state
6472     char buf[2*MOVE_LEN], *p;
6473     Exclusion *e = excluTab;
6474     int i;
6475     for(i=0; i<exCnt; i++)
6476         if(e[i].ff == fromX && e[i].fr == fromY &&
6477            e[i].tf == toX   && e[i].tr == toY && e[i].pc == promoChar) break;
6478     if(i == exCnt) { // was not in exclude list; add it
6479         CoordsToAlgebraic(boards[currentMove], PosFlags(currentMove), fromY, fromX, toY, toX, promoChar, buf);
6480         if(strlen(exclusionHeader + excludePtr) < strlen(buf)) { // no space to write move
6481             if(state != exclusionHeader[19]) exclusionHeader[19] = '*'; // tail is now in mixed state
6482             return; // abort
6483         }
6484         e[i].ff = fromX; e[i].fr = fromY; e[i].tf = toX; e[i].tr = toY; e[i].pc = promoChar;
6485         excludePtr++; e[i].mark = excludePtr++;
6486         for(p=buf; *p; p++) exclusionHeader[excludePtr++] = *p; // copy move
6487         exCnt++;
6488     }
6489     exclusionHeader[e[i].mark] = state;
6490 }
6491
6492 static int
6493 ExcludeOneMove (int fromY, int fromX, int toY, int toX, char promoChar, char state)
6494 {   // include or exclude the given move, as specified by state ('+' or '-'), or toggle
6495     char buf[MSG_SIZ];
6496     int j, k;
6497     ChessMove moveType;
6498     if((signed char)promoChar == -1) { // kludge to indicate best move
6499         if(!ParseOneMove(lastPV[0], currentMove, &moveType, &fromX, &fromY, &toX, &toY, &promoChar)) // get current best move from last PV
6500             return 1; // if unparsable, abort
6501     }
6502     // update exclusion map (resolving toggle by consulting existing state)
6503     k=(BOARD_FILES*fromY+fromX)*BOARD_RANKS*BOARD_FILES + (BOARD_FILES*toY+toX);
6504     j = k%8; k >>= 3;
6505     if(state == '*') state = (excludeMap[k] & 1<<j ? '+' : '-'); // toggle
6506     if(state == '-' && !promoChar) // only non-promotions get marked as excluded, to allow exclusion of under-promotions
6507          excludeMap[k] |=   1<<j;
6508     else excludeMap[k] &= ~(1<<j);
6509     // update header
6510     UpdateExcludeHeader(fromY, fromX, toY, toX, promoChar, state);
6511     // inform engine
6512     snprintf(buf, MSG_SIZ, "%sclude ", state == '+' ? "in" : "ex");
6513     CoordsToComputerAlgebraic(fromY, fromX, toY, toX, promoChar, buf+8);
6514     SendToBoth(buf);
6515     return (state == '+');
6516 }
6517
6518 static void
6519 ExcludeClick (int index)
6520 {
6521     int i, j;
6522     Exclusion *e = excluTab;
6523     if(index < 25) { // none, best or tail clicked
6524         if(index < 13) { // none: include all
6525             WriteMap(0); // clear map
6526             for(i=0; i<exCnt; i++) exclusionHeader[excluTab[i].mark] = '+'; // and moves
6527             SendToBoth("include all\n"); // and inform engine
6528         } else if(index > 18) { // tail
6529             if(exclusionHeader[19] == '-') { // tail was excluded
6530                 SendToBoth("include all\n");
6531                 WriteMap(0); // clear map completely
6532                 // now re-exclude selected moves
6533                 for(i=0; i<exCnt; i++) if(exclusionHeader[e[i].mark] == '-')
6534                     ExcludeOneMove(e[i].fr, e[i].ff, e[i].tr, e[i].tf, e[i].pc, '-');
6535             } else { // tail was included or in mixed state
6536                 SendToBoth("exclude all\n");
6537                 WriteMap(0xFF); // fill map completely
6538                 // now re-include selected moves
6539                 j = 0; // count them
6540                 for(i=0; i<exCnt; i++) if(exclusionHeader[e[i].mark] == '+')
6541                     ExcludeOneMove(e[i].fr, e[i].ff, e[i].tr, e[i].tf, e[i].pc, '+'), j++;
6542                 if(!j) ExcludeOneMove(0, 0, 0, 0, -1, '+'); // if no moves were selected, keep best
6543             }
6544         } else { // best
6545             ExcludeOneMove(0, 0, 0, 0, -1, '-'); // exclude it
6546         }
6547     } else {
6548         for(i=0; i<exCnt; i++) if(i == exCnt-1 || excluTab[i+1].mark > index) {
6549             char *p=exclusionHeader + excluTab[i].mark; // do trust header more than map (promotions!)
6550             ExcludeOneMove(e[i].fr, e[i].ff, e[i].tr, e[i].tf, e[i].pc, *p == '+' ? '-' : '+');
6551             break;
6552         }
6553     }
6554 }
6555
6556 ChessSquare
6557 DefaultPromoChoice (int white)
6558 {
6559     ChessSquare result;
6560     if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier ||
6561        gameInfo.variant == VariantMakruk)
6562         result = WhiteFerz; // no choice
6563     else if(gameInfo.variant == VariantASEAN)
6564         result = WhiteRook; // no choice
6565     else if(gameInfo.variant == VariantSuicide || gameInfo.variant == VariantGiveaway)
6566         result= WhiteKing; // in Suicide Q is the last thing we want
6567     else if(gameInfo.variant == VariantSpartan)
6568         result = white ? WhiteQueen : WhiteAngel;
6569     else result = WhiteQueen;
6570     if(!white) result = WHITE_TO_BLACK result;
6571     return result;
6572 }
6573
6574 static int autoQueen; // [HGM] oneclick
6575
6576 int
6577 HasPromotionChoice (int fromX, int fromY, int toX, int toY, char *promoChoice, int sweepSelect)
6578 {
6579     /* [HGM] rewritten IsPromotion to only flag promotions that offer a choice */
6580     /* [HGM] add Shogi promotions */
6581     int promotionZoneSize=1, highestPromotingPiece = (int)WhitePawn;
6582     ChessSquare piece, partner;
6583     ChessMove moveType;
6584     Boolean premove;
6585
6586     if(fromX < BOARD_LEFT || fromX >= BOARD_RGHT) return FALSE; // drop
6587     if(toX   < BOARD_LEFT || toX   >= BOARD_RGHT) return FALSE; // move into holdings
6588
6589     if(gameMode == EditPosition || gameInfo.variant == VariantXiangqi || // no promotions
6590       !(fromX >=0 && fromY >= 0 && toX >= 0 && toY >= 0) ) // invalid move
6591         return FALSE;
6592
6593     piece = boards[currentMove][fromY][fromX];
6594     if(gameInfo.variant == VariantChu) {
6595         int p = piece >= BlackPawn ? BLACK_TO_WHITE piece : piece;
6596         promotionZoneSize = BOARD_HEIGHT/3;
6597         highestPromotingPiece = (p >= WhiteLion || PieceToChar(piece + 22) == '.') ? WhitePawn : WhiteLion;
6598     } else if(gameInfo.variant == VariantShogi) {
6599         promotionZoneSize = BOARD_HEIGHT/3 +(BOARD_HEIGHT == 8);
6600         highestPromotingPiece = (int)WhiteAlfil;
6601     } else if(gameInfo.variant == VariantMakruk || gameInfo.variant == VariantGrand || gameInfo.variant == VariantChuChess) {
6602         promotionZoneSize = 3;
6603     }
6604
6605     // Treat Lance as Pawn when it is not representing Amazon or Lance
6606     if(gameInfo.variant != VariantSuper && gameInfo.variant != VariantChu) {
6607         if(piece == WhiteLance) piece = WhitePawn; else
6608         if(piece == BlackLance) piece = BlackPawn;
6609     }
6610
6611     // next weed out all moves that do not touch the promotion zone at all
6612     if((int)piece >= BlackPawn) {
6613         if(toY >= promotionZoneSize && fromY >= promotionZoneSize)
6614              return FALSE;
6615         if(fromY < promotionZoneSize && gameInfo.variant == VariantChuChess) return FALSE;
6616         highestPromotingPiece = WHITE_TO_BLACK highestPromotingPiece;
6617     } else {
6618         if(  toY < BOARD_HEIGHT - promotionZoneSize &&
6619            fromY < BOARD_HEIGHT - promotionZoneSize) return FALSE;
6620         if(fromY >= BOARD_HEIGHT - promotionZoneSize && gameInfo.variant == VariantChuChess)
6621              return FALSE;
6622     }
6623
6624     if( (int)piece > highestPromotingPiece ) return FALSE; // non-promoting piece
6625
6626     // weed out mandatory Shogi promotions
6627     if(gameInfo.variant == VariantShogi) {
6628         if(piece >= BlackPawn) {
6629             if(toY == 0 && piece == BlackPawn ||
6630                toY == 0 && piece == BlackQueen ||
6631                toY <= 1 && piece == BlackKnight) {
6632                 *promoChoice = '+';
6633                 return FALSE;
6634             }
6635         } else {
6636             if(toY == BOARD_HEIGHT-1 && piece == WhitePawn ||
6637                toY == BOARD_HEIGHT-1 && piece == WhiteQueen ||
6638                toY >= BOARD_HEIGHT-2 && piece == WhiteKnight) {
6639                 *promoChoice = '+';
6640                 return FALSE;
6641             }
6642         }
6643     }
6644
6645     // weed out obviously illegal Pawn moves
6646     if(appData.testLegality  && (piece == WhitePawn || piece == BlackPawn) ) {
6647         if(toX > fromX+1 || toX < fromX-1) return FALSE; // wide
6648         if(piece == WhitePawn && toY != fromY+1) return FALSE; // deep
6649         if(piece == BlackPawn && toY != fromY-1) return FALSE; // deep
6650         if(fromX != toX && gameInfo.variant == VariantShogi) return FALSE;
6651         // note we are not allowed to test for valid (non-)capture, due to premove
6652     }
6653
6654     // we either have a choice what to promote to, or (in Shogi) whether to promote
6655     if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier ||
6656        gameInfo.variant == VariantMakruk) {
6657         ChessSquare p=BlackFerz;  // no choice
6658         while(p < EmptySquare) {  //but make sure we use piece that exists
6659             *promoChoice = PieceToChar(p++);
6660             if(*promoChoice != '.') break;
6661         }
6662         return FALSE;
6663     }
6664     // no sense asking what we must promote to if it is going to explode...
6665     if(gameInfo.variant == VariantAtomic && boards[currentMove][toY][toX] != EmptySquare) {
6666         *promoChoice = PieceToChar(BlackQueen); // Queen as good as any
6667         return FALSE;
6668     }
6669     // give caller the default choice even if we will not make it
6670     *promoChoice = ToLower(PieceToChar(defaultPromoChoice));
6671     partner = piece; // pieces can promote if the pieceToCharTable says so
6672     if(IS_SHOGI(gameInfo.variant)) *promoChoice = (defaultPromoChoice == piece && sweepSelect ? '=' : '+'); // obsolete?
6673     else if(Partner(&partner))     *promoChoice = (defaultPromoChoice == piece && sweepSelect ? NULLCHAR : '+');
6674     if(        sweepSelect && gameInfo.variant != VariantGreat
6675                            && gameInfo.variant != VariantGrand
6676                            && gameInfo.variant != VariantSuper) return FALSE;
6677     if(autoQueen) return FALSE; // predetermined
6678
6679     // suppress promotion popup on illegal moves that are not premoves
6680     premove = gameMode == IcsPlayingWhite && !WhiteOnMove(currentMove) ||
6681               gameMode == IcsPlayingBlack &&  WhiteOnMove(currentMove);
6682     if(appData.testLegality && !premove) {
6683         moveType = LegalityTest(boards[currentMove], PosFlags(currentMove),
6684                         fromY, fromX, toY, toX, IS_SHOGI(gameInfo.variant) || gameInfo.variant == VariantChuChess ? '+' : NULLCHAR);
6685         if(moveType == IllegalMove) *promoChoice = NULLCHAR; // could be the fact we promoted was illegal
6686         if(moveType != WhitePromotion && moveType  != BlackPromotion)
6687             return FALSE;
6688     }
6689
6690     return TRUE;
6691 }
6692
6693 int
6694 InPalace (int row, int column)
6695 {   /* [HGM] for Xiangqi */
6696     if( (row < 3 || row > BOARD_HEIGHT-4) &&
6697          column < (BOARD_WIDTH + 4)/2 &&
6698          column > (BOARD_WIDTH - 5)/2 ) return TRUE;
6699     return FALSE;
6700 }
6701
6702 int
6703 PieceForSquare (int x, int y)
6704 {
6705   if (x < 0 || x >= BOARD_WIDTH || y < 0 || y >= BOARD_HEIGHT)
6706      return -1;
6707   else
6708      return boards[currentMove][y][x];
6709 }
6710
6711 int
6712 OKToStartUserMove (int x, int y)
6713 {
6714     ChessSquare from_piece;
6715     int white_piece;
6716
6717     if (matchMode) return FALSE;
6718     if (gameMode == EditPosition) return TRUE;
6719
6720     if (x >= 0 && y >= 0)
6721       from_piece = boards[currentMove][y][x];
6722     else
6723       from_piece = EmptySquare;
6724
6725     if (from_piece == EmptySquare) return FALSE;
6726
6727     white_piece = (int)from_piece >= (int)WhitePawn &&
6728       (int)from_piece < (int)BlackPawn; /* [HGM] can be > King! */
6729
6730     switch (gameMode) {
6731       case AnalyzeFile:
6732       case TwoMachinesPlay:
6733       case EndOfGame:
6734         return FALSE;
6735
6736       case IcsObserving:
6737       case IcsIdle:
6738         return FALSE;
6739
6740       case MachinePlaysWhite:
6741       case IcsPlayingBlack:
6742         if (appData.zippyPlay) return FALSE;
6743         if (white_piece) {
6744             DisplayMoveError(_("You are playing Black"));
6745             return FALSE;
6746         }
6747         break;
6748
6749       case MachinePlaysBlack:
6750       case IcsPlayingWhite:
6751         if (appData.zippyPlay) return FALSE;
6752         if (!white_piece) {
6753             DisplayMoveError(_("You are playing White"));
6754             return FALSE;
6755         }
6756         break;
6757
6758       case PlayFromGameFile:
6759             if(!shiftKey || !appData.variations) return FALSE; // [HGM] allow starting variation in this mode
6760       case EditGame:
6761         if (!white_piece && WhiteOnMove(currentMove)) {
6762             DisplayMoveError(_("It is White's turn"));
6763             return FALSE;
6764         }
6765         if (white_piece && !WhiteOnMove(currentMove)) {
6766             DisplayMoveError(_("It is Black's turn"));
6767             return FALSE;
6768         }
6769         if (cmailMsgLoaded && (currentMove < cmailOldMove)) {
6770             /* Editing correspondence game history */
6771             /* Could disallow this or prompt for confirmation */
6772             cmailOldMove = -1;
6773         }
6774         break;
6775
6776       case BeginningOfGame:
6777         if (appData.icsActive) return FALSE;
6778         if (!appData.noChessProgram) {
6779             if (!white_piece) {
6780                 DisplayMoveError(_("You are playing White"));
6781                 return FALSE;
6782             }
6783         }
6784         break;
6785
6786       case Training:
6787         if (!white_piece && WhiteOnMove(currentMove)) {
6788             DisplayMoveError(_("It is White's turn"));
6789             return FALSE;
6790         }
6791         if (white_piece && !WhiteOnMove(currentMove)) {
6792             DisplayMoveError(_("It is Black's turn"));
6793             return FALSE;
6794         }
6795         break;
6796
6797       default:
6798       case IcsExamining:
6799         break;
6800     }
6801     if (currentMove != forwardMostMove && gameMode != AnalyzeMode
6802         && gameMode != EditGame // [HGM] vari: treat as AnalyzeMode
6803         && gameMode != PlayFromGameFile // [HGM] as EditGame, with protected main line
6804         && gameMode != AnalyzeFile && gameMode != Training) {
6805         DisplayMoveError(_("Displayed position is not current"));
6806         return FALSE;
6807     }
6808     return TRUE;
6809 }
6810
6811 Boolean
6812 OnlyMove (int *x, int *y, Boolean captures)
6813 {
6814     DisambiguateClosure cl;
6815     if (appData.zippyPlay || !appData.testLegality) return FALSE;
6816     switch(gameMode) {
6817       case MachinePlaysBlack:
6818       case IcsPlayingWhite:
6819       case BeginningOfGame:
6820         if(!WhiteOnMove(currentMove)) return FALSE;
6821         break;
6822       case MachinePlaysWhite:
6823       case IcsPlayingBlack:
6824         if(WhiteOnMove(currentMove)) return FALSE;
6825         break;
6826       case EditGame:
6827         break;
6828       default:
6829         return FALSE;
6830     }
6831     cl.pieceIn = EmptySquare;
6832     cl.rfIn = *y;
6833     cl.ffIn = *x;
6834     cl.rtIn = -1;
6835     cl.ftIn = -1;
6836     cl.promoCharIn = NULLCHAR;
6837     Disambiguate(boards[currentMove], PosFlags(currentMove), &cl);
6838     if( cl.kind == NormalMove ||
6839         cl.kind == AmbiguousMove && captures && cl.captures == 1 ||
6840         cl.kind == WhitePromotion || cl.kind == BlackPromotion ||
6841         cl.kind == WhiteCapturesEnPassant || cl.kind == BlackCapturesEnPassant) {
6842       fromX = cl.ff;
6843       fromY = cl.rf;
6844       *x = cl.ft;
6845       *y = cl.rt;
6846       return TRUE;
6847     }
6848     if(cl.kind != ImpossibleMove) return FALSE;
6849     cl.pieceIn = EmptySquare;
6850     cl.rfIn = -1;
6851     cl.ffIn = -1;
6852     cl.rtIn = *y;
6853     cl.ftIn = *x;
6854     cl.promoCharIn = NULLCHAR;
6855     Disambiguate(boards[currentMove], PosFlags(currentMove), &cl);
6856     if( cl.kind == NormalMove ||
6857         cl.kind == AmbiguousMove && captures && cl.captures == 1 ||
6858         cl.kind == WhitePromotion || cl.kind == BlackPromotion ||
6859         cl.kind == WhiteCapturesEnPassant || cl.kind == BlackCapturesEnPassant) {
6860       fromX = cl.ff;
6861       fromY = cl.rf;
6862       *x = cl.ft;
6863       *y = cl.rt;
6864       autoQueen = TRUE; // act as if autoQueen on when we click to-square
6865       return TRUE;
6866     }
6867     return FALSE;
6868 }
6869
6870 FILE *lastLoadGameFP = NULL, *lastLoadPositionFP = NULL;
6871 int lastLoadGameNumber = 0, lastLoadPositionNumber = 0;
6872 int lastLoadGameUseList = FALSE;
6873 char lastLoadGameTitle[MSG_SIZ], lastLoadPositionTitle[MSG_SIZ];
6874 ChessMove lastLoadGameStart = EndOfFile;
6875 int doubleClick;
6876 Boolean addToBookFlag;
6877
6878 void
6879 UserMoveEvent(int fromX, int fromY, int toX, int toY, int promoChar)
6880 {
6881     ChessMove moveType;
6882     ChessSquare pup;
6883     int ff=fromX, rf=fromY, ft=toX, rt=toY;
6884
6885     /* Check if the user is playing in turn.  This is complicated because we
6886        let the user "pick up" a piece before it is his turn.  So the piece he
6887        tried to pick up may have been captured by the time he puts it down!
6888        Therefore we use the color the user is supposed to be playing in this
6889        test, not the color of the piece that is currently on the starting
6890        square---except in EditGame mode, where the user is playing both
6891        sides; fortunately there the capture race can't happen.  (It can
6892        now happen in IcsExamining mode, but that's just too bad.  The user
6893        will get a somewhat confusing message in that case.)
6894        */
6895
6896     switch (gameMode) {
6897       case AnalyzeFile:
6898       case TwoMachinesPlay:
6899       case EndOfGame:
6900       case IcsObserving:
6901       case IcsIdle:
6902         /* We switched into a game mode where moves are not accepted,
6903            perhaps while the mouse button was down. */
6904         return;
6905
6906       case MachinePlaysWhite:
6907         /* User is moving for Black */
6908         if (WhiteOnMove(currentMove)) {
6909             DisplayMoveError(_("It is White's turn"));
6910             return;
6911         }
6912         break;
6913
6914       case MachinePlaysBlack:
6915         /* User is moving for White */
6916         if (!WhiteOnMove(currentMove)) {
6917             DisplayMoveError(_("It is Black's turn"));
6918             return;
6919         }
6920         break;
6921
6922       case PlayFromGameFile:
6923             if(!shiftKey ||!appData.variations) return; // [HGM] only variations
6924       case EditGame:
6925       case IcsExamining:
6926       case BeginningOfGame:
6927       case AnalyzeMode:
6928       case Training:
6929         if(fromY == DROP_RANK) break; // [HGM] drop moves (entered through move type-in) are automatically assigned to side-to-move
6930         if ((int) boards[currentMove][fromY][fromX] >= (int) BlackPawn &&
6931             (int) boards[currentMove][fromY][fromX] < (int) EmptySquare) {
6932             /* User is moving for Black */
6933             if (WhiteOnMove(currentMove)) {
6934                 DisplayMoveError(_("It is White's turn"));
6935                 return;
6936             }
6937         } else {
6938             /* User is moving for White */
6939             if (!WhiteOnMove(currentMove)) {
6940                 DisplayMoveError(_("It is Black's turn"));
6941                 return;
6942             }
6943         }
6944         break;
6945
6946       case IcsPlayingBlack:
6947         /* User is moving for Black */
6948         if (WhiteOnMove(currentMove)) {
6949             if (!appData.premove) {
6950                 DisplayMoveError(_("It is White's turn"));
6951             } else if (toX >= 0 && toY >= 0) {
6952                 premoveToX = toX;
6953                 premoveToY = toY;
6954                 premoveFromX = fromX;
6955                 premoveFromY = fromY;
6956                 premovePromoChar = promoChar;
6957                 gotPremove = 1;
6958                 if (appData.debugMode)
6959                     fprintf(debugFP, "Got premove: fromX %d,"
6960                             "fromY %d, toX %d, toY %d\n",
6961                             fromX, fromY, toX, toY);
6962             }
6963             return;
6964         }
6965         break;
6966
6967       case IcsPlayingWhite:
6968         /* User is moving for White */
6969         if (!WhiteOnMove(currentMove)) {
6970             if (!appData.premove) {
6971                 DisplayMoveError(_("It is Black's turn"));
6972             } else if (toX >= 0 && toY >= 0) {
6973                 premoveToX = toX;
6974                 premoveToY = toY;
6975                 premoveFromX = fromX;
6976                 premoveFromY = fromY;
6977                 premovePromoChar = promoChar;
6978                 gotPremove = 1;
6979                 if (appData.debugMode)
6980                     fprintf(debugFP, "Got premove: fromX %d,"
6981                             "fromY %d, toX %d, toY %d\n",
6982                             fromX, fromY, toX, toY);
6983             }
6984             return;
6985         }
6986         break;
6987
6988       default:
6989         break;
6990
6991       case EditPosition:
6992         /* EditPosition, empty square, or different color piece;
6993            click-click move is possible */
6994         if (toX == -2 || toY == -2) {
6995             boards[0][fromY][fromX] = (boards[0][fromY][fromX] == EmptySquare ? DarkSquare : EmptySquare);
6996             DrawPosition(FALSE, boards[currentMove]);
6997             return;
6998         } else if (toX >= 0 && toY >= 0) {
6999             if(!appData.pieceMenu && toX == fromX && toY == fromY && boards[0][rf][ff] != EmptySquare) {
7000                 ChessSquare q, p = boards[0][rf][ff];
7001                 if(p >= BlackPawn) p = BLACK_TO_WHITE p;
7002                 if(CHUPROMOTED p < BlackPawn) p = q = CHUPROMOTED boards[0][rf][ff];
7003                 else p = CHUDEMOTED (q = boards[0][rf][ff]);
7004                 if(PieceToChar(q) == '+') gatingPiece = p;
7005             }
7006             boards[0][toY][toX] = boards[0][fromY][fromX];
7007             if(fromX == BOARD_LEFT-2) { // handle 'moves' out of holdings
7008                 if(boards[0][fromY][0] != EmptySquare) {
7009                     if(boards[0][fromY][1]) boards[0][fromY][1]--;
7010                     if(boards[0][fromY][1] == 0)  boards[0][fromY][0] = EmptySquare;
7011                 }
7012             } else
7013             if(fromX == BOARD_RGHT+1) {
7014                 if(boards[0][fromY][BOARD_WIDTH-1] != EmptySquare) {
7015                     if(boards[0][fromY][BOARD_WIDTH-2]) boards[0][fromY][BOARD_WIDTH-2]--;
7016                     if(boards[0][fromY][BOARD_WIDTH-2] == 0)  boards[0][fromY][BOARD_WIDTH-1] = EmptySquare;
7017                 }
7018             } else
7019             boards[0][fromY][fromX] = gatingPiece;
7020             DrawPosition(FALSE, boards[currentMove]);
7021             return;
7022         }
7023         return;
7024     }
7025
7026     if((toX < 0 || toY < 0) && (fromY != DROP_RANK || fromX != EmptySquare)) return;
7027     pup = boards[currentMove][toY][toX];
7028
7029     /* [HGM] If move started in holdings, it means a drop. Convert to standard form */
7030     if( (fromX == BOARD_LEFT-2 || fromX == BOARD_RGHT+1) && fromY != DROP_RANK ) {
7031          if( pup != EmptySquare ) return;
7032          moveType = WhiteOnMove(currentMove) ? WhiteDrop : BlackDrop;
7033            if(appData.debugMode) fprintf(debugFP, "Drop move %d, curr=%d, x=%d,y=%d, p=%d\n",
7034                 moveType, currentMove, fromX, fromY, boards[currentMove][fromY][fromX]);
7035            // holdings might not be sent yet in ICS play; we have to figure out which piece belongs here
7036            if(fromX == 0) fromY = BOARD_HEIGHT-1 - fromY; // black holdings upside-down
7037            fromX = fromX ? WhitePawn : BlackPawn; // first piece type in selected holdings
7038            while(PieceToChar(fromX) == '.' || PieceToChar(fromX) == '+' || PieceToNumber(fromX) != fromY && fromX != (int) EmptySquare) fromX++;
7039          fromY = DROP_RANK;
7040     }
7041
7042     /* [HGM] always test for legality, to get promotion info */
7043     moveType = LegalityTest(boards[currentMove], PosFlags(currentMove),
7044                                          fromY, fromX, toY, toX, promoChar);
7045
7046     if(fromY == DROP_RANK && fromX == EmptySquare && (gameMode == AnalyzeMode || gameMode == EditGame || PosFlags(0) & F_NULL_MOVE)) moveType = NormalMove;
7047
7048     /* [HGM] but possibly ignore an IllegalMove result */
7049     if (appData.testLegality) {
7050         if (moveType == IllegalMove || moveType == ImpossibleMove) {
7051             DisplayMoveError(_("Illegal move"));
7052             return;
7053         }
7054     }
7055
7056     if(doubleClick && gameMode == AnalyzeMode) { // [HGM] exclude: move entered with double-click on from square is for exclusion, not playing
7057         if(ExcludeOneMove(fromY, fromX, toY, toX, promoChar, '*')) // toggle
7058              ClearPremoveHighlights(); // was included
7059         else ClearHighlights(), SetPremoveHighlights(ff, rf, ft, rt); // exclusion indicated  by premove highlights
7060         return;
7061     }
7062
7063     if(addToBookFlag) { // adding moves to book
7064         char buf[MSG_SIZ], move[MSG_SIZ];
7065         CoordsToAlgebraic(boards[currentMove], PosFlags(currentMove), fromY, fromX, toY, toX, promoChar, move);
7066         if(killX >= 0) snprintf(move, MSG_SIZ, "%c%dx%c%d-%c%d", fromX + AAA, fromY + ONE - '0', killX + AAA, killY + ONE - '0', toX + AAA, toY + ONE - '0');
7067         snprintf(buf, MSG_SIZ, "  0.0%%     1  %s\n", move);
7068         AddBookMove(buf);
7069         addToBookFlag = FALSE;
7070         ClearHighlights();
7071         return;
7072     }
7073
7074     FinishMove(moveType, fromX, fromY, toX, toY, promoChar);
7075 }
7076
7077 /* Common tail of UserMoveEvent and DropMenuEvent */
7078 int
7079 FinishMove (ChessMove moveType, int fromX, int fromY, int toX, int toY, int promoChar)
7080 {
7081     char *bookHit = 0;
7082
7083     if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat || gameInfo.variant == VariantGrand) && promoChar != NULLCHAR) {
7084         // [HGM] superchess: suppress promotions to non-available piece (but P always allowed)
7085         int k = PieceToNumber(CharToPiece(ToUpper(promoChar)));
7086         if(WhiteOnMove(currentMove)) {
7087             if(!boards[currentMove][k][BOARD_WIDTH-2]) return 0;
7088         } else {
7089             if(!boards[currentMove][BOARD_HEIGHT-1-k][1]) return 0;
7090         }
7091     }
7092
7093     /* [HGM] <popupFix> kludge to avoid having to know the exact promotion
7094        move type in caller when we know the move is a legal promotion */
7095     if(moveType == NormalMove && promoChar)
7096         moveType = WhiteOnMove(currentMove) ? WhitePromotion : BlackPromotion;
7097
7098     /* [HGM] <popupFix> The following if has been moved here from
7099        UserMoveEvent(). Because it seemed to belong here (why not allow
7100        piece drops in training games?), and because it can only be
7101        performed after it is known to what we promote. */
7102     if (gameMode == Training) {
7103       /* compare the move played on the board to the next move in the
7104        * game. If they match, display the move and the opponent's response.
7105        * If they don't match, display an error message.
7106        */
7107       int saveAnimate;
7108       Board testBoard;
7109       CopyBoard(testBoard, boards[currentMove]);
7110       ApplyMove(fromX, fromY, toX, toY, promoChar, testBoard);
7111
7112       if (CompareBoards(testBoard, boards[currentMove+1])) {
7113         ForwardInner(currentMove+1);
7114
7115         /* Autoplay the opponent's response.
7116          * if appData.animate was TRUE when Training mode was entered,
7117          * the response will be animated.
7118          */
7119         saveAnimate = appData.animate;
7120         appData.animate = animateTraining;
7121         ForwardInner(currentMove+1);
7122         appData.animate = saveAnimate;
7123
7124         /* check for the end of the game */
7125         if (currentMove >= forwardMostMove) {
7126           gameMode = PlayFromGameFile;
7127           ModeHighlight();
7128           SetTrainingModeOff();
7129           DisplayInformation(_("End of game"));
7130         }
7131       } else {
7132         DisplayError(_("Incorrect move"), 0);
7133       }
7134       return 1;
7135     }
7136
7137   /* Ok, now we know that the move is good, so we can kill
7138      the previous line in Analysis Mode */
7139   if ((gameMode == AnalyzeMode || gameMode == EditGame || gameMode == PlayFromGameFile && appData.variations && shiftKey)
7140                                 && currentMove < forwardMostMove) {
7141     if(appData.variations && shiftKey) PushTail(currentMove, forwardMostMove); // [HGM] vari: save tail of game
7142     else forwardMostMove = currentMove;
7143   }
7144
7145   ClearMap();
7146
7147   /* If we need the chess program but it's dead, restart it */
7148   ResurrectChessProgram();
7149
7150   /* A user move restarts a paused game*/
7151   if (pausing)
7152     PauseEvent();
7153
7154   thinkOutput[0] = NULLCHAR;
7155
7156   MakeMove(fromX, fromY, toX, toY, promoChar); /*updates forwardMostMove*/
7157
7158   if(Adjudicate(NULL)) { // [HGM] adjudicate: take care of automatic game end
7159     ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
7160     return 1;
7161   }
7162
7163   if (gameMode == BeginningOfGame) {
7164     if (appData.noChessProgram) {
7165       gameMode = EditGame;
7166       SetGameInfo();
7167     } else {
7168       char buf[MSG_SIZ];
7169       gameMode = MachinePlaysBlack;
7170       StartClocks();
7171       SetGameInfo();
7172       snprintf(buf, MSG_SIZ, "%s %s %s", gameInfo.white, _("vs."), gameInfo.black);
7173       DisplayTitle(buf);
7174       if (first.sendName) {
7175         snprintf(buf, MSG_SIZ,"name %s\n", gameInfo.white);
7176         SendToProgram(buf, &first);
7177       }
7178       StartClocks();
7179     }
7180     ModeHighlight();
7181   }
7182
7183   /* Relay move to ICS or chess engine */
7184   if (appData.icsActive) {
7185     if (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack ||
7186         gameMode == IcsExamining) {
7187       if(userOfferedDraw && (signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
7188         SendToICS(ics_prefix); // [HGM] drawclaim: send caim and move on one line for FICS
7189         SendToICS("draw ");
7190         SendMoveToICS(moveType, fromX, fromY, toX, toY, promoChar);
7191       }
7192       // also send plain move, in case ICS does not understand atomic claims
7193       SendMoveToICS(moveType, fromX, fromY, toX, toY, promoChar);
7194       ics_user_moved = 1;
7195     }
7196   } else {
7197     if (first.sendTime && (gameMode == BeginningOfGame ||
7198                            gameMode == MachinePlaysWhite ||
7199                            gameMode == MachinePlaysBlack)) {
7200       SendTimeRemaining(&first, gameMode != MachinePlaysBlack);
7201     }
7202     if (gameMode != EditGame && gameMode != PlayFromGameFile && gameMode != AnalyzeMode) {
7203          // [HGM] book: if program might be playing, let it use book
7204         bookHit = SendMoveToBookUser(forwardMostMove-1, &first, FALSE);
7205         first.maybeThinking = TRUE;
7206     } else if(fromY == DROP_RANK && fromX == EmptySquare) {
7207         if(!first.useSetboard) SendToProgram("undo\n", &first); // kludge to change stm in engines that do not support setboard
7208         SendBoard(&first, currentMove+1);
7209         if(second.analyzing) {
7210             if(!second.useSetboard) SendToProgram("undo\n", &second);
7211             SendBoard(&second, currentMove+1);
7212         }
7213     } else {
7214         SendMoveToProgram(forwardMostMove-1, &first);
7215         if(second.analyzing) SendMoveToProgram(forwardMostMove-1, &second);
7216     }
7217     if (currentMove == cmailOldMove + 1) {
7218       cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
7219     }
7220   }
7221
7222   ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
7223
7224   switch (gameMode) {
7225   case EditGame:
7226     if(appData.testLegality)
7227     switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
7228     case MT_NONE:
7229     case MT_CHECK:
7230       break;
7231     case MT_CHECKMATE:
7232     case MT_STAINMATE:
7233       if (WhiteOnMove(currentMove)) {
7234         GameEnds(BlackWins, "Black mates", GE_PLAYER);
7235       } else {
7236         GameEnds(WhiteWins, "White mates", GE_PLAYER);
7237       }
7238       break;
7239     case MT_STALEMATE:
7240       GameEnds(GameIsDrawn, "Stalemate", GE_PLAYER);
7241       break;
7242     }
7243     break;
7244
7245   case MachinePlaysBlack:
7246   case MachinePlaysWhite:
7247     /* disable certain menu options while machine is thinking */
7248     SetMachineThinkingEnables();
7249     break;
7250
7251   default:
7252     break;
7253   }
7254
7255   userOfferedDraw = FALSE; // [HGM] drawclaim: after move made, and tested for claimable draw
7256   promoDefaultAltered = FALSE; // [HGM] fall back on default choice
7257
7258   if(bookHit) { // [HGM] book: simulate book reply
7259         static char bookMove[MSG_SIZ]; // a bit generous?
7260
7261         programStats.nodes = programStats.depth = programStats.time =
7262         programStats.score = programStats.got_only_move = 0;
7263         sprintf(programStats.movelist, "%s (xbook)", bookHit);
7264
7265         safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
7266         strcat(bookMove, bookHit);
7267         HandleMachineMove(bookMove, &first);
7268   }
7269   return 1;
7270 }
7271
7272 void
7273 MarkByFEN(char *fen)
7274 {
7275         int r, f;
7276         if(!appData.markers || !appData.highlightDragging) return;
7277         for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) legal[r][f] = 0;
7278         r=BOARD_HEIGHT-1; f=BOARD_LEFT;
7279         while(*fen) {
7280             int s = 0;
7281             marker[r][f] = 0;
7282             if(*fen == 'M') legal[r][f] = 2; else // request promotion choice
7283             if(*fen >= 'A' && *fen <= 'Z') legal[r][f] = 1; else
7284             if(*fen >= 'a' && *fen <= 'z') *fen += 'A' - 'a';
7285             if(*fen == '/' && f > BOARD_LEFT) f = BOARD_LEFT, r--; else
7286             if(*fen == 'T') marker[r][f++] = 0; else
7287             if(*fen == 'Y') marker[r][f++] = 1; else
7288             if(*fen == 'G') marker[r][f++] = 3; else
7289             if(*fen == 'B') marker[r][f++] = 4; else
7290             if(*fen == 'C') marker[r][f++] = 5; else
7291             if(*fen == 'M') marker[r][f++] = 6; else
7292             if(*fen == 'W') marker[r][f++] = 7; else
7293             if(*fen == 'D') marker[r][f++] = 8; else
7294             if(*fen == 'R') marker[r][f++] = 2; else {
7295                 while(*fen <= '9' && *fen >= '0') s = 10*s + *fen++ - '0';
7296               f += s; fen -= s>0;
7297             }
7298             while(f >= BOARD_RGHT) f -= BOARD_RGHT - BOARD_LEFT, r--;
7299             if(r < 0) break;
7300             fen++;
7301         }
7302         DrawPosition(TRUE, NULL);
7303 }
7304
7305 static char baseMarker[BOARD_RANKS][BOARD_FILES], baseLegal[BOARD_RANKS][BOARD_FILES];
7306
7307 void
7308 Mark (Board board, int flags, ChessMove kind, int rf, int ff, int rt, int ft, VOIDSTAR closure)
7309 {
7310     typedef char Markers[BOARD_RANKS][BOARD_FILES];
7311     Markers *m = (Markers *) closure;
7312     if(rf == fromY && ff == fromX && (killX < 0 ? !(rt == rf && ft == ff) && legNr & 1 : rt == killY && ft == killX || legNr & 2))
7313         (*m)[rt][ft] = 1 + (board[rt][ft] != EmptySquare
7314                          || kind == WhiteCapturesEnPassant
7315                          || kind == BlackCapturesEnPassant) + 3*(kind == FirstLeg && killX < 0), legal[rt][ft] = 1;
7316     else if(flags & F_MANDATORY_CAPTURE && board[rt][ft] != EmptySquare) (*m)[rt][ft] = 3, legal[rt][ft] = 1;
7317 }
7318
7319 static int hoverSavedValid;
7320
7321 void
7322 MarkTargetSquares (int clear)
7323 {
7324   int x, y, sum=0;
7325   if(clear) { // no reason to ever suppress clearing
7326     for(x=0; x<BOARD_WIDTH; x++) for(y=0; y<BOARD_HEIGHT; y++) sum += marker[y][x], marker[y][x] = 0;
7327     hoverSavedValid = 0;
7328     if(!sum) return; // nothing was cleared,no redraw needed
7329   } else {
7330     int capt = 0;
7331     if(!appData.markers || !appData.highlightDragging || appData.icsActive && gameInfo.variant < VariantShogi ||
7332        !appData.testLegality && !pieceDefs || gameMode == EditPosition) return;
7333     GenLegal(boards[currentMove], PosFlags(currentMove), Mark, (void*) marker, EmptySquare);
7334     if(PosFlags(0) & F_MANDATORY_CAPTURE) {
7335       for(x=0; x<BOARD_WIDTH; x++) for(y=0; y<BOARD_HEIGHT; y++) if(marker[y][x]>1) capt++;
7336       if(capt)
7337       for(x=0; x<BOARD_WIDTH; x++) for(y=0; y<BOARD_HEIGHT; y++) if(marker[y][x] == 1) marker[y][x] = 0;
7338     }
7339   }
7340   DrawPosition(FALSE, NULL);
7341 }
7342
7343 int
7344 Explode (Board board, int fromX, int fromY, int toX, int toY)
7345 {
7346     if(gameInfo.variant == VariantAtomic &&
7347        (board[toY][toX] != EmptySquare ||                     // capture?
7348         toX != fromX && (board[fromY][fromX] == WhitePawn ||  // e.p. ?
7349                          board[fromY][fromX] == BlackPawn   )
7350       )) {
7351         AnimateAtomicCapture(board, fromX, fromY, toX, toY);
7352         return TRUE;
7353     }
7354     return FALSE;
7355 }
7356
7357 ChessSquare gatingPiece = EmptySquare; // exported to front-end, for dragging
7358
7359 int
7360 CanPromote (ChessSquare piece, int y)
7361 {
7362         int zone = (gameInfo.variant == VariantChuChess ? 3 : 1);
7363         if(gameMode == EditPosition) return FALSE; // no promotions when editing position
7364         // some variants have fixed promotion piece, no promotion at all, or another selection mechanism
7365         if(IS_SHOGI(gameInfo.variant)          || gameInfo.variant == VariantXiangqi ||
7366            gameInfo.variant == VariantSuper    || gameInfo.variant == VariantGreat   ||
7367            gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier ||
7368          gameInfo.variant == VariantMakruk) return FALSE;
7369         return (piece == BlackPawn && y <= zone ||
7370                 piece == WhitePawn && y >= BOARD_HEIGHT-1-zone ||
7371                 piece == BlackLance && y <= zone ||
7372                 piece == WhiteLance && y >= BOARD_HEIGHT-1-zone );
7373 }
7374
7375 void
7376 HoverEvent (int xPix, int yPix, int x, int y)
7377 {
7378         static int oldX = -1, oldY = -1, oldFromX = -1, oldFromY = -1;
7379         int r, f;
7380         if(!first.highlight) return;
7381         if(fromX != oldFromX || fromY != oldFromY)  oldX = oldY = -1; // kludge to fake entry on from-click
7382         if(x == oldX && y == oldY) return; // only do something if we enter new square
7383         oldFromX = fromX; oldFromY = fromY;
7384         if(oldX == -1 && oldY == -1 && x == fromX && y == fromY) { // record markings after from-change
7385           for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++)
7386             baseMarker[r][f] = marker[r][f], baseLegal[r][f] = legal[r][f];
7387           hoverSavedValid = 1;
7388         } else if(oldX != x || oldY != y) {
7389           // [HGM] lift: entered new to-square; redraw arrow, and inform engine
7390           if(hoverSavedValid) // don't restore markers that are supposed to be cleared
7391           for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++)
7392             marker[r][f] = baseMarker[r][f], legal[r][f] = baseLegal[r][f];
7393           if((marker[y][x] == 2 || marker[y][x] == 6) && legal[y][x]) {
7394             char buf[MSG_SIZ];
7395             snprintf(buf, MSG_SIZ, "hover %c%d\n", x + AAA, y + ONE - '0');
7396             SendToProgram(buf, &first);
7397           }
7398           oldX = x; oldY = y;
7399 //        SetHighlights(fromX, fromY, x, y);
7400         }
7401 }
7402
7403 void ReportClick(char *action, int x, int y)
7404 {
7405         char buf[MSG_SIZ]; // Inform engine of what user does
7406         int r, f;
7407         if(action[0] == 'l') // mark any target square of a lifted piece as legal to-square, clear markers
7408           for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++)
7409             legal[r][f] = !pieceDefs || !appData.markers, marker[r][f] = 0;
7410         if(!first.highlight || gameMode == EditPosition) return;
7411         snprintf(buf, MSG_SIZ, "%s %c%d%s\n", action, x+AAA, y+ONE-'0', controlKey && action[0]=='p' ? "," : "");
7412         SendToProgram(buf, &first);
7413 }
7414
7415 Boolean right; // instructs front-end to use button-1 events as if they were button 3
7416
7417 void
7418 LeftClick (ClickType clickType, int xPix, int yPix)
7419 {
7420     int x, y;
7421     Boolean saveAnimate;
7422     static int second = 0, promotionChoice = 0, clearFlag = 0, sweepSelecting = 0;
7423     char promoChoice = NULLCHAR;
7424     ChessSquare piece;
7425     static TimeMark lastClickTime, prevClickTime;
7426
7427     x = EventToSquare(xPix, BOARD_WIDTH);
7428     y = EventToSquare(yPix, BOARD_HEIGHT);
7429     if (!flipView && y >= 0) {
7430         y = BOARD_HEIGHT - 1 - y;
7431     }
7432     if (flipView && x >= 0) {
7433         x = BOARD_WIDTH - 1 - x;
7434     }
7435
7436     if(appData.monoMouse && gameMode == EditPosition && fromX < 0 && clickType == Press && boards[currentMove][y][x] == EmptySquare) {
7437         static int dummy;
7438         RightClick(clickType, xPix, yPix, &dummy, &dummy);
7439         right = TRUE;
7440         return;
7441     }
7442
7443     if(SeekGraphClick(clickType, xPix, yPix, 0)) return;
7444
7445     prevClickTime = lastClickTime; GetTimeMark(&lastClickTime);
7446
7447     if (clickType == Press) ErrorPopDown();
7448     lastClickType = clickType, lastLeftX = xPix, lastLeftY = yPix; // [HGM] alien: remember state
7449
7450     if(promoSweep != EmptySquare) { // up-click during sweep-select of promo-piece
7451         defaultPromoChoice = promoSweep;
7452         promoSweep = EmptySquare;   // terminate sweep
7453         promoDefaultAltered = TRUE;
7454         if(!selectFlag && !sweepSelecting && (x != toX || y != toY)) x = fromX, y = fromY; // and fake up-click on same square if we were still selecting
7455     }
7456
7457     if(promotionChoice) { // we are waiting for a click to indicate promotion piece
7458         if(clickType == Release) return; // ignore upclick of click-click destination
7459         promotionChoice = FALSE; // only one chance: if click not OK it is interpreted as cancel
7460         if(appData.debugMode) fprintf(debugFP, "promotion click, x=%d, y=%d\n", x, y);
7461         if(gameInfo.holdingsWidth &&
7462                 (WhiteOnMove(currentMove)
7463                         ? x == BOARD_WIDTH-1 && y < gameInfo.holdingsSize && y >= 0
7464                         : x == 0 && y >= BOARD_HEIGHT - gameInfo.holdingsSize && y < BOARD_HEIGHT) ) {
7465             // click in right holdings, for determining promotion piece
7466             ChessSquare p = boards[currentMove][y][x];
7467             if(appData.debugMode) fprintf(debugFP, "square contains %d\n", (int)p);
7468             if(p == WhitePawn || p == BlackPawn) p = EmptySquare; // [HGM] Pawns could be valid as deferral
7469             if(p != EmptySquare || gameInfo.variant == VariantGrand && toY != 0 && toY != BOARD_HEIGHT-1) { // [HGM] grand: empty square means defer
7470                 FinishMove(NormalMove, fromX, fromY, toX, toY, p==EmptySquare ? NULLCHAR : ToLower(PieceToChar(p)));
7471                 fromX = fromY = -1;
7472                 return;
7473             }
7474         }
7475         DrawPosition(FALSE, boards[currentMove]);
7476         return;
7477     }
7478
7479     /* [HGM] holdings: next 5 lines: ignore all clicks between board and holdings */
7480     if(clickType == Press
7481             && ( x == BOARD_LEFT-1 || x == BOARD_RGHT
7482               || x == BOARD_LEFT-2 && y < BOARD_HEIGHT-gameInfo.holdingsSize
7483               || x == BOARD_RGHT+1 && y >= gameInfo.holdingsSize) )
7484         return;
7485
7486     if(gotPremove && x == premoveFromX && y == premoveFromY && clickType == Release) {
7487         // could be static click on premove from-square: abort premove
7488         gotPremove = 0;
7489         ClearPremoveHighlights();
7490     }
7491
7492     if(clickType == Press && fromX == x && fromY == y && promoDefaultAltered && SubtractTimeMarks(&lastClickTime, &prevClickTime) >= 200)
7493         fromX = fromY = -1; // second click on piece after altering default promo piece treated as first click
7494
7495     if(!promoDefaultAltered) { // determine default promotion piece, based on the side the user is moving for
7496         int side = (gameMode == IcsPlayingWhite || gameMode == MachinePlaysBlack ||
7497                     gameMode != MachinePlaysWhite && gameMode != IcsPlayingBlack && WhiteOnMove(currentMove));
7498         defaultPromoChoice = DefaultPromoChoice(side);
7499     }
7500
7501     autoQueen = appData.alwaysPromoteToQueen;
7502
7503     if (fromX == -1) {
7504       int originalY = y;
7505       gatingPiece = EmptySquare;
7506       if (clickType != Press) {
7507         if(dragging) { // [HGM] from-square must have been reset due to game end since last press
7508             DragPieceEnd(xPix, yPix); dragging = 0;
7509             DrawPosition(FALSE, NULL);
7510         }
7511         return;
7512       }
7513       doubleClick = FALSE;
7514       if(gameMode == AnalyzeMode && (pausing || controlKey) && first.excludeMoves) { // use pause state to exclude moves
7515         doubleClick = TRUE; gatingPiece = boards[currentMove][y][x];
7516       }
7517       fromX = x; fromY = y; toX = toY = killX = killY = -1;
7518       if(!appData.oneClick || !OnlyMove(&x, &y, FALSE) ||
7519          // even if only move, we treat as normal when this would trigger a promotion popup, to allow sweep selection
7520          appData.sweepSelect && CanPromote(boards[currentMove][fromY][fromX], fromY) && originalY != y) {
7521             /* First square */
7522             if (OKToStartUserMove(fromX, fromY)) {
7523                 second = 0;
7524                 ReportClick("lift", x, y);
7525                 MarkTargetSquares(0);
7526                 if(gameMode == EditPosition && controlKey) gatingPiece = boards[currentMove][fromY][fromX];
7527                 DragPieceBegin(xPix, yPix, FALSE); dragging = 1;
7528                 if(appData.sweepSelect && CanPromote(piece = boards[currentMove][fromY][fromX], fromY)) {
7529                     promoSweep = defaultPromoChoice;
7530                     selectFlag = 0; lastX = xPix; lastY = yPix;
7531                     Sweep(0); // Pawn that is going to promote: preview promotion piece
7532                     DisplayMessage("", _("Pull pawn backwards to under-promote"));
7533                 }
7534                 if (appData.highlightDragging) {
7535                     SetHighlights(fromX, fromY, -1, -1);
7536                 } else {
7537                     ClearHighlights();
7538                 }
7539             } else fromX = fromY = -1;
7540             return;
7541         }
7542     }
7543 printf("to click %d,%d\n",x,y);
7544     /* fromX != -1 */
7545     if (clickType == Press && gameMode != EditPosition) {
7546         ChessSquare fromP;
7547         ChessSquare toP;
7548         int frc;
7549
7550         // ignore off-board to clicks
7551         if(y < 0 || x < 0) return;
7552
7553         /* Check if clicking again on the same color piece */
7554         fromP = boards[currentMove][fromY][fromX];
7555         toP = boards[currentMove][y][x];
7556         frc = appData.fischerCastling || gameInfo.variant == VariantSChess;
7557         if( (killX < 0 || x != fromX || y != fromY) && // [HGM] lion: do not interpret igui as deselect!
7558             marker[y][x] == 0 && // if engine told we can move to here, do it even if own piece
7559            ((WhitePawn <= fromP && fromP <= WhiteKing &&
7560              WhitePawn <= toP && toP <= WhiteKing &&
7561              !(fromP == WhiteKing && toP == WhiteRook && frc) &&
7562              !(fromP == WhiteRook && toP == WhiteKing && frc)) ||
7563             (BlackPawn <= fromP && fromP <= BlackKing &&
7564              BlackPawn <= toP && toP <= BlackKing &&
7565              !(fromP == BlackRook && toP == BlackKing && frc) && // allow also RxK as FRC castling
7566              !(fromP == BlackKing && toP == BlackRook && frc)))) {
7567             /* Clicked again on same color piece -- changed his mind */
7568             second = (x == fromX && y == fromY);
7569             killX = killY = -1;
7570             if(second && gameMode == AnalyzeMode && SubtractTimeMarks(&lastClickTime, &prevClickTime) < 200) {
7571                 second = FALSE; // first double-click rather than scond click
7572                 doubleClick = first.excludeMoves; // used by UserMoveEvent to recognize exclude moves
7573             }
7574             promoDefaultAltered = FALSE;
7575             MarkTargetSquares(1);
7576            if(!(second && appData.oneClick && OnlyMove(&x, &y, TRUE))) {
7577             if (appData.highlightDragging) {
7578                 SetHighlights(x, y, -1, -1);
7579             } else {
7580                 ClearHighlights();
7581             }
7582             if (OKToStartUserMove(x, y)) {
7583                 if(gameInfo.variant == VariantSChess && // S-Chess: back-rank piece selected after holdings means gating
7584                   (fromX == BOARD_LEFT-2 || fromX == BOARD_RGHT+1) &&
7585                y == (toP < BlackPawn ? 0 : BOARD_HEIGHT-1))
7586                  gatingPiece = boards[currentMove][fromY][fromX];
7587                 else gatingPiece = doubleClick ? fromP : EmptySquare;
7588                 fromX = x;
7589                 fromY = y; dragging = 1;
7590                 if(!second) ReportClick("lift", x, y);
7591                 MarkTargetSquares(0);
7592                 DragPieceBegin(xPix, yPix, FALSE);
7593                 if(appData.sweepSelect && CanPromote(piece = boards[currentMove][y][x], y)) {
7594                     promoSweep = defaultPromoChoice;
7595                     selectFlag = 0; lastX = xPix; lastY = yPix;
7596                     Sweep(0); // Pawn that is going to promote: preview promotion piece
7597                 }
7598             }
7599            }
7600            if(x == fromX && y == fromY) return; // if OnlyMove altered (x,y) we go on
7601            second = FALSE;
7602         }
7603         // ignore clicks on holdings
7604         if(x < BOARD_LEFT || x >= BOARD_RGHT) return;
7605     }
7606 printf("A type=%d\n",clickType);
7607
7608     if(x == fromX && y == fromY && gameMode == EditPosition && SubtractTimeMarks(&lastClickTime, &prevClickTime) < 200) {
7609         gatingPiece = boards[currentMove][fromY][fromX]; // prepare to copy rather than move
7610         return;
7611     }
7612
7613     if (clickType == Release && x == fromX && y == fromY && killX < 0 && !sweepSelecting) {
7614         DragPieceEnd(xPix, yPix); dragging = 0;
7615         if(clearFlag) {
7616             // a deferred attempt to click-click move an empty square on top of a piece
7617             boards[currentMove][y][x] = EmptySquare;
7618             ClearHighlights();
7619             DrawPosition(FALSE, boards[currentMove]);
7620             fromX = fromY = -1; clearFlag = 0;
7621             return;
7622         }
7623         if (appData.animateDragging) {
7624             /* Undo animation damage if any */
7625             DrawPosition(FALSE, NULL);
7626         }
7627         if (second) {
7628             /* Second up/down in same square; just abort move */
7629             second = 0;
7630             fromX = fromY = -1;
7631             gatingPiece = EmptySquare;
7632             MarkTargetSquares(1);
7633             ClearHighlights();
7634             gotPremove = 0;
7635             ClearPremoveHighlights();
7636         } else {
7637             /* First upclick in same square; start click-click mode */
7638             SetHighlights(x, y, -1, -1);
7639         }
7640         return;
7641     }
7642
7643     clearFlag = 0;
7644 printf("B\n");
7645     if(gameMode != EditPosition && !appData.testLegality && !legal[y][x] &&
7646        fromX >= BOARD_LEFT && fromX < BOARD_RGHT && (x != killX || y != killY) && !sweepSelecting) {
7647         if(dragging) DragPieceEnd(xPix, yPix), dragging = 0;
7648         DisplayMessage(_("only marked squares are legal"),"");
7649         DrawPosition(TRUE, NULL);
7650         return; // ignore to-click
7651     }
7652 printf("(%d,%d)-(%d,%d) %d %d\n",fromX,fromY,toX,toY,x,y);
7653     /* we now have a different from- and (possibly off-board) to-square */
7654     /* Completed move */
7655     if(!sweepSelecting) {
7656         toX = x;
7657         toY = y;
7658     }
7659
7660     piece = boards[currentMove][fromY][fromX];
7661
7662     saveAnimate = appData.animate;
7663     if (clickType == Press) {
7664         if(gameInfo.variant == VariantChuChess && piece != WhitePawn && piece != BlackPawn) defaultPromoChoice = piece;
7665         if(gameMode == EditPosition && boards[currentMove][fromY][fromX] == EmptySquare) {
7666             // must be Edit Position mode with empty-square selected
7667             fromX = x; fromY = y; DragPieceBegin(xPix, yPix, FALSE); dragging = 1; // consider this a new attempt to drag
7668             if(x >= BOARD_LEFT && x < BOARD_RGHT) clearFlag = 1; // and defer click-click move of empty-square to up-click
7669             return;
7670         }
7671         if(dragging == 2) {  // [HGM] lion: just turn buttonless drag into normal drag, and let release to the job
7672             return;
7673         }
7674         if(x == killX && y == killY) {              // second click on this square, which was selected as first-leg target
7675             killX = killY = -1;                     // this informs us no second leg is coming, so treat as to-click without intermediate
7676         } else
7677         if(marker[y][x] == 5) return; // [HGM] lion: to-click on cyan square; defer action to release
7678         if(legal[y][x] == 2 || HasPromotionChoice(fromX, fromY, toX, toY, &promoChoice, FALSE)) {
7679           if(appData.sweepSelect) {
7680             promoSweep = defaultPromoChoice;
7681             if(gameInfo.variant != VariantChuChess && PieceToChar(CHUPROMOTED piece) == '+') promoSweep = CHUPROMOTED piece;
7682             selectFlag = 0; lastX = xPix; lastY = yPix;
7683             Sweep(0); // Pawn that is going to promote: preview promotion piece
7684             sweepSelecting = 1;
7685             DisplayMessage("", _("Pull pawn backwards to under-promote"));
7686             MarkTargetSquares(1);
7687           }
7688           return; // promo popup appears on up-click
7689         }
7690         /* Finish clickclick move */
7691         if (appData.animate || appData.highlightLastMove) {
7692             SetHighlights(fromX, fromY, toX, toY);
7693         } else {
7694             ClearHighlights();
7695         }
7696     } else if(sweepSelecting) { // this must be the up-click corresponding to the down-click that started the sweep
7697         sweepSelecting = 0; appData.animate = FALSE; // do not animate, a selected piece already on to-square
7698         if (appData.animate || appData.highlightLastMove) {
7699             SetHighlights(fromX, fromY, toX, toY);
7700         } else {
7701             ClearHighlights();
7702         }
7703     } else {
7704 #if 0
7705 // [HGM] this must be done after the move is made, as with arrow it could lead to a board redraw with piece still on from square
7706         /* Finish drag move */
7707         if (appData.highlightLastMove) {
7708             SetHighlights(fromX, fromY, toX, toY);
7709         } else {
7710             ClearHighlights();
7711         }
7712 #endif
7713         if(gameInfo.variant == VariantChuChess && piece != WhitePawn && piece != BlackPawn) defaultPromoChoice = piece;
7714         if(marker[y][x] == 5) { // [HGM] lion: this was the release of a to-click or drag on a cyan square
7715           dragging *= 2;            // flag button-less dragging if we are dragging
7716           MarkTargetSquares(1);
7717           if(x == killX && y == killY) killX = kill2X, killY = kill2Y, kill2X = kill2Y = -1; // cancel last kill
7718           else {
7719             kill2X = killX; kill2Y = killY;
7720             killX = x; killY = y;     //remeber this square as intermediate
7721             ReportClick("put", x, y); // and inform engine
7722             ReportClick("lift", x, y);
7723             MarkTargetSquares(0);
7724             return;
7725           }
7726         }
7727         DragPieceEnd(xPix, yPix); dragging = 0;
7728         /* Don't animate move and drag both */
7729         appData.animate = FALSE;
7730     }
7731
7732     // moves into holding are invalid for now (except in EditPosition, adapting to-square)
7733     if(x >= 0 && x < BOARD_LEFT || x >= BOARD_RGHT) {
7734         ChessSquare piece = boards[currentMove][fromY][fromX];
7735         if(gameMode == EditPosition && piece != EmptySquare &&
7736            fromX >= BOARD_LEFT && fromX < BOARD_RGHT) {
7737             int n;
7738
7739             if(x == BOARD_LEFT-2 && piece >= BlackPawn) {
7740                 n = PieceToNumber(piece - (int)BlackPawn);
7741                 if(n >= gameInfo.holdingsSize) { n = 0; piece = BlackPawn; }
7742                 boards[currentMove][BOARD_HEIGHT-1 - n][0] = piece;
7743                 boards[currentMove][BOARD_HEIGHT-1 - n][1]++;
7744             } else
7745             if(x == BOARD_RGHT+1 && piece < BlackPawn) {
7746                 n = PieceToNumber(piece);
7747                 if(n >= gameInfo.holdingsSize) { n = 0; piece = WhitePawn; }
7748                 boards[currentMove][n][BOARD_WIDTH-1] = piece;
7749                 boards[currentMove][n][BOARD_WIDTH-2]++;
7750             }
7751             boards[currentMove][fromY][fromX] = EmptySquare;
7752         }
7753         ClearHighlights();
7754         fromX = fromY = -1;
7755         MarkTargetSquares(1);
7756         DrawPosition(TRUE, boards[currentMove]);
7757         return;
7758     }
7759
7760     // off-board moves should not be highlighted
7761     if(x < 0 || y < 0) ClearHighlights();
7762     else ReportClick("put", x, y);
7763
7764     if(gatingPiece != EmptySquare && gameInfo.variant == VariantSChess) promoChoice = ToLower(PieceToChar(gatingPiece));
7765
7766     if(legal[toY][toX] == 2) promoChoice = ToLower(PieceToChar(defaultPromoChoice)); // highlight-induced promotion
7767
7768     if (legal[toY][toX] == 2 && !appData.sweepSelect || HasPromotionChoice(fromX, fromY, toX, toY, &promoChoice, appData.sweepSelect)) {
7769         SetHighlights(fromX, fromY, toX, toY);
7770         MarkTargetSquares(1);
7771         if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat || gameInfo.variant == VariantGrand) {
7772             // [HGM] super: promotion to captured piece selected from holdings
7773             ChessSquare p = boards[currentMove][fromY][fromX], q = boards[currentMove][toY][toX];
7774             promotionChoice = TRUE;
7775             // kludge follows to temporarily execute move on display, without promoting yet
7776             boards[currentMove][fromY][fromX] = EmptySquare; // move Pawn to 8th rank
7777             boards[currentMove][toY][toX] = p;
7778             DrawPosition(FALSE, boards[currentMove]);
7779             boards[currentMove][fromY][fromX] = p; // take back, but display stays
7780             boards[currentMove][toY][toX] = q;
7781             DisplayMessage("Click in holdings to choose piece", "");
7782             return;
7783         }
7784         PromotionPopUp(promoChoice);
7785     } else {
7786         int oldMove = currentMove;
7787         UserMoveEvent(fromX, fromY, toX, toY, promoChoice);
7788         if (!appData.highlightLastMove || gotPremove) ClearHighlights();
7789         if (gotPremove) SetPremoveHighlights(fromX, fromY, toX, toY);
7790         if(saveAnimate && !appData.animate && currentMove != oldMove && // drag-move was performed
7791            Explode(boards[currentMove-1], fromX, fromY, toX, toY))
7792             DrawPosition(TRUE, boards[currentMove]);
7793         MarkTargetSquares(1);
7794         fromX = fromY = -1;
7795     }
7796     appData.animate = saveAnimate;
7797     if (appData.animate || appData.animateDragging) {
7798         /* Undo animation damage if needed */
7799         DrawPosition(FALSE, NULL);
7800     }
7801 }
7802
7803 int
7804 RightClick (ClickType action, int x, int y, int *fromX, int *fromY)
7805 {   // front-end-free part taken out of PieceMenuPopup
7806     int whichMenu; int xSqr, ySqr;
7807
7808     if(seekGraphUp) { // [HGM] seekgraph
7809         if(action == Press)   SeekGraphClick(Press, x, y, 2); // 2 indicates right-click: no pop-down on miss
7810         if(action == Release) SeekGraphClick(Release, x, y, 2); // and no challenge on hit
7811         return -2;
7812     }
7813
7814     if((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack)
7815          && !appData.zippyPlay && appData.bgObserve) { // [HGM] bughouse: show background game
7816         if(!partnerBoardValid) return -2; // suppress display of uninitialized boards
7817         if( appData.dualBoard) return -2; // [HGM] dual: is already displayed
7818         if(action == Press)   {
7819             originalFlip = flipView;
7820             flipView = !flipView; // temporarily flip board to see game from partners perspective
7821             DrawPosition(TRUE, partnerBoard);
7822             DisplayMessage(partnerStatus, "");
7823             partnerUp = TRUE;
7824         } else if(action == Release) {
7825             flipView = originalFlip;
7826             DrawPosition(TRUE, boards[currentMove]);
7827             partnerUp = FALSE;
7828         }
7829         return -2;
7830     }
7831
7832     xSqr = EventToSquare(x, BOARD_WIDTH);
7833     ySqr = EventToSquare(y, BOARD_HEIGHT);
7834     if (action == Release) {
7835         if(pieceSweep != EmptySquare) {
7836             EditPositionMenuEvent(pieceSweep, toX, toY);
7837             pieceSweep = EmptySquare;
7838         } else UnLoadPV(); // [HGM] pv
7839     }
7840     if (action != Press) return -2; // return code to be ignored
7841     switch (gameMode) {
7842       case IcsExamining:
7843         if(xSqr < BOARD_LEFT || xSqr >= BOARD_RGHT) return -1;
7844       case EditPosition:
7845         if (xSqr == BOARD_LEFT-1 || xSqr == BOARD_RGHT) return -1;
7846         if (xSqr < 0 || ySqr < 0) return -1;
7847         if(appData.pieceMenu) { whichMenu = 0; break; } // edit-position menu
7848         pieceSweep = shiftKey ? BlackPawn : WhitePawn;  // [HGM] sweep: prepare selecting piece by mouse sweep
7849         toX = xSqr; toY = ySqr; lastX = x, lastY = y;
7850         if(flipView) toX = BOARD_WIDTH - 1 - toX; else toY = BOARD_HEIGHT - 1 - toY;
7851         NextPiece(0);
7852         return 2; // grab
7853       case IcsObserving:
7854         if(!appData.icsEngineAnalyze) return -1;
7855       case IcsPlayingWhite:
7856       case IcsPlayingBlack:
7857         if(!appData.zippyPlay) goto noZip;
7858       case AnalyzeMode:
7859       case AnalyzeFile:
7860       case MachinePlaysWhite:
7861       case MachinePlaysBlack:
7862       case TwoMachinesPlay: // [HGM] pv: use for showing PV
7863         if (!appData.dropMenu) {
7864           LoadPV(x, y);
7865           return 2; // flag front-end to grab mouse events
7866         }
7867         if(gameMode == TwoMachinesPlay || gameMode == AnalyzeMode ||
7868            gameMode == AnalyzeFile || gameMode == IcsObserving) return -1;
7869       case EditGame:
7870       noZip:
7871         if (xSqr < 0 || ySqr < 0) return -1;
7872         if (!appData.dropMenu || appData.testLegality &&
7873             gameInfo.variant != VariantBughouse &&
7874             gameInfo.variant != VariantCrazyhouse) return -1;
7875         whichMenu = 1; // drop menu
7876         break;
7877       default:
7878         return -1;
7879     }
7880
7881     if (((*fromX = xSqr) < 0) ||
7882         ((*fromY = ySqr) < 0)) {
7883         *fromX = *fromY = -1;
7884         return -1;
7885     }
7886     if (flipView)
7887       *fromX = BOARD_WIDTH - 1 - *fromX;
7888     else
7889       *fromY = BOARD_HEIGHT - 1 - *fromY;
7890
7891     return whichMenu;
7892 }
7893
7894 void
7895 SendProgramStatsToFrontend (ChessProgramState * cps, ChessProgramStats * cpstats)
7896 {
7897 //    char * hint = lastHint;
7898     FrontEndProgramStats stats;
7899
7900     stats.which = cps == &first ? 0 : 1;
7901     stats.depth = cpstats->depth;
7902     stats.nodes = cpstats->nodes;
7903     stats.score = cpstats->score;
7904     stats.time = cpstats->time;
7905     stats.pv = cpstats->movelist;
7906     stats.hint = lastHint;
7907     stats.an_move_index = 0;
7908     stats.an_move_count = 0;
7909
7910     if( gameMode == AnalyzeMode || gameMode == AnalyzeFile ) {
7911         stats.hint = cpstats->move_name;
7912         stats.an_move_index = cpstats->nr_moves - cpstats->moves_left;
7913         stats.an_move_count = cpstats->nr_moves;
7914     }
7915
7916     if(stats.pv && stats.pv[0]) safeStrCpy(lastPV[stats.which], stats.pv, sizeof(lastPV[stats.which])/sizeof(lastPV[stats.which][0])); // [HGM] pv: remember last PV of each
7917
7918     SetProgramStats( &stats );
7919 }
7920
7921 void
7922 ClearEngineOutputPane (int which)
7923 {
7924     static FrontEndProgramStats dummyStats;
7925     dummyStats.which = which;
7926     dummyStats.pv = "#";
7927     SetProgramStats( &dummyStats );
7928 }
7929
7930 #define MAXPLAYERS 500
7931
7932 char *
7933 TourneyStandings (int display)
7934 {
7935     int i, w, b, color, wScore, bScore, dummy, nr=0, nPlayers=0;
7936     int score[MAXPLAYERS], ranking[MAXPLAYERS], points[MAXPLAYERS], games[MAXPLAYERS];
7937     char result, *p, *names[MAXPLAYERS];
7938
7939     if(appData.tourneyType < 0 && !strchr(appData.results, '*'))
7940         return strdup(_("Swiss tourney finished")); // standings of Swiss yet TODO
7941     names[0] = p = strdup(appData.participants);
7942     while(p = strchr(p, '\n')) *p++ = NULLCHAR, names[++nPlayers] = p; // count participants
7943
7944     for(i=0; i<nPlayers; i++) score[i] = games[i] = 0;
7945
7946     while(result = appData.results[nr]) {
7947         color = Pairing(nr, nPlayers, &w, &b, &dummy);
7948         if(!(color ^ matchGame & 1)) { dummy = w; w = b; b = dummy; }
7949         wScore = bScore = 0;
7950         switch(result) {
7951           case '+': wScore = 2; break;
7952           case '-': bScore = 2; break;
7953           case '=': wScore = bScore = 1; break;
7954           case ' ':
7955           case '*': return strdup("busy"); // tourney not finished
7956         }
7957         score[w] += wScore;
7958         score[b] += bScore;
7959         games[w]++;
7960         games[b]++;
7961         nr++;
7962     }
7963     if(appData.tourneyType > 0) nPlayers = appData.tourneyType; // in gauntlet, list only gauntlet engine(s)
7964     for(w=0; w<nPlayers; w++) {
7965         bScore = -1;
7966         for(i=0; i<nPlayers; i++) if(score[i] > bScore) bScore = score[i], b = i;
7967         ranking[w] = b; points[w] = bScore; score[b] = -2;
7968     }
7969     p = malloc(nPlayers*34+1);
7970     for(w=0; w<nPlayers && w<display; w++)
7971         sprintf(p+34*w, "%2d. %5.1f/%-3d %-19.19s\n", w+1, points[w]/2., games[ranking[w]], names[ranking[w]]);
7972     free(names[0]);
7973     return p;
7974 }
7975
7976 void
7977 Count (Board board, int pCnt[], int *nW, int *nB, int *wStale, int *bStale, int *bishopColor)
7978 {       // count all piece types
7979         int p, f, r;
7980         *nB = *nW = *wStale = *bStale = *bishopColor = 0;
7981         for(p=WhitePawn; p<=EmptySquare; p++) pCnt[p] = 0;
7982         for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
7983                 p = board[r][f];
7984                 pCnt[p]++;
7985                 if(p == WhitePawn && r == BOARD_HEIGHT-1) (*wStale)++; else
7986                 if(p == BlackPawn && r == 0) (*bStale)++; // count last-Rank Pawns (XQ) separately
7987                 if(p <= WhiteKing) (*nW)++; else if(p <= BlackKing) (*nB)++;
7988                 if(p == WhiteBishop || p == WhiteFerz || p == WhiteAlfil ||
7989                    p == BlackBishop || p == BlackFerz || p == BlackAlfil   )
7990                         *bishopColor |= 1 << ((f^r)&1); // track square color of color-bound pieces
7991         }
7992 }
7993
7994 int
7995 SufficientDefence (int pCnt[], int side, int nMine, int nHis)
7996 {
7997         int myPawns = pCnt[WhitePawn+side]; // my total Pawn count;
7998         int majorDefense = pCnt[BlackRook-side] + pCnt[BlackCannon-side] + pCnt[BlackKnight-side];
7999
8000         nMine -= pCnt[WhiteFerz+side] + pCnt[WhiteAlfil+side]; // discount defenders
8001         if(nMine - myPawns > 2) return FALSE; // no trivial draws with more than 1 major
8002         if(myPawns == 2 && nMine == 3) // KPP
8003             return majorDefense || pCnt[BlackFerz-side] + pCnt[BlackAlfil-side] >= 3;
8004         if(myPawns == 1 && nMine == 2) // KP
8005             return majorDefense || pCnt[BlackFerz-side] + pCnt[BlackAlfil-side]  + pCnt[BlackPawn-side] >= 1;
8006         if(myPawns == 1 && nMine == 3 && pCnt[WhiteKnight+side]) // KHP
8007             return majorDefense || pCnt[BlackFerz-side] + pCnt[BlackAlfil-side]*2 >= 5;
8008         if(myPawns) return FALSE;
8009         if(pCnt[WhiteRook+side])
8010             return pCnt[BlackRook-side] ||
8011                    pCnt[BlackCannon-side] && (pCnt[BlackFerz-side] >= 2 || pCnt[BlackAlfil-side] >= 2) ||
8012                    pCnt[BlackKnight-side] && pCnt[BlackFerz-side] + pCnt[BlackAlfil-side] > 2 ||
8013                    pCnt[BlackFerz-side] + pCnt[BlackAlfil-side] >= 4;
8014         if(pCnt[WhiteCannon+side]) {
8015             if(pCnt[WhiteFerz+side] + myPawns == 0) return TRUE; // Cannon needs platform
8016             return majorDefense || pCnt[BlackAlfil-side] >= 2;
8017         }
8018         if(pCnt[WhiteKnight+side])
8019             return majorDefense || pCnt[BlackFerz-side] >= 2 || pCnt[BlackAlfil-side] + pCnt[BlackPawn-side] >= 1;
8020         return FALSE;
8021 }
8022
8023 int
8024 MatingPotential (int pCnt[], int side, int nMine, int nHis, int stale, int bisColor)
8025 {
8026         VariantClass v = gameInfo.variant;
8027
8028         if(v == VariantShogi || v == VariantCrazyhouse || v == VariantBughouse) return TRUE; // drop games always winnable
8029         if(v == VariantShatranj) return TRUE; // always winnable through baring
8030         if(v == VariantLosers || v == VariantSuicide || v == VariantGiveaway) return TRUE;
8031         if(v == Variant3Check || v == VariantAtomic) return nMine > 1; // can win through checking / exploding King
8032
8033         if(v == VariantXiangqi) {
8034                 int majors = 5*pCnt[BlackKnight-side] + 7*pCnt[BlackCannon-side] + 7*pCnt[BlackRook-side];
8035
8036                 nMine -= pCnt[WhiteFerz+side] + pCnt[WhiteAlfil+side] + stale; // discount defensive pieces and back-rank Pawns
8037                 if(nMine + stale == 1) return (pCnt[BlackFerz-side] > 1 && pCnt[BlackKnight-side] > 0); // bare K can stalemate KHAA (!)
8038                 if(nMine > 2) return TRUE; // if we don't have P, H or R, we must have CC
8039                 if(nMine == 2 && pCnt[WhiteCannon+side] == 0) return TRUE; // We have at least one P, H or R
8040                 // if we get here, we must have KC... or KP..., possibly with additional A, E or last-rank P
8041                 if(stale) // we have at least one last-rank P plus perhaps C
8042                     return majors // KPKX
8043                         || pCnt[BlackFerz-side] && pCnt[BlackFerz-side] + pCnt[WhiteCannon+side] + stale > 2; // KPKAA, KPPKA and KCPKA
8044                 else // KCA*E*
8045                     return pCnt[WhiteFerz+side] // KCAK
8046                         || pCnt[WhiteAlfil+side] && pCnt[BlackRook-side] + pCnt[BlackCannon-side] + pCnt[BlackFerz-side] // KCEKA, KCEKX (X!=H)
8047                         || majors + (12*pCnt[BlackFerz-side] | 6*pCnt[BlackAlfil-side]) > 16; // KCKAA, KCKAX, KCKEEX, KCKEXX (XX!=HH), KCKXXX
8048                 // TO DO: cases wih an unpromoted f-Pawn acting as platform for an opponent Cannon
8049
8050         } else if(v == VariantKnightmate) {
8051                 if(nMine == 1) return FALSE;
8052                 if(nMine == 2 && nHis == 1 && pCnt[WhiteBishop+side] + pCnt[WhiteFerz+side] + pCnt[WhiteKnight+side]) return FALSE; // KBK is only draw
8053         } else if(pCnt[WhiteKing] == 1 && pCnt[BlackKing] == 1) { // other variants with orthodox Kings
8054                 int nBishops = pCnt[WhiteBishop+side] + pCnt[WhiteFerz+side];
8055
8056                 if(nMine == 1) return FALSE; // bare King
8057                 if(nBishops && bisColor == 3) return TRUE; // There must be a second B/A/F, which can either block (his) or attack (mine) the escape square
8058                 nMine += (nBishops > 0) - nBishops; // By now all Bishops (and Ferz) on like-colored squares, so count as one
8059                 if(nMine > 2 && nMine != pCnt[WhiteAlfil+side] + 1) return TRUE; // At least two pieces, not all Alfils
8060                 // by now we have King + 1 piece (or multiple Bishops on the same color)
8061                 if(pCnt[WhiteKnight+side])
8062                         return (pCnt[BlackKnight-side] + pCnt[BlackBishop-side] + pCnt[BlackMan-side] +
8063                                 pCnt[BlackWazir-side] + pCnt[BlackSilver-side] + bisColor // KNKN, KNKB, KNKF, KNKE, KNKW, KNKM, KNKS
8064                              || nHis > 3); // be sure to cover suffocation mates in corner (e.g. KNKQCA)
8065                 if(nBishops)
8066                         return (pCnt[BlackKnight-side]); // KBKN, KFKN
8067                 if(pCnt[WhiteAlfil+side])
8068                         return (nHis > 2); // Alfils can in general not reach a corner square, but there might be edge (suffocation) mates
8069                 if(pCnt[WhiteWazir+side])
8070                         return (pCnt[BlackKnight-side] + pCnt[BlackWazir-side] + pCnt[BlackAlfil-side]); // KWKN, KWKW, KWKE
8071         }
8072
8073         return TRUE;
8074 }
8075
8076 int
8077 CompareWithRights (Board b1, Board b2)
8078 {
8079     int rights = 0;
8080     if(!CompareBoards(b1, b2)) return FALSE;
8081     if(b1[EP_STATUS] != b2[EP_STATUS]) return FALSE;
8082     /* compare castling rights */
8083     if( b1[CASTLING][2] != b2[CASTLING][2] && (b2[CASTLING][0] != NoRights || b2[CASTLING][1] != NoRights) )
8084            rights++; /* King lost rights, while rook still had them */
8085     if( b1[CASTLING][2] != NoRights ) { /* king has rights */
8086         if( b1[CASTLING][0] != b2[CASTLING][0] || b1[CASTLING][1] != b2[CASTLING][1] )
8087            rights++; /* but at least one rook lost them */
8088     }
8089     if( b1[CASTLING][5] != b1[CASTLING][5] && (b2[CASTLING][3] != NoRights || b2[CASTLING][4] != NoRights) )
8090            rights++;
8091     if( b1[CASTLING][5] != NoRights ) {
8092         if( b1[CASTLING][3] != b2[CASTLING][3] || b1[CASTLING][4] != b2[CASTLING][4] )
8093            rights++;
8094     }
8095     return rights == 0;
8096 }
8097
8098 int
8099 Adjudicate (ChessProgramState *cps)
8100 {       // [HGM] some adjudications useful with buggy engines
8101         // [HGM] adjudicate: made into separate routine, which now can be called after every move
8102         //       In any case it determnes if the game is a claimable draw (filling in EP_STATUS).
8103         //       Actually ending the game is now based on the additional internal condition canAdjudicate.
8104         //       Only when the game is ended, and the opponent is a computer, this opponent gets the move relayed.
8105         int k, drop, count = 0; static int bare = 1;
8106         ChessProgramState *engineOpponent = (gameMode == TwoMachinesPlay ? cps->other : (cps ? NULL : &first));
8107         Boolean canAdjudicate = !appData.icsActive;
8108
8109         // most tests only when we understand the game, i.e. legality-checking on
8110             if( appData.testLegality )
8111             {   /* [HGM] Some more adjudications for obstinate engines */
8112                 int nrW, nrB, bishopColor, staleW, staleB, nr[EmptySquare+2], i;
8113                 static int moveCount = 6;
8114                 ChessMove result;
8115                 char *reason = NULL;
8116
8117                 /* Count what is on board. */
8118                 Count(boards[forwardMostMove], nr, &nrW, &nrB, &staleW, &staleB, &bishopColor);
8119
8120                 /* Some material-based adjudications that have to be made before stalemate test */
8121                 if(gameInfo.variant == VariantAtomic && nr[WhiteKing] + nr[BlackKing] < 2) {
8122                     // [HGM] atomic: stm must have lost his King on previous move, as destroying own K is illegal
8123                      boards[forwardMostMove][EP_STATUS] = EP_CHECKMATE; // make claimable as if stm is checkmated
8124                      if(canAdjudicate && appData.checkMates) {
8125                          if(engineOpponent)
8126                            SendMoveToProgram(forwardMostMove-1, engineOpponent); // make sure opponent gets move
8127                          GameEnds( WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins,
8128                                                         "Xboard adjudication: King destroyed", GE_XBOARD );
8129                          return 1;
8130                      }
8131                 }
8132
8133                 /* Bare King in Shatranj (loses) or Losers (wins) */
8134                 if( nrW == 1 || nrB == 1) {
8135                   if( gameInfo.variant == VariantLosers) { // [HGM] losers: bare King wins (stm must have it first)
8136                      boards[forwardMostMove][EP_STATUS] = EP_WINS;  // mark as win, so it becomes claimable
8137                      if(canAdjudicate && appData.checkMates) {
8138                          if(engineOpponent)
8139                            SendMoveToProgram(forwardMostMove-1, engineOpponent); // make sure opponent gets to see move
8140                          GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
8141                                                         "Xboard adjudication: Bare king", GE_XBOARD );
8142                          return 1;
8143                      }
8144                   } else
8145                   if( gameInfo.variant == VariantShatranj && --bare < 0)
8146                   {    /* bare King */
8147                         boards[forwardMostMove][EP_STATUS] = EP_WINS; // make claimable as win for stm
8148                         if(canAdjudicate && appData.checkMates) {
8149                             /* but only adjudicate if adjudication enabled */
8150                             if(engineOpponent)
8151                               SendMoveToProgram(forwardMostMove-1, engineOpponent); // make sure opponent gets move
8152                             GameEnds( nrW > 1 ? WhiteWins : nrB > 1 ? BlackWins : GameIsDrawn,
8153                                                         "Xboard adjudication: Bare king", GE_XBOARD );
8154                             return 1;
8155                         }
8156                   }
8157                 } else bare = 1;
8158
8159
8160             // don't wait for engine to announce game end if we can judge ourselves
8161             switch (MateTest(boards[forwardMostMove], PosFlags(forwardMostMove)) ) {
8162               case MT_CHECK:
8163                 if(gameInfo.variant == Variant3Check) { // [HGM] 3check: when in check, test if 3rd time
8164                     int i, checkCnt = 0;    // (should really be done by making nr of checks part of game state)
8165                     for(i=forwardMostMove-2; i>=backwardMostMove; i-=2) {
8166                         if(MateTest(boards[i], PosFlags(i)) == MT_CHECK)
8167                             checkCnt++;
8168                         if(checkCnt >= 2) {
8169                             reason = "Xboard adjudication: 3rd check";
8170                             boards[forwardMostMove][EP_STATUS] = EP_CHECKMATE;
8171                             break;
8172                         }
8173                     }
8174                 }
8175               case MT_NONE:
8176               default:
8177                 break;
8178               case MT_STEALMATE:
8179               case MT_STALEMATE:
8180               case MT_STAINMATE:
8181                 reason = "Xboard adjudication: Stalemate";
8182                 if((signed char)boards[forwardMostMove][EP_STATUS] != EP_CHECKMATE) { // [HGM] don't touch win through baring or K-capt
8183                     boards[forwardMostMove][EP_STATUS] = EP_STALEMATE;   // default result for stalemate is draw
8184                     if(gameInfo.variant == VariantLosers  || gameInfo.variant == VariantGiveaway) // [HGM] losers:
8185                         boards[forwardMostMove][EP_STATUS] = EP_WINS;    // in these variants stalemated is always a win
8186                     else if(gameInfo.variant == VariantSuicide) // in suicide it depends
8187                         boards[forwardMostMove][EP_STATUS] = nrW == nrB ? EP_STALEMATE :
8188                                                    ((nrW < nrB) != WhiteOnMove(forwardMostMove) ?
8189                                                                         EP_CHECKMATE : EP_WINS);
8190                     else if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantXiangqi || gameInfo.variant == VariantShogi)
8191                         boards[forwardMostMove][EP_STATUS] = EP_CHECKMATE; // and in these variants being stalemated loses
8192                 }
8193                 break;
8194               case MT_CHECKMATE:
8195                 reason = "Xboard adjudication: Checkmate";
8196                 boards[forwardMostMove][EP_STATUS] = (gameInfo.variant == VariantLosers ? EP_WINS : EP_CHECKMATE);
8197                 if(gameInfo.variant == VariantShogi) {
8198                     if(forwardMostMove > backwardMostMove
8199                        && moveList[forwardMostMove-1][1] == '@'
8200                        && CharToPiece(ToUpper(moveList[forwardMostMove-1][0])) == WhitePawn) {
8201                         reason = "XBoard adjudication: pawn-drop mate";
8202                         boards[forwardMostMove][EP_STATUS] = EP_WINS;
8203                     }
8204                 }
8205                 break;
8206             }
8207
8208                 switch(i = (signed char)boards[forwardMostMove][EP_STATUS]) {
8209                     case EP_STALEMATE:
8210                         result = GameIsDrawn; break;
8211                     case EP_CHECKMATE:
8212                         result = WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins; break;
8213                     case EP_WINS:
8214                         result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins; break;
8215                     default:
8216                         result = EndOfFile;
8217                 }
8218                 if(canAdjudicate && appData.checkMates && result) { // [HGM] mates: adjudicate finished games if requested
8219                     if(engineOpponent)
8220                       SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
8221                     GameEnds( result, reason, GE_XBOARD );
8222                     return 1;
8223                 }
8224
8225                 /* Next absolutely insufficient mating material. */
8226                 if(!MatingPotential(nr, WhitePawn, nrW, nrB, staleW, bishopColor) &&
8227                    !MatingPotential(nr, BlackPawn, nrB, nrW, staleB, bishopColor))
8228                 {    /* includes KBK, KNK, KK of KBKB with like Bishops */
8229
8230                      /* always flag draws, for judging claims */
8231                      boards[forwardMostMove][EP_STATUS] = EP_INSUF_DRAW;
8232
8233                      if(canAdjudicate && appData.materialDraws) {
8234                          /* but only adjudicate them if adjudication enabled */
8235                          if(engineOpponent) {
8236                            SendToProgram("force\n", engineOpponent); // suppress reply
8237                            SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see last move */
8238                          }
8239                          GameEnds( GameIsDrawn, "Xboard adjudication: Insufficient mating material", GE_XBOARD );
8240                          return 1;
8241                      }
8242                 }
8243
8244                 /* Then some trivial draws (only adjudicate, cannot be claimed) */
8245                 if(gameInfo.variant == VariantXiangqi ?
8246                        SufficientDefence(nr, WhitePawn, nrW, nrB) && SufficientDefence(nr, BlackPawn, nrB, nrW)
8247                  : nrW + nrB == 4 &&
8248                    (   nr[WhiteRook] == 1 && nr[BlackRook] == 1 /* KRKR */
8249                    || nr[WhiteQueen] && nr[BlackQueen]==1     /* KQKQ */
8250                    || nr[WhiteKnight]==2 || nr[BlackKnight]==2     /* KNNK */
8251                    || nr[WhiteKnight]+nr[WhiteBishop] == 1 && nr[BlackKnight]+nr[BlackBishop] == 1 /* KBKN, KBKB, KNKN */
8252                    ) ) {
8253                      if(--moveCount < 0 && appData.trivialDraws && canAdjudicate)
8254                      {    /* if the first 3 moves do not show a tactical win, declare draw */
8255                           if(engineOpponent) {
8256                             SendToProgram("force\n", engineOpponent); // suppress reply
8257                             SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
8258                           }
8259                           GameEnds( GameIsDrawn, "Xboard adjudication: Trivial draw", GE_XBOARD );
8260                           return 1;
8261                      }
8262                 } else moveCount = 6;
8263             }
8264
8265         // Repetition draws and 50-move rule can be applied independently of legality testing
8266
8267                 /* Check for rep-draws */
8268                 count = 0;
8269                 drop = gameInfo.holdingsSize && (gameInfo.variant != VariantSuper && gameInfo.variant != VariantSChess
8270                                               && gameInfo.variant != VariantGreat && gameInfo.variant != VariantGrand);
8271                 for(k = forwardMostMove-2;
8272                     k>=backwardMostMove && k>=forwardMostMove-100 && (drop ||
8273                         (signed char)boards[k][EP_STATUS] < EP_UNKNOWN &&
8274                         (signed char)boards[k+2][EP_STATUS] <= EP_NONE && (signed char)boards[k+1][EP_STATUS] <= EP_NONE);
8275                     k-=2)
8276                 {   int rights=0;
8277                     if(CompareBoards(boards[k], boards[forwardMostMove])) {
8278                         /* compare castling rights */
8279                         if( boards[forwardMostMove][CASTLING][2] != boards[k][CASTLING][2] &&
8280                              (boards[k][CASTLING][0] != NoRights || boards[k][CASTLING][1] != NoRights) )
8281                                 rights++; /* King lost rights, while rook still had them */
8282                         if( boards[forwardMostMove][CASTLING][2] != NoRights ) { /* king has rights */
8283                             if( boards[forwardMostMove][CASTLING][0] != boards[k][CASTLING][0] ||
8284                                 boards[forwardMostMove][CASTLING][1] != boards[k][CASTLING][1] )
8285                                    rights++; /* but at least one rook lost them */
8286                         }
8287                         if( boards[forwardMostMove][CASTLING][5] != boards[k][CASTLING][5] &&
8288                              (boards[k][CASTLING][3] != NoRights || boards[k][CASTLING][4] != NoRights) )
8289                                 rights++;
8290                         if( boards[forwardMostMove][CASTLING][5] != NoRights ) {
8291                             if( boards[forwardMostMove][CASTLING][3] != boards[k][CASTLING][3] ||
8292                                 boards[forwardMostMove][CASTLING][4] != boards[k][CASTLING][4] )
8293                                    rights++;
8294                         }
8295                         if( rights == 0 && ++count > appData.drawRepeats-2 && canAdjudicate
8296                             && appData.drawRepeats > 1) {
8297                              /* adjudicate after user-specified nr of repeats */
8298                              int result = GameIsDrawn;
8299                              char *details = "XBoard adjudication: repetition draw";
8300                              if((gameInfo.variant == VariantXiangqi || gameInfo.variant == VariantShogi) && appData.testLegality) {
8301                                 // [HGM] xiangqi: check for forbidden perpetuals
8302                                 int m, ourPerpetual = 1, hisPerpetual = 1;
8303                                 for(m=forwardMostMove; m>k; m-=2) {
8304                                     if(MateTest(boards[m], PosFlags(m)) != MT_CHECK)
8305                                         ourPerpetual = 0; // the current mover did not always check
8306                                     if(MateTest(boards[m-1], PosFlags(m-1)) != MT_CHECK)
8307                                         hisPerpetual = 0; // the opponent did not always check
8308                                 }
8309                                 if(appData.debugMode) fprintf(debugFP, "XQ perpetual test, our=%d, his=%d\n",
8310                                                                         ourPerpetual, hisPerpetual);
8311                                 if(ourPerpetual && !hisPerpetual) { // we are actively checking him: forfeit
8312                                     result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
8313                                     details = "Xboard adjudication: perpetual checking";
8314                                 } else
8315                                 if(hisPerpetual && !ourPerpetual) { // he is checking us, but did not repeat yet
8316                                     break; // (or we would have caught him before). Abort repetition-checking loop.
8317                                 } else
8318                                 if(gameInfo.variant == VariantShogi) { // in Shogi other repetitions are draws
8319                                     if(BOARD_HEIGHT == 5 && BOARD_RGHT - BOARD_LEFT == 5) { // but in mini-Shogi gote wins!
8320                                         result = BlackWins;
8321                                         details = "Xboard adjudication: repetition";
8322                                     }
8323                                 } else // it must be XQ
8324                                 // Now check for perpetual chases
8325                                 if(!ourPerpetual && !hisPerpetual) { // no perpetual check, test for chase
8326                                     hisPerpetual = PerpetualChase(k, forwardMostMove);
8327                                     ourPerpetual = PerpetualChase(k+1, forwardMostMove);
8328                                     if(ourPerpetual && !hisPerpetual) { // we are actively chasing him: forfeit
8329                                         static char resdet[MSG_SIZ];
8330                                         result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
8331                                         details = resdet;
8332                                         snprintf(resdet, MSG_SIZ, "Xboard adjudication: perpetual chasing of %c%c", ourPerpetual>>8, ourPerpetual&255);
8333                                     } else
8334                                     if(hisPerpetual && !ourPerpetual)   // he is chasing us, but did not repeat yet
8335                                         break; // Abort repetition-checking loop.
8336                                 }
8337                                 // if neither of us is checking or chasing all the time, or both are, it is draw
8338                              }
8339                              if(engineOpponent) {
8340                                SendToProgram("force\n", engineOpponent); // suppress reply
8341                                SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
8342                              }
8343                              GameEnds( result, details, GE_XBOARD );
8344                              return 1;
8345                         }
8346                         if( rights == 0 && count > 1 ) /* occurred 2 or more times before */
8347                              boards[forwardMostMove][EP_STATUS] = EP_REP_DRAW;
8348                     }
8349                 }
8350
8351                 /* Now we test for 50-move draws. Determine ply count */
8352                 count = forwardMostMove;
8353                 /* look for last irreversble move */
8354                 while( (signed char)boards[count][EP_STATUS] <= EP_NONE && count > backwardMostMove )
8355                     count--;
8356                 /* if we hit starting position, add initial plies */
8357                 if( count == backwardMostMove )
8358                     count -= initialRulePlies;
8359                 count = forwardMostMove - count;
8360                 if(gameInfo.variant == VariantXiangqi && ( count >= 100 || count >= 2*appData.ruleMoves ) ) {
8361                         // adjust reversible move counter for checks in Xiangqi
8362                         int i = forwardMostMove - count, inCheck = 0, lastCheck;
8363                         if(i < backwardMostMove) i = backwardMostMove;
8364                         while(i <= forwardMostMove) {
8365                                 lastCheck = inCheck; // check evasion does not count
8366                                 inCheck = (MateTest(boards[i], PosFlags(i)) == MT_CHECK);
8367                                 if(inCheck || lastCheck) count--; // check does not count
8368                                 i++;
8369                         }
8370                 }
8371                 if( count >= 100)
8372                          boards[forwardMostMove][EP_STATUS] = EP_RULE_DRAW;
8373                          /* this is used to judge if draw claims are legal */
8374                 if(canAdjudicate && appData.ruleMoves > 0 && count >= 2*appData.ruleMoves) {
8375                          if(engineOpponent) {
8376                            SendToProgram("force\n", engineOpponent); // suppress reply
8377                            SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
8378                          }
8379                          GameEnds( GameIsDrawn, "Xboard adjudication: 50-move rule", GE_XBOARD );
8380                          return 1;
8381                 }
8382
8383                 /* if draw offer is pending, treat it as a draw claim
8384                  * when draw condition present, to allow engines a way to
8385                  * claim draws before making their move to avoid a race
8386                  * condition occurring after their move
8387                  */
8388                 if((gameMode == TwoMachinesPlay ? second.offeredDraw : userOfferedDraw) || first.offeredDraw ) {
8389                          char *p = NULL;
8390                          if((signed char)boards[forwardMostMove][EP_STATUS] == EP_RULE_DRAW)
8391                              p = "Draw claim: 50-move rule";
8392                          if((signed char)boards[forwardMostMove][EP_STATUS] == EP_REP_DRAW)
8393                              p = "Draw claim: 3-fold repetition";
8394                          if((signed char)boards[forwardMostMove][EP_STATUS] == EP_INSUF_DRAW)
8395                              p = "Draw claim: insufficient mating material";
8396                          if( p != NULL && canAdjudicate) {
8397                              if(engineOpponent) {
8398                                SendToProgram("force\n", engineOpponent); // suppress reply
8399                                SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
8400                              }
8401                              GameEnds( GameIsDrawn, p, GE_XBOARD );
8402                              return 1;
8403                          }
8404                 }
8405
8406                 if( canAdjudicate && appData.adjudicateDrawMoves > 0 && forwardMostMove > (2*appData.adjudicateDrawMoves) ) {
8407                     if(engineOpponent) {
8408                       SendToProgram("force\n", engineOpponent); // suppress reply
8409                       SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
8410                     }
8411                     GameEnds( GameIsDrawn, "Xboard adjudication: long game", GE_XBOARD );
8412                     return 1;
8413                 }
8414         return 0;
8415 }
8416
8417 typedef int (CDECL *PPROBE_EGBB) (int player, int *piece, int *square);
8418 typedef int (CDECL *PLOAD_EGBB) (char *path, int cache_size, int load_options);
8419 static int egbbCode[] = { 6, 5, 4, 3, 2, 1 };
8420
8421 static int
8422 BitbaseProbe ()
8423 {
8424     int pieces[10], squares[10], cnt=0, r, f, res;
8425     static int loaded;
8426     static PPROBE_EGBB probeBB;
8427     if(!appData.testLegality) return 10;
8428     if(BOARD_HEIGHT != 8 || BOARD_RGHT-BOARD_LEFT != 8) return 12;
8429     if(gameInfo.holdingsSize && gameInfo.variant != VariantSuper && gameInfo.variant != VariantSChess) return 12;
8430     if(loaded == 2 && forwardMostMove < 2) loaded = 0; // retry on new game
8431     for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
8432         ChessSquare piece = boards[forwardMostMove][r][f];
8433         int black = (piece >= BlackPawn);
8434         int type = piece - black*BlackPawn;
8435         if(piece == EmptySquare) continue;
8436         if(type != WhiteKing && type > WhiteQueen) return 12; // unorthodox piece
8437         if(type == WhiteKing) type = WhiteQueen + 1;
8438         type = egbbCode[type];
8439         squares[cnt] = r*(BOARD_RGHT - BOARD_LEFT) + f - BOARD_LEFT;
8440         pieces[cnt] = type + black*6;
8441         if(++cnt > 5) return 11;
8442     }
8443     pieces[cnt] = squares[cnt] = 0;
8444     // probe EGBB
8445     if(loaded == 2) return 13; // loading failed before
8446     if(loaded == 0) {
8447         char *p, *path = strstr(appData.egtFormats, "scorpio:"), buf[MSG_SIZ];
8448         HMODULE lib;
8449         PLOAD_EGBB loadBB;
8450         loaded = 2; // prepare for failure
8451         if(!path) return 13; // no egbb installed
8452         strncpy(buf, path + 8, MSG_SIZ);
8453         if(p = strchr(buf, ',')) *p = NULLCHAR; else p = buf + strlen(buf);
8454         snprintf(p, MSG_SIZ - strlen(buf), "%c%s", SLASH, EGBB_NAME);
8455         lib = LoadLibrary(buf);
8456         if(!lib) { DisplayError(_("could not load EGBB library"), 0); return 13; }
8457         loadBB = (PLOAD_EGBB) GetProcAddress(lib, "load_egbb_xmen");
8458         probeBB = (PPROBE_EGBB) GetProcAddress(lib, "probe_egbb_xmen");
8459         if(!loadBB || !probeBB) { DisplayError(_("wrong EGBB version"), 0); return 13; }
8460         p[1] = NULLCHAR; loadBB(buf, 64*1028, 2); // 2 = SMART_LOAD
8461         loaded = 1; // success!
8462     }
8463     res = probeBB(forwardMostMove & 1, pieces, squares);
8464     return res > 0 ? 1 : res < 0 ? -1 : 0;
8465 }
8466
8467 char *
8468 SendMoveToBookUser (int moveNr, ChessProgramState *cps, int initial)
8469 {   // [HGM] book: this routine intercepts moves to simulate book replies
8470     char *bookHit = NULL;
8471
8472     if(cps->drawDepth && BitbaseProbe() == 0) { // [HG} egbb: reduce depth in drawn position
8473         char buf[MSG_SIZ];
8474         snprintf(buf, MSG_SIZ, "sd %d\n", cps->drawDepth);
8475         SendToProgram(buf, cps);
8476     }
8477     //first determine if the incoming move brings opponent into his book
8478     if(appData.usePolyglotBook && (cps == &first ? !appData.firstHasOwnBookUCI : !appData.secondHasOwnBookUCI))
8479         bookHit = ProbeBook(moveNr+1, appData.polyglotBook); // returns move
8480     if(appData.debugMode) fprintf(debugFP, "book hit = %s\n", bookHit ? bookHit : "(NULL)");
8481     if(bookHit != NULL && !cps->bookSuspend) {
8482         // make sure opponent is not going to reply after receiving move to book position
8483         SendToProgram("force\n", cps);
8484         cps->bookSuspend = TRUE; // flag indicating it has to be restarted
8485     }
8486     if(bookHit) setboardSpoiledMachineBlack = FALSE; // suppress 'go' in SendMoveToProgram
8487     if(!initial) SendMoveToProgram(moveNr, cps); // with hit on initial position there is no move
8488     // now arrange restart after book miss
8489     if(bookHit) {
8490         // after a book hit we never send 'go', and the code after the call to this routine
8491         // has '&& !bookHit' added to suppress potential sending there (based on 'firstMove').
8492         char buf[MSG_SIZ], *move = bookHit;
8493         if(cps->useSAN) {
8494             int fromX, fromY, toX, toY;
8495             char promoChar;
8496             ChessMove moveType;
8497             move = buf + 30;
8498             if (ParseOneMove(bookHit, forwardMostMove, &moveType,
8499                                  &fromX, &fromY, &toX, &toY, &promoChar)) {
8500                 (void) CoordsToAlgebraic(boards[forwardMostMove],
8501                                     PosFlags(forwardMostMove),
8502                                     fromY, fromX, toY, toX, promoChar, move);
8503             } else {
8504                 if(appData.debugMode) fprintf(debugFP, "Book move could not be parsed\n");
8505                 bookHit = NULL;
8506             }
8507         }
8508         snprintf(buf, MSG_SIZ, "%s%s\n", (cps->useUsermove ? "usermove " : ""), move); // force book move into program supposed to play it
8509         SendToProgram(buf, cps);
8510         if(!initial) firstMove = FALSE; // normally we would clear the firstMove condition after return & sending 'go'
8511     } else if(initial) { // 'go' was needed irrespective of firstMove, and it has to be done in this routine
8512         SendToProgram("go\n", cps);
8513         cps->bookSuspend = FALSE; // after a 'go' we are never suspended
8514     } else { // 'go' might be sent based on 'firstMove' after this routine returns
8515         if(cps->bookSuspend && !firstMove) // 'go' needed, and it will not be done after we return
8516             SendToProgram("go\n", cps);
8517         cps->bookSuspend = FALSE; // anyhow, we will not be suspended after a miss
8518     }
8519     return bookHit; // notify caller of hit, so it can take action to send move to opponent
8520 }
8521
8522 int
8523 LoadError (char *errmess, ChessProgramState *cps)
8524 {   // unloads engine and switches back to -ncp mode if it was first
8525     if(cps->initDone) return FALSE;
8526     cps->isr = NULL; // this should suppress further error popups from breaking pipes
8527     DestroyChildProcess(cps->pr, 9 ); // just to be sure
8528     cps->pr = NoProc;
8529     if(cps == &first) {
8530         appData.noChessProgram = TRUE;
8531         gameMode = MachinePlaysBlack; ModeHighlight(); // kludge to unmark Machine Black menu
8532         gameMode = BeginningOfGame; ModeHighlight();
8533         SetNCPMode();
8534     }
8535     if(GetDelayedEvent()) CancelDelayedEvent(), ThawUI(); // [HGM] cancel remaining loading effort scheduled after feature timeout
8536     DisplayMessage("", ""); // erase waiting message
8537     if(errmess) DisplayError(errmess, 0); // announce reason, if given
8538     return TRUE;
8539 }
8540
8541 char *savedMessage;
8542 ChessProgramState *savedState;
8543 void
8544 DeferredBookMove (void)
8545 {
8546         if(savedState->lastPing != savedState->lastPong)
8547                     ScheduleDelayedEvent(DeferredBookMove, 10);
8548         else
8549         HandleMachineMove(savedMessage, savedState);
8550 }
8551
8552 static int savedWhitePlayer, savedBlackPlayer, pairingReceived;
8553 static ChessProgramState *stalledEngine;
8554 static char stashedInputMove[MSG_SIZ];
8555
8556 void
8557 HandleMachineMove (char *message, ChessProgramState *cps)
8558 {
8559     static char firstLeg[20];
8560     char machineMove[MSG_SIZ], buf1[MSG_SIZ*10], buf2[MSG_SIZ];
8561     char realname[MSG_SIZ];
8562     int fromX, fromY, toX, toY;
8563     ChessMove moveType;
8564     char promoChar, roar;
8565     char *p, *pv=buf1;
8566     int machineWhite, oldError;
8567     char *bookHit;
8568
8569     if(cps == &pairing && sscanf(message, "%d-%d", &savedWhitePlayer, &savedBlackPlayer) == 2) {
8570         // [HGM] pairing: Mega-hack! Pairing engine also uses this routine (so it could give other WB commands).
8571         if(savedWhitePlayer == 0 || savedBlackPlayer == 0) {
8572             DisplayError(_("Invalid pairing from pairing engine"), 0);
8573             return;
8574         }
8575         pairingReceived = 1;
8576         NextMatchGame();
8577         return; // Skim the pairing messages here.
8578     }
8579
8580     oldError = cps->userError; cps->userError = 0;
8581
8582 FakeBookMove: // [HGM] book: we jump here to simulate machine moves after book hit
8583     /*
8584      * Kludge to ignore BEL characters
8585      */
8586     while (*message == '\007') message++;
8587
8588     /*
8589      * [HGM] engine debug message: ignore lines starting with '#' character
8590      */
8591     if(cps->debug && *message == '#') return;
8592
8593     /*
8594      * Look for book output
8595      */
8596     if (cps == &first && bookRequested) {
8597         if (message[0] == '\t' || message[0] == ' ') {
8598             /* Part of the book output is here; append it */
8599             strcat(bookOutput, message);
8600             strcat(bookOutput, "  \n");
8601             return;
8602         } else if (bookOutput[0] != NULLCHAR) {
8603             /* All of book output has arrived; display it */
8604             char *p = bookOutput;
8605             while (*p != NULLCHAR) {
8606                 if (*p == '\t') *p = ' ';
8607                 p++;
8608             }
8609             DisplayInformation(bookOutput);
8610             bookRequested = FALSE;
8611             /* Fall through to parse the current output */
8612         }
8613     }
8614
8615     /*
8616      * Look for machine move.
8617      */
8618     if ((sscanf(message, "%s %s %s", buf1, buf2, machineMove) == 3 && strcmp(buf2, "...") == 0) ||
8619         (sscanf(message, "%s %s", buf1, machineMove) == 2 && strcmp(buf1, "move") == 0))
8620     {
8621         if(pausing && !cps->pause) { // for pausing engine that does not support 'pause', we stash its move for processing when we resume.
8622             if(appData.debugMode) fprintf(debugFP, "pause %s engine after move\n", cps->which);
8623             safeStrCpy(stashedInputMove, message, MSG_SIZ);
8624             stalledEngine = cps;
8625             if(appData.ponderNextMove) { // bring opponent out of ponder
8626                 if(gameMode == TwoMachinesPlay) {
8627                     if(cps->other->pause)
8628                         PauseEngine(cps->other);
8629                     else
8630                         SendToProgram("easy\n", cps->other);
8631                 }
8632             }
8633             StopClocks();
8634             return;
8635         }
8636
8637         /* This method is only useful on engines that support ping */
8638         if (cps->lastPing != cps->lastPong) {
8639           if (gameMode == BeginningOfGame) {
8640             /* Extra move from before last new; ignore */
8641             if (appData.debugMode) {
8642                 fprintf(debugFP, "Ignoring extra move from %s\n", cps->which);
8643             }
8644           } else {
8645             if (appData.debugMode) {
8646                 fprintf(debugFP, "Undoing extra move from %s, gameMode %d\n",
8647                         cps->which, gameMode);
8648             }
8649
8650             SendToProgram("undo\n", cps);
8651           }
8652           return;
8653         }
8654
8655         switch (gameMode) {
8656           case BeginningOfGame:
8657             /* Extra move from before last reset; ignore */
8658             if (appData.debugMode) {
8659                 fprintf(debugFP, "Ignoring extra move from %s\n", cps->which);
8660             }
8661             return;
8662
8663           case EndOfGame:
8664           case IcsIdle:
8665           default:
8666             /* Extra move after we tried to stop.  The mode test is
8667                not a reliable way of detecting this problem, but it's
8668                the best we can do on engines that don't support ping.
8669             */
8670             if (appData.debugMode) {
8671                 fprintf(debugFP, "Undoing extra move from %s, gameMode %d\n",
8672                         cps->which, gameMode);
8673             }
8674             SendToProgram("undo\n", cps);
8675             return;
8676
8677           case MachinePlaysWhite:
8678           case IcsPlayingWhite:
8679             machineWhite = TRUE;
8680             break;
8681
8682           case MachinePlaysBlack:
8683           case IcsPlayingBlack:
8684             machineWhite = FALSE;
8685             break;
8686
8687           case TwoMachinesPlay:
8688             machineWhite = (cps->twoMachinesColor[0] == 'w');
8689             break;
8690         }
8691         if (WhiteOnMove(forwardMostMove) != machineWhite) {
8692             if (appData.debugMode) {
8693                 fprintf(debugFP,
8694                         "Ignoring move out of turn by %s, gameMode %d"
8695                         ", forwardMost %d\n",
8696                         cps->which, gameMode, forwardMostMove);
8697             }
8698             return;
8699         }
8700
8701         if(cps->alphaRank) AlphaRank(machineMove, 4);
8702
8703         // [HGM] lion: (some very limited) support for Alien protocol
8704         killX = killY = kill2X = kill2Y = -1;
8705         if(machineMove[strlen(machineMove)-1] == ',') { // move ends in coma: non-final leg of composite move
8706             safeStrCpy(firstLeg, machineMove, 20); // just remember it for processing when second leg arrives
8707             return;
8708         }
8709         if(p = strchr(machineMove, ',')) {         // we got both legs in one (happens on book move)
8710             safeStrCpy(firstLeg, machineMove, 20); // kludge: fake we received the first leg earlier, and clip it off
8711             safeStrCpy(machineMove, firstLeg + (p - machineMove) + 1, 20);
8712         }
8713         if(firstLeg[0]) { // there was a previous leg;
8714             // only support case where same piece makes two step
8715             char buf[20], *p = machineMove+1, *q = buf+1, f;
8716             safeStrCpy(buf, machineMove, 20);
8717             while(isdigit(*q)) q++; // find start of to-square
8718             safeStrCpy(machineMove, firstLeg, 20);
8719             while(isdigit(*p)) p++; // to-square of first leg (which is now copied to machineMove)
8720             if(*p == *buf)          // if first-leg to not equal to second-leg from first leg says unmodified (assume it ia King move of castling)
8721             safeStrCpy(p, q, 20); // glue to-square of second leg to from-square of first, to process over-all move
8722             sscanf(buf, "%c%d", &f, &killY); killX = f - AAA; killY -= ONE - '0'; // pass intermediate square to MakeMove in global
8723             firstLeg[0] = NULLCHAR;
8724         }
8725
8726         if (!ParseOneMove(machineMove, forwardMostMove, &moveType,
8727                               &fromX, &fromY, &toX, &toY, &promoChar)) {
8728             /* Machine move could not be parsed; ignore it. */
8729           snprintf(buf1, MSG_SIZ*10, _("Illegal move \"%s\" from %s machine"),
8730                     machineMove, _(cps->which));
8731             DisplayMoveError(buf1);
8732             snprintf(buf1, MSG_SIZ*10, "Xboard: Forfeit due to invalid move: %s (%c%c%c%c via %c%c, %c%c) res=%d",
8733                     machineMove, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, killX+AAA, killY+ONE, kill2X+AAA, kill2Y+ONE, moveType);
8734             if (gameMode == TwoMachinesPlay) {
8735               GameEnds(machineWhite ? BlackWins : WhiteWins,
8736                        buf1, GE_XBOARD);
8737             }
8738             return;
8739         }
8740
8741         /* [HGM] Apparently legal, but so far only tested with EP_UNKOWN */
8742         /* So we have to redo legality test with true e.p. status here,  */
8743         /* to make sure an illegal e.p. capture does not slip through,   */
8744         /* to cause a forfeit on a justified illegal-move complaint      */
8745         /* of the opponent.                                              */
8746         if( gameMode==TwoMachinesPlay && appData.testLegality ) {
8747            ChessMove moveType;
8748            moveType = LegalityTest(boards[forwardMostMove], PosFlags(forwardMostMove),
8749                              fromY, fromX, toY, toX, promoChar);
8750             if(moveType == IllegalMove) {
8751               snprintf(buf1, MSG_SIZ*10, "Xboard: Forfeit due to illegal move: %s (%c%c%c%c)%c",
8752                         machineMove, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, 0);
8753                 GameEnds(machineWhite ? BlackWins : WhiteWins,
8754                            buf1, GE_XBOARD);
8755                 return;
8756            } else if(!appData.fischerCastling)
8757            /* [HGM] Kludge to handle engines that send FRC-style castling
8758               when they shouldn't (like TSCP-Gothic) */
8759            switch(moveType) {
8760              case WhiteASideCastleFR:
8761              case BlackASideCastleFR:
8762                toX+=2;
8763                currentMoveString[2]++;
8764                break;
8765              case WhiteHSideCastleFR:
8766              case BlackHSideCastleFR:
8767                toX--;
8768                currentMoveString[2]--;
8769                break;
8770              default: ; // nothing to do, but suppresses warning of pedantic compilers
8771            }
8772         }
8773         hintRequested = FALSE;
8774         lastHint[0] = NULLCHAR;
8775         bookRequested = FALSE;
8776         /* Program may be pondering now */
8777         cps->maybeThinking = TRUE;
8778         if (cps->sendTime == 2) cps->sendTime = 1;
8779         if (cps->offeredDraw) cps->offeredDraw--;
8780
8781         /* [AS] Save move info*/
8782         pvInfoList[ forwardMostMove ].score = programStats.score;
8783         pvInfoList[ forwardMostMove ].depth = programStats.depth;
8784         pvInfoList[ forwardMostMove ].time =  programStats.time; // [HGM] PGNtime: take time from engine stats
8785
8786         MakeMove(fromX, fromY, toX, toY, promoChar);/*updates forwardMostMove*/
8787
8788         /* Test suites abort the 'game' after one move */
8789         if(*appData.finger) {
8790            static FILE *f;
8791            char *fen = PositionToFEN(backwardMostMove, NULL, 0); // no counts in EPD
8792            if(!f) f = fopen(appData.finger, "w");
8793            if(f) fprintf(f, "%s bm %s;\n", fen, parseList[backwardMostMove]), fflush(f);
8794            else { DisplayFatalError("Bad output file", errno, 0); return; }
8795            free(fen);
8796            GameEnds(GameUnfinished, NULL, GE_XBOARD);
8797         }
8798         if(appData.epd) {
8799            if(solvingTime >= 0) {
8800               snprintf(buf1, MSG_SIZ, "%d. %4.2fs\n", matchGame, solvingTime/100.);
8801               totalTime += solvingTime; first.matchWins++;
8802            } else {
8803               snprintf(buf1, MSG_SIZ, "%d. wrong (%s)\n", matchGame, parseList[backwardMostMove]);
8804               second.matchWins++;
8805            }
8806            OutputKibitz(2, buf1);
8807            GameEnds(GameUnfinished, NULL, GE_XBOARD);
8808         }
8809
8810         /* [AS] Adjudicate game if needed (note: remember that forwardMostMove now points past the last move) */
8811         if( gameMode == TwoMachinesPlay && appData.adjudicateLossThreshold != 0 && forwardMostMove >= adjudicateLossPlies ) {
8812             int count = 0;
8813
8814             while( count < adjudicateLossPlies ) {
8815                 int score = pvInfoList[ forwardMostMove - count - 1 ].score;
8816
8817                 if( count & 1 ) {
8818                     score = -score; /* Flip score for winning side */
8819                 }
8820
8821                 if( score > appData.adjudicateLossThreshold ) {
8822                     break;
8823                 }
8824
8825                 count++;
8826             }
8827
8828             if( count >= adjudicateLossPlies ) {
8829                 ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
8830
8831                 GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
8832                     "Xboard adjudication",
8833                     GE_XBOARD );
8834
8835                 return;
8836             }
8837         }
8838
8839         if(Adjudicate(cps)) {
8840             ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
8841             return; // [HGM] adjudicate: for all automatic game ends
8842         }
8843
8844 #if ZIPPY
8845         if ((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack) &&
8846             first.initDone) {
8847           if(cps->offeredDraw && (signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
8848                 SendToICS(ics_prefix); // [HGM] drawclaim: send caim and move on one line for FICS
8849                 SendToICS("draw ");
8850                 SendMoveToICS(moveType, fromX, fromY, toX, toY, promoChar);
8851           }
8852           SendMoveToICS(moveType, fromX, fromY, toX, toY, promoChar);
8853           ics_user_moved = 1;
8854           if(appData.autoKibitz && !appData.icsEngineAnalyze ) { /* [HGM] kibitz: send most-recent PV info to ICS */
8855                 char buf[3*MSG_SIZ];
8856
8857                 snprintf(buf, 3*MSG_SIZ, "kibitz !!! %+.2f/%d (%.2f sec, %u nodes, %.0f knps) PV=%s\n",
8858                         programStats.score / 100.,
8859                         programStats.depth,
8860                         programStats.time / 100.,
8861                         (unsigned int)programStats.nodes,
8862                         (unsigned int)programStats.nodes / (10*abs(programStats.time) + 1.),
8863                         programStats.movelist);
8864                 SendToICS(buf);
8865           }
8866         }
8867 #endif
8868
8869         /* [AS] Clear stats for next move */
8870         ClearProgramStats();
8871         thinkOutput[0] = NULLCHAR;
8872         hiddenThinkOutputState = 0;
8873
8874         bookHit = NULL;
8875         if (gameMode == TwoMachinesPlay) {
8876             /* [HGM] relaying draw offers moved to after reception of move */
8877             /* and interpreting offer as claim if it brings draw condition */
8878             if (cps->offeredDraw == 1 && cps->other->sendDrawOffers) {
8879                 SendToProgram("draw\n", cps->other);
8880             }
8881             if (cps->other->sendTime) {
8882                 SendTimeRemaining(cps->other,
8883                                   cps->other->twoMachinesColor[0] == 'w');
8884             }
8885             bookHit = SendMoveToBookUser(forwardMostMove-1, cps->other, FALSE);
8886             if (firstMove && !bookHit) {
8887                 firstMove = FALSE;
8888                 if (cps->other->useColors) {
8889                   SendToProgram(cps->other->twoMachinesColor, cps->other);
8890                 }
8891                 SendToProgram("go\n", cps->other);
8892             }
8893             cps->other->maybeThinking = TRUE;
8894         }
8895
8896         roar = (killX >= 0 && IS_LION(boards[forwardMostMove][toY][toX]));
8897
8898         ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
8899
8900         if (!pausing && appData.ringBellAfterMoves) {
8901             if(!roar) RingBell();
8902         }
8903
8904         /*
8905          * Reenable menu items that were disabled while
8906          * machine was thinking
8907          */
8908         if (gameMode != TwoMachinesPlay)
8909             SetUserThinkingEnables();
8910
8911         // [HGM] book: after book hit opponent has received move and is now in force mode
8912         // force the book reply into it, and then fake that it outputted this move by jumping
8913         // back to the beginning of HandleMachineMove, with cps toggled and message set to this move
8914         if(bookHit) {
8915                 static char bookMove[MSG_SIZ]; // a bit generous?
8916
8917                 safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
8918                 strcat(bookMove, bookHit);
8919                 message = bookMove;
8920                 cps = cps->other;
8921                 programStats.nodes = programStats.depth = programStats.time =
8922                 programStats.score = programStats.got_only_move = 0;
8923                 sprintf(programStats.movelist, "%s (xbook)", bookHit);
8924
8925                 if(cps->lastPing != cps->lastPong) {
8926                     savedMessage = message; // args for deferred call
8927                     savedState = cps;
8928                     ScheduleDelayedEvent(DeferredBookMove, 10);
8929                     return;
8930                 }
8931                 goto FakeBookMove;
8932         }
8933
8934         return;
8935     }
8936
8937     /* Set special modes for chess engines.  Later something general
8938      *  could be added here; for now there is just one kludge feature,
8939      *  needed because Crafty 15.10 and earlier don't ignore SIGINT
8940      *  when "xboard" is given as an interactive command.
8941      */
8942     if (strncmp(message, "kibitz Hello from Crafty", 24) == 0) {
8943         cps->useSigint = FALSE;
8944         cps->useSigterm = FALSE;
8945     }
8946     if (strncmp(message, "feature ", 8) == 0) { // [HGM] moved forward to pre-empt non-compliant commands
8947       ParseFeatures(message+8, cps);
8948       return; // [HGM] This return was missing, causing option features to be recognized as non-compliant commands!
8949     }
8950
8951     if (!strncmp(message, "setup ", 6) &&
8952         (!appData.testLegality || gameInfo.variant == VariantFairy || gameInfo.variant == VariantUnknown ||
8953           NonStandardBoardSize(gameInfo.variant, gameInfo.boardWidth, gameInfo.boardHeight, gameInfo.holdingsSize))
8954                                         ) { // [HGM] allow first engine to define opening position
8955       int dummy, w, h, hand, s=6; char buf[MSG_SIZ], varName[MSG_SIZ];
8956       if(appData.icsActive || forwardMostMove != 0 || cps != &first) return;
8957       *buf = NULLCHAR;
8958       if(sscanf(message, "setup (%s", buf) == 1) {
8959         s = 8 + strlen(buf), buf[s-9] = NULLCHAR, SetCharTableEsc(pieceToChar, buf, SUFFIXES);
8960         ASSIGN(appData.pieceToCharTable, buf);
8961       }
8962       dummy = sscanf(message+s, "%dx%d+%d_%s", &w, &h, &hand, varName);
8963       if(dummy >= 3) {
8964         while(message[s] && message[s++] != ' ');
8965         if(BOARD_HEIGHT != h || BOARD_WIDTH != w + 4*(hand != 0) || gameInfo.holdingsSize != hand ||
8966            dummy == 4 && gameInfo.variant != StringToVariant(varName) ) { // engine wants to change board format or variant
8967             appData.NrFiles = w; appData.NrRanks = h; appData.holdingsSize = hand;
8968             if(dummy == 4) gameInfo.variant = StringToVariant(varName);     // parent variant
8969           InitPosition(1); // calls InitDrawingSizes to let new parameters take effect
8970           if(*buf) SetCharTableEsc(pieceToChar, buf, SUFFIXES); // do again, for it was spoiled by InitPosition
8971           startedFromSetupPosition = FALSE;
8972         }
8973       }
8974       if(startedFromSetupPosition) return;
8975       ParseFEN(boards[0], &dummy, message+s, FALSE);
8976       DrawPosition(TRUE, boards[0]);
8977       CopyBoard(initialPosition, boards[0]);
8978       startedFromSetupPosition = TRUE;
8979       return;
8980     }
8981     if(sscanf(message, "piece %s %s", buf2, buf1) == 2) {
8982       ChessSquare piece = WhitePawn;
8983       char *p=message+6, *q, *s = SUFFIXES, ID = *p;
8984       if(*p == '+') piece = CHUPROMOTED WhitePawn, ID = *++p;
8985       if(q = strchr(s, p[1])) ID += 64*(q - s + 1), p++;
8986       piece += CharToPiece(ID & 255) - WhitePawn;
8987       if(cps != &first || appData.testLegality && *engineVariant == NULLCHAR
8988       /* always accept definition of  */       && piece != WhiteFalcon && piece != BlackFalcon
8989       /* wild-card pieces.            */       && piece != WhiteCobra  && piece != BlackCobra
8990       /* For variants we don't have   */       && gameInfo.variant != VariantBerolina
8991       /* correct rules for, we cannot */       && gameInfo.variant != VariantCylinder
8992       /* enforce legality on our own! */       && gameInfo.variant != VariantUnknown
8993                                                && gameInfo.variant != VariantGreat
8994                                                && gameInfo.variant != VariantFairy    ) return;
8995       if(piece < EmptySquare) {
8996         pieceDefs = TRUE;
8997         ASSIGN(pieceDesc[piece], buf1);
8998         if((ID & 32) == 0 && p[1] == '&') { ASSIGN(pieceDesc[WHITE_TO_BLACK piece], buf1); }
8999       }
9000       return;
9001     }
9002     /* [HGM] Allow engine to set up a position. Don't ask me why one would
9003      * want this, I was asked to put it in, and obliged.
9004      */
9005     if (!strncmp(message, "setboard ", 9)) {
9006         Board initial_position;
9007
9008         GameEnds(GameUnfinished, "Engine aborts game", GE_XBOARD);
9009
9010         if (!ParseFEN(initial_position, &blackPlaysFirst, message + 9, FALSE)) {
9011             DisplayError(_("Bad FEN received from engine"), 0);
9012             return ;
9013         } else {
9014            Reset(TRUE, FALSE);
9015            CopyBoard(boards[0], initial_position);
9016            initialRulePlies = FENrulePlies;
9017            if(blackPlaysFirst) gameMode = MachinePlaysWhite;
9018            else gameMode = MachinePlaysBlack;
9019            DrawPosition(FALSE, boards[currentMove]);
9020         }
9021         return;
9022     }
9023
9024     /*
9025      * Look for communication commands
9026      */
9027     if (!strncmp(message, "telluser ", 9)) {
9028         if(message[9] == '\\' && message[10] == '\\')
9029             EscapeExpand(message+9, message+11); // [HGM] esc: allow escape sequences in popup box
9030         PlayTellSound();
9031         DisplayNote(message + 9);
9032         return;
9033     }
9034     if (!strncmp(message, "tellusererror ", 14)) {
9035         cps->userError = 1;
9036         if(message[14] == '\\' && message[15] == '\\')
9037             EscapeExpand(message+14, message+16); // [HGM] esc: allow escape sequences in popup box
9038         PlayTellSound();
9039         DisplayError(message + 14, 0);
9040         return;
9041     }
9042     if (!strncmp(message, "tellopponent ", 13)) {
9043       if (appData.icsActive) {
9044         if (loggedOn) {
9045           snprintf(buf1, sizeof(buf1), "%ssay %s\n", ics_prefix, message + 13);
9046           SendToICS(buf1);
9047         }
9048       } else {
9049         DisplayNote(message + 13);
9050       }
9051       return;
9052     }
9053     if (!strncmp(message, "tellothers ", 11)) {
9054       if (appData.icsActive) {
9055         if (loggedOn) {
9056           snprintf(buf1, sizeof(buf1), "%swhisper %s\n", ics_prefix, message + 11);
9057           SendToICS(buf1);
9058         }
9059       } else if(appData.autoComment) AppendComment (forwardMostMove, message + 11, 1); // in local mode, add as move comment
9060       return;
9061     }
9062     if (!strncmp(message, "tellall ", 8)) {
9063       if (appData.icsActive) {
9064         if (loggedOn) {
9065           snprintf(buf1, sizeof(buf1), "%skibitz %s\n", ics_prefix, message + 8);
9066           SendToICS(buf1);
9067         }
9068       } else {
9069         DisplayNote(message + 8);
9070       }
9071       return;
9072     }
9073     if (strncmp(message, "warning", 7) == 0) {
9074         /* Undocumented feature, use tellusererror in new code */
9075         DisplayError(message, 0);
9076         return;
9077     }
9078     if (sscanf(message, "askuser %s %[^\n]", buf1, buf2) == 2) {
9079         safeStrCpy(realname, cps->tidy, sizeof(realname)/sizeof(realname[0]));
9080         strcat(realname, " query");
9081         AskQuestion(realname, buf2, buf1, cps->pr);
9082         return;
9083     }
9084     /* Commands from the engine directly to ICS.  We don't allow these to be
9085      *  sent until we are logged on. Crafty kibitzes have been known to
9086      *  interfere with the login process.
9087      */
9088     if (loggedOn) {
9089         if (!strncmp(message, "tellics ", 8)) {
9090             SendToICS(message + 8);
9091             SendToICS("\n");
9092             return;
9093         }
9094         if (!strncmp(message, "tellicsnoalias ", 15)) {
9095             SendToICS(ics_prefix);
9096             SendToICS(message + 15);
9097             SendToICS("\n");
9098             return;
9099         }
9100         /* The following are for backward compatibility only */
9101         if (!strncmp(message,"whisper",7) || !strncmp(message,"kibitz",6) ||
9102             !strncmp(message,"draw",4) || !strncmp(message,"tell",3)) {
9103             SendToICS(ics_prefix);
9104             SendToICS(message);
9105             SendToICS("\n");
9106             return;
9107         }
9108     }
9109     if (sscanf(message, "pong %d", &cps->lastPong) == 1) {
9110         if(initPing == cps->lastPong) {
9111             if(gameInfo.variant == VariantUnknown) {
9112                 DisplayError(_("Engine did not send setup for non-standard variant"), 0);
9113                 *engineVariant = NULLCHAR; appData.variant = VariantNormal; // back to normal as error recovery?
9114                 GameEnds(GameUnfinished, NULL, GE_XBOARD);
9115             }
9116             initPing = -1;
9117         }
9118         return;
9119     }
9120     if(!strncmp(message, "highlight ", 10)) {
9121         if(appData.testLegality && !*engineVariant && appData.markers) return;
9122         MarkByFEN(message+10); // [HGM] alien: allow engine to mark board squares
9123         return;
9124     }
9125     if(!strncmp(message, "click ", 6)) {
9126         char f, c=0; int x, y; // [HGM] alien: allow engine to finish user moves (i.e. engine-driven one-click moving)
9127         if(appData.testLegality || !appData.oneClick) return;
9128         sscanf(message+6, "%c%d%c", &f, &y, &c);
9129         x = f - 'a' + BOARD_LEFT, y -= ONE - '0';
9130         if(flipView) x = BOARD_WIDTH-1 - x; else y = BOARD_HEIGHT-1 - y;
9131         x = x*squareSize + (x+1)*lineGap + squareSize/2;
9132         y = y*squareSize + (y+1)*lineGap + squareSize/2;
9133         f = first.highlight; first.highlight = 0; // kludge to suppress lift/put in response to own clicks
9134         if(lastClickType == Press) // if button still down, fake release on same square, to be ready for next click
9135             LeftClick(Release, lastLeftX, lastLeftY);
9136         controlKey  = (c == ',');
9137         LeftClick(Press, x, y);
9138         LeftClick(Release, x, y);
9139         first.highlight = f;
9140         return;
9141     }
9142     /*
9143      * If the move is illegal, cancel it and redraw the board.
9144      * Also deal with other error cases.  Matching is rather loose
9145      * here to accommodate engines written before the spec.
9146      */
9147     if (strncmp(message + 1, "llegal move", 11) == 0 ||
9148         strncmp(message, "Error", 5) == 0) {
9149         if (StrStr(message, "name") ||
9150             StrStr(message, "rating") || StrStr(message, "?") ||
9151             StrStr(message, "result") || StrStr(message, "board") ||
9152             StrStr(message, "bk") || StrStr(message, "computer") ||
9153             StrStr(message, "variant") || StrStr(message, "hint") ||
9154             StrStr(message, "random") || StrStr(message, "depth") ||
9155             StrStr(message, "accepted")) {
9156             return;
9157         }
9158         if (StrStr(message, "protover")) {
9159           /* Program is responding to input, so it's apparently done
9160              initializing, and this error message indicates it is
9161              protocol version 1.  So we don't need to wait any longer
9162              for it to initialize and send feature commands. */
9163           FeatureDone(cps, 1);
9164           cps->protocolVersion = 1;
9165           return;
9166         }
9167         cps->maybeThinking = FALSE;
9168
9169         if (StrStr(message, "draw")) {
9170             /* Program doesn't have "draw" command */
9171             cps->sendDrawOffers = 0;
9172             return;
9173         }
9174         if (cps->sendTime != 1 &&
9175             (StrStr(message, "time") || StrStr(message, "otim"))) {
9176           /* Program apparently doesn't have "time" or "otim" command */
9177           cps->sendTime = 0;
9178           return;
9179         }
9180         if (StrStr(message, "analyze")) {
9181             cps->analysisSupport = FALSE;
9182             cps->analyzing = FALSE;
9183 //          Reset(FALSE, TRUE); // [HGM] this caused discrepancy between display and internal state!
9184             EditGameEvent(); // [HGM] try to preserve loaded game
9185             snprintf(buf2,MSG_SIZ, _("%s does not support analysis"), cps->tidy);
9186             DisplayError(buf2, 0);
9187             return;
9188         }
9189         if (StrStr(message, "(no matching move)st")) {
9190           /* Special kludge for GNU Chess 4 only */
9191           cps->stKludge = TRUE;
9192           SendTimeControl(cps, movesPerSession, timeControl,
9193                           timeIncrement, appData.searchDepth,
9194                           searchTime);
9195           return;
9196         }
9197         if (StrStr(message, "(no matching move)sd")) {
9198           /* Special kludge for GNU Chess 4 only */
9199           cps->sdKludge = TRUE;
9200           SendTimeControl(cps, movesPerSession, timeControl,
9201                           timeIncrement, appData.searchDepth,
9202                           searchTime);
9203           return;
9204         }
9205         if (!StrStr(message, "llegal")) {
9206             return;
9207         }
9208         if (gameMode == BeginningOfGame || gameMode == EndOfGame ||
9209             gameMode == IcsIdle) return;
9210         if (forwardMostMove <= backwardMostMove) return;
9211         if (pausing) PauseEvent();
9212       if(appData.forceIllegal) {
9213             // [HGM] illegal: machine refused move; force position after move into it
9214           SendToProgram("force\n", cps);
9215           if(!cps->useSetboard) { // hideous kludge on kludge, because SendBoard sucks.
9216                 // we have a real problem now, as SendBoard will use the a2a3 kludge
9217                 // when black is to move, while there might be nothing on a2 or black
9218                 // might already have the move. So send the board as if white has the move.
9219                 // But first we must change the stm of the engine, as it refused the last move
9220                 SendBoard(cps, 0); // always kludgeless, as white is to move on boards[0]
9221                 if(WhiteOnMove(forwardMostMove)) {
9222                     SendToProgram("a7a6\n", cps); // for the engine black still had the move
9223                     SendBoard(cps, forwardMostMove); // kludgeless board
9224                 } else {
9225                     SendToProgram("a2a3\n", cps); // for the engine white still had the move
9226                     CopyBoard(boards[forwardMostMove+1], boards[forwardMostMove]);
9227                     SendBoard(cps, forwardMostMove+1); // kludgeless board
9228                 }
9229           } else SendBoard(cps, forwardMostMove); // FEN case, also sets stm properly
9230             if(gameMode == MachinePlaysWhite || gameMode == MachinePlaysBlack ||
9231                  gameMode == TwoMachinesPlay)
9232               SendToProgram("go\n", cps);
9233             return;
9234       } else
9235         if (gameMode == PlayFromGameFile) {
9236             /* Stop reading this game file */
9237             gameMode = EditGame;
9238             ModeHighlight();
9239         }
9240         /* [HGM] illegal-move claim should forfeit game when Xboard */
9241         /* only passes fully legal moves                            */
9242         if( appData.testLegality && gameMode == TwoMachinesPlay ) {
9243             GameEnds( cps->twoMachinesColor[0] == 'w' ? BlackWins : WhiteWins,
9244                                 "False illegal-move claim", GE_XBOARD );
9245             return; // do not take back move we tested as valid
9246         }
9247         currentMove = forwardMostMove-1;
9248         DisplayMove(currentMove-1); /* before DisplayMoveError */
9249         SwitchClocks(forwardMostMove-1); // [HGM] race
9250         DisplayBothClocks();
9251         snprintf(buf1, 10*MSG_SIZ, _("Illegal move \"%s\" (rejected by %s chess program)"),
9252                 parseList[currentMove], _(cps->which));
9253         DisplayMoveError(buf1);
9254         DrawPosition(FALSE, boards[currentMove]);
9255
9256         SetUserThinkingEnables();
9257         return;
9258     }
9259     if (strncmp(message, "time", 4) == 0 && StrStr(message, "Illegal")) {
9260         /* Program has a broken "time" command that
9261            outputs a string not ending in newline.
9262            Don't use it. */
9263         cps->sendTime = 0;
9264     }
9265     if (cps->pseudo) { // [HGM] pseudo-engine, granted unusual powers
9266         if (sscanf(message, "wtime %ld\n", &whiteTimeRemaining) == 1 || // adjust clock times
9267             sscanf(message, "btime %ld\n", &blackTimeRemaining) == 1   ) return;
9268     }
9269
9270     /*
9271      * If chess program startup fails, exit with an error message.
9272      * Attempts to recover here are futile. [HGM] Well, we try anyway
9273      */
9274     if ((StrStr(message, "unknown host") != NULL)
9275         || (StrStr(message, "No remote directory") != NULL)
9276         || (StrStr(message, "not found") != NULL)
9277         || (StrStr(message, "No such file") != NULL)
9278         || (StrStr(message, "can't alloc") != NULL)
9279         || (StrStr(message, "Permission denied") != NULL)) {
9280
9281         cps->maybeThinking = FALSE;
9282         snprintf(buf1, sizeof(buf1), _("Failed to start %s chess program %s on %s: %s\n"),
9283                 _(cps->which), cps->program, cps->host, message);
9284         RemoveInputSource(cps->isr);
9285         if(appData.icsActive) DisplayFatalError(buf1, 0, 1); else {
9286             if(LoadError(oldError ? NULL : buf1, cps)) return; // error has then been handled by LoadError
9287             if(!oldError) DisplayError(buf1, 0); // if reason neatly announced, suppress general error popup
9288         }
9289         return;
9290     }
9291
9292     /*
9293      * Look for hint output
9294      */
9295     if (sscanf(message, "Hint: %s", buf1) == 1) {
9296         if (cps == &first && hintRequested) {
9297             hintRequested = FALSE;
9298             if (ParseOneMove(buf1, forwardMostMove, &moveType,
9299                                  &fromX, &fromY, &toX, &toY, &promoChar)) {
9300                 (void) CoordsToAlgebraic(boards[forwardMostMove],
9301                                     PosFlags(forwardMostMove),
9302                                     fromY, fromX, toY, toX, promoChar, buf1);
9303                 snprintf(buf2, sizeof(buf2), _("Hint: %s"), buf1);
9304                 DisplayInformation(buf2);
9305             } else {
9306                 /* Hint move could not be parsed!? */
9307               snprintf(buf2, sizeof(buf2),
9308                         _("Illegal hint move \"%s\"\nfrom %s chess program"),
9309                         buf1, _(cps->which));
9310                 DisplayError(buf2, 0);
9311             }
9312         } else {
9313           safeStrCpy(lastHint, buf1, sizeof(lastHint)/sizeof(lastHint[0]));
9314         }
9315         return;
9316     }
9317
9318     /*
9319      * Ignore other messages if game is not in progress
9320      */
9321     if (gameMode == BeginningOfGame || gameMode == EndOfGame ||
9322         gameMode == IcsIdle || cps->lastPing != cps->lastPong) return;
9323
9324     /*
9325      * look for win, lose, draw, or draw offer
9326      */
9327     if (strncmp(message, "1-0", 3) == 0) {
9328         char *p, *q, *r = "";
9329         p = strchr(message, '{');
9330         if (p) {
9331             q = strchr(p, '}');
9332             if (q) {
9333                 *q = NULLCHAR;
9334                 r = p + 1;
9335             }
9336         }
9337         GameEnds(WhiteWins, r, GE_ENGINE1 + (cps != &first)); /* [HGM] pass claimer indication for claim test */
9338         return;
9339     } else if (strncmp(message, "0-1", 3) == 0) {
9340         char *p, *q, *r = "";
9341         p = strchr(message, '{');
9342         if (p) {
9343             q = strchr(p, '}');
9344             if (q) {
9345                 *q = NULLCHAR;
9346                 r = p + 1;
9347             }
9348         }
9349         /* Kludge for Arasan 4.1 bug */
9350         if (strcmp(r, "Black resigns") == 0) {
9351             GameEnds(WhiteWins, r, GE_ENGINE1 + (cps != &first));
9352             return;
9353         }
9354         GameEnds(BlackWins, r, GE_ENGINE1 + (cps != &first));
9355         return;
9356     } else if (strncmp(message, "1/2", 3) == 0) {
9357         char *p, *q, *r = "";
9358         p = strchr(message, '{');
9359         if (p) {
9360             q = strchr(p, '}');
9361             if (q) {
9362                 *q = NULLCHAR;
9363                 r = p + 1;
9364             }
9365         }
9366
9367         GameEnds(GameIsDrawn, r, GE_ENGINE1 + (cps != &first));
9368         return;
9369
9370     } else if (strncmp(message, "White resign", 12) == 0) {
9371         GameEnds(BlackWins, "White resigns", GE_ENGINE1 + (cps != &first));
9372         return;
9373     } else if (strncmp(message, "Black resign", 12) == 0) {
9374         GameEnds(WhiteWins, "Black resigns", GE_ENGINE1 + (cps != &first));
9375         return;
9376     } else if (strncmp(message, "White matches", 13) == 0 ||
9377                strncmp(message, "Black matches", 13) == 0   ) {
9378         /* [HGM] ignore GNUShogi noises */
9379         return;
9380     } else if (strncmp(message, "White", 5) == 0 &&
9381                message[5] != '(' &&
9382                StrStr(message, "Black") == NULL) {
9383         GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
9384         return;
9385     } else if (strncmp(message, "Black", 5) == 0 &&
9386                message[5] != '(') {
9387         GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
9388         return;
9389     } else if (strcmp(message, "resign") == 0 ||
9390                strcmp(message, "computer resigns") == 0) {
9391         switch (gameMode) {
9392           case MachinePlaysBlack:
9393           case IcsPlayingBlack:
9394             GameEnds(WhiteWins, "Black resigns", GE_ENGINE);
9395             break;
9396           case MachinePlaysWhite:
9397           case IcsPlayingWhite:
9398             GameEnds(BlackWins, "White resigns", GE_ENGINE);
9399             break;
9400           case TwoMachinesPlay:
9401             if (cps->twoMachinesColor[0] == 'w')
9402               GameEnds(BlackWins, "White resigns", GE_ENGINE1 + (cps != &first));
9403             else
9404               GameEnds(WhiteWins, "Black resigns", GE_ENGINE1 + (cps != &first));
9405             break;
9406           default:
9407             /* can't happen */
9408             break;
9409         }
9410         return;
9411     } else if (strncmp(message, "opponent mates", 14) == 0) {
9412         switch (gameMode) {
9413           case MachinePlaysBlack:
9414           case IcsPlayingBlack:
9415             GameEnds(WhiteWins, "White mates", GE_ENGINE);
9416             break;
9417           case MachinePlaysWhite:
9418           case IcsPlayingWhite:
9419             GameEnds(BlackWins, "Black mates", GE_ENGINE);
9420             break;
9421           case TwoMachinesPlay:
9422             if (cps->twoMachinesColor[0] == 'w')
9423               GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
9424             else
9425               GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
9426             break;
9427           default:
9428             /* can't happen */
9429             break;
9430         }
9431         return;
9432     } else if (strncmp(message, "computer mates", 14) == 0) {
9433         switch (gameMode) {
9434           case MachinePlaysBlack:
9435           case IcsPlayingBlack:
9436             GameEnds(BlackWins, "Black mates", GE_ENGINE1);
9437             break;
9438           case MachinePlaysWhite:
9439           case IcsPlayingWhite:
9440             GameEnds(WhiteWins, "White mates", GE_ENGINE);
9441             break;
9442           case TwoMachinesPlay:
9443             if (cps->twoMachinesColor[0] == 'w')
9444               GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
9445             else
9446               GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
9447             break;
9448           default:
9449             /* can't happen */
9450             break;
9451         }
9452         return;
9453     } else if (strncmp(message, "checkmate", 9) == 0) {
9454         if (WhiteOnMove(forwardMostMove)) {
9455             GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
9456         } else {
9457             GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
9458         }
9459         return;
9460     } else if (strstr(message, "Draw") != NULL ||
9461                strstr(message, "game is a draw") != NULL) {
9462         GameEnds(GameIsDrawn, "Draw", GE_ENGINE1 + (cps != &first));
9463         return;
9464     } else if (strstr(message, "offer") != NULL &&
9465                strstr(message, "draw") != NULL) {
9466 #if ZIPPY
9467         if (appData.zippyPlay && first.initDone) {
9468             /* Relay offer to ICS */
9469             SendToICS(ics_prefix);
9470             SendToICS("draw\n");
9471         }
9472 #endif
9473         cps->offeredDraw = 2; /* valid until this engine moves twice */
9474         if (gameMode == TwoMachinesPlay) {
9475             if (cps->other->offeredDraw) {
9476                 GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
9477             /* [HGM] in two-machine mode we delay relaying draw offer      */
9478             /* until after we also have move, to see if it is really claim */
9479             }
9480         } else if (gameMode == MachinePlaysWhite ||
9481                    gameMode == MachinePlaysBlack) {
9482           if (userOfferedDraw) {
9483             DisplayInformation(_("Machine accepts your draw offer"));
9484             GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
9485           } else {
9486             DisplayInformation(_("Machine offers a draw.\nSelect Action / Draw to accept."));
9487           }
9488         }
9489     }
9490
9491
9492     /*
9493      * Look for thinking output
9494      */
9495     if ( appData.showThinking // [HGM] thinking: test all options that cause this output
9496           || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp()
9497                                 ) {
9498         int plylev, mvleft, mvtot, curscore, time;
9499         char mvname[MOVE_LEN];
9500         u64 nodes; // [DM]
9501         char plyext;
9502         int ignore = FALSE;
9503         int prefixHint = FALSE;
9504         mvname[0] = NULLCHAR;
9505
9506         switch (gameMode) {
9507           case MachinePlaysBlack:
9508           case IcsPlayingBlack:
9509             if (WhiteOnMove(forwardMostMove)) prefixHint = TRUE;
9510             break;
9511           case MachinePlaysWhite:
9512           case IcsPlayingWhite:
9513             if (!WhiteOnMove(forwardMostMove)) prefixHint = TRUE;
9514             break;
9515           case AnalyzeMode:
9516           case AnalyzeFile:
9517             break;
9518           case IcsObserving: /* [DM] icsEngineAnalyze */
9519             if (!appData.icsEngineAnalyze) ignore = TRUE;
9520             break;
9521           case TwoMachinesPlay:
9522             if ((cps->twoMachinesColor[0] == 'w') != WhiteOnMove(forwardMostMove)) {
9523                 ignore = TRUE;
9524             }
9525             break;
9526           default:
9527             ignore = TRUE;
9528             break;
9529         }
9530
9531         if (!ignore) {
9532             ChessProgramStats tempStats = programStats; // [HGM] info: filter out info lines
9533             buf1[0] = NULLCHAR;
9534             if (sscanf(message, "%d%c %d %d " u64Display " %[^\n]\n",
9535                        &plylev, &plyext, &curscore, &time, &nodes, buf1) >= 5) {
9536                 char score_buf[MSG_SIZ];
9537
9538                 if(nodes>>32 == u64Const(0xFFFFFFFF))   // [HGM] negative node count read
9539                     nodes += u64Const(0x100000000);
9540
9541                 if (plyext != ' ' && plyext != '\t') {
9542                     time *= 100;
9543                 }
9544
9545                 /* [AS] Negate score if machine is playing black and reporting absolute scores */
9546                 if( cps->scoreIsAbsolute &&
9547                     ( gameMode == MachinePlaysBlack ||
9548                       gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b' ||
9549                       gameMode == IcsPlayingBlack ||     // [HGM] also add other situations where engine should report black POV
9550                      (gameMode == AnalyzeMode || gameMode == AnalyzeFile || gameMode == IcsObserving && appData.icsEngineAnalyze) &&
9551                      !WhiteOnMove(currentMove)
9552                     ) )
9553                 {
9554                     curscore = -curscore;
9555                 }
9556
9557                 if(appData.pvSAN[cps==&second]) pv = PvToSAN(buf1);
9558
9559                 if(*bestMove) { // rememer time best EPD move was first found
9560                     int ff1, tf1, fr1, tr1, ff2, tf2, fr2, tr2; char pp1, pp2;
9561                     ChessMove mt;
9562                     int ok = ParseOneMove(bestMove, forwardMostMove, &mt, &ff1, &fr1, &tf1, &tr1, &pp1);
9563                     ok    &= ParseOneMove(pv, forwardMostMove, &mt, &ff2, &fr2, &tf2, &tr2, &pp2);
9564                     solvingTime = (ok && ff1==ff2 && fr1==fr2 && tf1==tf2 && tr1==tr2 && pp1==pp2 ? time : -1);
9565                 }
9566
9567                 if(serverMoves && (time > 100 || time == 0 && plylev > 7)) {
9568                         char buf[MSG_SIZ];
9569                         FILE *f;
9570                         snprintf(buf, MSG_SIZ, "%s", appData.serverMovesName);
9571                         buf[strlen(buf)-1] = gameMode == MachinePlaysWhite ? 'w' :
9572                                              gameMode == MachinePlaysBlack ? 'b' : cps->twoMachinesColor[0];
9573                         if(appData.debugMode) fprintf(debugFP, "write PV on file '%s'\n", buf);
9574                         if(f = fopen(buf, "w")) { // export PV to applicable PV file
9575                                 fprintf(f, "%5.2f/%-2d %s", curscore/100., plylev, pv);
9576                                 fclose(f);
9577                         }
9578                         else
9579                           /* TRANSLATORS: PV = principal variation, the variation the chess engine thinks is the best for everyone */
9580                           DisplayError(_("failed writing PV"), 0);
9581                 }
9582
9583                 tempStats.depth = plylev;
9584                 tempStats.nodes = nodes;
9585                 tempStats.time = time;
9586                 tempStats.score = curscore;
9587                 tempStats.got_only_move = 0;
9588
9589                 if(cps->nps >= 0) { /* [HGM] nps: use engine nodes or time to decrement clock */
9590                         int ticklen;
9591
9592                         if(cps->nps == 0) ticklen = 10*time;                    // use engine reported time
9593                         else ticklen = (1000. * u64ToDouble(nodes)) / cps->nps; // convert node count to time
9594                         if(WhiteOnMove(forwardMostMove) && (gameMode == MachinePlaysWhite ||
9595                                                 gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'w'))
9596                              whiteTimeRemaining = timeRemaining[0][forwardMostMove] - ticklen;
9597                         if(!WhiteOnMove(forwardMostMove) && (gameMode == MachinePlaysBlack ||
9598                                                 gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b'))
9599                              blackTimeRemaining = timeRemaining[1][forwardMostMove] - ticklen;
9600                 }
9601
9602                 /* Buffer overflow protection */
9603                 if (pv[0] != NULLCHAR) {
9604                     if (strlen(pv) >= sizeof(tempStats.movelist)
9605                         && appData.debugMode) {
9606                         fprintf(debugFP,
9607                                 "PV is too long; using the first %u bytes.\n",
9608                                 (unsigned) sizeof(tempStats.movelist) - 1);
9609                     }
9610
9611                     safeStrCpy( tempStats.movelist, pv, sizeof(tempStats.movelist)/sizeof(tempStats.movelist[0]) );
9612                 } else {
9613                     sprintf(tempStats.movelist, " no PV\n");
9614                 }
9615
9616                 if (tempStats.seen_stat) {
9617                     tempStats.ok_to_send = 1;
9618                 }
9619
9620                 if (strchr(tempStats.movelist, '(') != NULL) {
9621                     tempStats.line_is_book = 1;
9622                     tempStats.nr_moves = 0;
9623                     tempStats.moves_left = 0;
9624                 } else {
9625                     tempStats.line_is_book = 0;
9626                 }
9627
9628                     if(tempStats.score != 0 || tempStats.nodes != 0 || tempStats.time != 0)
9629                         programStats = tempStats; // [HGM] info: only set stats if genuine PV and not an info line
9630
9631                 SendProgramStatsToFrontend( cps, &tempStats );
9632
9633                 /*
9634                     [AS] Protect the thinkOutput buffer from overflow... this
9635                     is only useful if buf1 hasn't overflowed first!
9636                 */
9637                 if(curscore >= MATE_SCORE)
9638                     snprintf(score_buf, MSG_SIZ, "#%d", curscore - MATE_SCORE);
9639                 else if(curscore <= -MATE_SCORE)
9640                     snprintf(score_buf, MSG_SIZ, "#%d", curscore + MATE_SCORE);
9641                 else
9642                     snprintf(score_buf, MSG_SIZ, "%+.2f", ((double) curscore) / 100.0);
9643                 snprintf(thinkOutput, sizeof(thinkOutput)/sizeof(thinkOutput[0]), "[%d]%c%s %s%s",
9644                          plylev,
9645                          (gameMode == TwoMachinesPlay ?
9646                           ToUpper(cps->twoMachinesColor[0]) : ' '),
9647                          score_buf,
9648                          prefixHint ? lastHint : "",
9649                          prefixHint ? " " : "" );
9650
9651                 if( buf1[0] != NULLCHAR ) {
9652                     unsigned max_len = sizeof(thinkOutput) - strlen(thinkOutput) - 1;
9653
9654                     if( strlen(pv) > max_len ) {
9655                         if( appData.debugMode) {
9656                             fprintf(debugFP,"PV is too long for thinkOutput, truncating.\n");
9657                         }
9658                         pv[max_len+1] = '\0';
9659                     }
9660
9661                     strcat( thinkOutput, pv);
9662                 }
9663
9664                 if (currentMove == forwardMostMove || gameMode == AnalyzeMode
9665                         || gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
9666                     DisplayMove(currentMove - 1);
9667                 }
9668                 return;
9669
9670             } else if ((p=StrStr(message, "(only move)")) != NULL) {
9671                 /* crafty (9.25+) says "(only move) <move>"
9672                  * if there is only 1 legal move
9673                  */
9674                 sscanf(p, "(only move) %s", buf1);
9675                 snprintf(thinkOutput, sizeof(thinkOutput)/sizeof(thinkOutput[0]), "%s (only move)", buf1);
9676                 sprintf(programStats.movelist, "%s (only move)", buf1);
9677                 programStats.depth = 1;
9678                 programStats.nr_moves = 1;
9679                 programStats.moves_left = 1;
9680                 programStats.nodes = 1;
9681                 programStats.time = 1;
9682                 programStats.got_only_move = 1;
9683
9684                 /* Not really, but we also use this member to
9685                    mean "line isn't going to change" (Crafty
9686                    isn't searching, so stats won't change) */
9687                 programStats.line_is_book = 1;
9688
9689                 SendProgramStatsToFrontend( cps, &programStats );
9690
9691                 if (currentMove == forwardMostMove || gameMode==AnalyzeMode ||
9692                            gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
9693                     DisplayMove(currentMove - 1);
9694                 }
9695                 return;
9696             } else if (sscanf(message,"stat01: %d " u64Display " %d %d %d %s",
9697                               &time, &nodes, &plylev, &mvleft,
9698                               &mvtot, mvname) >= 5) {
9699                 /* The stat01: line is from Crafty (9.29+) in response
9700                    to the "." command */
9701                 programStats.seen_stat = 1;
9702                 cps->maybeThinking = TRUE;
9703
9704                 if (programStats.got_only_move || !appData.periodicUpdates)
9705                   return;
9706
9707                 programStats.depth = plylev;
9708                 programStats.time = time;
9709                 programStats.nodes = nodes;
9710                 programStats.moves_left = mvleft;
9711                 programStats.nr_moves = mvtot;
9712                 safeStrCpy(programStats.move_name, mvname, sizeof(programStats.move_name)/sizeof(programStats.move_name[0]));
9713                 programStats.ok_to_send = 1;
9714                 programStats.movelist[0] = '\0';
9715
9716                 SendProgramStatsToFrontend( cps, &programStats );
9717
9718                 return;
9719
9720             } else if (strncmp(message,"++",2) == 0) {
9721                 /* Crafty 9.29+ outputs this */
9722                 programStats.got_fail = 2;
9723                 return;
9724
9725             } else if (strncmp(message,"--",2) == 0) {
9726                 /* Crafty 9.29+ outputs this */
9727                 programStats.got_fail = 1;
9728                 return;
9729
9730             } else if (thinkOutput[0] != NULLCHAR &&
9731                        strncmp(message, "    ", 4) == 0) {
9732                 unsigned message_len;
9733
9734                 p = message;
9735                 while (*p && *p == ' ') p++;
9736
9737                 message_len = strlen( p );
9738
9739                 /* [AS] Avoid buffer overflow */
9740                 if( sizeof(thinkOutput) - strlen(thinkOutput) - 1 > message_len ) {
9741                     strcat(thinkOutput, " ");
9742                     strcat(thinkOutput, p);
9743                 }
9744
9745                 if( sizeof(programStats.movelist) - strlen(programStats.movelist) - 1 > message_len ) {
9746                     strcat(programStats.movelist, " ");
9747                     strcat(programStats.movelist, p);
9748                 }
9749
9750                 if (currentMove == forwardMostMove || gameMode==AnalyzeMode ||
9751                            gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
9752                     DisplayMove(currentMove - 1);
9753                 }
9754                 return;
9755             }
9756         }
9757         else {
9758             buf1[0] = NULLCHAR;
9759
9760             if (sscanf(message, "%d%c %d %d " u64Display " %[^\n]\n",
9761                        &plylev, &plyext, &curscore, &time, &nodes, buf1) >= 5)
9762             {
9763                 ChessProgramStats cpstats;
9764
9765                 if (plyext != ' ' && plyext != '\t') {
9766                     time *= 100;
9767                 }
9768
9769                 /* [AS] Negate score if machine is playing black and reporting absolute scores */
9770                 if( cps->scoreIsAbsolute && ((gameMode == MachinePlaysBlack) || (gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b')) ) {
9771                     curscore = -curscore;
9772                 }
9773
9774                 cpstats.depth = plylev;
9775                 cpstats.nodes = nodes;
9776                 cpstats.time = time;
9777                 cpstats.score = curscore;
9778                 cpstats.got_only_move = 0;
9779                 cpstats.movelist[0] = '\0';
9780
9781                 if (buf1[0] != NULLCHAR) {
9782                     safeStrCpy( cpstats.movelist, buf1, sizeof(cpstats.movelist)/sizeof(cpstats.movelist[0]) );
9783                 }
9784
9785                 cpstats.ok_to_send = 0;
9786                 cpstats.line_is_book = 0;
9787                 cpstats.nr_moves = 0;
9788                 cpstats.moves_left = 0;
9789
9790                 SendProgramStatsToFrontend( cps, &cpstats );
9791             }
9792         }
9793     }
9794 }
9795
9796
9797 /* Parse a game score from the character string "game", and
9798    record it as the history of the current game.  The game
9799    score is NOT assumed to start from the standard position.
9800    The display is not updated in any way.
9801    */
9802 void
9803 ParseGameHistory (char *game)
9804 {
9805     ChessMove moveType;
9806     int fromX, fromY, toX, toY, boardIndex;
9807     char promoChar;
9808     char *p, *q;
9809     char buf[MSG_SIZ];
9810
9811     if (appData.debugMode)
9812       fprintf(debugFP, "Parsing game history: %s\n", game);
9813
9814     if (gameInfo.event == NULL) gameInfo.event = StrSave("ICS game");
9815     gameInfo.site = StrSave(appData.icsHost);
9816     gameInfo.date = PGNDate();
9817     gameInfo.round = StrSave("-");
9818
9819     /* Parse out names of players */
9820     while (*game == ' ') game++;
9821     p = buf;
9822     while (*game != ' ') *p++ = *game++;
9823     *p = NULLCHAR;
9824     gameInfo.white = StrSave(buf);
9825     while (*game == ' ') game++;
9826     p = buf;
9827     while (*game != ' ' && *game != '\n') *p++ = *game++;
9828     *p = NULLCHAR;
9829     gameInfo.black = StrSave(buf);
9830
9831     /* Parse moves */
9832     boardIndex = blackPlaysFirst ? 1 : 0;
9833     yynewstr(game);
9834     for (;;) {
9835         yyboardindex = boardIndex;
9836         moveType = (ChessMove) Myylex();
9837         switch (moveType) {
9838           case IllegalMove:             /* maybe suicide chess, etc. */
9839   if (appData.debugMode) {
9840     fprintf(debugFP, "Illegal move from ICS: '%s'\n", yy_text);
9841     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
9842     setbuf(debugFP, NULL);
9843   }
9844           case WhitePromotion:
9845           case BlackPromotion:
9846           case WhiteNonPromotion:
9847           case BlackNonPromotion:
9848           case NormalMove:
9849           case FirstLeg:
9850           case WhiteCapturesEnPassant:
9851           case BlackCapturesEnPassant:
9852           case WhiteKingSideCastle:
9853           case WhiteQueenSideCastle:
9854           case BlackKingSideCastle:
9855           case BlackQueenSideCastle:
9856           case WhiteKingSideCastleWild:
9857           case WhiteQueenSideCastleWild:
9858           case BlackKingSideCastleWild:
9859           case BlackQueenSideCastleWild:
9860           /* PUSH Fabien */
9861           case WhiteHSideCastleFR:
9862           case WhiteASideCastleFR:
9863           case BlackHSideCastleFR:
9864           case BlackASideCastleFR:
9865           /* POP Fabien */
9866             fromX = currentMoveString[0] - AAA;
9867             fromY = currentMoveString[1] - ONE;
9868             toX = currentMoveString[2] - AAA;
9869             toY = currentMoveString[3] - ONE;
9870             promoChar = currentMoveString[4];
9871             break;
9872           case WhiteDrop:
9873           case BlackDrop:
9874             if(currentMoveString[0] == '@') continue; // no null moves in ICS mode!
9875             fromX = moveType == WhiteDrop ?
9876               (int) CharToPiece(ToUpper(currentMoveString[0])) :
9877             (int) CharToPiece(ToLower(currentMoveString[0]));
9878             fromY = DROP_RANK;
9879             toX = currentMoveString[2] - AAA;
9880             toY = currentMoveString[3] - ONE;
9881             promoChar = NULLCHAR;
9882             break;
9883           case AmbiguousMove:
9884             /* bug? */
9885             snprintf(buf, MSG_SIZ, _("Ambiguous move in ICS output: \"%s\""), yy_text);
9886   if (appData.debugMode) {
9887     fprintf(debugFP, "Ambiguous move from ICS: '%s'\n", yy_text);
9888     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
9889     setbuf(debugFP, NULL);
9890   }
9891             DisplayError(buf, 0);
9892             return;
9893           case ImpossibleMove:
9894             /* bug? */
9895             snprintf(buf, MSG_SIZ, _("Illegal move in ICS output: \"%s\""), yy_text);
9896   if (appData.debugMode) {
9897     fprintf(debugFP, "Impossible move from ICS: '%s'\n", yy_text);
9898     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
9899     setbuf(debugFP, NULL);
9900   }
9901             DisplayError(buf, 0);
9902             return;
9903           case EndOfFile:
9904             if (boardIndex < backwardMostMove) {
9905                 /* Oops, gap.  How did that happen? */
9906                 DisplayError(_("Gap in move list"), 0);
9907                 return;
9908             }
9909             backwardMostMove =  blackPlaysFirst ? 1 : 0;
9910             if (boardIndex > forwardMostMove) {
9911                 forwardMostMove = boardIndex;
9912             }
9913             return;
9914           case ElapsedTime:
9915             if (boardIndex > (blackPlaysFirst ? 1 : 0)) {
9916                 strcat(parseList[boardIndex-1], " ");
9917                 strcat(parseList[boardIndex-1], yy_text);
9918             }
9919             continue;
9920           case Comment:
9921           case PGNTag:
9922           case NAG:
9923           default:
9924             /* ignore */
9925             continue;
9926           case WhiteWins:
9927           case BlackWins:
9928           case GameIsDrawn:
9929           case GameUnfinished:
9930             if (gameMode == IcsExamining) {
9931                 if (boardIndex < backwardMostMove) {
9932                     /* Oops, gap.  How did that happen? */
9933                     return;
9934                 }
9935                 backwardMostMove = blackPlaysFirst ? 1 : 0;
9936                 return;
9937             }
9938             gameInfo.result = moveType;
9939             p = strchr(yy_text, '{');
9940             if (p == NULL) p = strchr(yy_text, '(');
9941             if (p == NULL) {
9942                 p = yy_text;
9943                 if (p[0] == '0' || p[0] == '1' || p[0] == '*') p = "";
9944             } else {
9945                 q = strchr(p, *p == '{' ? '}' : ')');
9946                 if (q != NULL) *q = NULLCHAR;
9947                 p++;
9948             }
9949             while(q = strchr(p, '\n')) *q = ' '; // [HGM] crush linefeeds in result message
9950             gameInfo.resultDetails = StrSave(p);
9951             continue;
9952         }
9953         if (boardIndex >= forwardMostMove &&
9954             !(gameMode == IcsObserving && ics_gamenum == -1)) {
9955             backwardMostMove = blackPlaysFirst ? 1 : 0;
9956             return;
9957         }
9958         (void) CoordsToAlgebraic(boards[boardIndex], PosFlags(boardIndex),
9959                                  fromY, fromX, toY, toX, promoChar,
9960                                  parseList[boardIndex]);
9961         CopyBoard(boards[boardIndex + 1], boards[boardIndex]);
9962         /* currentMoveString is set as a side-effect of yylex */
9963         safeStrCpy(moveList[boardIndex], currentMoveString, sizeof(moveList[boardIndex])/sizeof(moveList[boardIndex][0]));
9964         strcat(moveList[boardIndex], "\n");
9965         boardIndex++;
9966         ApplyMove(fromX, fromY, toX, toY, promoChar, boards[boardIndex]);
9967         switch (MateTest(boards[boardIndex], PosFlags(boardIndex)) ) {
9968           case MT_NONE:
9969           case MT_STALEMATE:
9970           default:
9971             break;
9972           case MT_CHECK:
9973             if(!IS_SHOGI(gameInfo.variant))
9974                 strcat(parseList[boardIndex - 1], "+");
9975             break;
9976           case MT_CHECKMATE:
9977           case MT_STAINMATE:
9978             strcat(parseList[boardIndex - 1], "#");
9979             break;
9980         }
9981     }
9982 }
9983
9984
9985 /* Apply a move to the given board  */
9986 void
9987 ApplyMove (int fromX, int fromY, int toX, int toY, int promoChar, Board board)
9988 {
9989   ChessSquare captured = board[toY][toX], piece, pawn, king, killed, killed2; int p, rookX, oldEP, epRank, berolina = 0;
9990   int promoRank = gameInfo.variant == VariantMakruk || gameInfo.variant == VariantGrand || gameInfo.variant == VariantChuChess ? 3 : 1;
9991
9992     /* [HGM] compute & store e.p. status and castling rights for new position */
9993     /* we can always do that 'in place', now pointers to these rights are passed to ApplyMove */
9994
9995       if(gameInfo.variant == VariantBerolina) berolina = EP_BEROLIN_A;
9996       oldEP = (signed char)board[EP_FILE]; epRank = board[EP_RANK];
9997       board[EP_STATUS] = EP_NONE;
9998       board[EP_FILE] = board[EP_RANK] = 100;
9999
10000   if (fromY == DROP_RANK) {
10001         /* must be first */
10002         if(fromX == EmptySquare) { // [HGM] pass: empty drop encodes null move; nothing to change.
10003             board[EP_STATUS] = EP_CAPTURE; // null move considered irreversible
10004             return;
10005         }
10006         piece = board[toY][toX] = (ChessSquare) fromX;
10007   } else {
10008 //      ChessSquare victim;
10009       int i;
10010
10011       if( killX >= 0 && killY >= 0 ) { // [HGM] lion: Lion trampled over something
10012 //           victim = board[killY][killX],
10013            killed = board[killY][killX],
10014            board[killY][killX] = EmptySquare,
10015            board[EP_STATUS] = EP_CAPTURE;
10016            if( kill2X >= 0 && kill2Y >= 0)
10017              killed2 = board[kill2Y][kill2X], board[kill2Y][kill2X] = EmptySquare;
10018       }
10019
10020       if( board[toY][toX] != EmptySquare ) {
10021            board[EP_STATUS] = EP_CAPTURE;
10022            if( (fromX != toX || fromY != toY) && // not igui!
10023                (captured == WhiteLion && board[fromY][fromX] != BlackLion ||
10024                 captured == BlackLion && board[fromY][fromX] != WhiteLion   ) ) { // [HGM] lion: Chu Lion-capture rules
10025                board[EP_STATUS] = EP_IRON_LION; // non-Lion x Lion: no counter-strike allowed
10026            }
10027       }
10028
10029       pawn = board[fromY][fromX];
10030       if( pawn == WhiteLance || pawn == BlackLance ) {
10031            if( gameInfo.variant != VariantSuper && gameInfo.variant != VariantChu ) {
10032                if(gameInfo.variant == VariantSpartan) board[EP_STATUS] = EP_PAWN_MOVE; // in Spartan no e.p. rights must be set
10033                else pawn += WhitePawn - WhiteLance; // Lance is Pawn-like in most variants, so let Pawn code treat it by this kludge
10034            }
10035       }
10036       if( pawn == WhitePawn ) {
10037            if(fromY != toY) // [HGM] Xiangqi sideway Pawn moves should not count as 50-move breakers
10038                board[EP_STATUS] = EP_PAWN_MOVE;
10039            if( toY-fromY>=2) {
10040                board[EP_FILE] = (fromX + toX)/2; board[EP_RANK] = toY - 1 | 128*(toY - fromY > 2);
10041                if(toX>BOARD_LEFT   && board[toY][toX-1] == BlackPawn &&
10042                         gameInfo.variant != VariantBerolina || toX < fromX)
10043                       board[EP_STATUS] = toX | berolina;
10044                if(toX<BOARD_RGHT-1 && board[toY][toX+1] == BlackPawn &&
10045                         gameInfo.variant != VariantBerolina || toX > fromX)
10046                       board[EP_STATUS] = toX;
10047            }
10048       } else
10049       if( pawn == BlackPawn ) {
10050            if(fromY != toY) // [HGM] Xiangqi sideway Pawn moves should not count as 50-move breakers
10051                board[EP_STATUS] = EP_PAWN_MOVE;
10052            if( toY-fromY<= -2) {
10053                board[EP_FILE] = (fromX + toX)/2; board[EP_RANK] = toY + 1 | 128*(fromY - toY > 2);
10054                if(toX>BOARD_LEFT   && board[toY][toX-1] == WhitePawn &&
10055                         gameInfo.variant != VariantBerolina || toX < fromX)
10056                       board[EP_STATUS] = toX | berolina;
10057                if(toX<BOARD_RGHT-1 && board[toY][toX+1] == WhitePawn &&
10058                         gameInfo.variant != VariantBerolina || toX > fromX)
10059                       board[EP_STATUS] = toX;
10060            }
10061        }
10062
10063        if(fromY == 0) board[TOUCHED_W] |= 1<<fromX; else // new way to keep track of virginity
10064        if(fromY == BOARD_HEIGHT-1) board[TOUCHED_B] |= 1<<fromX;
10065        if(toY == 0) board[TOUCHED_W] |= 1<<toX; else
10066        if(toY == BOARD_HEIGHT-1) board[TOUCHED_B] |= 1<<toX;
10067
10068        for(i=0; i<nrCastlingRights; i++) {
10069            if(board[CASTLING][i] == fromX && castlingRank[i] == fromY ||
10070               board[CASTLING][i] == toX   && castlingRank[i] == toY
10071              ) board[CASTLING][i] = NoRights; // revoke for moved or captured piece
10072        }
10073
10074        if(gameInfo.variant == VariantSChess) { // update virginity
10075            if(fromY == 0)              board[VIRGIN][fromX] &= ~VIRGIN_W; // loss by moving
10076            if(fromY == BOARD_HEIGHT-1) board[VIRGIN][fromX] &= ~VIRGIN_B;
10077            if(toY == 0)                board[VIRGIN][toX]   &= ~VIRGIN_W; // loss by capture
10078            if(toY == BOARD_HEIGHT-1)   board[VIRGIN][toX]   &= ~VIRGIN_B;
10079        }
10080
10081      if (fromX == toX && fromY == toY) return;
10082
10083      piece = board[fromY][fromX]; /* [HGM] remember, for Shogi promotion */
10084      king = piece < (int) BlackPawn ? WhiteKing : BlackKing; /* [HGM] Knightmate simplify testing for castling */
10085      if(gameInfo.variant == VariantKnightmate)
10086          king += (int) WhiteUnicorn - (int) WhiteKing;
10087
10088     if(pieceDesc[piece] && killX >= 0 && strchr(pieceDesc[piece], 'O') // Betza castling-enabled
10089        && (piece < BlackPawn ? killed < BlackPawn : killed >= BlackPawn)) {    // and tramples own
10090         board[toY][toX] = piece; board[fromY][fromX] = EmptySquare;
10091         board[toY][toX + (killX < fromX ? 1 : -1)] = killed;
10092         board[EP_STATUS] = EP_NONE; // capture was fake!
10093     } else
10094     /* Code added by Tord: */
10095     /* FRC castling assumed when king captures friendly rook. [HGM] or RxK for S-Chess */
10096     if (board[fromY][fromX] == WhiteKing && board[toY][toX] == WhiteRook ||
10097         board[fromY][fromX] == WhiteRook && board[toY][toX] == WhiteKing) {
10098       board[EP_STATUS] = EP_NONE; // capture was fake!
10099       board[fromY][fromX] = EmptySquare;
10100       board[toY][toX] = EmptySquare;
10101       if((toX > fromX) != (piece == WhiteRook)) {
10102         board[0][BOARD_RGHT-2] = WhiteKing; board[0][BOARD_RGHT-3] = WhiteRook;
10103       } else {
10104         board[0][BOARD_LEFT+2] = WhiteKing; board[0][BOARD_LEFT+3] = WhiteRook;
10105       }
10106     } else if (board[fromY][fromX] == BlackKing && board[toY][toX] == BlackRook ||
10107                board[fromY][fromX] == BlackRook && board[toY][toX] == BlackKing) {
10108       board[EP_STATUS] = EP_NONE;
10109       board[fromY][fromX] = EmptySquare;
10110       board[toY][toX] = EmptySquare;
10111       if((toX > fromX) != (piece == BlackRook)) {
10112         board[BOARD_HEIGHT-1][BOARD_RGHT-2] = BlackKing; board[BOARD_HEIGHT-1][BOARD_RGHT-3] = BlackRook;
10113       } else {
10114         board[BOARD_HEIGHT-1][BOARD_LEFT+2] = BlackKing; board[BOARD_HEIGHT-1][BOARD_LEFT+3] = BlackRook;
10115       }
10116     /* End of code added by Tord */
10117
10118     } else if (board[fromY][fromX] == king
10119         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
10120         && toY == fromY && toX > fromX+1) {
10121         for(rookX=fromX+1; board[toY][rookX] == EmptySquare && rookX < BOARD_RGHT-1; rookX++); // castle with nearest piece
10122         board[fromY][toX-1] = board[fromY][rookX];
10123         board[fromY][rookX] = EmptySquare;
10124         board[fromY][fromX] = EmptySquare;
10125         board[toY][toX] = king;
10126     } else if (board[fromY][fromX] == king
10127         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
10128                && toY == fromY && toX < fromX-1) {
10129         for(rookX=fromX-1; board[toY][rookX] == EmptySquare && rookX > 0; rookX--); // castle with nearest piece
10130         board[fromY][toX+1] = board[fromY][rookX];
10131         board[fromY][rookX] = EmptySquare;
10132         board[fromY][fromX] = EmptySquare;
10133         board[toY][toX] = king;
10134     } else if ((board[fromY][fromX] == WhitePawn && gameInfo.variant != VariantXiangqi ||
10135                 board[fromY][fromX] == WhiteLance && gameInfo.variant != VariantSuper && gameInfo.variant != VariantChu)
10136                && toY >= BOARD_HEIGHT-promoRank && promoChar // defaulting to Q is done elsewhere
10137                ) {
10138         /* white pawn promotion */
10139         board[toY][toX] = CharToPiece(ToUpper(promoChar));
10140         if(board[toY][toX] < WhiteCannon && PieceToChar(PROMOTED board[toY][toX]) == '~') /* [HGM] use shadow piece (if available) */
10141             board[toY][toX] = (ChessSquare) (PROMOTED board[toY][toX]);
10142         board[fromY][fromX] = EmptySquare;
10143     } else if ((fromY >= BOARD_HEIGHT>>1)
10144                && (oldEP == toX || oldEP == EP_UNKNOWN || appData.testLegality || abs(toX - fromX) > 4)
10145                && (toX != fromX)
10146                && gameInfo.variant != VariantXiangqi
10147                && gameInfo.variant != VariantBerolina
10148                && (pawn == WhitePawn)
10149                && (board[toY][toX] == EmptySquare)) {
10150         board[fromY][fromX] = EmptySquare;
10151         board[toY][toX] = piece;
10152         if(toY == epRank - 128 + 1)
10153             captured = board[toY - 2][toX], board[toY - 2][toX] = EmptySquare;
10154         else
10155             captured = board[toY - 1][toX], board[toY - 1][toX] = EmptySquare;
10156     } else if ((fromY == BOARD_HEIGHT-4)
10157                && (toX == fromX)
10158                && gameInfo.variant == VariantBerolina
10159                && (board[fromY][fromX] == WhitePawn)
10160                && (board[toY][toX] == EmptySquare)) {
10161         board[fromY][fromX] = EmptySquare;
10162         board[toY][toX] = WhitePawn;
10163         if(oldEP & EP_BEROLIN_A) {
10164                 captured = board[fromY][fromX-1];
10165                 board[fromY][fromX-1] = EmptySquare;
10166         }else{  captured = board[fromY][fromX+1];
10167                 board[fromY][fromX+1] = EmptySquare;
10168         }
10169     } else if (board[fromY][fromX] == king
10170         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
10171                && toY == fromY && toX > fromX+1) {
10172         for(rookX=toX+1; board[toY][rookX] == EmptySquare && rookX < BOARD_RGHT - 1; rookX++);
10173         board[fromY][toX-1] = board[fromY][rookX];
10174         board[fromY][rookX] = EmptySquare;
10175         board[fromY][fromX] = EmptySquare;
10176         board[toY][toX] = king;
10177     } else if (board[fromY][fromX] == king
10178         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
10179                && toY == fromY && toX < fromX-1) {
10180         for(rookX=toX-1; board[toY][rookX] == EmptySquare && rookX > 0; rookX--);
10181         board[fromY][toX+1] = board[fromY][rookX];
10182         board[fromY][rookX] = EmptySquare;
10183         board[fromY][fromX] = EmptySquare;
10184         board[toY][toX] = king;
10185     } else if (fromY == 7 && fromX == 3
10186                && board[fromY][fromX] == BlackKing
10187                && toY == 7 && toX == 5) {
10188         board[fromY][fromX] = EmptySquare;
10189         board[toY][toX] = BlackKing;
10190         board[fromY][7] = EmptySquare;
10191         board[toY][4] = BlackRook;
10192     } else if (fromY == 7 && fromX == 3
10193                && board[fromY][fromX] == BlackKing
10194                && toY == 7 && toX == 1) {
10195         board[fromY][fromX] = EmptySquare;
10196         board[toY][toX] = BlackKing;
10197         board[fromY][0] = EmptySquare;
10198         board[toY][2] = BlackRook;
10199     } else if ((board[fromY][fromX] == BlackPawn && gameInfo.variant != VariantXiangqi ||
10200                 board[fromY][fromX] == BlackLance && gameInfo.variant != VariantSuper && gameInfo.variant != VariantChu)
10201                && toY < promoRank && promoChar
10202                ) {
10203         /* black pawn promotion */
10204         board[toY][toX] = CharToPiece(ToLower(promoChar));
10205         if(board[toY][toX] < BlackCannon && PieceToChar(PROMOTED board[toY][toX]) == '~') /* [HGM] use shadow piece (if available) */
10206             board[toY][toX] = (ChessSquare) (PROMOTED board[toY][toX]);
10207         board[fromY][fromX] = EmptySquare;
10208     } else if ((fromY < BOARD_HEIGHT>>1)
10209                && (oldEP == toX || oldEP == EP_UNKNOWN || appData.testLegality || abs(toX - fromX) > 4)
10210                && (toX != fromX)
10211                && gameInfo.variant != VariantXiangqi
10212                && gameInfo.variant != VariantBerolina
10213                && (pawn == BlackPawn)
10214                && (board[toY][toX] == EmptySquare)) {
10215         board[fromY][fromX] = EmptySquare;
10216         board[toY][toX] = piece;
10217         if(toY == epRank - 128 - 1)
10218             captured = board[toY + 2][toX], board[toY + 2][toX] = EmptySquare;
10219         else
10220             captured = board[toY + 1][toX], board[toY + 1][toX] = EmptySquare;
10221     } else if ((fromY == 3)
10222                && (toX == fromX)
10223                && gameInfo.variant == VariantBerolina
10224                && (board[fromY][fromX] == BlackPawn)
10225                && (board[toY][toX] == EmptySquare)) {
10226         board[fromY][fromX] = EmptySquare;
10227         board[toY][toX] = BlackPawn;
10228         if(oldEP & EP_BEROLIN_A) {
10229                 captured = board[fromY][fromX-1];
10230                 board[fromY][fromX-1] = EmptySquare;
10231         }else{  captured = board[fromY][fromX+1];
10232                 board[fromY][fromX+1] = EmptySquare;
10233         }
10234     } else {
10235         ChessSquare piece = board[fromY][fromX]; // [HGM] lion: allow for igui (where from == to)
10236         board[fromY][fromX] = EmptySquare;
10237         board[toY][toX] = piece;
10238     }
10239   }
10240
10241     if (gameInfo.holdingsWidth != 0) {
10242
10243       /* !!A lot more code needs to be written to support holdings  */
10244       /* [HGM] OK, so I have written it. Holdings are stored in the */
10245       /* penultimate board files, so they are automaticlly stored   */
10246       /* in the game history.                                       */
10247       if (fromY == DROP_RANK || gameInfo.variant == VariantSChess
10248                                 && promoChar && piece != WhitePawn && piece != BlackPawn) {
10249         /* Delete from holdings, by decreasing count */
10250         /* and erasing image if necessary            */
10251         p = fromY == DROP_RANK ? (int) fromX : CharToPiece(piece > BlackPawn ? ToLower(promoChar) : ToUpper(promoChar));
10252         if(p < (int) BlackPawn) { /* white drop */
10253              p -= (int)WhitePawn;
10254                  p = PieceToNumber((ChessSquare)p);
10255              if(p >= gameInfo.holdingsSize) p = 0;
10256              if(--board[p][BOARD_WIDTH-2] <= 0)
10257                   board[p][BOARD_WIDTH-1] = EmptySquare;
10258              if((int)board[p][BOARD_WIDTH-2] < 0)
10259                         board[p][BOARD_WIDTH-2] = 0;
10260         } else {                  /* black drop */
10261              p -= (int)BlackPawn;
10262                  p = PieceToNumber((ChessSquare)p);
10263              if(p >= gameInfo.holdingsSize) p = 0;
10264              if(--board[BOARD_HEIGHT-1-p][1] <= 0)
10265                   board[BOARD_HEIGHT-1-p][0] = EmptySquare;
10266              if((int)board[BOARD_HEIGHT-1-p][1] < 0)
10267                         board[BOARD_HEIGHT-1-p][1] = 0;
10268         }
10269       }
10270       if (captured != EmptySquare && gameInfo.holdingsSize > 0
10271           && gameInfo.variant != VariantBughouse && gameInfo.variant != VariantSChess        ) {
10272         /* [HGM] holdings: Add to holdings, if holdings exist */
10273         if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat || gameInfo.variant == VariantGrand) {
10274                 // [HGM] superchess: suppress flipping color of captured pieces by reverse pre-flip
10275                 captured = (int) captured >= (int) BlackPawn ? BLACK_TO_WHITE captured : WHITE_TO_BLACK captured;
10276         }
10277         p = (int) captured;
10278         if (p >= (int) BlackPawn) {
10279           p -= (int)BlackPawn;
10280           if(DEMOTED p >= 0 && PieceToChar(p) == '+') {
10281                   /* Restore shogi-promoted piece to its original  first */
10282                   captured = (ChessSquare) (DEMOTED captured);
10283                   p = DEMOTED p;
10284           }
10285           p = PieceToNumber((ChessSquare)p);
10286           if(p >= gameInfo.holdingsSize) { p = 0; captured = BlackPawn; }
10287           board[p][BOARD_WIDTH-2]++;
10288           board[p][BOARD_WIDTH-1] = BLACK_TO_WHITE captured;
10289         } else {
10290           p -= (int)WhitePawn;
10291           if(DEMOTED p >= 0 && PieceToChar(p) == '+') {
10292                   captured = (ChessSquare) (DEMOTED captured);
10293                   p = DEMOTED p;
10294           }
10295           p = PieceToNumber((ChessSquare)p);
10296           if(p >= gameInfo.holdingsSize) { p = 0; captured = WhitePawn; }
10297           board[BOARD_HEIGHT-1-p][1]++;
10298           board[BOARD_HEIGHT-1-p][0] = WHITE_TO_BLACK captured;
10299         }
10300       }
10301     } else if (gameInfo.variant == VariantAtomic) {
10302       if (captured != EmptySquare) {
10303         int y, x;
10304         for (y = toY-1; y <= toY+1; y++) {
10305           for (x = toX-1; x <= toX+1; x++) {
10306             if (y >= 0 && y < BOARD_HEIGHT && x >= BOARD_LEFT && x < BOARD_RGHT &&
10307                 board[y][x] != WhitePawn && board[y][x] != BlackPawn) {
10308               board[y][x] = EmptySquare;
10309             }
10310           }
10311         }
10312         board[toY][toX] = EmptySquare;
10313       }
10314     }
10315
10316     if(gameInfo.variant == VariantSChess && promoChar != NULLCHAR && promoChar != '=' && piece != WhitePawn && piece != BlackPawn) {
10317         board[fromY][fromX] = CharToPiece(piece < BlackPawn ? ToUpper(promoChar) : ToLower(promoChar)); // S-Chess gating
10318     } else
10319     if(promoChar == '+') {
10320         /* [HGM] Shogi-style promotions, to piece implied by original (Might overwrite ordinary Pawn promotion) */
10321         board[toY][toX] = (ChessSquare) (CHUPROMOTED piece);
10322         if(gameInfo.variant == VariantChuChess && (piece == WhiteKnight || piece == BlackKnight))
10323           board[toY][toX] = piece + WhiteLion - WhiteKnight; // adjust Knight promotions to Lion
10324     } else if(!appData.testLegality && promoChar != NULLCHAR && promoChar != '=') { // without legality testing, unconditionally believe promoChar
10325         ChessSquare newPiece = CharToPiece(piece < BlackPawn ? ToUpper(promoChar) : ToLower(promoChar));
10326         if((newPiece <= WhiteMan || newPiece >= BlackPawn && newPiece <= BlackMan) // unpromoted piece specified
10327            && pieceToChar[PROMOTED newPiece] == '~') newPiece = PROMOTED newPiece; // but promoted version available
10328         board[toY][toX] = newPiece;
10329     }
10330     if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat || gameInfo.variant == VariantGrand)
10331                 && promoChar != NULLCHAR && gameInfo.holdingsSize) {
10332         // [HGM] superchess: take promotion piece out of holdings
10333         int k = PieceToNumber(CharToPiece(ToUpper(promoChar)));
10334         if((int)piece < (int)BlackPawn) { // determine stm from piece color
10335             if(!--board[k][BOARD_WIDTH-2])
10336                 board[k][BOARD_WIDTH-1] = EmptySquare;
10337         } else {
10338             if(!--board[BOARD_HEIGHT-1-k][1])
10339                 board[BOARD_HEIGHT-1-k][0] = EmptySquare;
10340         }
10341     }
10342 }
10343
10344 /* Updates forwardMostMove */
10345 void
10346 MakeMove (int fromX, int fromY, int toX, int toY, int promoChar)
10347 {
10348     int x = toX, y = toY;
10349     char *s = parseList[forwardMostMove];
10350     ChessSquare p = boards[forwardMostMove][toY][toX];
10351 //    forwardMostMove++; // [HGM] bare: moved downstream
10352
10353     if(killX >= 0 && killY >= 0) x = killX, y = killY; // [HGM] lion: make SAN move to intermediate square, if there is one
10354     (void) CoordsToAlgebraic(boards[forwardMostMove],
10355                              PosFlags(forwardMostMove),
10356                              fromY, fromX, y, x, promoChar,
10357                              s);
10358     if(killX >= 0 && killY >= 0)
10359         sprintf(s + strlen(s), "%c%c%d", p == EmptySquare || toX == fromX && toY == fromY ? '-' : 'x', toX + AAA, toY + ONE - '0');
10360
10361     if(serverMoves != NULL) { /* [HGM] write moves on file for broadcasting (should be separate routine, really) */
10362         int timeLeft; static int lastLoadFlag=0; int king, piece;
10363         piece = boards[forwardMostMove][fromY][fromX];
10364         king = piece < (int) BlackPawn ? WhiteKing : BlackKing;
10365         if(gameInfo.variant == VariantKnightmate)
10366             king += (int) WhiteUnicorn - (int) WhiteKing;
10367         if(forwardMostMove == 0) {
10368             if(gameMode == MachinePlaysBlack || gameMode == BeginningOfGame)
10369                 fprintf(serverMoves, "%s;", UserName());
10370             else if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b')
10371                 fprintf(serverMoves, "%s;", second.tidy);
10372             fprintf(serverMoves, "%s;", first.tidy);
10373             if(gameMode == MachinePlaysWhite)
10374                 fprintf(serverMoves, "%s;", UserName());
10375             else if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'w')
10376                 fprintf(serverMoves, "%s;", second.tidy);
10377         } else fprintf(serverMoves, loadFlag|lastLoadFlag ? ":" : ";");
10378         lastLoadFlag = loadFlag;
10379         // print base move
10380         fprintf(serverMoves, "%c%c:%c%c", AAA+fromX, ONE+fromY, AAA+toX, ONE+toY);
10381         // print castling suffix
10382         if( toY == fromY && piece == king ) {
10383             if(toX-fromX > 1)
10384                 fprintf(serverMoves, ":%c%c:%c%c", AAA+BOARD_RGHT-1, ONE+fromY, AAA+toX-1,ONE+toY);
10385             if(fromX-toX >1)
10386                 fprintf(serverMoves, ":%c%c:%c%c", AAA+BOARD_LEFT, ONE+fromY, AAA+toX+1,ONE+toY);
10387         }
10388         // e.p. suffix
10389         if( (boards[forwardMostMove][fromY][fromX] == WhitePawn ||
10390              boards[forwardMostMove][fromY][fromX] == BlackPawn   ) &&
10391              boards[forwardMostMove][toY][toX] == EmptySquare
10392              && fromX != toX && fromY != toY)
10393                 fprintf(serverMoves, ":%c%c:%c%c", AAA+fromX, ONE+fromY, AAA+toX, ONE+fromY);
10394         // promotion suffix
10395         if(promoChar != NULLCHAR) {
10396             if(fromY == 0 || fromY == BOARD_HEIGHT-1)
10397                  fprintf(serverMoves, ":%c%c:%c%c", WhiteOnMove(forwardMostMove) ? 'w' : 'b',
10398                                                  ToLower(promoChar), AAA+fromX, ONE+fromY); // Seirawan gating
10399             else fprintf(serverMoves, ":%c:%c%c", ToLower(promoChar), AAA+toX, ONE+toY);
10400         }
10401         if(!loadFlag) {
10402                 char buf[MOVE_LEN*2], *p; int len;
10403             fprintf(serverMoves, "/%d/%d",
10404                pvInfoList[forwardMostMove].depth, pvInfoList[forwardMostMove].score);
10405             if(forwardMostMove+1 & 1) timeLeft = whiteTimeRemaining/1000;
10406             else                      timeLeft = blackTimeRemaining/1000;
10407             fprintf(serverMoves, "/%d", timeLeft);
10408                 strncpy(buf, parseList[forwardMostMove], MOVE_LEN*2);
10409                 if(p = strchr(buf, '/')) *p = NULLCHAR; else
10410                 if(p = strchr(buf, '=')) *p = NULLCHAR;
10411                 len = strlen(buf); if(len > 1 && buf[len-2] != '-') buf[len-2] = NULLCHAR; // strip to-square
10412             fprintf(serverMoves, "/%s", buf);
10413         }
10414         fflush(serverMoves);
10415     }
10416
10417     if (forwardMostMove+1 > framePtr) { // [HGM] vari: do not run into saved variations..
10418         GameEnds(GameUnfinished, _("Game too long; increase MAX_MOVES and recompile"), GE_XBOARD);
10419       return;
10420     }
10421     UnLoadPV(); // [HGM] pv: if we are looking at a PV, abort this
10422     if (commentList[forwardMostMove+1] != NULL) {
10423         free(commentList[forwardMostMove+1]);
10424         commentList[forwardMostMove+1] = NULL;
10425     }
10426     CopyBoard(boards[forwardMostMove+1], boards[forwardMostMove]);
10427     ApplyMove(fromX, fromY, toX, toY, promoChar, boards[forwardMostMove+1]);
10428     // forwardMostMove++; // [HGM] bare: moved to after ApplyMove, to make sure clock interrupt finds complete board
10429     SwitchClocks(forwardMostMove+1); // [HGM] race: incrementing move nr inside
10430     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
10431     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
10432     adjustedClock = FALSE;
10433     gameInfo.result = GameUnfinished;
10434     if (gameInfo.resultDetails != NULL) {
10435         free(gameInfo.resultDetails);
10436         gameInfo.resultDetails = NULL;
10437     }
10438     CoordsToComputerAlgebraic(fromY, fromX, toY, toX, promoChar,
10439                               moveList[forwardMostMove - 1]);
10440     switch (MateTest(boards[forwardMostMove], PosFlags(forwardMostMove)) ) {
10441       case MT_NONE:
10442       case MT_STALEMATE:
10443       default:
10444         break;
10445       case MT_CHECK:
10446         if(!IS_SHOGI(gameInfo.variant))
10447             strcat(parseList[forwardMostMove - 1], "+");
10448         break;
10449       case MT_CHECKMATE:
10450       case MT_STAINMATE:
10451         strcat(parseList[forwardMostMove - 1], "#");
10452         break;
10453     }
10454 }
10455
10456 /* Updates currentMove if not pausing */
10457 void
10458 ShowMove (int fromX, int fromY, int toX, int toY)
10459 {
10460     int instant = (gameMode == PlayFromGameFile) ?
10461         (matchMode || (appData.timeDelay == 0 && !pausing)) : pausing;
10462     if(appData.noGUI) return;
10463     if (!pausing || gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
10464         if (!instant) {
10465             if (forwardMostMove == currentMove + 1) {
10466                 AnimateMove(boards[forwardMostMove - 1],
10467                             fromX, fromY, toX, toY);
10468             }
10469         }
10470         currentMove = forwardMostMove;
10471     }
10472
10473     killX = killY = -1; // [HGM] lion: used up
10474
10475     if (instant) return;
10476
10477     DisplayMove(currentMove - 1);
10478     if (!pausing || gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
10479             if (appData.highlightLastMove) { // [HGM] moved to after DrawPosition, as with arrow it could redraw old board
10480                 SetHighlights(fromX, fromY, toX, toY);
10481             }
10482     }
10483     DrawPosition(FALSE, boards[currentMove]);
10484     DisplayBothClocks();
10485     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
10486 }
10487
10488 void
10489 SendEgtPath (ChessProgramState *cps)
10490 {       /* [HGM] EGT: match formats given in feature with those given by user, and send info for each match */
10491         char buf[MSG_SIZ], name[MSG_SIZ], *p;
10492
10493         if((p = cps->egtFormats) == NULL || appData.egtFormats == NULL) return;
10494
10495         while(*p) {
10496             char c, *q = name+1, *r, *s;
10497
10498             name[0] = ','; // extract next format name from feature and copy with prefixed ','
10499             while(*p && *p != ',') *q++ = *p++;
10500             *q++ = ':'; *q = 0;
10501             if( appData.defaultPathEGTB && appData.defaultPathEGTB[0] &&
10502                 strcmp(name, ",nalimov:") == 0 ) {
10503                 // take nalimov path from the menu-changeable option first, if it is defined
10504               snprintf(buf, MSG_SIZ, "egtpath nalimov %s\n", appData.defaultPathEGTB);
10505                 SendToProgram(buf,cps);     // send egtbpath command for nalimov
10506             } else
10507             if( (s = StrStr(appData.egtFormats, name+1)) == appData.egtFormats ||
10508                 (s = StrStr(appData.egtFormats, name)) != NULL) {
10509                 // format name occurs amongst user-supplied formats, at beginning or immediately after comma
10510                 s = r = StrStr(s, ":") + 1; // beginning of path info
10511                 while(*r && *r != ',') r++; // path info is everything upto next ';' or end of string
10512                 c = *r; *r = 0;             // temporarily null-terminate path info
10513                     *--q = 0;               // strip of trailig ':' from name
10514                     snprintf(buf, MSG_SIZ, "egtpath %s %s\n", name+1, s);
10515                 *r = c;
10516                 SendToProgram(buf,cps);     // send egtbpath command for this format
10517             }
10518             if(*p == ',') p++; // read away comma to position for next format name
10519         }
10520 }
10521
10522 static int
10523 NonStandardBoardSize (VariantClass v, int boardWidth, int boardHeight, int holdingsSize)
10524 {
10525       int width = 8, height = 8, holdings = 0;             // most common sizes
10526       if( v == VariantUnknown || *engineVariant) return 0; // engine-defined name never needs prefix
10527       // correct the deviations default for each variant
10528       if( v == VariantXiangqi ) width = 9,  height = 10;
10529       if( v == VariantShogi )   width = 9,  height = 9,  holdings = 7;
10530       if( v == VariantBughouse || v == VariantCrazyhouse) holdings = 5;
10531       if( v == VariantCapablanca || v == VariantCapaRandom ||
10532           v == VariantGothic || v == VariantFalcon || v == VariantJanus )
10533                                 width = 10;
10534       if( v == VariantCourier ) width = 12;
10535       if( v == VariantSuper )                            holdings = 8;
10536       if( v == VariantGreat )   width = 10,              holdings = 8;
10537       if( v == VariantSChess )                           holdings = 7;
10538       if( v == VariantGrand )   width = 10, height = 10, holdings = 7;
10539       if( v == VariantChuChess) width = 10, height = 10;
10540       if( v == VariantChu )     width = 12, height = 12;
10541       return boardWidth >= 0   && boardWidth   != width  || // -1 is default,
10542              boardHeight >= 0  && boardHeight  != height || // and thus by definition OK
10543              holdingsSize >= 0 && holdingsSize != holdings;
10544 }
10545
10546 char variantError[MSG_SIZ];
10547
10548 char *
10549 SupportedVariant (char *list, VariantClass v, int boardWidth, int boardHeight, int holdingsSize, int proto, char *engine)
10550 {     // returns error message (recognizable by upper-case) if engine does not support the variant
10551       char *p, *variant = VariantName(v);
10552       static char b[MSG_SIZ];
10553       if(NonStandardBoardSize(v, boardWidth, boardHeight, holdingsSize)) { /* [HGM] make prefix for non-standard board size. */
10554            snprintf(b, MSG_SIZ, "%dx%d+%d_%s", boardWidth, boardHeight,
10555                                                holdingsSize, variant); // cook up sized variant name
10556            /* [HGM] varsize: try first if this deviant size variant is specifically known */
10557            if(StrStr(list, b) == NULL) {
10558                // specific sized variant not known, check if general sizing allowed
10559                if(proto != 1 && StrStr(list, "boardsize") == NULL) {
10560                    snprintf(variantError, MSG_SIZ, "Board size %dx%d+%d not supported by %s",
10561                             boardWidth, boardHeight, holdingsSize, engine);
10562                    return NULL;
10563                }
10564                /* [HGM] here we really should compare with the maximum supported board size */
10565            }
10566       } else snprintf(b, MSG_SIZ,"%s", variant);
10567       if(proto == 1) return b; // for protocol 1 we cannot check and hope for the best
10568       p = StrStr(list, b);
10569       while(p && (p != list && p[-1] != ',' || p[strlen(b)] && p[strlen(b)] != ',') ) p = StrStr(p+1, b);
10570       if(p == NULL) {
10571           // occurs not at all in list, or only as sub-string
10572           snprintf(variantError, MSG_SIZ, _("Variant %s not supported by %s"), b, engine);
10573           if(p = StrStr(list, b)) { // handle requesting parent variant when only size-overridden is supported
10574               int l = strlen(variantError);
10575               char *q;
10576               while(p != list && p[-1] != ',') p--;
10577               q = strchr(p, ',');
10578               if(q) *q = NULLCHAR;
10579               snprintf(variantError + l, MSG_SIZ - l,  _(", but %s is"), p);
10580               if(q) *q= ',';
10581           }
10582           return NULL;
10583       }
10584       return b;
10585 }
10586
10587 void
10588 InitChessProgram (ChessProgramState *cps, int setup)
10589 /* setup needed to setup FRC opening position */
10590 {
10591     char buf[MSG_SIZ], *b;
10592     if (appData.noChessProgram) return;
10593     hintRequested = FALSE;
10594     bookRequested = FALSE;
10595
10596     ParseFeatures(appData.features[cps == &second], cps); // [HGM] allow user to overrule features
10597     /* [HGM] some new WB protocol commands to configure engine are sent now, if engine supports them */
10598     /*       moved to before sending initstring in 4.3.15, so Polyglot can delay UCI 'isready' to recepton of 'new' */
10599     if(cps->memSize) { /* [HGM] memory */
10600       snprintf(buf, MSG_SIZ, "memory %d\n", appData.defaultHashSize + appData.defaultCacheSizeEGTB);
10601         SendToProgram(buf, cps);
10602     }
10603     SendEgtPath(cps); /* [HGM] EGT */
10604     if(cps->maxCores) { /* [HGM] SMP: (protocol specified must be last settings command before new!) */
10605       snprintf(buf, MSG_SIZ, "cores %d\n", appData.smpCores);
10606         SendToProgram(buf, cps);
10607     }
10608
10609     setboardSpoiledMachineBlack = FALSE;
10610     SendToProgram(cps->initString, cps);
10611     if (gameInfo.variant != VariantNormal &&
10612         gameInfo.variant != VariantLoadable
10613         /* [HGM] also send variant if board size non-standard */
10614         || gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0) {
10615
10616       b = SupportedVariant(cps->variants, gameInfo.variant, gameInfo.boardWidth,
10617                            gameInfo.boardHeight, gameInfo.holdingsSize, cps->protocolVersion, cps->tidy);
10618       if (b == NULL) {
10619         VariantClass v;
10620         char c, *q = cps->variants, *p = strchr(q, ',');
10621         if(p) *p = NULLCHAR;
10622         v = StringToVariant(q);
10623         DisplayError(variantError, 0);
10624         if(v != VariantUnknown && cps == &first) {
10625             int w, h, s;
10626             if(sscanf(q, "%dx%d+%d_%c", &w, &h, &s, &c) == 4) // get size overrides the engine needs with it (if any)
10627                 appData.NrFiles = w, appData.NrRanks = h, appData.holdingsSize = s, q = strchr(q, '_') + 1;
10628             ASSIGN(appData.variant, q);
10629             Reset(TRUE, FALSE);
10630         }
10631         if(p) *p = ',';
10632         return;
10633       }
10634
10635       snprintf(buf, MSG_SIZ, "variant %s\n", b);
10636       SendToProgram(buf, cps);
10637     }
10638     currentlyInitializedVariant = gameInfo.variant;
10639
10640     /* [HGM] send opening position in FRC to first engine */
10641     if(setup) {
10642           SendToProgram("force\n", cps);
10643           SendBoard(cps, 0);
10644           /* engine is now in force mode! Set flag to wake it up after first move. */
10645           setboardSpoiledMachineBlack = 1;
10646     }
10647
10648     if (cps->sendICS) {
10649       snprintf(buf, sizeof(buf), "ics %s\n", appData.icsActive ? appData.icsHost : "-");
10650       SendToProgram(buf, cps);
10651     }
10652     cps->maybeThinking = FALSE;
10653     cps->offeredDraw = 0;
10654     if (!appData.icsActive) {
10655         SendTimeControl(cps, movesPerSession, timeControl,
10656                         timeIncrement, appData.searchDepth,
10657                         searchTime);
10658     }
10659     if (appData.showThinking
10660         // [HGM] thinking: four options require thinking output to be sent
10661         || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp()
10662                                 ) {
10663         SendToProgram("post\n", cps);
10664     }
10665     SendToProgram("hard\n", cps);
10666     if (!appData.ponderNextMove) {
10667         /* Warning: "easy" is a toggle in GNU Chess, so don't send
10668            it without being sure what state we are in first.  "hard"
10669            is not a toggle, so that one is OK.
10670          */
10671         SendToProgram("easy\n", cps);
10672     }
10673     if (cps->usePing) {
10674       snprintf(buf, MSG_SIZ, "ping %d\n", initPing = ++cps->lastPing);
10675       SendToProgram(buf, cps);
10676     }
10677     cps->initDone = TRUE;
10678     ClearEngineOutputPane(cps == &second);
10679 }
10680
10681
10682 void
10683 ResendOptions (ChessProgramState *cps)
10684 { // send the stored value of the options
10685   int i;
10686   char buf[MSG_SIZ];
10687   Option *opt = cps->option;
10688   for(i=0; i<cps->nrOptions; i++, opt++) {
10689       switch(opt->type) {
10690         case Spin:
10691         case Slider:
10692         case CheckBox:
10693             snprintf(buf, MSG_SIZ, "option %s=%d\n", opt->name, opt->value);
10694           break;
10695         case ComboBox:
10696           snprintf(buf, MSG_SIZ, "option %s=%s\n", opt->name, opt->choice[opt->value]);
10697           break;
10698         default:
10699             snprintf(buf, MSG_SIZ, "option %s=%s\n", opt->name, opt->textValue);
10700           break;
10701         case Button:
10702         case SaveButton:
10703           continue;
10704       }
10705       SendToProgram(buf, cps);
10706   }
10707 }
10708
10709 void
10710 StartChessProgram (ChessProgramState *cps)
10711 {
10712     char buf[MSG_SIZ];
10713     int err;
10714
10715     if (appData.noChessProgram) return;
10716     cps->initDone = FALSE;
10717
10718     if (strcmp(cps->host, "localhost") == 0) {
10719         err = StartChildProcess(cps->program, cps->dir, &cps->pr);
10720     } else if (*appData.remoteShell == NULLCHAR) {
10721         err = OpenRcmd(cps->host, appData.remoteUser, cps->program, &cps->pr);
10722     } else {
10723         if (*appData.remoteUser == NULLCHAR) {
10724           snprintf(buf, sizeof(buf), "%s %s %s", appData.remoteShell, cps->host,
10725                     cps->program);
10726         } else {
10727           snprintf(buf, sizeof(buf), "%s %s -l %s %s", appData.remoteShell,
10728                     cps->host, appData.remoteUser, cps->program);
10729         }
10730         err = StartChildProcess(buf, "", &cps->pr);
10731     }
10732
10733     if (err != 0) {
10734       snprintf(buf, MSG_SIZ, _("Startup failure on '%s'"), cps->program);
10735         DisplayError(buf, err); // [HGM] bit of a rough kludge: ignore failure, (which XBoard would do anyway), and let I/O discover it
10736         if(cps != &first) return;
10737         appData.noChessProgram = TRUE;
10738         ThawUI();
10739         SetNCPMode();
10740 //      DisplayFatalError(buf, err, 1);
10741 //      cps->pr = NoProc;
10742 //      cps->isr = NULL;
10743         return;
10744     }
10745
10746     cps->isr = AddInputSource(cps->pr, TRUE, ReceiveFromProgram, cps);
10747     if (cps->protocolVersion > 1) {
10748       snprintf(buf, MSG_SIZ, "xboard\nprotover %d\n", cps->protocolVersion);
10749       if(!cps->reload) { // do not clear options when reloading because of -xreuse
10750         cps->nrOptions = 0; // [HGM] options: clear all engine-specific options
10751         cps->comboCnt = 0;  //                and values of combo boxes
10752       }
10753       SendToProgram(buf, cps);
10754       if(cps->reload) ResendOptions(cps);
10755     } else {
10756       SendToProgram("xboard\n", cps);
10757     }
10758 }
10759
10760 void
10761 TwoMachinesEventIfReady P((void))
10762 {
10763   static int curMess = 0;
10764   if (first.lastPing != first.lastPong) {
10765     if(curMess != 1) DisplayMessage("", _("Waiting for first chess program")); curMess = 1;
10766     ScheduleDelayedEvent(TwoMachinesEventIfReady, 10); // [HGM] fast: lowered from 1000
10767     return;
10768   }
10769   if (second.lastPing != second.lastPong) {
10770     if(curMess != 2) DisplayMessage("", _("Waiting for second chess program")); curMess = 2;
10771     ScheduleDelayedEvent(TwoMachinesEventIfReady, 10); // [HGM] fast: lowered from 1000
10772     return;
10773   }
10774   DisplayMessage("", ""); curMess = 0;
10775   TwoMachinesEvent();
10776 }
10777
10778 char *
10779 MakeName (char *template)
10780 {
10781     time_t clock;
10782     struct tm *tm;
10783     static char buf[MSG_SIZ];
10784     char *p = buf;
10785     int i;
10786
10787     clock = time((time_t *)NULL);
10788     tm = localtime(&clock);
10789
10790     while(*p++ = *template++) if(p[-1] == '%') {
10791         switch(*template++) {
10792           case 0:   *p = 0; return buf;
10793           case 'Y': i = tm->tm_year+1900; break;
10794           case 'y': i = tm->tm_year-100; break;
10795           case 'M': i = tm->tm_mon+1; break;
10796           case 'd': i = tm->tm_mday; break;
10797           case 'h': i = tm->tm_hour; break;
10798           case 'm': i = tm->tm_min; break;
10799           case 's': i = tm->tm_sec; break;
10800           default:  i = 0;
10801         }
10802         snprintf(p-1, MSG_SIZ-10 - (p - buf), "%02d", i); p += strlen(p);
10803     }
10804     return buf;
10805 }
10806
10807 int
10808 CountPlayers (char *p)
10809 {
10810     int n = 0;
10811     while(p = strchr(p, '\n')) p++, n++; // count participants
10812     return n;
10813 }
10814
10815 FILE *
10816 WriteTourneyFile (char *results, FILE *f)
10817 {   // write tournament parameters on tourneyFile; on success return the stream pointer for closing
10818     if(f == NULL) f = fopen(appData.tourneyFile, "w");
10819     if(f == NULL) DisplayError(_("Could not write on tourney file"), 0); else {
10820         // create a file with tournament description
10821         fprintf(f, "-participants {%s}\n", appData.participants);
10822         fprintf(f, "-seedBase %d\n", appData.seedBase);
10823         fprintf(f, "-tourneyType %d\n", appData.tourneyType);
10824         fprintf(f, "-tourneyCycles %d\n", appData.tourneyCycles);
10825         fprintf(f, "-defaultMatchGames %d\n", appData.defaultMatchGames);
10826         fprintf(f, "-syncAfterRound %s\n", appData.roundSync ? "true" : "false");
10827         fprintf(f, "-syncAfterCycle %s\n", appData.cycleSync ? "true" : "false");
10828         fprintf(f, "-saveGameFile \"%s\"\n", appData.saveGameFile);
10829         fprintf(f, "-loadGameFile \"%s\"\n", appData.loadGameFile);
10830         fprintf(f, "-loadGameIndex %d\n", appData.loadGameIndex);
10831         fprintf(f, "-loadPositionFile \"%s\"\n", appData.loadPositionFile);
10832         fprintf(f, "-loadPositionIndex %d\n", appData.loadPositionIndex);
10833         fprintf(f, "-rewindIndex %d\n", appData.rewindIndex);
10834         fprintf(f, "-usePolyglotBook %s\n", appData.usePolyglotBook ? "true" : "false");
10835         fprintf(f, "-polyglotBook \"%s\"\n", appData.polyglotBook);
10836         fprintf(f, "-bookDepth %d\n", appData.bookDepth);
10837         fprintf(f, "-bookVariation %d\n", appData.bookStrength);
10838         fprintf(f, "-discourageOwnBooks %s\n", appData.defNoBook ? "true" : "false");
10839         fprintf(f, "-defaultHashSize %d\n", appData.defaultHashSize);
10840         fprintf(f, "-defaultCacheSizeEGTB %d\n", appData.defaultCacheSizeEGTB);
10841         fprintf(f, "-ponderNextMove %s\n", appData.ponderNextMove ? "true" : "false");
10842         fprintf(f, "-smpCores %d\n", appData.smpCores);
10843         if(searchTime > 0)
10844                 fprintf(f, "-searchTime \"%d:%02d\"\n", searchTime/60, searchTime%60);
10845         else {
10846                 fprintf(f, "-mps %d\n", appData.movesPerSession);
10847                 fprintf(f, "-tc %s\n", appData.timeControl);
10848                 fprintf(f, "-inc %.2f\n", appData.timeIncrement);
10849         }
10850         fprintf(f, "-results \"%s\"\n", results);
10851     }
10852     return f;
10853 }
10854
10855 char *command[MAXENGINES], *mnemonic[MAXENGINES];
10856
10857 void
10858 Substitute (char *participants, int expunge)
10859 {
10860     int i, changed, changes=0, nPlayers=0;
10861     char *p, *q, *r, buf[MSG_SIZ];
10862     if(participants == NULL) return;
10863     if(appData.tourneyFile[0] == NULLCHAR) { free(participants); return; }
10864     r = p = participants; q = appData.participants;
10865     while(*p && *p == *q) {
10866         if(*p == '\n') r = p+1, nPlayers++;
10867         p++; q++;
10868     }
10869     if(*p) { // difference
10870         while(*p && *p++ != '\n');
10871         while(*q && *q++ != '\n');
10872       changed = nPlayers;
10873         changes = 1 + (strcmp(p, q) != 0);
10874     }
10875     if(changes == 1) { // a single engine mnemonic was changed
10876         q = r; while(*q) nPlayers += (*q++ == '\n');
10877         p = buf; while(*r && (*p = *r++) != '\n') p++;
10878         *p = NULLCHAR;
10879         NamesToList(firstChessProgramNames, command, mnemonic, "all");
10880         for(i=1; mnemonic[i]; i++) if(!strcmp(buf, mnemonic[i])) break;
10881         if(mnemonic[i]) { // The substitute is valid
10882             FILE *f;
10883             if(appData.tourneyFile[0] && (f = fopen(appData.tourneyFile, "r+")) ) {
10884                 flock(fileno(f), LOCK_EX);
10885                 ParseArgsFromFile(f);
10886                 fseek(f, 0, SEEK_SET);
10887                 FREE(appData.participants); appData.participants = participants;
10888                 if(expunge) { // erase results of replaced engine
10889                     int len = strlen(appData.results), w, b, dummy;
10890                     for(i=0; i<len; i++) {
10891                         Pairing(i, nPlayers, &w, &b, &dummy);
10892                         if((w == changed || b == changed) && appData.results[i] == '*') {
10893                             DisplayError(_("You cannot replace an engine while it is engaged!\nTerminate its game first."), 0);
10894                             fclose(f);
10895                             return;
10896                         }
10897                     }
10898                     for(i=0; i<len; i++) {
10899                         Pairing(i, nPlayers, &w, &b, &dummy);
10900                         if(w == changed || b == changed) appData.results[i] = ' '; // mark as not played
10901                     }
10902                 }
10903                 WriteTourneyFile(appData.results, f);
10904                 fclose(f); // release lock
10905                 return;
10906             }
10907         } else DisplayError(_("No engine with the name you gave is installed"), 0);
10908     }
10909     if(changes == 0) DisplayError(_("First change an engine by editing the participants list\nof the Tournament Options dialog"), 0);
10910     if(changes > 1)  DisplayError(_("You can only change one engine at the time"), 0);
10911     free(participants);
10912     return;
10913 }
10914
10915 int
10916 CheckPlayers (char *participants)
10917 {
10918         int i;
10919         char buf[MSG_SIZ], *p;
10920         NamesToList(firstChessProgramNames, command, mnemonic, "all");
10921         while(p = strchr(participants, '\n')) {
10922             *p = NULLCHAR;
10923             for(i=1; mnemonic[i]; i++) if(!strcmp(participants, mnemonic[i])) break;
10924             if(!mnemonic[i]) {
10925                 snprintf(buf, MSG_SIZ, _("No engine %s is installed"), participants);
10926                 *p = '\n';
10927                 DisplayError(buf, 0);
10928                 return 1;
10929             }
10930             *p = '\n';
10931             participants = p + 1;
10932         }
10933         return 0;
10934 }
10935
10936 int
10937 CreateTourney (char *name)
10938 {
10939         FILE *f;
10940         if(matchMode && strcmp(name, appData.tourneyFile)) {
10941              ASSIGN(name, appData.tourneyFile); //do not allow change of tourneyfile while playing
10942         }
10943         if(name[0] == NULLCHAR) {
10944             if(appData.participants[0])
10945                 DisplayError(_("You must supply a tournament file,\nfor storing the tourney progress"), 0);
10946             return 0;
10947         }
10948         f = fopen(name, "r");
10949         if(f) { // file exists
10950             ASSIGN(appData.tourneyFile, name);
10951             ParseArgsFromFile(f); // parse it
10952         } else {
10953             if(!appData.participants[0]) return 0; // ignore tourney file if non-existing & no participants
10954             if(CountPlayers(appData.participants) < (appData.tourneyType>0 ? appData.tourneyType+1 : 2)) {
10955                 DisplayError(_("Not enough participants"), 0);
10956                 return 0;
10957             }
10958             if(CheckPlayers(appData.participants)) return 0;
10959             ASSIGN(appData.tourneyFile, name);
10960             if(appData.tourneyType < 0) appData.defaultMatchGames = 1; // Swiss forces games/pairing = 1
10961             if((f = WriteTourneyFile("", NULL)) == NULL) return 0;
10962         }
10963         fclose(f);
10964         appData.noChessProgram = FALSE;
10965         appData.clockMode = TRUE;
10966         SetGNUMode();
10967         return 1;
10968 }
10969
10970 int
10971 NamesToList (char *names, char **engineList, char **engineMnemonic, char *group)
10972 {
10973     char buf[MSG_SIZ], *p, *q;
10974     int i=1, header, skip, all = !strcmp(group, "all"), depth = 0;
10975     insert = names; // afterwards, this global will point just after last retrieved engine line or group end in the 'names'
10976     skip = !all && group[0]; // if group requested, we start in skip mode
10977     for(;*names && depth >= 0 && i < MAXENGINES-1; names = p) {
10978         p = names; q = buf; header = 0;
10979         while(*p && *p != '\n') *q++ = *p++;
10980         *q = 0;
10981         if(*p == '\n') p++;
10982         if(buf[0] == '#') {
10983             if(strstr(buf, "# end") == buf) { if(!--depth) insert = p; continue; } // leave group, and suppress printing label
10984             depth++; // we must be entering a new group
10985             if(all) continue; // suppress printing group headers when complete list requested
10986             header = 1;
10987             if(skip && !strcmp(group, buf)) { depth = 0; skip = FALSE; } // start when we reach requested group
10988         }
10989         if(depth != header && !all || skip) continue; // skip contents of group (but print first-level header)
10990         if(engineList[i]) free(engineList[i]);
10991         engineList[i] = strdup(buf);
10992         if(buf[0] != '#') insert = p, TidyProgramName(engineList[i], "localhost", buf); // group headers not tidied
10993         if(engineMnemonic[i]) free(engineMnemonic[i]);
10994         if((q = strstr(engineList[i]+2, "variant")) && q[-2]== ' ' && (q[-1]=='/' || q[-1]=='-') && (q[7]==' ' || q[7]=='=')) {
10995             strcat(buf, " (");
10996             sscanf(q + 8, "%s", buf + strlen(buf));
10997             strcat(buf, ")");
10998         }
10999         engineMnemonic[i] = strdup(buf);
11000         i++;
11001     }
11002     engineList[i] = engineMnemonic[i] = NULL;
11003     return i;
11004 }
11005
11006 // following implemented as macro to avoid type limitations
11007 #define SWAP(item, temp) temp = appData.item[0]; appData.item[0] = appData.item[n]; appData.item[n] = temp;
11008
11009 void
11010 SwapEngines (int n)
11011 {   // swap settings for first engine and other engine (so far only some selected options)
11012     int h;
11013     char *p;
11014     if(n == 0) return;
11015     SWAP(directory, p)
11016     SWAP(chessProgram, p)
11017     SWAP(isUCI, h)
11018     SWAP(hasOwnBookUCI, h)
11019     SWAP(protocolVersion, h)
11020     SWAP(reuse, h)
11021     SWAP(scoreIsAbsolute, h)
11022     SWAP(timeOdds, h)
11023     SWAP(logo, p)
11024     SWAP(pgnName, p)
11025     SWAP(pvSAN, h)
11026     SWAP(engOptions, p)
11027     SWAP(engInitString, p)
11028     SWAP(computerString, p)
11029     SWAP(features, p)
11030     SWAP(fenOverride, p)
11031     SWAP(NPS, h)
11032     SWAP(accumulateTC, h)
11033     SWAP(drawDepth, h)
11034     SWAP(host, p)
11035     SWAP(pseudo, h)
11036 }
11037
11038 int
11039 GetEngineLine (char *s, int n)
11040 {
11041     int i;
11042     char buf[MSG_SIZ];
11043     extern char *icsNames;
11044     if(!s || !*s) return 0;
11045     NamesToList(n >= 10 ? icsNames : firstChessProgramNames, command, mnemonic, "all");
11046     for(i=1; mnemonic[i]; i++) if(!strcmp(s, mnemonic[i])) break;
11047     if(!mnemonic[i]) return 0;
11048     if(n == 11) return 1; // just testing if there was a match
11049     snprintf(buf, MSG_SIZ, "-%s %s", n == 10 ? "icshost" : "fcp", command[i]);
11050     if(n == 1) SwapEngines(n);
11051     ParseArgsFromString(buf);
11052     if(n == 1) SwapEngines(n);
11053     if(n == 0 && *appData.secondChessProgram == NULLCHAR) {
11054         SwapEngines(1); // set second same as first if not yet set (to suppress WB startup dialog)
11055         ParseArgsFromString(buf);
11056     }
11057     return 1;
11058 }
11059
11060 int
11061 SetPlayer (int player, char *p)
11062 {   // [HGM] find the engine line of the partcipant given by number, and parse its options.
11063     int i;
11064     char buf[MSG_SIZ], *engineName;
11065     for(i=0; i<player; i++) p = strchr(p, '\n') + 1;
11066     engineName = strdup(p); if(p = strchr(engineName, '\n')) *p = NULLCHAR;
11067     for(i=1; command[i]; i++) if(!strcmp(mnemonic[i], engineName)) break;
11068     if(mnemonic[i]) {
11069         snprintf(buf, MSG_SIZ, "-fcp %s", command[i]);
11070         ParseArgsFromString(resetOptions); appData.fenOverride[0] = NULL; appData.pvSAN[0] = FALSE;
11071         appData.firstHasOwnBookUCI = !appData.defNoBook; appData.protocolVersion[0] = PROTOVER;
11072         ParseArgsFromString(buf);
11073     } else { // no engine with this nickname is installed!
11074         snprintf(buf, MSG_SIZ, _("No engine %s is installed"), engineName);
11075         ReserveGame(nextGame, ' '); // unreserve game and drop out of match mode with error
11076         matchMode = FALSE; appData.matchGames = matchGame = roundNr = 0;
11077         ModeHighlight();
11078         DisplayError(buf, 0);
11079         return 0;
11080     }
11081     free(engineName);
11082     return i;
11083 }
11084
11085 char *recentEngines;
11086
11087 void
11088 RecentEngineEvent (int nr)
11089 {
11090     int n;
11091 //    SwapEngines(1); // bump first to second
11092 //    ReplaceEngine(&second, 1); // and load it there
11093     NamesToList(firstChessProgramNames, command, mnemonic, "all"); // get mnemonics of installed engines
11094     n = SetPlayer(nr, recentEngines); // select new (using original menu order!)
11095     if(mnemonic[n]) { // if somehow the engine with the selected nickname is no longer found in the list, we skip
11096         ReplaceEngine(&first, 0);
11097         FloatToFront(&appData.recentEngineList, command[n]);
11098     }
11099 }
11100
11101 int
11102 Pairing (int nr, int nPlayers, int *whitePlayer, int *blackPlayer, int *syncInterval)
11103 {   // determine players from game number
11104     int curCycle, curRound, curPairing, gamesPerCycle, gamesPerRound, roundsPerCycle=1, pairingsPerRound=1;
11105
11106     if(appData.tourneyType == 0) {
11107         roundsPerCycle = (nPlayers - 1) | 1;
11108         pairingsPerRound = nPlayers / 2;
11109     } else if(appData.tourneyType > 0) {
11110         roundsPerCycle = nPlayers - appData.tourneyType;
11111         pairingsPerRound = appData.tourneyType;
11112     }
11113     gamesPerRound = pairingsPerRound * appData.defaultMatchGames;
11114     gamesPerCycle = gamesPerRound * roundsPerCycle;
11115     appData.matchGames = gamesPerCycle * appData.tourneyCycles - 1; // fake like all games are one big match
11116     curCycle = nr / gamesPerCycle; nr %= gamesPerCycle;
11117     curRound = nr / gamesPerRound; nr %= gamesPerRound;
11118     curPairing = nr / appData.defaultMatchGames; nr %= appData.defaultMatchGames;
11119     matchGame = nr + curCycle * appData.defaultMatchGames + 1; // fake game nr that loads correct game or position from file
11120     roundNr = (curCycle * roundsPerCycle + curRound) * appData.defaultMatchGames + nr + 1;
11121
11122     if(appData.cycleSync) *syncInterval = gamesPerCycle;
11123     if(appData.roundSync) *syncInterval = gamesPerRound;
11124
11125     if(appData.debugMode) fprintf(debugFP, "cycle=%d, round=%d, pairing=%d curGame=%d\n", curCycle, curRound, curPairing, matchGame);
11126
11127     if(appData.tourneyType == 0) {
11128         if(curPairing == (nPlayers-1)/2 ) {
11129             *whitePlayer = curRound;
11130             *blackPlayer = nPlayers - 1; // this is the 'bye' when nPlayer is odd
11131         } else {
11132             *whitePlayer = curRound - (nPlayers-1)/2 + curPairing;
11133             if(*whitePlayer < 0) *whitePlayer += nPlayers-1+(nPlayers&1);
11134             *blackPlayer = curRound + (nPlayers-1)/2 - curPairing;
11135             if(*blackPlayer >= nPlayers-1+(nPlayers&1)) *blackPlayer -= nPlayers-1+(nPlayers&1);
11136         }
11137     } else if(appData.tourneyType > 1) {
11138         *blackPlayer = curPairing; // in multi-gauntlet, assign gauntlet engines to second, so first an be kept loaded during round
11139         *whitePlayer = curRound + appData.tourneyType;
11140     } else if(appData.tourneyType > 0) {
11141         *whitePlayer = curPairing;
11142         *blackPlayer = curRound + appData.tourneyType;
11143     }
11144
11145     // take care of white/black alternation per round.
11146     // For cycles and games this is already taken care of by default, derived from matchGame!
11147     return curRound & 1;
11148 }
11149
11150 int
11151 NextTourneyGame (int nr, int *swapColors)
11152 {   // !!!major kludge!!! fiddle appData settings to get everything in order for next tourney game
11153     char *p, *q;
11154     int whitePlayer, blackPlayer, firstBusy=1000000000, syncInterval = 0, nPlayers, OK = 1;
11155     FILE *tf;
11156     if(appData.tourneyFile[0] == NULLCHAR) return 1; // no tourney, always allow next game
11157     tf = fopen(appData.tourneyFile, "r");
11158     if(tf == NULL) { DisplayFatalError(_("Bad tournament file"), 0, 1); return 0; }
11159     ParseArgsFromFile(tf); fclose(tf);
11160     InitTimeControls(); // TC might be altered from tourney file
11161
11162     nPlayers = CountPlayers(appData.participants); // count participants
11163     if(appData.tourneyType < 0) syncInterval = nPlayers/2; else
11164     *swapColors = Pairing(nr<0 ? 0 : nr, nPlayers, &whitePlayer, &blackPlayer, &syncInterval);
11165
11166     if(syncInterval) {
11167         p = q = appData.results;
11168         while(*q) if(*q++ == '*' || q[-1] == ' ') { firstBusy = q - p - 1; break; }
11169         if(firstBusy/syncInterval < (nextGame/syncInterval)) {
11170             DisplayMessage(_("Waiting for other game(s)"),"");
11171             waitingForGame = TRUE;
11172             ScheduleDelayedEvent(NextMatchGame, 1000); // wait for all games of previous round to finish
11173             return 0;
11174         }
11175         waitingForGame = FALSE;
11176     }
11177
11178     if(appData.tourneyType < 0) {
11179         if(nr>=0 && !pairingReceived) {
11180             char buf[1<<16];
11181             if(pairing.pr == NoProc) {
11182                 if(!appData.pairingEngine[0]) {
11183                     DisplayFatalError(_("No pairing engine specified"), 0, 1);
11184                     return 0;
11185                 }
11186                 StartChessProgram(&pairing); // starts the pairing engine
11187             }
11188             snprintf(buf, 1<<16, "results %d %s\n", nPlayers, appData.results);
11189             SendToProgram(buf, &pairing);
11190             snprintf(buf, 1<<16, "pairing %d\n", nr+1);
11191             SendToProgram(buf, &pairing);
11192             return 0; // wait for pairing engine to answer (which causes NextTourneyGame to be called again...
11193         }
11194         pairingReceived = 0;                              // ... so we continue here
11195         *swapColors = 0;
11196         appData.matchGames = appData.tourneyCycles * syncInterval - 1;
11197         whitePlayer = savedWhitePlayer-1; blackPlayer = savedBlackPlayer-1;
11198         matchGame = 1; roundNr = nr / syncInterval + 1;
11199     }
11200
11201     if(first.pr != NoProc && second.pr != NoProc || nr<0) return 1; // engines already loaded
11202
11203     // redefine engines, engine dir, etc.
11204     NamesToList(firstChessProgramNames, command, mnemonic, "all"); // get mnemonics of installed engines
11205     if(first.pr == NoProc) {
11206       if(!SetPlayer(whitePlayer, appData.participants)) OK = 0; // find white player amongst it, and parse its engine line
11207       InitEngine(&first, 0);  // initialize ChessProgramStates based on new settings.
11208     }
11209     if(second.pr == NoProc) {
11210       SwapEngines(1);
11211       if(!SetPlayer(blackPlayer, appData.participants)) OK = 0; // find black player amongst it, and parse its engine line
11212       SwapEngines(1);         // and make that valid for second engine by swapping
11213       InitEngine(&second, 1);
11214     }
11215     CommonEngineInit();     // after this TwoMachinesEvent will create correct engine processes
11216     UpdateLogos(FALSE);     // leave display to ModeHiglight()
11217     return OK;
11218 }
11219
11220 void
11221 NextMatchGame ()
11222 {   // performs game initialization that does not invoke engines, and then tries to start the game
11223     int res, firstWhite, swapColors = 0;
11224     if(!NextTourneyGame(nextGame, &swapColors)) return; // this sets matchGame, -fcp / -scp and other options for next game, if needed
11225     if(matchMode && appData.debugMode) { // [HGM] debug split: game is part of a match; we might have to create a debug file just for this game
11226         char buf[MSG_SIZ];
11227         snprintf(buf, MSG_SIZ, appData.nameOfDebugFile, nextGame+1); // expand name of debug file with %d in it
11228         if(strcmp(buf, currentDebugFile)) { // name has changed
11229             FILE *f = fopen(buf, "w");
11230             if(f) { // if opening the new file failed, just keep using the old one
11231                 ASSIGN(currentDebugFile, buf);
11232                 fclose(debugFP);
11233                 debugFP = f;
11234             }
11235             if(appData.serverFileName) {
11236                 if(serverFP) fclose(serverFP);
11237                 serverFP = fopen(appData.serverFileName, "w");
11238                 if(serverFP && first.pr != NoProc) fprintf(serverFP, "StartChildProcess (dir=\".\") .\\%s\n", first.tidy);
11239                 if(serverFP && second.pr != NoProc) fprintf(serverFP, "StartChildProcess (dir=\".\") .\\%s\n", second.tidy);
11240             }
11241         }
11242     }
11243     firstWhite = appData.firstPlaysBlack ^ (matchGame & 1 | appData.sameColorGames > 1); // non-incremental default
11244     firstWhite ^= swapColors; // reverses if NextTourneyGame says we are in an odd round
11245     first.twoMachinesColor =  firstWhite ? "white\n" : "black\n";   // perform actual color assignement
11246     second.twoMachinesColor = firstWhite ? "black\n" : "white\n";
11247     appData.noChessProgram = (first.pr == NoProc); // kludge to prevent Reset from starting up chess program
11248     if(appData.loadGameIndex == -2) srandom(appData.seedBase + 68163*(nextGame & ~1)); // deterministic seed to force same opening
11249     Reset(FALSE, first.pr != NoProc);
11250     res = LoadGameOrPosition(matchGame); // setup game
11251     appData.noChessProgram = FALSE; // LoadGameOrPosition might call Reset too!
11252     if(!res) return; // abort when bad game/pos file
11253     TwoMachinesEvent();
11254 }
11255
11256 void
11257 UserAdjudicationEvent (int result)
11258 {
11259     ChessMove gameResult = GameIsDrawn;
11260
11261     if( result > 0 ) {
11262         gameResult = WhiteWins;
11263     }
11264     else if( result < 0 ) {
11265         gameResult = BlackWins;
11266     }
11267
11268     if( gameMode == TwoMachinesPlay ) {
11269         GameEnds( gameResult, "User adjudication", GE_XBOARD );
11270     }
11271 }
11272
11273
11274 // [HGM] save: calculate checksum of game to make games easily identifiable
11275 int
11276 StringCheckSum (char *s)
11277 {
11278         int i = 0;
11279         if(s==NULL) return 0;
11280         while(*s) i = i*259 + *s++;
11281         return i;
11282 }
11283
11284 int
11285 GameCheckSum ()
11286 {
11287         int i, sum=0;
11288         for(i=backwardMostMove; i<forwardMostMove; i++) {
11289                 sum += pvInfoList[i].depth;
11290                 sum += StringCheckSum(parseList[i]);
11291                 sum += StringCheckSum(commentList[i]);
11292                 sum *= 261;
11293         }
11294         if(i>1 && sum==0) sum++; // make sure never zero for non-empty game
11295         return sum + StringCheckSum(commentList[i]);
11296 } // end of save patch
11297
11298 void
11299 GameEnds (ChessMove result, char *resultDetails, int whosays)
11300 {
11301     GameMode nextGameMode;
11302     int isIcsGame;
11303     char buf[MSG_SIZ], popupRequested = 0, *ranking = NULL;
11304
11305     if(endingGame) return; /* [HGM] crash: forbid recursion */
11306     endingGame = 1;
11307     if(twoBoards) { // [HGM] dual: switch back to one board
11308         twoBoards = partnerUp = 0; InitDrawingSizes(-2, 0);
11309         DrawPosition(TRUE, partnerBoard); // observed game becomes foreground
11310     }
11311     if (appData.debugMode) {
11312       fprintf(debugFP, "GameEnds(%d, %s, %d)\n",
11313               result, resultDetails ? resultDetails : "(null)", whosays);
11314     }
11315
11316     fromX = fromY = killX = killY = -1; // [HGM] abort any move the user is entering. // [HGM] lion
11317
11318     if(pausing) PauseEvent(); // can happen when we abort a paused game (New Game or Quit)
11319
11320     if (appData.icsActive && (whosays == GE_ENGINE || whosays >= GE_ENGINE1)) {
11321         /* If we are playing on ICS, the server decides when the
11322            game is over, but the engine can offer to draw, claim
11323            a draw, or resign.
11324          */
11325 #if ZIPPY
11326         if (appData.zippyPlay && first.initDone) {
11327             if (result == GameIsDrawn) {
11328                 /* In case draw still needs to be claimed */
11329                 SendToICS(ics_prefix);
11330                 SendToICS("draw\n");
11331             } else if (StrCaseStr(resultDetails, "resign")) {
11332                 SendToICS(ics_prefix);
11333                 SendToICS("resign\n");
11334             }
11335         }
11336 #endif
11337         endingGame = 0; /* [HGM] crash */
11338         return;
11339     }
11340
11341     /* If we're loading the game from a file, stop */
11342     if (whosays == GE_FILE) {
11343       (void) StopLoadGameTimer();
11344       gameFileFP = NULL;
11345     }
11346
11347     /* Cancel draw offers */
11348     first.offeredDraw = second.offeredDraw = 0;
11349
11350     /* If this is an ICS game, only ICS can really say it's done;
11351        if not, anyone can. */
11352     isIcsGame = (gameMode == IcsPlayingWhite ||
11353                  gameMode == IcsPlayingBlack ||
11354                  gameMode == IcsObserving    ||
11355                  gameMode == IcsExamining);
11356
11357     if (!isIcsGame || whosays == GE_ICS) {
11358         /* OK -- not an ICS game, or ICS said it was done */
11359         StopClocks();
11360         if (!isIcsGame && !appData.noChessProgram)
11361           SetUserThinkingEnables();
11362
11363         /* [HGM] if a machine claims the game end we verify this claim */
11364         if(gameMode == TwoMachinesPlay && appData.testClaims) {
11365             if(appData.testLegality && whosays >= GE_ENGINE1 ) {
11366                 char claimer;
11367                 ChessMove trueResult = (ChessMove) -1;
11368
11369                 claimer = whosays == GE_ENGINE1 ?      /* color of claimer */
11370                                             first.twoMachinesColor[0] :
11371                                             second.twoMachinesColor[0] ;
11372
11373                 // [HGM] losers: because the logic is becoming a bit hairy, determine true result first
11374                 if((signed char)boards[forwardMostMove][EP_STATUS] == EP_CHECKMATE) {
11375                     /* [HGM] verify: engine mate claims accepted if they were flagged */
11376                     trueResult = WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins;
11377                 } else
11378                 if((signed char)boards[forwardMostMove][EP_STATUS] == EP_WINS) { // added code for games where being mated is a win
11379                     /* [HGM] verify: engine mate claims accepted if they were flagged */
11380                     trueResult = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
11381                 } else
11382                 if((signed char)boards[forwardMostMove][EP_STATUS] == EP_STALEMATE) { // only used to indicate draws now
11383                     trueResult = GameIsDrawn; // default; in variants where stalemate loses, Status is CHECKMATE
11384                 }
11385
11386                 // now verify win claims, but not in drop games, as we don't understand those yet
11387                 if( (gameInfo.holdingsWidth == 0 || gameInfo.variant == VariantSuper
11388                                                  || gameInfo.variant == VariantGreat || gameInfo.variant == VariantGrand) &&
11389                     (result == WhiteWins && claimer == 'w' ||
11390                      result == BlackWins && claimer == 'b'   ) ) { // case to verify: engine claims own win
11391                       if (appData.debugMode) {
11392                         fprintf(debugFP, "result=%d sp=%d move=%d\n",
11393                                 result, (signed char)boards[forwardMostMove][EP_STATUS], forwardMostMove);
11394                       }
11395                       if(result != trueResult) {
11396                         snprintf(buf, MSG_SIZ, "False win claim: '%s'", resultDetails);
11397                               result = claimer == 'w' ? BlackWins : WhiteWins;
11398                               resultDetails = buf;
11399                       }
11400                 } else
11401                 if( result == GameIsDrawn && (signed char)boards[forwardMostMove][EP_STATUS] > EP_DRAWS
11402                     && (forwardMostMove <= backwardMostMove ||
11403                         (signed char)boards[forwardMostMove-1][EP_STATUS] > EP_DRAWS ||
11404                         (claimer=='b')==(forwardMostMove&1))
11405                                                                                   ) {
11406                       /* [HGM] verify: draws that were not flagged are false claims */
11407                   snprintf(buf, MSG_SIZ, "False draw claim: '%s'", resultDetails);
11408                       result = claimer == 'w' ? BlackWins : WhiteWins;
11409                       resultDetails = buf;
11410                 }
11411                 /* (Claiming a loss is accepted no questions asked!) */
11412             } else if(matchMode && result == GameIsDrawn && !strcmp(resultDetails, "Engine Abort Request")) {
11413                 forwardMostMove = backwardMostMove; // [HGM] delete game to surpress saving
11414                 result = GameUnfinished;
11415                 if(!*appData.tourneyFile) matchGame--; // replay even in plain match
11416             }
11417             /* [HGM] bare: don't allow bare King to win */
11418             if((gameInfo.holdingsWidth == 0 || gameInfo.variant == VariantSuper
11419                                             || gameInfo.variant == VariantGreat || gameInfo.variant == VariantGrand)
11420                && gameInfo.variant != VariantLosers && gameInfo.variant != VariantGiveaway
11421                && gameInfo.variant != VariantSuicide // [HGM] losers: except in losers, of course...
11422                && result != GameIsDrawn)
11423             {   int i, j, k=0, oppoKings = 0, color = (result==WhiteWins ? (int)WhitePawn : (int)BlackPawn);
11424                 for(j=BOARD_LEFT; j<BOARD_RGHT; j++) for(i=0; i<BOARD_HEIGHT; i++) {
11425                         int p = (signed char)boards[forwardMostMove][i][j] - color;
11426                         if(p >= 0 && p <= (int)WhiteKing) k++;
11427                         oppoKings += (p + color == WhiteKing + BlackPawn - color);
11428                 }
11429                 if (appData.debugMode) {
11430                      fprintf(debugFP, "GE(%d, %s, %d) bare king k=%d color=%d\n",
11431                         result, resultDetails ? resultDetails : "(null)", whosays, k, color);
11432                 }
11433                 if(k <= 1 && oppoKings > 0) { // the latter needed in Atomic, where bare K wins if opponent King already destroyed
11434                         result = GameIsDrawn;
11435                         snprintf(buf, MSG_SIZ, "%s but bare king", resultDetails);
11436                         resultDetails = buf;
11437                 }
11438             }
11439         }
11440
11441
11442         if(serverMoves != NULL && !loadFlag) { char c = '=';
11443             if(result==WhiteWins) c = '+';
11444             if(result==BlackWins) c = '-';
11445             if(resultDetails != NULL)
11446                 fprintf(serverMoves, ";%c;%s\n", c, resultDetails), fflush(serverMoves);
11447         }
11448         if (resultDetails != NULL) {
11449             gameInfo.result = result;
11450             gameInfo.resultDetails = StrSave(resultDetails);
11451
11452             /* display last move only if game was not loaded from file */
11453             if ((whosays != GE_FILE) && (currentMove == forwardMostMove))
11454                 DisplayMove(currentMove - 1);
11455
11456             if (forwardMostMove != 0) {
11457                 if (gameMode != PlayFromGameFile && gameMode != EditGame
11458                     && lastSavedGame != GameCheckSum() // [HGM] save: suppress duplicates
11459                                                                 ) {
11460                     if (*appData.saveGameFile != NULLCHAR) {
11461                         if(result == GameUnfinished && matchMode && *appData.tourneyFile)
11462                             AutoSaveGame(); // [HGM] protect tourney PGN from aborted games, and prompt for name instead
11463                         else
11464                         SaveGameToFile(appData.saveGameFile, TRUE);
11465                     } else if (appData.autoSaveGames) {
11466                         if(gameMode != IcsObserving || !appData.onlyOwn) AutoSaveGame();
11467                     }
11468                     if (*appData.savePositionFile != NULLCHAR) {
11469                         SavePositionToFile(appData.savePositionFile);
11470                     }
11471                     AddGameToBook(FALSE); // Only does something during Monte-Carlo book building
11472                 }
11473             }
11474
11475             /* Tell program how game ended in case it is learning */
11476             /* [HGM] Moved this to after saving the PGN, just in case */
11477             /* engine died and we got here through time loss. In that */
11478             /* case we will get a fatal error writing the pipe, which */
11479             /* would otherwise lose us the PGN.                       */
11480             /* [HGM] crash: not needed anymore, but doesn't hurt;     */
11481             /* output during GameEnds should never be fatal anymore   */
11482             if (gameMode == MachinePlaysWhite ||
11483                 gameMode == MachinePlaysBlack ||
11484                 gameMode == TwoMachinesPlay ||
11485                 gameMode == IcsPlayingWhite ||
11486                 gameMode == IcsPlayingBlack ||
11487                 gameMode == BeginningOfGame) {
11488                 char buf[MSG_SIZ];
11489                 snprintf(buf, MSG_SIZ, "result %s {%s}\n", PGNResult(result),
11490                         resultDetails);
11491                 if (first.pr != NoProc) {
11492                     SendToProgram(buf, &first);
11493                 }
11494                 if (second.pr != NoProc &&
11495                     gameMode == TwoMachinesPlay) {
11496                     SendToProgram(buf, &second);
11497                 }
11498             }
11499         }
11500
11501         if (appData.icsActive) {
11502             if (appData.quietPlay &&
11503                 (gameMode == IcsPlayingWhite ||
11504                  gameMode == IcsPlayingBlack)) {
11505                 SendToICS(ics_prefix);
11506                 SendToICS("set shout 1\n");
11507             }
11508             nextGameMode = IcsIdle;
11509             ics_user_moved = FALSE;
11510             /* clean up premove.  It's ugly when the game has ended and the
11511              * premove highlights are still on the board.
11512              */
11513             if (gotPremove) {
11514               gotPremove = FALSE;
11515               ClearPremoveHighlights();
11516               DrawPosition(FALSE, boards[currentMove]);
11517             }
11518             if (whosays == GE_ICS) {
11519                 switch (result) {
11520                 case WhiteWins:
11521                     if (gameMode == IcsPlayingWhite)
11522                         PlayIcsWinSound();
11523                     else if(gameMode == IcsPlayingBlack)
11524                         PlayIcsLossSound();
11525                     break;
11526                 case BlackWins:
11527                     if (gameMode == IcsPlayingBlack)
11528                         PlayIcsWinSound();
11529                     else if(gameMode == IcsPlayingWhite)
11530                         PlayIcsLossSound();
11531                     break;
11532                 case GameIsDrawn:
11533                     PlayIcsDrawSound();
11534                     break;
11535                 default:
11536                     PlayIcsUnfinishedSound();
11537                 }
11538             }
11539             if(appData.quitNext) { ExitEvent(0); return; }
11540         } else if (gameMode == EditGame ||
11541                    gameMode == PlayFromGameFile ||
11542                    gameMode == AnalyzeMode ||
11543                    gameMode == AnalyzeFile) {
11544             nextGameMode = gameMode;
11545         } else {
11546             nextGameMode = EndOfGame;
11547         }
11548         pausing = FALSE;
11549         ModeHighlight();
11550     } else {
11551         nextGameMode = gameMode;
11552     }
11553
11554     if (appData.noChessProgram) {
11555         gameMode = nextGameMode;
11556         ModeHighlight();
11557         endingGame = 0; /* [HGM] crash */
11558         return;
11559     }
11560
11561     if (first.reuse) {
11562         /* Put first chess program into idle state */
11563         if (first.pr != NoProc &&
11564             (gameMode == MachinePlaysWhite ||
11565              gameMode == MachinePlaysBlack ||
11566              gameMode == TwoMachinesPlay ||
11567              gameMode == IcsPlayingWhite ||
11568              gameMode == IcsPlayingBlack ||
11569              gameMode == BeginningOfGame)) {
11570             SendToProgram("force\n", &first);
11571             if (first.usePing) {
11572               char buf[MSG_SIZ];
11573               snprintf(buf, MSG_SIZ, "ping %d\n", ++first.lastPing);
11574               SendToProgram(buf, &first);
11575             }
11576         }
11577     } else if (result != GameUnfinished || nextGameMode == IcsIdle) {
11578         /* Kill off first chess program */
11579         if (first.isr != NULL)
11580           RemoveInputSource(first.isr);
11581         first.isr = NULL;
11582
11583         if (first.pr != NoProc) {
11584             ExitAnalyzeMode();
11585             DoSleep( appData.delayBeforeQuit );
11586             SendToProgram("quit\n", &first);
11587             DestroyChildProcess(first.pr, 4 + first.useSigterm);
11588             first.reload = TRUE;
11589         }
11590         first.pr = NoProc;
11591     }
11592     if (second.reuse) {
11593         /* Put second chess program into idle state */
11594         if (second.pr != NoProc &&
11595             gameMode == TwoMachinesPlay) {
11596             SendToProgram("force\n", &second);
11597             if (second.usePing) {
11598               char buf[MSG_SIZ];
11599               snprintf(buf, MSG_SIZ, "ping %d\n", ++second.lastPing);
11600               SendToProgram(buf, &second);
11601             }
11602         }
11603     } else if (result != GameUnfinished || nextGameMode == IcsIdle) {
11604         /* Kill off second chess program */
11605         if (second.isr != NULL)
11606           RemoveInputSource(second.isr);
11607         second.isr = NULL;
11608
11609         if (second.pr != NoProc) {
11610             DoSleep( appData.delayBeforeQuit );
11611             SendToProgram("quit\n", &second);
11612             DestroyChildProcess(second.pr, 4 + second.useSigterm);
11613             second.reload = TRUE;
11614         }
11615         second.pr = NoProc;
11616     }
11617
11618     if (matchMode && (gameMode == TwoMachinesPlay || (waitingForGame || startingEngine) && exiting)) {
11619         char resChar = '=';
11620         switch (result) {
11621         case WhiteWins:
11622           resChar = '+';
11623           if (first.twoMachinesColor[0] == 'w') {
11624             first.matchWins++;
11625           } else {
11626             second.matchWins++;
11627           }
11628           break;
11629         case BlackWins:
11630           resChar = '-';
11631           if (first.twoMachinesColor[0] == 'b') {
11632             first.matchWins++;
11633           } else {
11634             second.matchWins++;
11635           }
11636           break;
11637         case GameUnfinished:
11638           resChar = ' ';
11639         default:
11640           break;
11641         }
11642
11643         if(exiting) resChar = ' '; // quit while waiting for round sync: unreserve already reserved game
11644         if(appData.tourneyFile[0]){ // [HGM] we are in a tourney; update tourney file with game result
11645             if(appData.afterGame && appData.afterGame[0]) RunCommand(appData.afterGame);
11646             ReserveGame(nextGame, resChar); // sets nextGame
11647             if(nextGame > appData.matchGames) appData.tourneyFile[0] = 0, ranking = TourneyStandings(3); // tourney is done
11648             else ranking = strdup("busy"); //suppress popup when aborted but not finished
11649         } else roundNr = nextGame = matchGame + 1; // normal match, just increment; round equals matchGame
11650
11651         if (nextGame <= appData.matchGames && !abortMatch) {
11652             gameMode = nextGameMode;
11653             matchGame = nextGame; // this will be overruled in tourney mode!
11654             GetTimeMark(&pauseStart); // [HGM] matchpause: stipulate a pause
11655             ScheduleDelayedEvent(NextMatchGame, 10); // but start game immediately (as it will wait out the pause itself)
11656             endingGame = 0; /* [HGM] crash */
11657             return;
11658         } else {
11659             gameMode = nextGameMode;
11660             snprintf(buf, MSG_SIZ, _("Match %s vs. %s: final score %d-%d-%d"),
11661                      first.tidy, second.tidy,
11662                      first.matchWins, second.matchWins,
11663                      appData.matchGames - (first.matchWins + second.matchWins));
11664             if(!appData.tourneyFile[0]) matchGame++, DisplayTwoMachinesTitle(); // [HGM] update result in window title
11665             if(ranking && strcmp(ranking, "busy") && appData.afterTourney && appData.afterTourney[0]) RunCommand(appData.afterTourney);
11666             popupRequested++; // [HGM] crash: postpone to after resetting endingGame
11667             if (appData.firstPlaysBlack) { // [HGM] match: back to original for next match
11668                 first.twoMachinesColor = "black\n";
11669                 second.twoMachinesColor = "white\n";
11670             } else {
11671                 first.twoMachinesColor = "white\n";
11672                 second.twoMachinesColor = "black\n";
11673             }
11674         }
11675     }
11676     if ((gameMode == AnalyzeMode || gameMode == AnalyzeFile) &&
11677         !(nextGameMode == AnalyzeMode || nextGameMode == AnalyzeFile))
11678       ExitAnalyzeMode();
11679     gameMode = nextGameMode;
11680     ModeHighlight();
11681     endingGame = 0;  /* [HGM] crash */
11682     if(popupRequested) { // [HGM] crash: this calls GameEnds recursively through ExitEvent! Make it a harmless tail recursion.
11683         if(matchMode == TRUE) { // match through command line: exit with or without popup
11684             if(ranking) {
11685                 ToNrEvent(forwardMostMove);
11686                 if(strcmp(ranking, "busy")) DisplayFatalError(ranking, 0, 0);
11687                 else ExitEvent(0);
11688             } else DisplayFatalError(buf, 0, 0);
11689         } else { // match through menu; just stop, with or without popup
11690             matchMode = FALSE; appData.matchGames = matchGame = roundNr = 0;
11691             ModeHighlight();
11692             if(ranking){
11693                 if(strcmp(ranking, "busy")) DisplayNote(ranking);
11694             } else DisplayNote(buf);
11695       }
11696       if(ranking) free(ranking);
11697     }
11698 }
11699
11700 /* Assumes program was just initialized (initString sent).
11701    Leaves program in force mode. */
11702 void
11703 FeedMovesToProgram (ChessProgramState *cps, int upto)
11704 {
11705     int i;
11706
11707     if (appData.debugMode)
11708       fprintf(debugFP, "Feeding %smoves %d through %d to %s chess program\n",
11709               startedFromSetupPosition ? "position and " : "",
11710               backwardMostMove, upto, cps->which);
11711     if(currentlyInitializedVariant != gameInfo.variant) {
11712       char buf[MSG_SIZ];
11713         // [HGM] variantswitch: make engine aware of new variant
11714         if(!SupportedVariant(cps->variants, gameInfo.variant, gameInfo.boardWidth,
11715                              gameInfo.boardHeight, gameInfo.holdingsSize, cps->protocolVersion, ""))
11716                 return; // [HGM] refrain from feeding moves altogether if variant is unsupported!
11717         snprintf(buf, MSG_SIZ, "variant %s\n", VariantName(gameInfo.variant));
11718         SendToProgram(buf, cps);
11719         currentlyInitializedVariant = gameInfo.variant;
11720     }
11721     SendToProgram("force\n", cps);
11722     if (startedFromSetupPosition) {
11723         SendBoard(cps, backwardMostMove);
11724     if (appData.debugMode) {
11725         fprintf(debugFP, "feedMoves\n");
11726     }
11727     }
11728     for (i = backwardMostMove; i < upto; i++) {
11729         SendMoveToProgram(i, cps);
11730     }
11731 }
11732
11733
11734 int
11735 ResurrectChessProgram ()
11736 {
11737      /* The chess program may have exited.
11738         If so, restart it and feed it all the moves made so far. */
11739     static int doInit = 0;
11740
11741     if (appData.noChessProgram) return 1;
11742
11743     if(matchMode /*&& appData.tourneyFile[0]*/) { // [HGM] tourney: make sure we get features after engine replacement. (Should we always do this?)
11744         if(WaitForEngine(&first, TwoMachinesEventIfReady)) { doInit = 1; return 0; } // request to do init on next visit, because we started engine
11745         if(!doInit) return 1; // this replaces testing first.pr != NoProc, which is true when we get here, but first time no reason to abort
11746         doInit = 0; // we fell through (first time after starting the engine); make sure it doesn't happen again
11747     } else {
11748         if (first.pr != NoProc) return 1;
11749         StartChessProgram(&first);
11750     }
11751     InitChessProgram(&first, FALSE);
11752     FeedMovesToProgram(&first, currentMove);
11753
11754     if (!first.sendTime) {
11755         /* can't tell gnuchess what its clock should read,
11756            so we bow to its notion. */
11757         ResetClocks();
11758         timeRemaining[0][currentMove] = whiteTimeRemaining;
11759         timeRemaining[1][currentMove] = blackTimeRemaining;
11760     }
11761
11762     if ((gameMode == AnalyzeMode || gameMode == AnalyzeFile ||
11763                 appData.icsEngineAnalyze) && first.analysisSupport) {
11764       SendToProgram("analyze\n", &first);
11765       first.analyzing = TRUE;
11766     }
11767     return 1;
11768 }
11769
11770 /*
11771  * Button procedures
11772  */
11773 void
11774 Reset (int redraw, int init)
11775 {
11776     int i;
11777
11778     if (appData.debugMode) {
11779         fprintf(debugFP, "Reset(%d, %d) from gameMode %d\n",
11780                 redraw, init, gameMode);
11781     }
11782     pieceDefs = FALSE; // [HGM] gen: reset engine-defined piece moves
11783     for(i=0; i<EmptySquare; i++) { FREE(pieceDesc[i]); pieceDesc[i] = NULL; }
11784     CleanupTail(); // [HGM] vari: delete any stored variations
11785     CommentPopDown(); // [HGM] make sure no comments to the previous game keep hanging on
11786     pausing = pauseExamInvalid = FALSE;
11787     startedFromSetupPosition = blackPlaysFirst = FALSE;
11788     firstMove = TRUE;
11789     whiteFlag = blackFlag = FALSE;
11790     userOfferedDraw = FALSE;
11791     hintRequested = bookRequested = FALSE;
11792     first.maybeThinking = FALSE;
11793     second.maybeThinking = FALSE;
11794     first.bookSuspend = FALSE; // [HGM] book
11795     second.bookSuspend = FALSE;
11796     thinkOutput[0] = NULLCHAR;
11797     lastHint[0] = NULLCHAR;
11798     ClearGameInfo(&gameInfo);
11799     gameInfo.variant = StringToVariant(appData.variant);
11800     if(gameInfo.variant == VariantNormal && strcmp(appData.variant, "normal")) gameInfo.variant = VariantUnknown;
11801     ics_user_moved = ics_clock_paused = FALSE;
11802     ics_getting_history = H_FALSE;
11803     ics_gamenum = -1;
11804     white_holding[0] = black_holding[0] = NULLCHAR;
11805     ClearProgramStats();
11806     opponentKibitzes = FALSE; // [HGM] kibitz: do not reserve space in engine-output window in zippy mode
11807
11808     ResetFrontEnd();
11809     ClearHighlights();
11810     flipView = appData.flipView;
11811     ClearPremoveHighlights();
11812     gotPremove = FALSE;
11813     alarmSounded = FALSE;
11814     killX = killY = -1; // [HGM] lion
11815
11816     GameEnds(EndOfFile, NULL, GE_PLAYER);
11817     if(appData.serverMovesName != NULL) {
11818         /* [HGM] prepare to make moves file for broadcasting */
11819         clock_t t = clock();
11820         if(serverMoves != NULL) fclose(serverMoves);
11821         serverMoves = fopen(appData.serverMovesName, "r");
11822         if(serverMoves != NULL) {
11823             fclose(serverMoves);
11824             /* delay 15 sec before overwriting, so all clients can see end */
11825             while(clock()-t < appData.serverPause*CLOCKS_PER_SEC);
11826         }
11827         serverMoves = fopen(appData.serverMovesName, "w");
11828     }
11829
11830     ExitAnalyzeMode();
11831     gameMode = BeginningOfGame;
11832     ModeHighlight();
11833     if(appData.icsActive) gameInfo.variant = VariantNormal;
11834     currentMove = forwardMostMove = backwardMostMove = 0;
11835     MarkTargetSquares(1);
11836     InitPosition(redraw);
11837     for (i = 0; i < MAX_MOVES; i++) {
11838         if (commentList[i] != NULL) {
11839             free(commentList[i]);
11840             commentList[i] = NULL;
11841         }
11842     }
11843     ResetClocks();
11844     timeRemaining[0][0] = whiteTimeRemaining;
11845     timeRemaining[1][0] = blackTimeRemaining;
11846
11847     if (first.pr == NoProc) {
11848         StartChessProgram(&first);
11849     }
11850     if (init) {
11851             InitChessProgram(&first, startedFromSetupPosition);
11852     }
11853     DisplayTitle("");
11854     DisplayMessage("", "");
11855     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
11856     lastSavedGame = 0; // [HGM] save: make sure next game counts as unsaved
11857     ClearMap();        // [HGM] exclude: invalidate map
11858 }
11859
11860 void
11861 AutoPlayGameLoop ()
11862 {
11863     for (;;) {
11864         if (!AutoPlayOneMove())
11865           return;
11866         if (matchMode || appData.timeDelay == 0)
11867           continue;
11868         if (appData.timeDelay < 0)
11869           return;
11870         StartLoadGameTimer((long)(1000.0f * appData.timeDelay));
11871         break;
11872     }
11873 }
11874
11875 void
11876 AnalyzeNextGame()
11877 {
11878     ReloadGame(1); // next game
11879 }
11880
11881 int
11882 AutoPlayOneMove ()
11883 {
11884     int fromX, fromY, toX, toY;
11885
11886     if (appData.debugMode) {
11887       fprintf(debugFP, "AutoPlayOneMove(): current %d\n", currentMove);
11888     }
11889
11890     if (gameMode != PlayFromGameFile && gameMode != AnalyzeFile)
11891       return FALSE;
11892
11893     if (gameMode == AnalyzeFile && currentMove > backwardMostMove && programStats.depth) {
11894       pvInfoList[currentMove].depth = programStats.depth;
11895       pvInfoList[currentMove].score = programStats.score;
11896       pvInfoList[currentMove].time  = 0;
11897       if(currentMove < forwardMostMove) AppendComment(currentMove+1, lastPV[0], 2);
11898       else { // append analysis of final position as comment
11899         char buf[MSG_SIZ];
11900         snprintf(buf, MSG_SIZ, "{final score %+4.2f/%d}", programStats.score/100., programStats.depth);
11901         AppendComment(currentMove, buf, 3); // the 3 prevents stripping of the score/depth!
11902       }
11903       programStats.depth = 0;
11904     }
11905
11906     if (currentMove >= forwardMostMove) {
11907       if(gameMode == AnalyzeFile) {
11908           if(appData.loadGameIndex == -1) {
11909             GameEnds(gameInfo.result, gameInfo.resultDetails ? gameInfo.resultDetails : "", GE_FILE);
11910           ScheduleDelayedEvent(AnalyzeNextGame, 10);
11911           } else {
11912           ExitAnalyzeMode(); SendToProgram("force\n", &first);
11913         }
11914       }
11915 //      gameMode = EndOfGame;
11916 //      ModeHighlight();
11917
11918       /* [AS] Clear current move marker at the end of a game */
11919       /* HistorySet(parseList, backwardMostMove, forwardMostMove, -1); */
11920
11921       return FALSE;
11922     }
11923
11924     toX = moveList[currentMove][2] - AAA;
11925     toY = moveList[currentMove][3] - ONE;
11926
11927     if (moveList[currentMove][1] == '@') {
11928         if (appData.highlightLastMove) {
11929             SetHighlights(-1, -1, toX, toY);
11930         }
11931     } else {
11932         int viaX = moveList[currentMove][5] - AAA;
11933         int viaY = moveList[currentMove][6] - ONE;
11934         fromX = moveList[currentMove][0] - AAA;
11935         fromY = moveList[currentMove][1] - ONE;
11936
11937         HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove); /* [AS] */
11938
11939         if(moveList[currentMove][4] == ';') { // multi-leg
11940             ChessSquare piece = boards[currentMove][viaY][viaX];
11941             AnimateMove(boards[currentMove], fromX, fromY, viaX, viaY);
11942             boards[currentMove][viaY][viaX] = boards[currentMove][fromY][fromX];
11943             AnimateMove(boards[currentMove], fromX=viaX, fromY=viaY, toX, toY);
11944             boards[currentMove][viaY][viaX] = piece;
11945         } else
11946         AnimateMove(boards[currentMove], fromX, fromY, toX, toY);
11947
11948         if (appData.highlightLastMove) {
11949             SetHighlights(fromX, fromY, toX, toY);
11950         }
11951     }
11952     DisplayMove(currentMove);
11953     SendMoveToProgram(currentMove++, &first);
11954     DisplayBothClocks();
11955     DrawPosition(FALSE, boards[currentMove]);
11956     // [HGM] PV info: always display, routine tests if empty
11957     DisplayComment(currentMove - 1, commentList[currentMove]);
11958     return TRUE;
11959 }
11960
11961
11962 int
11963 LoadGameOneMove (ChessMove readAhead)
11964 {
11965     int fromX = 0, fromY = 0, toX = 0, toY = 0, done;
11966     char promoChar = NULLCHAR;
11967     ChessMove moveType;
11968     char move[MSG_SIZ];
11969     char *p, *q;
11970
11971     if (gameMode != PlayFromGameFile && gameMode != AnalyzeFile &&
11972         gameMode != AnalyzeMode && gameMode != Training) {
11973         gameFileFP = NULL;
11974         return FALSE;
11975     }
11976
11977     yyboardindex = forwardMostMove;
11978     if (readAhead != EndOfFile) {
11979       moveType = readAhead;
11980     } else {
11981       if (gameFileFP == NULL)
11982           return FALSE;
11983       moveType = (ChessMove) Myylex();
11984     }
11985
11986     done = FALSE;
11987     switch (moveType) {
11988       case Comment:
11989         if (appData.debugMode)
11990           fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
11991         p = yy_text;
11992
11993         /* append the comment but don't display it */
11994         AppendComment(currentMove, p, FALSE);
11995         return TRUE;
11996
11997       case WhiteCapturesEnPassant:
11998       case BlackCapturesEnPassant:
11999       case WhitePromotion:
12000       case BlackPromotion:
12001       case WhiteNonPromotion:
12002       case BlackNonPromotion:
12003       case NormalMove:
12004       case FirstLeg:
12005       case WhiteKingSideCastle:
12006       case WhiteQueenSideCastle:
12007       case BlackKingSideCastle:
12008       case BlackQueenSideCastle:
12009       case WhiteKingSideCastleWild:
12010       case WhiteQueenSideCastleWild:
12011       case BlackKingSideCastleWild:
12012       case BlackQueenSideCastleWild:
12013       /* PUSH Fabien */
12014       case WhiteHSideCastleFR:
12015       case WhiteASideCastleFR:
12016       case BlackHSideCastleFR:
12017       case BlackASideCastleFR:
12018       /* POP Fabien */
12019         if (appData.debugMode)
12020           fprintf(debugFP, "Parsed %s into %s\n", yy_text, currentMoveString);
12021         fromX = currentMoveString[0] - AAA;
12022         fromY = currentMoveString[1] - ONE;
12023         toX = currentMoveString[2] - AAA;
12024         toY = currentMoveString[3] - ONE;
12025         promoChar = currentMoveString[4];
12026         if(promoChar == ';') promoChar = NULLCHAR;
12027         break;
12028
12029       case WhiteDrop:
12030       case BlackDrop:
12031         if (appData.debugMode)
12032           fprintf(debugFP, "Parsed %s into %s\n", yy_text, currentMoveString);
12033         fromX = moveType == WhiteDrop ?
12034           (int) CharToPiece(ToUpper(currentMoveString[0])) :
12035         (int) CharToPiece(ToLower(currentMoveString[0]));
12036         fromY = DROP_RANK;
12037         toX = currentMoveString[2] - AAA;
12038         toY = currentMoveString[3] - ONE;
12039         break;
12040
12041       case WhiteWins:
12042       case BlackWins:
12043       case GameIsDrawn:
12044       case GameUnfinished:
12045         if (appData.debugMode)
12046           fprintf(debugFP, "Parsed game end: %s\n", yy_text);
12047         p = strchr(yy_text, '{');
12048         if (p == NULL) p = strchr(yy_text, '(');
12049         if (p == NULL) {
12050             p = yy_text;
12051             if (p[0] == '0' || p[0] == '1' || p[0] == '*') p = "";
12052         } else {
12053             q = strchr(p, *p == '{' ? '}' : ')');
12054             if (q != NULL) *q = NULLCHAR;
12055             p++;
12056         }
12057         while(q = strchr(p, '\n')) *q = ' '; // [HGM] crush linefeeds in result message
12058         GameEnds(moveType, p, GE_FILE);
12059         done = TRUE;
12060         if (cmailMsgLoaded) {
12061             ClearHighlights();
12062             flipView = WhiteOnMove(currentMove);
12063             if (moveType == GameUnfinished) flipView = !flipView;
12064             if (appData.debugMode)
12065               fprintf(debugFP, "Setting flipView to %d\n", flipView) ;
12066         }
12067         break;
12068
12069       case EndOfFile:
12070         if (appData.debugMode)
12071           fprintf(debugFP, "Parser hit end of file\n");
12072         switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
12073           case MT_NONE:
12074           case MT_CHECK:
12075             break;
12076           case MT_CHECKMATE:
12077           case MT_STAINMATE:
12078             if (WhiteOnMove(currentMove)) {
12079                 GameEnds(BlackWins, "Black mates", GE_FILE);
12080             } else {
12081                 GameEnds(WhiteWins, "White mates", GE_FILE);
12082             }
12083             break;
12084           case MT_STALEMATE:
12085             GameEnds(GameIsDrawn, "Stalemate", GE_FILE);
12086             break;
12087         }
12088         done = TRUE;
12089         break;
12090
12091       case MoveNumberOne:
12092         if (lastLoadGameStart == GNUChessGame) {
12093             /* GNUChessGames have numbers, but they aren't move numbers */
12094             if (appData.debugMode)
12095               fprintf(debugFP, "Parser ignoring: '%s' (%d)\n",
12096                       yy_text, (int) moveType);
12097             return LoadGameOneMove(EndOfFile); /* tail recursion */
12098         }
12099         /* else fall thru */
12100
12101       case XBoardGame:
12102       case GNUChessGame:
12103       case PGNTag:
12104         /* Reached start of next game in file */
12105         if (appData.debugMode)
12106           fprintf(debugFP, "Parsed start of next game: %s\n", yy_text);
12107         switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
12108           case MT_NONE:
12109           case MT_CHECK:
12110             break;
12111           case MT_CHECKMATE:
12112           case MT_STAINMATE:
12113             if (WhiteOnMove(currentMove)) {
12114                 GameEnds(BlackWins, "Black mates", GE_FILE);
12115             } else {
12116                 GameEnds(WhiteWins, "White mates", GE_FILE);
12117             }
12118             break;
12119           case MT_STALEMATE:
12120             GameEnds(GameIsDrawn, "Stalemate", GE_FILE);
12121             break;
12122         }
12123         done = TRUE;
12124         break;
12125
12126       case PositionDiagram:     /* should not happen; ignore */
12127       case ElapsedTime:         /* ignore */
12128       case NAG:                 /* ignore */
12129         if (appData.debugMode)
12130           fprintf(debugFP, "Parser ignoring: '%s' (%d)\n",
12131                   yy_text, (int) moveType);
12132         return LoadGameOneMove(EndOfFile); /* tail recursion */
12133
12134       case IllegalMove:
12135         if (appData.testLegality) {
12136             if (appData.debugMode)
12137               fprintf(debugFP, "Parsed IllegalMove: %s\n", yy_text);
12138             snprintf(move, MSG_SIZ, _("Illegal move: %d.%s%s"),
12139                     (forwardMostMove / 2) + 1,
12140                     WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
12141             DisplayError(move, 0);
12142             done = TRUE;
12143         } else {
12144             if (appData.debugMode)
12145               fprintf(debugFP, "Parsed %s into IllegalMove %s\n",
12146                       yy_text, currentMoveString);
12147             if(currentMoveString[1] == '@') {
12148                 fromX = CharToPiece(WhiteOnMove(currentMove) ? ToUpper(currentMoveString[0]) : ToLower(currentMoveString[0]));
12149                 fromY = DROP_RANK;
12150             } else {
12151                 fromX = currentMoveString[0] - AAA;
12152                 fromY = currentMoveString[1] - ONE;
12153             }
12154             toX = currentMoveString[2] - AAA;
12155             toY = currentMoveString[3] - ONE;
12156             promoChar = currentMoveString[4];
12157         }
12158         break;
12159
12160       case AmbiguousMove:
12161         if (appData.debugMode)
12162           fprintf(debugFP, "Parsed AmbiguousMove: %s\n", yy_text);
12163         snprintf(move, MSG_SIZ, _("Ambiguous move: %d.%s%s"),
12164                 (forwardMostMove / 2) + 1,
12165                 WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
12166         DisplayError(move, 0);
12167         done = TRUE;
12168         break;
12169
12170       default:
12171       case ImpossibleMove:
12172         if (appData.debugMode)
12173           fprintf(debugFP, "Parsed ImpossibleMove (type = %d): %s\n", moveType, yy_text);
12174         snprintf(move, MSG_SIZ, _("Illegal move: %d.%s%s"),
12175                 (forwardMostMove / 2) + 1,
12176                 WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
12177         DisplayError(move, 0);
12178         done = TRUE;
12179         break;
12180     }
12181
12182     if (done) {
12183         if (appData.matchMode || (appData.timeDelay == 0 && !pausing)) {
12184             DrawPosition(FALSE, boards[currentMove]);
12185             DisplayBothClocks();
12186             if (!appData.matchMode) // [HGM] PV info: routine tests if empty
12187               DisplayComment(currentMove - 1, commentList[currentMove]);
12188         }
12189         (void) StopLoadGameTimer();
12190         gameFileFP = NULL;
12191         cmailOldMove = forwardMostMove;
12192         return FALSE;
12193     } else {
12194         /* currentMoveString is set as a side-effect of yylex */
12195
12196         thinkOutput[0] = NULLCHAR;
12197         MakeMove(fromX, fromY, toX, toY, promoChar);
12198         killX = killY = -1; // [HGM] lion: used up
12199         currentMove = forwardMostMove;
12200         return TRUE;
12201     }
12202 }
12203
12204 /* Load the nth game from the given file */
12205 int
12206 LoadGameFromFile (char *filename, int n, char *title, int useList)
12207 {
12208     FILE *f;
12209     char buf[MSG_SIZ];
12210
12211     if (strcmp(filename, "-") == 0) {
12212         f = stdin;
12213         title = "stdin";
12214     } else {
12215         f = fopen(filename, "rb");
12216         if (f == NULL) {
12217           snprintf(buf, sizeof(buf),  _("Can't open \"%s\""), filename);
12218             DisplayError(buf, errno);
12219             return FALSE;
12220         }
12221     }
12222     if (fseek(f, 0, 0) == -1) {
12223         /* f is not seekable; probably a pipe */
12224         useList = FALSE;
12225     }
12226     if (useList && n == 0) {
12227         int error = GameListBuild(f);
12228         if (error) {
12229             DisplayError(_("Cannot build game list"), error);
12230         } else if (!ListEmpty(&gameList) &&
12231                    ((ListGame *) gameList.tailPred)->number > 1) {
12232             GameListPopUp(f, title);
12233             return TRUE;
12234         }
12235         GameListDestroy();
12236         n = 1;
12237     }
12238     if (n == 0) n = 1;
12239     return LoadGame(f, n, title, FALSE);
12240 }
12241
12242
12243 void
12244 MakeRegisteredMove ()
12245 {
12246     int fromX, fromY, toX, toY;
12247     char promoChar;
12248     if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
12249         switch (cmailMoveType[lastLoadGameNumber - 1]) {
12250           case CMAIL_MOVE:
12251           case CMAIL_DRAW:
12252             if (appData.debugMode)
12253               fprintf(debugFP, "Restoring %s for game %d\n",
12254                       cmailMove[lastLoadGameNumber - 1], lastLoadGameNumber);
12255
12256             thinkOutput[0] = NULLCHAR;
12257             safeStrCpy(moveList[currentMove], cmailMove[lastLoadGameNumber - 1], sizeof(moveList[currentMove])/sizeof(moveList[currentMove][0]));
12258             fromX = cmailMove[lastLoadGameNumber - 1][0] - AAA;
12259             fromY = cmailMove[lastLoadGameNumber - 1][1] - ONE;
12260             toX = cmailMove[lastLoadGameNumber - 1][2] - AAA;
12261             toY = cmailMove[lastLoadGameNumber - 1][3] - ONE;
12262             promoChar = cmailMove[lastLoadGameNumber - 1][4];
12263             MakeMove(fromX, fromY, toX, toY, promoChar);
12264             ShowMove(fromX, fromY, toX, toY);
12265
12266             switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
12267               case MT_NONE:
12268               case MT_CHECK:
12269                 break;
12270
12271               case MT_CHECKMATE:
12272               case MT_STAINMATE:
12273                 if (WhiteOnMove(currentMove)) {
12274                     GameEnds(BlackWins, "Black mates", GE_PLAYER);
12275                 } else {
12276                     GameEnds(WhiteWins, "White mates", GE_PLAYER);
12277                 }
12278                 break;
12279
12280               case MT_STALEMATE:
12281                 GameEnds(GameIsDrawn, "Stalemate", GE_PLAYER);
12282                 break;
12283             }
12284
12285             break;
12286
12287           case CMAIL_RESIGN:
12288             if (WhiteOnMove(currentMove)) {
12289                 GameEnds(BlackWins, "White resigns", GE_PLAYER);
12290             } else {
12291                 GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
12292             }
12293             break;
12294
12295           case CMAIL_ACCEPT:
12296             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
12297             break;
12298
12299           default:
12300             break;
12301         }
12302     }
12303
12304     return;
12305 }
12306
12307 /* Wrapper around LoadGame for use when a Cmail message is loaded */
12308 int
12309 CmailLoadGame (FILE *f, int gameNumber, char *title, int useList)
12310 {
12311     int retVal;
12312
12313     if (gameNumber > nCmailGames) {
12314         DisplayError(_("No more games in this message"), 0);
12315         return FALSE;
12316     }
12317     if (f == lastLoadGameFP) {
12318         int offset = gameNumber - lastLoadGameNumber;
12319         if (offset == 0) {
12320             cmailMsg[0] = NULLCHAR;
12321             if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
12322                 cmailMoveRegistered[lastLoadGameNumber - 1] = FALSE;
12323                 nCmailMovesRegistered--;
12324             }
12325             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
12326             if (cmailResult[lastLoadGameNumber - 1] == CMAIL_NEW_RESULT) {
12327                 cmailResult[lastLoadGameNumber - 1] = CMAIL_NOT_RESULT;
12328             }
12329         } else {
12330             if (! RegisterMove()) return FALSE;
12331         }
12332     }
12333
12334     retVal = LoadGame(f, gameNumber, title, useList);
12335
12336     /* Make move registered during previous look at this game, if any */
12337     MakeRegisteredMove();
12338
12339     if (cmailCommentList[lastLoadGameNumber - 1] != NULL) {
12340         commentList[currentMove]
12341           = StrSave(cmailCommentList[lastLoadGameNumber - 1]);
12342         DisplayComment(currentMove - 1, commentList[currentMove]);
12343     }
12344
12345     return retVal;
12346 }
12347
12348 /* Support for LoadNextGame, LoadPreviousGame, ReloadSameGame */
12349 int
12350 ReloadGame (int offset)
12351 {
12352     int gameNumber = lastLoadGameNumber + offset;
12353     if (lastLoadGameFP == NULL) {
12354         DisplayError(_("No game has been loaded yet"), 0);
12355         return FALSE;
12356     }
12357     if (gameNumber <= 0) {
12358         DisplayError(_("Can't back up any further"), 0);
12359         return FALSE;
12360     }
12361     if (cmailMsgLoaded) {
12362         return CmailLoadGame(lastLoadGameFP, gameNumber,
12363                              lastLoadGameTitle, lastLoadGameUseList);
12364     } else {
12365         return LoadGame(lastLoadGameFP, gameNumber,
12366                         lastLoadGameTitle, lastLoadGameUseList);
12367     }
12368 }
12369
12370 int keys[EmptySquare+1];
12371
12372 int
12373 PositionMatches (Board b1, Board b2)
12374 {
12375     int r, f, sum=0;
12376     switch(appData.searchMode) {
12377         case 1: return CompareWithRights(b1, b2);
12378         case 2:
12379             for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12380                 if(b2[r][f] != EmptySquare && b1[r][f] != b2[r][f]) return FALSE;
12381             }
12382             return TRUE;
12383         case 3:
12384             for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12385               if((b2[r][f] == WhitePawn || b2[r][f] == BlackPawn) && b1[r][f] != b2[r][f]) return FALSE;
12386                 sum += keys[b1[r][f]] - keys[b2[r][f]];
12387             }
12388             return sum==0;
12389         case 4:
12390             for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12391                 sum += keys[b1[r][f]] - keys[b2[r][f]];
12392             }
12393             return sum==0;
12394     }
12395     return TRUE;
12396 }
12397
12398 #define Q_PROMO  4
12399 #define Q_EP     3
12400 #define Q_BCASTL 2
12401 #define Q_WCASTL 1
12402
12403 int pieceList[256], quickBoard[256];
12404 ChessSquare pieceType[256] = { EmptySquare };
12405 Board soughtBoard, reverseBoard, flipBoard, rotateBoard;
12406 int counts[EmptySquare], minSought[EmptySquare], minReverse[EmptySquare], maxSought[EmptySquare], maxReverse[EmptySquare];
12407 int soughtTotal, turn;
12408 Boolean epOK, flipSearch;
12409
12410 typedef struct {
12411     unsigned char piece, to;
12412 } Move;
12413
12414 #define DSIZE (250000)
12415
12416 Move initialSpace[DSIZE+1000]; // gamble on that game will not be more than 500 moves
12417 Move *moveDatabase = initialSpace;
12418 unsigned int movePtr, dataSize = DSIZE;
12419
12420 int
12421 MakePieceList (Board board, int *counts)
12422 {
12423     int r, f, n=Q_PROMO, total=0;
12424     for(r=0;r<EmptySquare;r++) counts[r] = 0; // piece-type counts
12425     for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12426         int sq = f + (r<<4);
12427         if(board[r][f] == EmptySquare) quickBoard[sq] = 0; else {
12428             quickBoard[sq] = ++n;
12429             pieceList[n] = sq;
12430             pieceType[n] = board[r][f];
12431             counts[board[r][f]]++;
12432             if(board[r][f] == WhiteKing) pieceList[1] = n; else
12433             if(board[r][f] == BlackKing) pieceList[2] = n; // remember which are Kings, for castling
12434             total++;
12435         }
12436     }
12437     epOK = gameInfo.variant != VariantXiangqi && gameInfo.variant != VariantBerolina;
12438     return total;
12439 }
12440
12441 void
12442 PackMove (int fromX, int fromY, int toX, int toY, ChessSquare promoPiece)
12443 {
12444     int sq = fromX + (fromY<<4);
12445     int piece = quickBoard[sq], rook;
12446     quickBoard[sq] = 0;
12447     moveDatabase[movePtr].to = pieceList[piece] = sq = toX + (toY<<4);
12448     if(piece == pieceList[1] && fromY == toY) {
12449       if((toX > fromX+1 || toX < fromX-1) && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1) {
12450         int from = toX>fromX ? BOARD_RGHT-1 : BOARD_LEFT;
12451         moveDatabase[movePtr++].piece = Q_WCASTL;
12452         quickBoard[sq] = piece;
12453         piece = quickBoard[from]; quickBoard[from] = 0;
12454         moveDatabase[movePtr].to = pieceList[piece] = sq = toX>fromX ? sq-1 : sq+1;
12455       } else if((rook = quickBoard[sq]) && pieceType[rook] == WhiteRook) { // FRC castling
12456         quickBoard[sq] = 0; // remove Rook
12457         moveDatabase[movePtr].to = sq = (toX>fromX ? BOARD_RGHT-2 : BOARD_LEFT+2); // King to-square
12458         moveDatabase[movePtr++].piece = Q_WCASTL;
12459         quickBoard[sq] = pieceList[1]; // put King
12460         piece = rook;
12461         moveDatabase[movePtr].to = pieceList[rook] = sq = toX>fromX ? sq-1 : sq+1;
12462       }
12463     } else
12464     if(piece == pieceList[2] && fromY == toY) {
12465       if((toX > fromX+1 || toX < fromX-1) && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1) {
12466         int from = (toX>fromX ? BOARD_RGHT-1 : BOARD_LEFT) + (BOARD_HEIGHT-1 <<4);
12467         moveDatabase[movePtr++].piece = Q_BCASTL;
12468         quickBoard[sq] = piece;
12469         piece = quickBoard[from]; quickBoard[from] = 0;
12470         moveDatabase[movePtr].to = pieceList[piece] = sq = toX>fromX ? sq-1 : sq+1;
12471       } else if((rook = quickBoard[sq]) && pieceType[rook] == BlackRook) { // FRC castling
12472         quickBoard[sq] = 0; // remove Rook
12473         moveDatabase[movePtr].to = sq = (toX>fromX ? BOARD_RGHT-2 : BOARD_LEFT+2);
12474         moveDatabase[movePtr++].piece = Q_BCASTL;
12475         quickBoard[sq] = pieceList[2]; // put King
12476         piece = rook;
12477         moveDatabase[movePtr].to = pieceList[rook] = sq = toX>fromX ? sq-1 : sq+1;
12478       }
12479     } else
12480     if(epOK && (pieceType[piece] == WhitePawn || pieceType[piece] == BlackPawn) && fromX != toX && quickBoard[sq] == 0) {
12481         quickBoard[(fromY<<4)+toX] = 0;
12482         moveDatabase[movePtr].piece = Q_EP;
12483         moveDatabase[movePtr++].to = (fromY<<4)+toX;
12484         moveDatabase[movePtr].to = sq;
12485     } else
12486     if(promoPiece != pieceType[piece]) {
12487         moveDatabase[movePtr++].piece = Q_PROMO;
12488         moveDatabase[movePtr].to = pieceType[piece] = (int) promoPiece;
12489     }
12490     moveDatabase[movePtr].piece = piece;
12491     quickBoard[sq] = piece;
12492     movePtr++;
12493 }
12494
12495 int
12496 PackGame (Board board)
12497 {
12498     Move *newSpace = NULL;
12499     moveDatabase[movePtr].piece = 0; // terminate previous game
12500     if(movePtr > dataSize) {
12501         if(appData.debugMode) fprintf(debugFP, "move-cache overflow, enlarge to %d MB\n", dataSize/128);
12502         dataSize *= 8; // increase size by factor 8 (512KB -> 4MB -> 32MB -> 256MB -> 2GB)
12503         if(dataSize) newSpace = (Move*) calloc(dataSize + 1000, sizeof(Move));
12504         if(newSpace) {
12505             int i;
12506             Move *p = moveDatabase, *q = newSpace;
12507             for(i=0; i<movePtr; i++) *q++ = *p++;    // copy to newly allocated space
12508             if(dataSize > 8*DSIZE) free(moveDatabase); // and free old space (if it was allocated)
12509             moveDatabase = newSpace;
12510         } else { // calloc failed, we must be out of memory. Too bad...
12511             dataSize = 0; // prevent calloc events for all subsequent games
12512             return 0;     // and signal this one isn't cached
12513         }
12514     }
12515     movePtr++;
12516     MakePieceList(board, counts);
12517     return movePtr;
12518 }
12519
12520 int
12521 QuickCompare (Board board, int *minCounts, int *maxCounts)
12522 {   // compare according to search mode
12523     int r, f;
12524     switch(appData.searchMode)
12525     {
12526       case 1: // exact position match
12527         if(!(turn & board[EP_STATUS-1])) return FALSE; // wrong side to move
12528         for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12529             if(board[r][f] != pieceType[quickBoard[(r<<4)+f]]) return FALSE;
12530         }
12531         break;
12532       case 2: // can have extra material on empty squares
12533         for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12534             if(board[r][f] == EmptySquare) continue;
12535             if(board[r][f] != pieceType[quickBoard[(r<<4)+f]]) return FALSE;
12536         }
12537         break;
12538       case 3: // material with exact Pawn structure
12539         for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12540             if(board[r][f] != WhitePawn && board[r][f] != BlackPawn) continue;
12541             if(board[r][f] != pieceType[quickBoard[(r<<4)+f]]) return FALSE;
12542         } // fall through to material comparison
12543       case 4: // exact material
12544         for(r=0; r<EmptySquare; r++) if(counts[r] != maxCounts[r]) return FALSE;
12545         break;
12546       case 6: // material range with given imbalance
12547         for(r=0; r<BlackPawn; r++) if(counts[r] - minCounts[r] != counts[r+BlackPawn] - minCounts[r+BlackPawn]) return FALSE;
12548         // fall through to range comparison
12549       case 5: // material range
12550         for(r=0; r<EmptySquare; r++) if(counts[r] < minCounts[r] || counts[r] > maxCounts[r]) return FALSE;
12551     }
12552     return TRUE;
12553 }
12554
12555 int
12556 QuickScan (Board board, Move *move)
12557 {   // reconstruct game,and compare all positions in it
12558     int cnt=0, stretch=0, found = -1, total = MakePieceList(board, counts);
12559     do {
12560         int piece = move->piece;
12561         int to = move->to, from = pieceList[piece];
12562         if(found < 0) { // if already found just scan to game end for final piece count
12563           if(QuickCompare(soughtBoard, minSought, maxSought) ||
12564            appData.ignoreColors && QuickCompare(reverseBoard, minReverse, maxReverse) ||
12565            flipSearch && (QuickCompare(flipBoard, minSought, maxSought) ||
12566                                 appData.ignoreColors && QuickCompare(rotateBoard, minReverse, maxReverse))
12567             ) {
12568             static int lastCounts[EmptySquare+1];
12569             int i;
12570             if(stretch) for(i=0; i<EmptySquare; i++) if(lastCounts[i] != counts[i]) { stretch = 0; break; } // reset if material changes
12571             if(stretch++ == 0) for(i=0; i<EmptySquare; i++) lastCounts[i] = counts[i]; // remember actual material
12572           } else stretch = 0;
12573           if(stretch && (appData.searchMode == 1 || stretch >= appData.stretch)) found = cnt + 1 - stretch;
12574           if(found >= 0 && !appData.minPieces) return found;
12575         }
12576         if(piece <= Q_PROMO) { // special moves encoded by otherwise invalid piece numbers 1-4
12577           if(!piece) return (appData.minPieces && (total < appData.minPieces || total > appData.maxPieces) ? -1 : found);
12578           if(piece == Q_PROMO) { // promotion, encoded as (Q_PROMO, to) + (piece, promoType)
12579             piece = (++move)->piece;
12580             from = pieceList[piece];
12581             counts[pieceType[piece]]--;
12582             pieceType[piece] = (ChessSquare) move->to;
12583             counts[move->to]++;
12584           } else if(piece == Q_EP) { // e.p. capture, encoded as (Q_EP, ep-sqr) + (piece, to)
12585             counts[pieceType[quickBoard[to]]]--;
12586             quickBoard[to] = 0; total--;
12587             move++;
12588             continue;
12589           } else if(piece <= Q_BCASTL) { // castling, encoded as (Q_XCASTL, king-to) + (rook, rook-to)
12590             piece = pieceList[piece]; // first two elements of pieceList contain King numbers
12591             from  = pieceList[piece]; // so this must be King
12592             quickBoard[from] = 0;
12593             pieceList[piece] = to;
12594             from = pieceList[(++move)->piece]; // for FRC this has to be done here
12595             quickBoard[from] = 0; // rook
12596             quickBoard[to] = piece;
12597             to = move->to; piece = move->piece;
12598             goto aftercastle;
12599           }
12600         }
12601         if(appData.searchMode > 2) counts[pieceType[quickBoard[to]]]--; // account capture
12602         if((total -= (quickBoard[to] != 0)) < soughtTotal && found < 0) return -1; // piece count dropped below what we search for
12603         quickBoard[from] = 0;
12604       aftercastle:
12605         quickBoard[to] = piece;
12606         pieceList[piece] = to;
12607         cnt++; turn ^= 3;
12608         move++;
12609     } while(1);
12610 }
12611
12612 void
12613 InitSearch ()
12614 {
12615     int r, f;
12616     flipSearch = FALSE;
12617     CopyBoard(soughtBoard, boards[currentMove]);
12618     soughtTotal = MakePieceList(soughtBoard, maxSought);
12619     soughtBoard[EP_STATUS-1] = (currentMove & 1) + 1;
12620     if(currentMove == 0 && gameMode == EditPosition) soughtBoard[EP_STATUS-1] = blackPlaysFirst + 1; // (!)
12621     CopyBoard(reverseBoard, boards[currentMove]);
12622     for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12623         int piece = boards[currentMove][BOARD_HEIGHT-1-r][f];
12624         if(piece < BlackPawn) piece += BlackPawn; else if(piece < EmptySquare) piece -= BlackPawn; // color-flip
12625         reverseBoard[r][f] = piece;
12626     }
12627     reverseBoard[EP_STATUS-1] = soughtBoard[EP_STATUS-1] ^ 3;
12628     for(r=0; r<6; r++) reverseBoard[CASTLING][r] = boards[currentMove][CASTLING][(r+3)%6];
12629     if(appData.findMirror && appData.searchMode <= 3 && (!nrCastlingRights
12630                  || (boards[currentMove][CASTLING][2] == NoRights ||
12631                      boards[currentMove][CASTLING][0] == NoRights && boards[currentMove][CASTLING][1] == NoRights )
12632                  && (boards[currentMove][CASTLING][5] == NoRights ||
12633                      boards[currentMove][CASTLING][3] == NoRights && boards[currentMove][CASTLING][4] == NoRights ) )
12634       ) {
12635         flipSearch = TRUE;
12636         CopyBoard(flipBoard, soughtBoard);
12637         CopyBoard(rotateBoard, reverseBoard);
12638         for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12639             flipBoard[r][f]    = soughtBoard[r][BOARD_WIDTH-1-f];
12640             rotateBoard[r][f] = reverseBoard[r][BOARD_WIDTH-1-f];
12641         }
12642     }
12643     for(r=0; r<BlackPawn; r++) maxReverse[r] = maxSought[r+BlackPawn], maxReverse[r+BlackPawn] = maxSought[r];
12644     if(appData.searchMode >= 5) {
12645         for(r=BOARD_HEIGHT/2; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) soughtBoard[r][f] = EmptySquare;
12646         MakePieceList(soughtBoard, minSought);
12647         for(r=0; r<BlackPawn; r++) minReverse[r] = minSought[r+BlackPawn], minReverse[r+BlackPawn] = minSought[r];
12648     }
12649     if(gameInfo.variant == VariantCrazyhouse || gameInfo.variant == VariantShogi || gameInfo.variant == VariantBughouse)
12650         soughtTotal = 0; // in drop games nr of pieces does not fall monotonously
12651 }
12652
12653 GameInfo dummyInfo;
12654 static int creatingBook;
12655
12656 int
12657 GameContainsPosition (FILE *f, ListGame *lg)
12658 {
12659     int next, btm=0, plyNr=0, scratch=forwardMostMove+2&~1;
12660     int fromX, fromY, toX, toY;
12661     char promoChar;
12662     static int initDone=FALSE;
12663
12664     // weed out games based on numerical tag comparison
12665     if(lg->gameInfo.variant != gameInfo.variant) return -1; // wrong variant
12666     if(appData.eloThreshold1 && (lg->gameInfo.whiteRating < appData.eloThreshold1 && lg->gameInfo.blackRating < appData.eloThreshold1)) return -1;
12667     if(appData.eloThreshold2 && (lg->gameInfo.whiteRating < appData.eloThreshold2 || lg->gameInfo.blackRating < appData.eloThreshold2)) return -1;
12668     if(appData.dateThreshold && (!lg->gameInfo.date || atoi(lg->gameInfo.date) < appData.dateThreshold)) return -1;
12669     if(!initDone) {
12670         for(next = WhitePawn; next<EmptySquare; next++) keys[next] = random()>>8 ^ random()<<6 ^random()<<20;
12671         initDone = TRUE;
12672     }
12673     if(lg->gameInfo.fen) ParseFEN(boards[scratch], &btm, lg->gameInfo.fen, FALSE);
12674     else CopyBoard(boards[scratch], initialPosition); // default start position
12675     if(lg->moves) {
12676         turn = btm + 1;
12677         if((next = QuickScan( boards[scratch], &moveDatabase[lg->moves] )) < 0) return -1; // quick scan rules out it is there
12678         if(appData.searchMode >= 4) return next; // for material searches, trust QuickScan.
12679     }
12680     if(btm) plyNr++;
12681     if(PositionMatches(boards[scratch], boards[currentMove])) return plyNr;
12682     fseek(f, lg->offset, 0);
12683     yynewfile(f);
12684     while(1) {
12685         yyboardindex = scratch;
12686         quickFlag = plyNr+1;
12687         next = Myylex();
12688         quickFlag = 0;
12689         switch(next) {
12690             case PGNTag:
12691                 if(plyNr) return -1; // after we have seen moves, any tags will be start of next game
12692             default:
12693                 continue;
12694
12695             case XBoardGame:
12696             case GNUChessGame:
12697                 if(plyNr) return -1; // after we have seen moves, this is for new game
12698               continue;
12699
12700             case AmbiguousMove: // we cannot reconstruct the game beyond these two
12701             case ImpossibleMove:
12702             case WhiteWins: // game ends here with these four
12703             case BlackWins:
12704             case GameIsDrawn:
12705             case GameUnfinished:
12706                 return -1;
12707
12708             case IllegalMove:
12709                 if(appData.testLegality) return -1;
12710             case WhiteCapturesEnPassant:
12711             case BlackCapturesEnPassant:
12712             case WhitePromotion:
12713             case BlackPromotion:
12714             case WhiteNonPromotion:
12715             case BlackNonPromotion:
12716             case NormalMove:
12717             case FirstLeg:
12718             case WhiteKingSideCastle:
12719             case WhiteQueenSideCastle:
12720             case BlackKingSideCastle:
12721             case BlackQueenSideCastle:
12722             case WhiteKingSideCastleWild:
12723             case WhiteQueenSideCastleWild:
12724             case BlackKingSideCastleWild:
12725             case BlackQueenSideCastleWild:
12726             case WhiteHSideCastleFR:
12727             case WhiteASideCastleFR:
12728             case BlackHSideCastleFR:
12729             case BlackASideCastleFR:
12730                 fromX = currentMoveString[0] - AAA;
12731                 fromY = currentMoveString[1] - ONE;
12732                 toX = currentMoveString[2] - AAA;
12733                 toY = currentMoveString[3] - ONE;
12734                 promoChar = currentMoveString[4];
12735                 break;
12736             case WhiteDrop:
12737             case BlackDrop:
12738                 fromX = next == WhiteDrop ?
12739                   (int) CharToPiece(ToUpper(currentMoveString[0])) :
12740                   (int) CharToPiece(ToLower(currentMoveString[0]));
12741                 fromY = DROP_RANK;
12742                 toX = currentMoveString[2] - AAA;
12743                 toY = currentMoveString[3] - ONE;
12744                 promoChar = 0;
12745                 break;
12746         }
12747         // Move encountered; peform it. We need to shuttle between two boards, as even/odd index determines side to move
12748         plyNr++;
12749         ApplyMove(fromX, fromY, toX, toY, promoChar, boards[scratch]);
12750         if(PositionMatches(boards[scratch], boards[currentMove])) return plyNr;
12751         if(appData.ignoreColors && PositionMatches(boards[scratch], reverseBoard)) return plyNr;
12752         if(appData.findMirror) {
12753             if(PositionMatches(boards[scratch], flipBoard)) return plyNr;
12754             if(appData.ignoreColors && PositionMatches(boards[scratch], rotateBoard)) return plyNr;
12755         }
12756     }
12757 }
12758
12759 /* Load the nth game from open file f */
12760 int
12761 LoadGame (FILE *f, int gameNumber, char *title, int useList)
12762 {
12763     ChessMove cm;
12764     char buf[MSG_SIZ];
12765     int gn = gameNumber;
12766     ListGame *lg = NULL;
12767     int numPGNTags = 0;
12768     int err, pos = -1;
12769     GameMode oldGameMode;
12770     VariantClass v, oldVariant = gameInfo.variant; /* [HGM] PGNvariant */
12771     char oldName[MSG_SIZ];
12772
12773     safeStrCpy(oldName, engineVariant, MSG_SIZ); v = oldVariant;
12774
12775     if (appData.debugMode)
12776         fprintf(debugFP, "LoadGame(): on entry, gameMode %d\n", gameMode);
12777
12778     if (gameMode == Training )
12779         SetTrainingModeOff();
12780
12781     oldGameMode = gameMode;
12782     if (gameMode != BeginningOfGame) {
12783       Reset(FALSE, TRUE);
12784     }
12785     killX = killY = -1; // [HGM] lion: in case we did not Reset
12786
12787     gameFileFP = f;
12788     if (lastLoadGameFP != NULL && lastLoadGameFP != f) {
12789         fclose(lastLoadGameFP);
12790     }
12791
12792     if (useList) {
12793         lg = (ListGame *) ListElem(&gameList, gameNumber-1);
12794
12795         if (lg) {
12796             fseek(f, lg->offset, 0);
12797             GameListHighlight(gameNumber);
12798             pos = lg->position;
12799             gn = 1;
12800         }
12801         else {
12802             if(oldGameMode == AnalyzeFile && appData.loadGameIndex == -1)
12803               appData.loadGameIndex = 0; // [HGM] suppress error message if we reach file end after auto-stepping analysis
12804             else
12805             DisplayError(_("Game number out of range"), 0);
12806             return FALSE;
12807         }
12808     } else {
12809         GameListDestroy();
12810         if (fseek(f, 0, 0) == -1) {
12811             if (f == lastLoadGameFP ?
12812                 gameNumber == lastLoadGameNumber + 1 :
12813                 gameNumber == 1) {
12814                 gn = 1;
12815             } else {
12816                 DisplayError(_("Can't seek on game file"), 0);
12817                 return FALSE;
12818             }
12819         }
12820     }
12821     lastLoadGameFP = f;
12822     lastLoadGameNumber = gameNumber;
12823     safeStrCpy(lastLoadGameTitle, title, sizeof(lastLoadGameTitle)/sizeof(lastLoadGameTitle[0]));
12824     lastLoadGameUseList = useList;
12825
12826     yynewfile(f);
12827
12828     if (lg && lg->gameInfo.white && lg->gameInfo.black) {
12829       snprintf(buf, sizeof(buf), "%s %s %s", lg->gameInfo.white, _("vs."),
12830                 lg->gameInfo.black);
12831             DisplayTitle(buf);
12832     } else if (*title != NULLCHAR) {
12833         if (gameNumber > 1) {
12834           snprintf(buf, MSG_SIZ, "%s %d", title, gameNumber);
12835             DisplayTitle(buf);
12836         } else {
12837             DisplayTitle(title);
12838         }
12839     }
12840
12841     if (gameMode != AnalyzeFile && gameMode != AnalyzeMode) {
12842         gameMode = PlayFromGameFile;
12843         ModeHighlight();
12844     }
12845
12846     currentMove = forwardMostMove = backwardMostMove = 0;
12847     CopyBoard(boards[0], initialPosition);
12848     StopClocks();
12849
12850     /*
12851      * Skip the first gn-1 games in the file.
12852      * Also skip over anything that precedes an identifiable
12853      * start of game marker, to avoid being confused by
12854      * garbage at the start of the file.  Currently
12855      * recognized start of game markers are the move number "1",
12856      * the pattern "gnuchess .* game", the pattern
12857      * "^[#;%] [^ ]* game file", and a PGN tag block.
12858      * A game that starts with one of the latter two patterns
12859      * will also have a move number 1, possibly
12860      * following a position diagram.
12861      * 5-4-02: Let's try being more lenient and allowing a game to
12862      * start with an unnumbered move.  Does that break anything?
12863      */
12864     cm = lastLoadGameStart = EndOfFile;
12865     while (gn > 0) {
12866         yyboardindex = forwardMostMove;
12867         cm = (ChessMove) Myylex();
12868         switch (cm) {
12869           case EndOfFile:
12870             if (cmailMsgLoaded) {
12871                 nCmailGames = CMAIL_MAX_GAMES - gn;
12872             } else {
12873                 Reset(TRUE, TRUE);
12874                 DisplayError(_("Game not found in file"), 0);
12875             }
12876             return FALSE;
12877
12878           case GNUChessGame:
12879           case XBoardGame:
12880             gn--;
12881             lastLoadGameStart = cm;
12882             break;
12883
12884           case MoveNumberOne:
12885             switch (lastLoadGameStart) {
12886               case GNUChessGame:
12887               case XBoardGame:
12888               case PGNTag:
12889                 break;
12890               case MoveNumberOne:
12891               case EndOfFile:
12892                 gn--;           /* count this game */
12893                 lastLoadGameStart = cm;
12894                 break;
12895               default:
12896                 /* impossible */
12897                 break;
12898             }
12899             break;
12900
12901           case PGNTag:
12902             switch (lastLoadGameStart) {
12903               case GNUChessGame:
12904               case PGNTag:
12905               case MoveNumberOne:
12906               case EndOfFile:
12907                 gn--;           /* count this game */
12908                 lastLoadGameStart = cm;
12909                 break;
12910               case XBoardGame:
12911                 lastLoadGameStart = cm; /* game counted already */
12912                 break;
12913               default:
12914                 /* impossible */
12915                 break;
12916             }
12917             if (gn > 0) {
12918                 do {
12919                     yyboardindex = forwardMostMove;
12920                     cm = (ChessMove) Myylex();
12921                 } while (cm == PGNTag || cm == Comment);
12922             }
12923             break;
12924
12925           case WhiteWins:
12926           case BlackWins:
12927           case GameIsDrawn:
12928             if (cmailMsgLoaded && (CMAIL_MAX_GAMES == lastLoadGameNumber)) {
12929                 if (   cmailResult[CMAIL_MAX_GAMES - gn - 1]
12930                     != CMAIL_OLD_RESULT) {
12931                     nCmailResults ++ ;
12932                     cmailResult[  CMAIL_MAX_GAMES
12933                                 - gn - 1] = CMAIL_OLD_RESULT;
12934                 }
12935             }
12936             break;
12937
12938           case NormalMove:
12939           case FirstLeg:
12940             /* Only a NormalMove can be at the start of a game
12941              * without a position diagram. */
12942             if (lastLoadGameStart == EndOfFile ) {
12943               gn--;
12944               lastLoadGameStart = MoveNumberOne;
12945             }
12946             break;
12947
12948           default:
12949             break;
12950         }
12951     }
12952
12953     if (appData.debugMode)
12954       fprintf(debugFP, "Parsed game start '%s' (%d)\n", yy_text, (int) cm);
12955
12956     if (cm == XBoardGame) {
12957         /* Skip any header junk before position diagram and/or move 1 */
12958         for (;;) {
12959             yyboardindex = forwardMostMove;
12960             cm = (ChessMove) Myylex();
12961
12962             if (cm == EndOfFile ||
12963                 cm == GNUChessGame || cm == XBoardGame) {
12964                 /* Empty game; pretend end-of-file and handle later */
12965                 cm = EndOfFile;
12966                 break;
12967             }
12968
12969             if (cm == MoveNumberOne || cm == PositionDiagram ||
12970                 cm == PGNTag || cm == Comment)
12971               break;
12972         }
12973     } else if (cm == GNUChessGame) {
12974         if (gameInfo.event != NULL) {
12975             free(gameInfo.event);
12976         }
12977         gameInfo.event = StrSave(yy_text);
12978     }
12979
12980     startedFromSetupPosition = FALSE;
12981     while (cm == PGNTag) {
12982         if (appData.debugMode)
12983           fprintf(debugFP, "Parsed PGNTag: %s\n", yy_text);
12984         err = ParsePGNTag(yy_text, &gameInfo);
12985         if (!err) numPGNTags++;
12986
12987         /* [HGM] PGNvariant: automatically switch to variant given in PGN tag */
12988         if(gameInfo.variant != oldVariant && (gameInfo.variant != VariantNormal || gameInfo.variantName == NULL || *gameInfo.variantName == NULLCHAR)) {
12989             startedFromPositionFile = FALSE; /* [HGM] loadPos: variant switch likely makes position invalid */
12990             ResetFrontEnd(); // [HGM] might need other bitmaps. Cannot use Reset() because it clears gameInfo :-(
12991             InitPosition(TRUE);
12992             oldVariant = gameInfo.variant;
12993             if (appData.debugMode)
12994               fprintf(debugFP, "New variant %d\n", (int) oldVariant);
12995         }
12996
12997
12998         if (gameInfo.fen != NULL) {
12999           Board initial_position;
13000           startedFromSetupPosition = TRUE;
13001           if (!ParseFEN(initial_position, &blackPlaysFirst, gameInfo.fen, TRUE)) {
13002             Reset(TRUE, TRUE);
13003             DisplayError(_("Bad FEN position in file"), 0);
13004             return FALSE;
13005           }
13006           CopyBoard(boards[0], initial_position);
13007           if(*engineVariant) // [HGM] for now, assume FEN in engine-defined variant game is default initial position
13008             CopyBoard(initialPosition, initial_position);
13009           if (blackPlaysFirst) {
13010             currentMove = forwardMostMove = backwardMostMove = 1;
13011             CopyBoard(boards[1], initial_position);
13012             safeStrCpy(moveList[0], "", sizeof(moveList[0])/sizeof(moveList[0][0]));
13013             safeStrCpy(parseList[0], "", sizeof(parseList[0])/sizeof(parseList[0][0]));
13014             timeRemaining[0][1] = whiteTimeRemaining;
13015             timeRemaining[1][1] = blackTimeRemaining;
13016             if (commentList[0] != NULL) {
13017               commentList[1] = commentList[0];
13018               commentList[0] = NULL;
13019             }
13020           } else {
13021             currentMove = forwardMostMove = backwardMostMove = 0;
13022           }
13023           /* [HGM] copy FEN attributes as well. Bugfix 4.3.14m and 4.3.15e: moved to after 'blackPlaysFirst' */
13024           {   int i;
13025               initialRulePlies = FENrulePlies;
13026               for( i=0; i< nrCastlingRights; i++ )
13027                   initialRights[i] = initial_position[CASTLING][i];
13028           }
13029           yyboardindex = forwardMostMove;
13030           free(gameInfo.fen);
13031           gameInfo.fen = NULL;
13032         }
13033
13034         yyboardindex = forwardMostMove;
13035         cm = (ChessMove) Myylex();
13036
13037         /* Handle comments interspersed among the tags */
13038         while (cm == Comment) {
13039             char *p;
13040             if (appData.debugMode)
13041               fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
13042             p = yy_text;
13043             AppendComment(currentMove, p, FALSE);
13044             yyboardindex = forwardMostMove;
13045             cm = (ChessMove) Myylex();
13046         }
13047     }
13048
13049     /* don't rely on existence of Event tag since if game was
13050      * pasted from clipboard the Event tag may not exist
13051      */
13052     if (numPGNTags > 0){
13053         char *tags;
13054         if (gameInfo.variant == VariantNormal) {
13055           VariantClass v = StringToVariant(gameInfo.event);
13056           // [HGM] do not recognize variants from event tag that were introduced after supporting variant tag
13057           if(v < VariantShogi) gameInfo.variant = v;
13058         }
13059         if (!matchMode) {
13060           if( appData.autoDisplayTags ) {
13061             tags = PGNTags(&gameInfo);
13062             TagsPopUp(tags, CmailMsg());
13063             free(tags);
13064           }
13065         }
13066     } else {
13067         /* Make something up, but don't display it now */
13068         SetGameInfo();
13069         TagsPopDown();
13070     }
13071
13072     if (cm == PositionDiagram) {
13073         int i, j;
13074         char *p;
13075         Board initial_position;
13076
13077         if (appData.debugMode)
13078           fprintf(debugFP, "Parsed PositionDiagram: %s\n", yy_text);
13079
13080         if (!startedFromSetupPosition) {
13081             p = yy_text;
13082             for (i = BOARD_HEIGHT - 1; i >= 0; i--)
13083               for (j = BOARD_LEFT; j < BOARD_RGHT; p++)
13084                 switch (*p) {
13085                   case '{':
13086                   case '[':
13087                   case '-':
13088                   case ' ':
13089                   case '\t':
13090                   case '\n':
13091                   case '\r':
13092                     break;
13093                   default:
13094                     initial_position[i][j++] = CharToPiece(*p);
13095                     break;
13096                 }
13097             while (*p == ' ' || *p == '\t' ||
13098                    *p == '\n' || *p == '\r') p++;
13099
13100             if (strncmp(p, "black", strlen("black"))==0)
13101               blackPlaysFirst = TRUE;
13102             else
13103               blackPlaysFirst = FALSE;
13104             startedFromSetupPosition = TRUE;
13105
13106             CopyBoard(boards[0], initial_position);
13107             if (blackPlaysFirst) {
13108                 currentMove = forwardMostMove = backwardMostMove = 1;
13109                 CopyBoard(boards[1], initial_position);
13110                 safeStrCpy(moveList[0], "", sizeof(moveList[0])/sizeof(moveList[0][0]));
13111                 safeStrCpy(parseList[0], "", sizeof(parseList[0])/sizeof(parseList[0][0]));
13112                 timeRemaining[0][1] = whiteTimeRemaining;
13113                 timeRemaining[1][1] = blackTimeRemaining;
13114                 if (commentList[0] != NULL) {
13115                     commentList[1] = commentList[0];
13116                     commentList[0] = NULL;
13117                 }
13118             } else {
13119                 currentMove = forwardMostMove = backwardMostMove = 0;
13120             }
13121         }
13122         yyboardindex = forwardMostMove;
13123         cm = (ChessMove) Myylex();
13124     }
13125
13126   if(!creatingBook) {
13127     if (first.pr == NoProc) {
13128         StartChessProgram(&first);
13129     }
13130     InitChessProgram(&first, FALSE);
13131     if(gameInfo.variant == VariantUnknown && *oldName) {
13132         safeStrCpy(engineVariant, oldName, MSG_SIZ);
13133         gameInfo.variant = v;
13134     }
13135     SendToProgram("force\n", &first);
13136     if (startedFromSetupPosition) {
13137         SendBoard(&first, forwardMostMove);
13138     if (appData.debugMode) {
13139         fprintf(debugFP, "Load Game\n");
13140     }
13141         DisplayBothClocks();
13142     }
13143   }
13144
13145     /* [HGM] server: flag to write setup moves in broadcast file as one */
13146     loadFlag = appData.suppressLoadMoves;
13147
13148     while (cm == Comment) {
13149         char *p;
13150         if (appData.debugMode)
13151           fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
13152         p = yy_text;
13153         AppendComment(currentMove, p, FALSE);
13154         yyboardindex = forwardMostMove;
13155         cm = (ChessMove) Myylex();
13156     }
13157
13158     if ((cm == EndOfFile && lastLoadGameStart != EndOfFile ) ||
13159         cm == WhiteWins || cm == BlackWins ||
13160         cm == GameIsDrawn || cm == GameUnfinished) {
13161         DisplayMessage("", _("No moves in game"));
13162         if (cmailMsgLoaded) {
13163             if (appData.debugMode)
13164               fprintf(debugFP, "Setting flipView to %d.\n", FALSE);
13165             ClearHighlights();
13166             flipView = FALSE;
13167         }
13168         DrawPosition(FALSE, boards[currentMove]);
13169         DisplayBothClocks();
13170         gameMode = EditGame;
13171         ModeHighlight();
13172         gameFileFP = NULL;
13173         cmailOldMove = 0;
13174         return TRUE;
13175     }
13176
13177     // [HGM] PV info: routine tests if comment empty
13178     if (!matchMode && (pausing || appData.timeDelay != 0)) {
13179         DisplayComment(currentMove - 1, commentList[currentMove]);
13180     }
13181     if (!matchMode && appData.timeDelay != 0)
13182       DrawPosition(FALSE, boards[currentMove]);
13183
13184     if (gameMode == AnalyzeFile || gameMode == AnalyzeMode) {
13185       programStats.ok_to_send = 1;
13186     }
13187
13188     /* if the first token after the PGN tags is a move
13189      * and not move number 1, retrieve it from the parser
13190      */
13191     if (cm != MoveNumberOne)
13192         LoadGameOneMove(cm);
13193
13194     /* load the remaining moves from the file */
13195     while (LoadGameOneMove(EndOfFile)) {
13196       timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
13197       timeRemaining[1][forwardMostMove] = blackTimeRemaining;
13198     }
13199
13200     /* rewind to the start of the game */
13201     currentMove = backwardMostMove;
13202
13203     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
13204
13205     if (oldGameMode == AnalyzeFile) {
13206       appData.loadGameIndex = -1; // [HGM] order auto-stepping through games
13207       AnalyzeFileEvent();
13208     } else
13209     if (oldGameMode == AnalyzeMode) {
13210       AnalyzeFileEvent();
13211     }
13212
13213     if(gameInfo.result == GameUnfinished && gameInfo.resultDetails && appData.clockMode) {
13214         long int w, b; // [HGM] adjourn: restore saved clock times
13215         char *p = strstr(gameInfo.resultDetails, "(Clocks:");
13216         if(p && sscanf(p+8, "%ld,%ld", &w, &b) == 2) {
13217             timeRemaining[0][forwardMostMove] = whiteTimeRemaining = 1000*w + 500;
13218             timeRemaining[1][forwardMostMove] = blackTimeRemaining = 1000*b + 500;
13219         }
13220     }
13221
13222     if(creatingBook) return TRUE;
13223     if (!matchMode && pos > 0) {
13224         ToNrEvent(pos); // [HGM] no autoplay if selected on position
13225     } else
13226     if (matchMode || appData.timeDelay == 0) {
13227       ToEndEvent();
13228     } else if (appData.timeDelay > 0) {
13229       AutoPlayGameLoop();
13230     }
13231
13232     if (appData.debugMode)
13233         fprintf(debugFP, "LoadGame(): on exit, gameMode %d\n", gameMode);
13234
13235     loadFlag = 0; /* [HGM] true game starts */
13236     return TRUE;
13237 }
13238
13239 /* Support for LoadNextPosition, LoadPreviousPosition, ReloadSamePosition */
13240 int
13241 ReloadPosition (int offset)
13242 {
13243     int positionNumber = lastLoadPositionNumber + offset;
13244     if (lastLoadPositionFP == NULL) {
13245         DisplayError(_("No position has been loaded yet"), 0);
13246         return FALSE;
13247     }
13248     if (positionNumber <= 0) {
13249         DisplayError(_("Can't back up any further"), 0);
13250         return FALSE;
13251     }
13252     return LoadPosition(lastLoadPositionFP, positionNumber,
13253                         lastLoadPositionTitle);
13254 }
13255
13256 /* Load the nth position from the given file */
13257 int
13258 LoadPositionFromFile (char *filename, int n, char *title)
13259 {
13260     FILE *f;
13261     char buf[MSG_SIZ];
13262
13263     if (strcmp(filename, "-") == 0) {
13264         return LoadPosition(stdin, n, "stdin");
13265     } else {
13266         f = fopen(filename, "rb");
13267         if (f == NULL) {
13268             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
13269             DisplayError(buf, errno);
13270             return FALSE;
13271         } else {
13272             return LoadPosition(f, n, title);
13273         }
13274     }
13275 }
13276
13277 /* Load the nth position from the given open file, and close it */
13278 int
13279 LoadPosition (FILE *f, int positionNumber, char *title)
13280 {
13281     char *p, line[MSG_SIZ];
13282     Board initial_position;
13283     int i, j, fenMode, pn;
13284
13285     if (gameMode == Training )
13286         SetTrainingModeOff();
13287
13288     if (gameMode != BeginningOfGame) {
13289         Reset(FALSE, TRUE);
13290     }
13291     if (lastLoadPositionFP != NULL && lastLoadPositionFP != f) {
13292         fclose(lastLoadPositionFP);
13293     }
13294     if (positionNumber == 0) positionNumber = 1;
13295     lastLoadPositionFP = f;
13296     lastLoadPositionNumber = positionNumber;
13297     safeStrCpy(lastLoadPositionTitle, title, sizeof(lastLoadPositionTitle)/sizeof(lastLoadPositionTitle[0]));
13298     if (first.pr == NoProc && !appData.noChessProgram) {
13299       StartChessProgram(&first);
13300       InitChessProgram(&first, FALSE);
13301     }
13302     pn = positionNumber;
13303     if (positionNumber < 0) {
13304         /* Negative position number means to seek to that byte offset */
13305         if (fseek(f, -positionNumber, 0) == -1) {
13306             DisplayError(_("Can't seek on position file"), 0);
13307             return FALSE;
13308         };
13309         pn = 1;
13310     } else {
13311         if (fseek(f, 0, 0) == -1) {
13312             if (f == lastLoadPositionFP ?
13313                 positionNumber == lastLoadPositionNumber + 1 :
13314                 positionNumber == 1) {
13315                 pn = 1;
13316             } else {
13317                 DisplayError(_("Can't seek on position file"), 0);
13318                 return FALSE;
13319             }
13320         }
13321     }
13322     /* See if this file is FEN or old-style xboard */
13323     if (fgets(line, MSG_SIZ, f) == NULL) {
13324         DisplayError(_("Position not found in file"), 0);
13325         return FALSE;
13326     }
13327     // [HGM] FEN can begin with digit, any piece letter valid in this variant, or a + for Shogi promoted pieces (or * for blackout)
13328     fenMode = line[0] >= '0' && line[0] <= '9' || line[0] == '+' || line[0] == '*' || CharToPiece(line[0]) != EmptySquare;
13329
13330     if (pn >= 2) {
13331         if (fenMode || line[0] == '#') pn--;
13332         while (pn > 0) {
13333             /* skip positions before number pn */
13334             if (fgets(line, MSG_SIZ, f) == NULL) {
13335                 Reset(TRUE, TRUE);
13336                 DisplayError(_("Position not found in file"), 0);
13337                 return FALSE;
13338             }
13339             if (fenMode || line[0] == '#') pn--;
13340         }
13341     }
13342
13343     if (fenMode) {
13344         char *p;
13345         if (!ParseFEN(initial_position, &blackPlaysFirst, line, TRUE)) {
13346             DisplayError(_("Bad FEN position in file"), 0);
13347             return FALSE;
13348         }
13349         if((p = strstr(line, ";")) && (p = strstr(p+1, "bm "))) { // EPD with best move
13350             sscanf(p+3, "%s", bestMove);
13351         } else *bestMove = NULLCHAR;
13352     } else {
13353         (void) fgets(line, MSG_SIZ, f);
13354         (void) fgets(line, MSG_SIZ, f);
13355
13356         for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
13357             (void) fgets(line, MSG_SIZ, f);
13358             for (p = line, j = BOARD_LEFT; j < BOARD_RGHT; p++) {
13359                 if (*p == ' ')
13360                   continue;
13361                 initial_position[i][j++] = CharToPiece(*p);
13362             }
13363         }
13364
13365         blackPlaysFirst = FALSE;
13366         if (!feof(f)) {
13367             (void) fgets(line, MSG_SIZ, f);
13368             if (strncmp(line, "black", strlen("black"))==0)
13369               blackPlaysFirst = TRUE;
13370         }
13371     }
13372     startedFromSetupPosition = TRUE;
13373
13374     CopyBoard(boards[0], initial_position);
13375     if (blackPlaysFirst) {
13376         currentMove = forwardMostMove = backwardMostMove = 1;
13377         safeStrCpy(moveList[0], "", sizeof(moveList[0])/sizeof(moveList[0][0]));
13378         safeStrCpy(parseList[0], "", sizeof(parseList[0])/sizeof(parseList[0][0]));
13379         CopyBoard(boards[1], initial_position);
13380         DisplayMessage("", _("Black to play"));
13381     } else {
13382         currentMove = forwardMostMove = backwardMostMove = 0;
13383         DisplayMessage("", _("White to play"));
13384     }
13385     initialRulePlies = FENrulePlies; /* [HGM] copy FEN attributes as well */
13386     if(first.pr != NoProc) { // [HGM] in tourney-mode a position can be loaded before the chess engine is installed
13387         SendToProgram("force\n", &first);
13388         SendBoard(&first, forwardMostMove);
13389     }
13390     if (appData.debugMode) {
13391 int i, j;
13392   for(i=0;i<2;i++){for(j=0;j<6;j++)fprintf(debugFP, " %d", boards[i][CASTLING][j]);fprintf(debugFP,"\n");}
13393   for(j=0;j<6;j++)fprintf(debugFP, " %d", initialRights[j]);fprintf(debugFP,"\n");
13394         fprintf(debugFP, "Load Position\n");
13395     }
13396
13397     if (positionNumber > 1) {
13398       snprintf(line, MSG_SIZ, "%s %d", title, positionNumber);
13399         DisplayTitle(line);
13400     } else {
13401         DisplayTitle(title);
13402     }
13403     gameMode = EditGame;
13404     ModeHighlight();
13405     ResetClocks();
13406     timeRemaining[0][1] = whiteTimeRemaining;
13407     timeRemaining[1][1] = blackTimeRemaining;
13408     DrawPosition(FALSE, boards[currentMove]);
13409
13410     return TRUE;
13411 }
13412
13413
13414 void
13415 CopyPlayerNameIntoFileName (char **dest, char *src)
13416 {
13417     while (*src != NULLCHAR && *src != ',') {
13418         if (*src == ' ') {
13419             *(*dest)++ = '_';
13420             src++;
13421         } else {
13422             *(*dest)++ = *src++;
13423         }
13424     }
13425 }
13426
13427 char *
13428 DefaultFileName (char *ext)
13429 {
13430     static char def[MSG_SIZ];
13431     char *p;
13432
13433     if (gameInfo.white != NULL && gameInfo.white[0] != '-') {
13434         p = def;
13435         CopyPlayerNameIntoFileName(&p, gameInfo.white);
13436         *p++ = '-';
13437         CopyPlayerNameIntoFileName(&p, gameInfo.black);
13438         *p++ = '.';
13439         safeStrCpy(p, ext, MSG_SIZ-2-strlen(gameInfo.white)-strlen(gameInfo.black));
13440     } else {
13441         def[0] = NULLCHAR;
13442     }
13443     return def;
13444 }
13445
13446 /* Save the current game to the given file */
13447 int
13448 SaveGameToFile (char *filename, int append)
13449 {
13450     FILE *f;
13451     char buf[MSG_SIZ];
13452     int result, i, t,tot=0;
13453
13454     if (strcmp(filename, "-") == 0) {
13455         return SaveGame(stdout, 0, NULL);
13456     } else {
13457         for(i=0; i<10; i++) { // upto 10 tries
13458              f = fopen(filename, append ? "a" : "w");
13459              if(f && i) fprintf(f, "[Delay \"%d retries, %d msec\"]\n",i,tot);
13460              if(f || errno != 13) break;
13461              DoSleep(t = 5 + random()%11); // wait 5-15 msec
13462              tot += t;
13463         }
13464         if (f == NULL) {
13465             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
13466             DisplayError(buf, errno);
13467             return FALSE;
13468         } else {
13469             safeStrCpy(buf, lastMsg, MSG_SIZ);
13470             DisplayMessage(_("Waiting for access to save file"), "");
13471             flock(fileno(f), LOCK_EX); // [HGM] lock: lock file while we are writing
13472             DisplayMessage(_("Saving game"), "");
13473             if(lseek(fileno(f), 0, SEEK_END) == -1) DisplayError(_("Bad Seek"), errno);     // better safe than sorry...
13474             result = SaveGame(f, 0, NULL);
13475             DisplayMessage(buf, "");
13476             return result;
13477         }
13478     }
13479 }
13480
13481 char *
13482 SavePart (char *str)
13483 {
13484     static char buf[MSG_SIZ];
13485     char *p;
13486
13487     p = strchr(str, ' ');
13488     if (p == NULL) return str;
13489     strncpy(buf, str, p - str);
13490     buf[p - str] = NULLCHAR;
13491     return buf;
13492 }
13493
13494 #define PGN_MAX_LINE 75
13495
13496 #define PGN_SIDE_WHITE  0
13497 #define PGN_SIDE_BLACK  1
13498
13499 static int
13500 FindFirstMoveOutOfBook (int side)
13501 {
13502     int result = -1;
13503
13504     if( backwardMostMove == 0 && ! startedFromSetupPosition) {
13505         int index = backwardMostMove;
13506         int has_book_hit = 0;
13507
13508         if( (index % 2) != side ) {
13509             index++;
13510         }
13511
13512         while( index < forwardMostMove ) {
13513             /* Check to see if engine is in book */
13514             int depth = pvInfoList[index].depth;
13515             int score = pvInfoList[index].score;
13516             int in_book = 0;
13517
13518             if( depth <= 2 ) {
13519                 in_book = 1;
13520             }
13521             else if( score == 0 && depth == 63 ) {
13522                 in_book = 1; /* Zappa */
13523             }
13524             else if( score == 2 && depth == 99 ) {
13525                 in_book = 1; /* Abrok */
13526             }
13527
13528             has_book_hit += in_book;
13529
13530             if( ! in_book ) {
13531                 result = index;
13532
13533                 break;
13534             }
13535
13536             index += 2;
13537         }
13538     }
13539
13540     return result;
13541 }
13542
13543 void
13544 GetOutOfBookInfo (char * buf)
13545 {
13546     int oob[2];
13547     int i;
13548     int offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
13549
13550     oob[0] = FindFirstMoveOutOfBook( PGN_SIDE_WHITE );
13551     oob[1] = FindFirstMoveOutOfBook( PGN_SIDE_BLACK );
13552
13553     *buf = '\0';
13554
13555     if( oob[0] >= 0 || oob[1] >= 0 ) {
13556         for( i=0; i<2; i++ ) {
13557             int idx = oob[i];
13558
13559             if( idx >= 0 ) {
13560                 if( i > 0 && oob[0] >= 0 ) {
13561                     strcat( buf, "   " );
13562                 }
13563
13564                 sprintf( buf+strlen(buf), "%d%s. ", (idx - offset)/2 + 1, idx & 1 ? ".." : "" );
13565                 sprintf( buf+strlen(buf), "%s%.2f",
13566                     pvInfoList[idx].score >= 0 ? "+" : "",
13567                     pvInfoList[idx].score / 100.0 );
13568             }
13569         }
13570     }
13571 }
13572
13573 /* Save game in PGN style */
13574 static void
13575 SaveGamePGN2 (FILE *f)
13576 {
13577     int i, offset, linelen, newblock;
13578 //    char *movetext;
13579     char numtext[32];
13580     int movelen, numlen, blank;
13581     char move_buffer[100]; /* [AS] Buffer for move+PV info */
13582
13583     offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
13584
13585     PrintPGNTags(f, &gameInfo);
13586
13587     if(appData.numberTag && matchMode) fprintf(f, "[Number \"%d\"]\n", nextGame+1); // [HGM] number tag
13588
13589     if (backwardMostMove > 0 || startedFromSetupPosition) {
13590         char *fen = PositionToFEN(backwardMostMove, NULL, 1);
13591         fprintf(f, "[FEN \"%s\"]\n[SetUp \"1\"]\n", fen);
13592         fprintf(f, "\n{--------------\n");
13593         PrintPosition(f, backwardMostMove);
13594         fprintf(f, "--------------}\n");
13595         free(fen);
13596     }
13597     else {
13598         /* [AS] Out of book annotation */
13599         if( appData.saveOutOfBookInfo ) {
13600             char buf[64];
13601
13602             GetOutOfBookInfo( buf );
13603
13604             if( buf[0] != '\0' ) {
13605                 fprintf( f, "[%s \"%s\"]\n", PGN_OUT_OF_BOOK, buf );
13606             }
13607         }
13608
13609         fprintf(f, "\n");
13610     }
13611
13612     i = backwardMostMove;
13613     linelen = 0;
13614     newblock = TRUE;
13615
13616     while (i < forwardMostMove) {
13617         /* Print comments preceding this move */
13618         if (commentList[i] != NULL) {
13619             if (linelen > 0) fprintf(f, "\n");
13620             fprintf(f, "%s", commentList[i]);
13621             linelen = 0;
13622             newblock = TRUE;
13623         }
13624
13625         /* Format move number */
13626         if ((i % 2) == 0)
13627           snprintf(numtext, sizeof(numtext)/sizeof(numtext[0]),"%d.", (i - offset)/2 + 1);
13628         else
13629           if (newblock)
13630             snprintf(numtext, sizeof(numtext)/sizeof(numtext[0]), "%d...", (i - offset)/2 + 1);
13631           else
13632             numtext[0] = NULLCHAR;
13633
13634         numlen = strlen(numtext);
13635         newblock = FALSE;
13636
13637         /* Print move number */
13638         blank = linelen > 0 && numlen > 0;
13639         if (linelen + (blank ? 1 : 0) + numlen > PGN_MAX_LINE) {
13640             fprintf(f, "\n");
13641             linelen = 0;
13642             blank = 0;
13643         }
13644         if (blank) {
13645             fprintf(f, " ");
13646             linelen++;
13647         }
13648         fprintf(f, "%s", numtext);
13649         linelen += numlen;
13650
13651         /* Get move */
13652         safeStrCpy(move_buffer, SavePart(parseList[i]), sizeof(move_buffer)/sizeof(move_buffer[0])); // [HGM] pgn: print move via buffer, so it can be edited
13653         movelen = strlen(move_buffer); /* [HGM] pgn: line-break point before move */
13654
13655         /* Print move */
13656         blank = linelen > 0 && movelen > 0;
13657         if (linelen + (blank ? 1 : 0) + movelen > PGN_MAX_LINE) {
13658             fprintf(f, "\n");
13659             linelen = 0;
13660             blank = 0;
13661         }
13662         if (blank) {
13663             fprintf(f, " ");
13664             linelen++;
13665         }
13666         fprintf(f, "%s", move_buffer);
13667         linelen += movelen;
13668
13669         /* [AS] Add PV info if present */
13670         if( i >= 0 && appData.saveExtendedInfoInPGN && pvInfoList[i].depth > 0 ) {
13671             /* [HGM] add time */
13672             char buf[MSG_SIZ]; int seconds;
13673
13674             seconds = (pvInfoList[i].time+5)/10; // deci-seconds, rounded to nearest
13675
13676             if( seconds <= 0)
13677               buf[0] = 0;
13678             else
13679               if( seconds < 30 )
13680                 snprintf(buf, MSG_SIZ, " %3.1f%c", seconds/10., 0);
13681               else
13682                 {
13683                   seconds = (seconds + 4)/10; // round to full seconds
13684                   if( seconds < 60 )
13685                     snprintf(buf, MSG_SIZ, " %d%c", seconds, 0);
13686                   else
13687                     snprintf(buf, MSG_SIZ, " %d:%02d%c", seconds/60, seconds%60, 0);
13688                 }
13689
13690             snprintf( move_buffer, sizeof(move_buffer)/sizeof(move_buffer[0]),"{%s%.2f/%d%s}",
13691                       pvInfoList[i].score >= 0 ? "+" : "",
13692                       pvInfoList[i].score / 100.0,
13693                       pvInfoList[i].depth,
13694                       buf );
13695
13696             movelen = strlen(move_buffer); /* [HGM] pgn: line-break point after move */
13697
13698             /* Print score/depth */
13699             blank = linelen > 0 && movelen > 0;
13700             if (linelen + (blank ? 1 : 0) + movelen > PGN_MAX_LINE) {
13701                 fprintf(f, "\n");
13702                 linelen = 0;
13703                 blank = 0;
13704             }
13705             if (blank) {
13706                 fprintf(f, " ");
13707                 linelen++;
13708             }
13709             fprintf(f, "%s", move_buffer);
13710             linelen += movelen;
13711         }
13712
13713         i++;
13714     }
13715
13716     /* Start a new line */
13717     if (linelen > 0) fprintf(f, "\n");
13718
13719     /* Print comments after last move */
13720     if (commentList[i] != NULL) {
13721         fprintf(f, "%s\n", commentList[i]);
13722     }
13723
13724     /* Print result */
13725     if (gameInfo.resultDetails != NULL &&
13726         gameInfo.resultDetails[0] != NULLCHAR) {
13727         char buf[MSG_SIZ], *p = gameInfo.resultDetails;
13728         if(gameInfo.result == GameUnfinished && appData.clockMode &&
13729            (gameMode == MachinePlaysWhite || gameMode == MachinePlaysBlack || gameMode == TwoMachinesPlay)) // [HGM] adjourn: save clock settings
13730             snprintf(buf, MSG_SIZ, "%s (Clocks: %ld, %ld)", p, whiteTimeRemaining/1000, blackTimeRemaining/1000), p = buf;
13731         fprintf(f, "{%s} %s\n\n", p, PGNResult(gameInfo.result));
13732     } else {
13733         fprintf(f, "%s\n\n", PGNResult(gameInfo.result));
13734     }
13735 }
13736
13737 /* Save game in PGN style and close the file */
13738 int
13739 SaveGamePGN (FILE *f)
13740 {
13741     SaveGamePGN2(f);
13742     fclose(f);
13743     lastSavedGame = GameCheckSum(); // [HGM] save: remember ID of last saved game to prevent double saving
13744     return TRUE;
13745 }
13746
13747 /* Save game in old style and close the file */
13748 int
13749 SaveGameOldStyle (FILE *f)
13750 {
13751     int i, offset;
13752     time_t tm;
13753
13754     tm = time((time_t *) NULL);
13755
13756     fprintf(f, "# %s game file -- %s", programName, ctime(&tm));
13757     PrintOpponents(f);
13758
13759     if (backwardMostMove > 0 || startedFromSetupPosition) {
13760         fprintf(f, "\n[--------------\n");
13761         PrintPosition(f, backwardMostMove);
13762         fprintf(f, "--------------]\n");
13763     } else {
13764         fprintf(f, "\n");
13765     }
13766
13767     i = backwardMostMove;
13768     offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
13769
13770     while (i < forwardMostMove) {
13771         if (commentList[i] != NULL) {
13772             fprintf(f, "[%s]\n", commentList[i]);
13773         }
13774
13775         if ((i % 2) == 1) {
13776             fprintf(f, "%d. ...  %s\n", (i - offset)/2 + 1, parseList[i]);
13777             i++;
13778         } else {
13779             fprintf(f, "%d. %s  ", (i - offset)/2 + 1, parseList[i]);
13780             i++;
13781             if (commentList[i] != NULL) {
13782                 fprintf(f, "\n");
13783                 continue;
13784             }
13785             if (i >= forwardMostMove) {
13786                 fprintf(f, "\n");
13787                 break;
13788             }
13789             fprintf(f, "%s\n", parseList[i]);
13790             i++;
13791         }
13792     }
13793
13794     if (commentList[i] != NULL) {
13795         fprintf(f, "[%s]\n", commentList[i]);
13796     }
13797
13798     /* This isn't really the old style, but it's close enough */
13799     if (gameInfo.resultDetails != NULL &&
13800         gameInfo.resultDetails[0] != NULLCHAR) {
13801         fprintf(f, "%s (%s)\n\n", PGNResult(gameInfo.result),
13802                 gameInfo.resultDetails);
13803     } else {
13804         fprintf(f, "%s\n\n", PGNResult(gameInfo.result));
13805     }
13806
13807     fclose(f);
13808     return TRUE;
13809 }
13810
13811 /* Save the current game to open file f and close the file */
13812 int
13813 SaveGame (FILE *f, int dummy, char *dummy2)
13814 {
13815     if (gameMode == EditPosition) EditPositionDone(TRUE);
13816     lastSavedGame = GameCheckSum(); // [HGM] save: remember ID of last saved game to prevent double saving
13817     if (appData.oldSaveStyle)
13818       return SaveGameOldStyle(f);
13819     else
13820       return SaveGamePGN(f);
13821 }
13822
13823 /* Save the current position to the given file */
13824 int
13825 SavePositionToFile (char *filename)
13826 {
13827     FILE *f;
13828     char buf[MSG_SIZ];
13829
13830     if (strcmp(filename, "-") == 0) {
13831         return SavePosition(stdout, 0, NULL);
13832     } else {
13833         f = fopen(filename, "a");
13834         if (f == NULL) {
13835             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
13836             DisplayError(buf, errno);
13837             return FALSE;
13838         } else {
13839             safeStrCpy(buf, lastMsg, MSG_SIZ);
13840             DisplayMessage(_("Waiting for access to save file"), "");
13841             flock(fileno(f), LOCK_EX); // [HGM] lock
13842             DisplayMessage(_("Saving position"), "");
13843             lseek(fileno(f), 0, SEEK_END);     // better safe than sorry...
13844             SavePosition(f, 0, NULL);
13845             DisplayMessage(buf, "");
13846             return TRUE;
13847         }
13848     }
13849 }
13850
13851 /* Save the current position to the given open file and close the file */
13852 int
13853 SavePosition (FILE *f, int dummy, char *dummy2)
13854 {
13855     time_t tm;
13856     char *fen;
13857
13858     if (gameMode == EditPosition) EditPositionDone(TRUE);
13859     if (appData.oldSaveStyle) {
13860         tm = time((time_t *) NULL);
13861
13862         fprintf(f, "# %s position file -- %s", programName, ctime(&tm));
13863         PrintOpponents(f);
13864         fprintf(f, "[--------------\n");
13865         PrintPosition(f, currentMove);
13866         fprintf(f, "--------------]\n");
13867     } else {
13868         fen = PositionToFEN(currentMove, NULL, 1);
13869         fprintf(f, "%s\n", fen);
13870         free(fen);
13871     }
13872     fclose(f);
13873     return TRUE;
13874 }
13875
13876 void
13877 ReloadCmailMsgEvent (int unregister)
13878 {
13879 #if !WIN32
13880     static char *inFilename = NULL;
13881     static char *outFilename;
13882     int i;
13883     struct stat inbuf, outbuf;
13884     int status;
13885
13886     /* Any registered moves are unregistered if unregister is set, */
13887     /* i.e. invoked by the signal handler */
13888     if (unregister) {
13889         for (i = 0; i < CMAIL_MAX_GAMES; i ++) {
13890             cmailMoveRegistered[i] = FALSE;
13891             if (cmailCommentList[i] != NULL) {
13892                 free(cmailCommentList[i]);
13893                 cmailCommentList[i] = NULL;
13894             }
13895         }
13896         nCmailMovesRegistered = 0;
13897     }
13898
13899     for (i = 0; i < CMAIL_MAX_GAMES; i ++) {
13900         cmailResult[i] = CMAIL_NOT_RESULT;
13901     }
13902     nCmailResults = 0;
13903
13904     if (inFilename == NULL) {
13905         /* Because the filenames are static they only get malloced once  */
13906         /* and they never get freed                                      */
13907         inFilename = (char *) malloc(strlen(appData.cmailGameName) + 9);
13908         sprintf(inFilename, "%s.game.in", appData.cmailGameName);
13909
13910         outFilename = (char *) malloc(strlen(appData.cmailGameName) + 5);
13911         sprintf(outFilename, "%s.out", appData.cmailGameName);
13912     }
13913
13914     status = stat(outFilename, &outbuf);
13915     if (status < 0) {
13916         cmailMailedMove = FALSE;
13917     } else {
13918         status = stat(inFilename, &inbuf);
13919         cmailMailedMove = (inbuf.st_mtime < outbuf.st_mtime);
13920     }
13921
13922     /* LoadGameFromFile(CMAIL_MAX_GAMES) with cmailMsgLoaded == TRUE
13923        counts the games, notes how each one terminated, etc.
13924
13925        It would be nice to remove this kludge and instead gather all
13926        the information while building the game list.  (And to keep it
13927        in the game list nodes instead of having a bunch of fixed-size
13928        parallel arrays.)  Note this will require getting each game's
13929        termination from the PGN tags, as the game list builder does
13930        not process the game moves.  --mann
13931        */
13932     cmailMsgLoaded = TRUE;
13933     LoadGameFromFile(inFilename, CMAIL_MAX_GAMES, "", FALSE);
13934
13935     /* Load first game in the file or popup game menu */
13936     LoadGameFromFile(inFilename, 0, appData.cmailGameName, TRUE);
13937
13938 #endif /* !WIN32 */
13939     return;
13940 }
13941
13942 int
13943 RegisterMove ()
13944 {
13945     FILE *f;
13946     char string[MSG_SIZ];
13947
13948     if (   cmailMailedMove
13949         || (cmailResult[lastLoadGameNumber - 1] == CMAIL_OLD_RESULT)) {
13950         return TRUE;            /* Allow free viewing  */
13951     }
13952
13953     /* Unregister move to ensure that we don't leave RegisterMove        */
13954     /* with the move registered when the conditions for registering no   */
13955     /* longer hold                                                       */
13956     if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
13957         cmailMoveRegistered[lastLoadGameNumber - 1] = FALSE;
13958         nCmailMovesRegistered --;
13959
13960         if (cmailCommentList[lastLoadGameNumber - 1] != NULL)
13961           {
13962               free(cmailCommentList[lastLoadGameNumber - 1]);
13963               cmailCommentList[lastLoadGameNumber - 1] = NULL;
13964           }
13965     }
13966
13967     if (cmailOldMove == -1) {
13968         DisplayError(_("You have edited the game history.\nUse Reload Same Game and make your move again."), 0);
13969         return FALSE;
13970     }
13971
13972     if (currentMove > cmailOldMove + 1) {
13973         DisplayError(_("You have entered too many moves.\nBack up to the correct position and try again."), 0);
13974         return FALSE;
13975     }
13976
13977     if (currentMove < cmailOldMove) {
13978         DisplayError(_("Displayed position is not current.\nStep forward to the correct position and try again."), 0);
13979         return FALSE;
13980     }
13981
13982     if (forwardMostMove > currentMove) {
13983         /* Silently truncate extra moves */
13984         TruncateGame();
13985     }
13986
13987     if (   (currentMove == cmailOldMove + 1)
13988         || (   (currentMove == cmailOldMove)
13989             && (   (cmailMoveType[lastLoadGameNumber - 1] == CMAIL_ACCEPT)
13990                 || (cmailMoveType[lastLoadGameNumber - 1] == CMAIL_RESIGN)))) {
13991         if (gameInfo.result != GameUnfinished) {
13992             cmailResult[lastLoadGameNumber - 1] = CMAIL_NEW_RESULT;
13993         }
13994
13995         if (commentList[currentMove] != NULL) {
13996             cmailCommentList[lastLoadGameNumber - 1]
13997               = StrSave(commentList[currentMove]);
13998         }
13999         safeStrCpy(cmailMove[lastLoadGameNumber - 1], moveList[currentMove - 1], sizeof(cmailMove[lastLoadGameNumber - 1])/sizeof(cmailMove[lastLoadGameNumber - 1][0]));
14000
14001         if (appData.debugMode)
14002           fprintf(debugFP, "Saving %s for game %d\n",
14003                   cmailMove[lastLoadGameNumber - 1], lastLoadGameNumber);
14004
14005         snprintf(string, MSG_SIZ, "%s.game.out.%d", appData.cmailGameName, lastLoadGameNumber);
14006
14007         f = fopen(string, "w");
14008         if (appData.oldSaveStyle) {
14009             SaveGameOldStyle(f); /* also closes the file */
14010
14011             snprintf(string, MSG_SIZ, "%s.pos.out", appData.cmailGameName);
14012             f = fopen(string, "w");
14013             SavePosition(f, 0, NULL); /* also closes the file */
14014         } else {
14015             fprintf(f, "{--------------\n");
14016             PrintPosition(f, currentMove);
14017             fprintf(f, "--------------}\n\n");
14018
14019             SaveGame(f, 0, NULL); /* also closes the file*/
14020         }
14021
14022         cmailMoveRegistered[lastLoadGameNumber - 1] = TRUE;
14023         nCmailMovesRegistered ++;
14024     } else if (nCmailGames == 1) {
14025         DisplayError(_("You have not made a move yet"), 0);
14026         return FALSE;
14027     }
14028
14029     return TRUE;
14030 }
14031
14032 void
14033 MailMoveEvent ()
14034 {
14035 #if !WIN32
14036     static char *partCommandString = "cmail -xv%s -remail -game %s 2>&1";
14037     FILE *commandOutput;
14038     char buffer[MSG_SIZ], msg[MSG_SIZ], string[MSG_SIZ];
14039     int nBytes = 0;             /*  Suppress warnings on uninitialized variables    */
14040     int nBuffers;
14041     int i;
14042     int archived;
14043     char *arcDir;
14044
14045     if (! cmailMsgLoaded) {
14046         DisplayError(_("The cmail message is not loaded.\nUse Reload CMail Message and make your move again."), 0);
14047         return;
14048     }
14049
14050     if (nCmailGames == nCmailResults) {
14051         DisplayError(_("No unfinished games"), 0);
14052         return;
14053     }
14054
14055 #if CMAIL_PROHIBIT_REMAIL
14056     if (cmailMailedMove) {
14057       snprintf(msg, MSG_SIZ, _("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);
14058         DisplayError(msg, 0);
14059         return;
14060     }
14061 #endif
14062
14063     if (! (cmailMailedMove || RegisterMove())) return;
14064
14065     if (   cmailMailedMove
14066         || (nCmailMovesRegistered + nCmailResults == nCmailGames)) {
14067       snprintf(string, MSG_SIZ, partCommandString,
14068                appData.debugMode ? " -v" : "", appData.cmailGameName);
14069         commandOutput = popen(string, "r");
14070
14071         if (commandOutput == NULL) {
14072             DisplayError(_("Failed to invoke cmail"), 0);
14073         } else {
14074             for (nBuffers = 0; (! feof(commandOutput)); nBuffers ++) {
14075                 nBytes = fread(buffer, 1, MSG_SIZ - 1, commandOutput);
14076             }
14077             if (nBuffers > 1) {
14078                 (void) memcpy(msg, buffer + nBytes, MSG_SIZ - nBytes - 1);
14079                 (void) memcpy(msg + MSG_SIZ - nBytes - 1, buffer, nBytes);
14080                 nBytes = MSG_SIZ - 1;
14081             } else {
14082                 (void) memcpy(msg, buffer, nBytes);
14083             }
14084             *(msg + nBytes) = '\0'; /* \0 for end-of-string*/
14085
14086             if(StrStr(msg, "Mailed cmail message to ") != NULL) {
14087                 cmailMailedMove = TRUE; /* Prevent >1 moves    */
14088
14089                 archived = TRUE;
14090                 for (i = 0; i < nCmailGames; i ++) {
14091                     if (cmailResult[i] == CMAIL_NOT_RESULT) {
14092                         archived = FALSE;
14093                     }
14094                 }
14095                 if (   archived
14096                     && (   (arcDir = (char *) getenv("CMAIL_ARCDIR"))
14097                         != NULL)) {
14098                   snprintf(buffer, MSG_SIZ, "%s/%s.%s.archive",
14099                            arcDir,
14100                            appData.cmailGameName,
14101                            gameInfo.date);
14102                     LoadGameFromFile(buffer, 1, buffer, FALSE);
14103                     cmailMsgLoaded = FALSE;
14104                 }
14105             }
14106
14107             DisplayInformation(msg);
14108             pclose(commandOutput);
14109         }
14110     } else {
14111         if ((*cmailMsg) != '\0') {
14112             DisplayInformation(cmailMsg);
14113         }
14114     }
14115
14116     return;
14117 #endif /* !WIN32 */
14118 }
14119
14120 char *
14121 CmailMsg ()
14122 {
14123 #if WIN32
14124     return NULL;
14125 #else
14126     int  prependComma = 0;
14127     char number[5];
14128     char string[MSG_SIZ];       /* Space for game-list */
14129     int  i;
14130
14131     if (!cmailMsgLoaded) return "";
14132
14133     if (cmailMailedMove) {
14134       snprintf(cmailMsg, MSG_SIZ, _("Waiting for reply from opponent\n"));
14135     } else {
14136         /* Create a list of games left */
14137       snprintf(string, MSG_SIZ, "[");
14138         for (i = 0; i < nCmailGames; i ++) {
14139             if (! (   cmailMoveRegistered[i]
14140                    || (cmailResult[i] == CMAIL_OLD_RESULT))) {
14141                 if (prependComma) {
14142                     snprintf(number, sizeof(number)/sizeof(number[0]), ",%d", i + 1);
14143                 } else {
14144                     snprintf(number, sizeof(number)/sizeof(number[0]), "%d", i + 1);
14145                     prependComma = 1;
14146                 }
14147
14148                 strcat(string, number);
14149             }
14150         }
14151         strcat(string, "]");
14152
14153         if (nCmailMovesRegistered + nCmailResults == 0) {
14154             switch (nCmailGames) {
14155               case 1:
14156                 snprintf(cmailMsg, MSG_SIZ, _("Still need to make move for game\n"));
14157                 break;
14158
14159               case 2:
14160                 snprintf(cmailMsg, MSG_SIZ, _("Still need to make moves for both games\n"));
14161                 break;
14162
14163               default:
14164                 snprintf(cmailMsg, MSG_SIZ, _("Still need to make moves for all %d games\n"),
14165                          nCmailGames);
14166                 break;
14167             }
14168         } else {
14169             switch (nCmailGames - nCmailMovesRegistered - nCmailResults) {
14170               case 1:
14171                 snprintf(cmailMsg, MSG_SIZ, _("Still need to make a move for game %s\n"),
14172                          string);
14173                 break;
14174
14175               case 0:
14176                 if (nCmailResults == nCmailGames) {
14177                   snprintf(cmailMsg, MSG_SIZ, _("No unfinished games\n"));
14178                 } else {
14179                   snprintf(cmailMsg, MSG_SIZ, _("Ready to send mail\n"));
14180                 }
14181                 break;
14182
14183               default:
14184                 snprintf(cmailMsg, MSG_SIZ, _("Still need to make moves for games %s\n"),
14185                          string);
14186             }
14187         }
14188     }
14189     return cmailMsg;
14190 #endif /* WIN32 */
14191 }
14192
14193 void
14194 ResetGameEvent ()
14195 {
14196     if (gameMode == Training)
14197       SetTrainingModeOff();
14198
14199     Reset(TRUE, TRUE);
14200     cmailMsgLoaded = FALSE;
14201     if (appData.icsActive) {
14202       SendToICS(ics_prefix);
14203       SendToICS("refresh\n");
14204     }
14205 }
14206
14207 void
14208 ExitEvent (int status)
14209 {
14210     exiting++;
14211     if (exiting > 2) {
14212       /* Give up on clean exit */
14213       exit(status);
14214     }
14215     if (exiting > 1) {
14216       /* Keep trying for clean exit */
14217       return;
14218     }
14219
14220     if (appData.icsActive) printf("\n"); // [HGM] end on new line after closing XBoard
14221     if (appData.icsActive && appData.colorize) Colorize(ColorNone, FALSE);
14222
14223     if (telnetISR != NULL) {
14224       RemoveInputSource(telnetISR);
14225     }
14226     if (icsPR != NoProc) {
14227       DestroyChildProcess(icsPR, TRUE);
14228     }
14229
14230     /* [HGM] crash: leave writing PGN and position entirely to GameEnds() */
14231     GameEnds(gameInfo.result, gameInfo.resultDetails==NULL ? "xboard exit" : gameInfo.resultDetails, GE_PLAYER);
14232
14233     /* [HGM] crash: the above GameEnds() is a dud if another one was running */
14234     /* make sure this other one finishes before killing it!                  */
14235     if(endingGame) { int count = 0;
14236         if(appData.debugMode) fprintf(debugFP, "ExitEvent() during GameEnds(), wait\n");
14237         while(endingGame && count++ < 10) DoSleep(1);
14238         if(appData.debugMode && endingGame) fprintf(debugFP, "GameEnds() seems stuck, proceed exiting\n");
14239     }
14240
14241     /* Kill off chess programs */
14242     if (first.pr != NoProc) {
14243         ExitAnalyzeMode();
14244
14245         DoSleep( appData.delayBeforeQuit );
14246         SendToProgram("quit\n", &first);
14247         DestroyChildProcess(first.pr, 4 + first.useSigterm /* [AS] first.useSigterm */ );
14248     }
14249     if (second.pr != NoProc) {
14250         DoSleep( appData.delayBeforeQuit );
14251         SendToProgram("quit\n", &second);
14252         DestroyChildProcess(second.pr, 4 + second.useSigterm /* [AS] second.useSigterm */ );
14253     }
14254     if (first.isr != NULL) {
14255         RemoveInputSource(first.isr);
14256     }
14257     if (second.isr != NULL) {
14258         RemoveInputSource(second.isr);
14259     }
14260
14261     if (pairing.pr != NoProc) SendToProgram("quit\n", &pairing);
14262     if (pairing.isr != NULL) RemoveInputSource(pairing.isr);
14263
14264     ShutDownFrontEnd();
14265     exit(status);
14266 }
14267
14268 void
14269 PauseEngine (ChessProgramState *cps)
14270 {
14271     SendToProgram("pause\n", cps);
14272     cps->pause = 2;
14273 }
14274
14275 void
14276 UnPauseEngine (ChessProgramState *cps)
14277 {
14278     SendToProgram("resume\n", cps);
14279     cps->pause = 1;
14280 }
14281
14282 void
14283 PauseEvent ()
14284 {
14285     if (appData.debugMode)
14286         fprintf(debugFP, "PauseEvent(): pausing %d\n", pausing);
14287     if (pausing) {
14288         pausing = FALSE;
14289         ModeHighlight();
14290         if(stalledEngine) { // [HGM] pause: resume game by releasing withheld move
14291             StartClocks();
14292             if(gameMode == TwoMachinesPlay) { // we might have to make the opponent resume pondering
14293                 if(stalledEngine->other->pause == 2) UnPauseEngine(stalledEngine->other);
14294                 else if(appData.ponderNextMove) SendToProgram("hard\n", stalledEngine->other);
14295             }
14296             if(appData.ponderNextMove) SendToProgram("hard\n", stalledEngine);
14297             HandleMachineMove(stashedInputMove, stalledEngine);
14298             stalledEngine = NULL;
14299             return;
14300         }
14301         if (gameMode == MachinePlaysWhite ||
14302             gameMode == TwoMachinesPlay   ||
14303             gameMode == MachinePlaysBlack) { // the thinking engine must have used pause mode, or it would have been stalledEngine
14304             if(first.pause)  UnPauseEngine(&first);
14305             else if(appData.ponderNextMove) SendToProgram("hard\n", &first);
14306             if(second.pause) UnPauseEngine(&second);
14307             else if(gameMode == TwoMachinesPlay && appData.ponderNextMove) SendToProgram("hard\n", &second);
14308             StartClocks();
14309         } else {
14310             DisplayBothClocks();
14311         }
14312         if (gameMode == PlayFromGameFile) {
14313             if (appData.timeDelay >= 0)
14314                 AutoPlayGameLoop();
14315         } else if (gameMode == IcsExamining && pauseExamInvalid) {
14316             Reset(FALSE, TRUE);
14317             SendToICS(ics_prefix);
14318             SendToICS("refresh\n");
14319         } else if (currentMove < forwardMostMove && gameMode != AnalyzeMode) {
14320             ForwardInner(forwardMostMove);
14321         }
14322         pauseExamInvalid = FALSE;
14323     } else {
14324         switch (gameMode) {
14325           default:
14326             return;
14327           case IcsExamining:
14328             pauseExamForwardMostMove = forwardMostMove;
14329             pauseExamInvalid = FALSE;
14330             /* fall through */
14331           case IcsObserving:
14332           case IcsPlayingWhite:
14333           case IcsPlayingBlack:
14334             pausing = TRUE;
14335             ModeHighlight();
14336             return;
14337           case PlayFromGameFile:
14338             (void) StopLoadGameTimer();
14339             pausing = TRUE;
14340             ModeHighlight();
14341             break;
14342           case BeginningOfGame:
14343             if (appData.icsActive) return;
14344             /* else fall through */
14345           case MachinePlaysWhite:
14346           case MachinePlaysBlack:
14347           case TwoMachinesPlay:
14348             if (forwardMostMove == 0)
14349               return;           /* don't pause if no one has moved */
14350             if(gameMode == TwoMachinesPlay) { // [HGM] pause: stop clocks if engine can be paused immediately
14351                 ChessProgramState *onMove = (WhiteOnMove(forwardMostMove) == (first.twoMachinesColor[0] == 'w') ? &first : &second);
14352                 if(onMove->pause) {           // thinking engine can be paused
14353                     PauseEngine(onMove);      // do it
14354                     if(onMove->other->pause)  // pondering opponent can always be paused immediately
14355                         PauseEngine(onMove->other);
14356                     else
14357                         SendToProgram("easy\n", onMove->other);
14358                     StopClocks();
14359                 } else if(appData.ponderNextMove) SendToProgram("easy\n", onMove); // pre-emptively bring out of ponder
14360             } else if(gameMode == (WhiteOnMove(forwardMostMove) ? MachinePlaysWhite : MachinePlaysBlack)) { // engine on move
14361                 if(first.pause) {
14362                     PauseEngine(&first);
14363                     StopClocks();
14364                 } else if(appData.ponderNextMove) SendToProgram("easy\n", &first); // pre-emptively bring out of ponder
14365             } else { // human on move, pause pondering by either method
14366                 if(first.pause)
14367                     PauseEngine(&first);
14368                 else if(appData.ponderNextMove)
14369                     SendToProgram("easy\n", &first);
14370                 StopClocks();
14371             }
14372             // if no immediate pausing is possible, wait for engine to move, and stop clocks then
14373           case AnalyzeMode:
14374             pausing = TRUE;
14375             ModeHighlight();
14376             break;
14377         }
14378     }
14379 }
14380
14381 void
14382 EditCommentEvent ()
14383 {
14384     char title[MSG_SIZ];
14385
14386     if (currentMove < 1 || parseList[currentMove - 1][0] == NULLCHAR) {
14387       safeStrCpy(title, _("Edit comment"), sizeof(title)/sizeof(title[0]));
14388     } else {
14389       snprintf(title, MSG_SIZ, _("Edit comment on %d.%s%s"), (currentMove - 1) / 2 + 1,
14390                WhiteOnMove(currentMove - 1) ? " " : ".. ",
14391                parseList[currentMove - 1]);
14392     }
14393
14394     EditCommentPopUp(currentMove, title, commentList[currentMove]);
14395 }
14396
14397
14398 void
14399 EditTagsEvent ()
14400 {
14401     char *tags = PGNTags(&gameInfo);
14402     bookUp = FALSE;
14403     EditTagsPopUp(tags, NULL);
14404     free(tags);
14405 }
14406
14407 void
14408 ToggleSecond ()
14409 {
14410   if(second.analyzing) {
14411     SendToProgram("exit\n", &second);
14412     second.analyzing = FALSE;
14413   } else {
14414     if (second.pr == NoProc) StartChessProgram(&second);
14415     InitChessProgram(&second, FALSE);
14416     FeedMovesToProgram(&second, currentMove);
14417
14418     SendToProgram("analyze\n", &second);
14419     second.analyzing = TRUE;
14420   }
14421 }
14422
14423 /* Toggle ShowThinking */
14424 void
14425 ToggleShowThinking()
14426 {
14427   appData.showThinking = !appData.showThinking;
14428   ShowThinkingEvent();
14429 }
14430
14431 int
14432 AnalyzeModeEvent ()
14433 {
14434     char buf[MSG_SIZ];
14435
14436     if (!first.analysisSupport) {
14437       snprintf(buf, sizeof(buf), _("%s does not support analysis"), first.tidy);
14438       DisplayError(buf, 0);
14439       return 0;
14440     }
14441     /* [DM] icsEngineAnalyze [HGM] This is horrible code; reverse the gameMode and isEngineAnalyze tests! */
14442     if (appData.icsActive) {
14443         if (gameMode != IcsObserving) {
14444           snprintf(buf, MSG_SIZ, _("You are not observing a game"));
14445             DisplayError(buf, 0);
14446             /* secure check */
14447             if (appData.icsEngineAnalyze) {
14448                 if (appData.debugMode)
14449                     fprintf(debugFP, "Found unexpected active ICS engine analyze \n");
14450                 ExitAnalyzeMode();
14451                 ModeHighlight();
14452             }
14453             return 0;
14454         }
14455         /* if enable, user wants to disable icsEngineAnalyze */
14456         if (appData.icsEngineAnalyze) {
14457                 ExitAnalyzeMode();
14458                 ModeHighlight();
14459                 return 0;
14460         }
14461         appData.icsEngineAnalyze = TRUE;
14462         if (appData.debugMode)
14463             fprintf(debugFP, "ICS engine analyze starting... \n");
14464     }
14465
14466     if (gameMode == AnalyzeMode) { ToggleSecond(); return 0; }
14467     if (appData.noChessProgram || gameMode == AnalyzeMode)
14468       return 0;
14469
14470     if (gameMode != AnalyzeFile) {
14471         if (!appData.icsEngineAnalyze) {
14472                EditGameEvent();
14473                if (gameMode != EditGame) return 0;
14474         }
14475         if (!appData.showThinking) ToggleShowThinking();
14476         ResurrectChessProgram();
14477         SendToProgram("analyze\n", &first);
14478         first.analyzing = TRUE;
14479         /*first.maybeThinking = TRUE;*/
14480         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
14481         EngineOutputPopUp();
14482     }
14483     if (!appData.icsEngineAnalyze) {
14484         gameMode = AnalyzeMode;
14485         ClearEngineOutputPane(0); // [TK] exclude: to print exclusion/multipv header
14486     }
14487     pausing = FALSE;
14488     ModeHighlight();
14489     SetGameInfo();
14490
14491     StartAnalysisClock();
14492     GetTimeMark(&lastNodeCountTime);
14493     lastNodeCount = 0;
14494     return 1;
14495 }
14496
14497 void
14498 AnalyzeFileEvent ()
14499 {
14500     if (appData.noChessProgram || gameMode == AnalyzeFile)
14501       return;
14502
14503     if (!first.analysisSupport) {
14504       char buf[MSG_SIZ];
14505       snprintf(buf, sizeof(buf), _("%s does not support analysis"), first.tidy);
14506       DisplayError(buf, 0);
14507       return;
14508     }
14509
14510     if (gameMode != AnalyzeMode) {
14511         keepInfo = 1; // mere annotating should not alter PGN tags
14512         EditGameEvent();
14513         keepInfo = 0;
14514         if (gameMode != EditGame) return;
14515         if (!appData.showThinking) ToggleShowThinking();
14516         ResurrectChessProgram();
14517         SendToProgram("analyze\n", &first);
14518         first.analyzing = TRUE;
14519         /*first.maybeThinking = TRUE;*/
14520         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
14521         EngineOutputPopUp();
14522     }
14523     gameMode = AnalyzeFile;
14524     pausing = FALSE;
14525     ModeHighlight();
14526
14527     StartAnalysisClock();
14528     GetTimeMark(&lastNodeCountTime);
14529     lastNodeCount = 0;
14530     if(appData.timeDelay > 0) StartLoadGameTimer((long)(1000.0f * appData.timeDelay));
14531     AnalysisPeriodicEvent(1);
14532 }
14533
14534 void
14535 MachineWhiteEvent ()
14536 {
14537     char buf[MSG_SIZ];
14538     char *bookHit = NULL;
14539
14540     if (appData.noChessProgram || (gameMode == MachinePlaysWhite))
14541       return;
14542
14543
14544     if (gameMode == PlayFromGameFile ||
14545         gameMode == TwoMachinesPlay  ||
14546         gameMode == Training         ||
14547         gameMode == AnalyzeMode      ||
14548         gameMode == EndOfGame)
14549         EditGameEvent();
14550
14551     if (gameMode == EditPosition)
14552         EditPositionDone(TRUE);
14553
14554     if (!WhiteOnMove(currentMove)) {
14555         DisplayError(_("It is not White's turn"), 0);
14556         return;
14557     }
14558
14559     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile)
14560       ExitAnalyzeMode();
14561
14562     if (gameMode == EditGame || gameMode == AnalyzeMode ||
14563         gameMode == AnalyzeFile)
14564         TruncateGame();
14565
14566     ResurrectChessProgram();    /* in case it isn't running */
14567     if(gameMode == BeginningOfGame) { /* [HGM] time odds: to get right odds in human mode */
14568         gameMode = MachinePlaysWhite;
14569         ResetClocks();
14570     } else
14571     gameMode = MachinePlaysWhite;
14572     pausing = FALSE;
14573     ModeHighlight();
14574     SetGameInfo();
14575     snprintf(buf, MSG_SIZ, "%s %s %s", gameInfo.white, _("vs."), gameInfo.black);
14576     DisplayTitle(buf);
14577     if (first.sendName) {
14578       snprintf(buf, MSG_SIZ, "name %s\n", gameInfo.black);
14579       SendToProgram(buf, &first);
14580     }
14581     if (first.sendTime) {
14582       if (first.useColors) {
14583         SendToProgram("black\n", &first); /*gnu kludge*/
14584       }
14585       SendTimeRemaining(&first, TRUE);
14586     }
14587     if (first.useColors) {
14588       SendToProgram("white\n", &first); // [HGM] book: send 'go' separately
14589     }
14590     bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: send go or retrieve book move
14591     SetMachineThinkingEnables();
14592     first.maybeThinking = TRUE;
14593     StartClocks();
14594     firstMove = FALSE;
14595
14596     if (appData.autoFlipView && !flipView) {
14597       flipView = !flipView;
14598       DrawPosition(FALSE, NULL);
14599       DisplayBothClocks();       // [HGM] logo: clocks might have to be exchanged;
14600     }
14601
14602     if(bookHit) { // [HGM] book: simulate book reply
14603         static char bookMove[MSG_SIZ]; // a bit generous?
14604
14605         programStats.nodes = programStats.depth = programStats.time =
14606         programStats.score = programStats.got_only_move = 0;
14607         sprintf(programStats.movelist, "%s (xbook)", bookHit);
14608
14609         safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
14610         strcat(bookMove, bookHit);
14611         HandleMachineMove(bookMove, &first);
14612     }
14613 }
14614
14615 void
14616 MachineBlackEvent ()
14617 {
14618   char buf[MSG_SIZ];
14619   char *bookHit = NULL;
14620
14621     if (appData.noChessProgram || (gameMode == MachinePlaysBlack))
14622         return;
14623
14624
14625     if (gameMode == PlayFromGameFile ||
14626         gameMode == TwoMachinesPlay  ||
14627         gameMode == Training         ||
14628         gameMode == AnalyzeMode      ||
14629         gameMode == EndOfGame)
14630         EditGameEvent();
14631
14632     if (gameMode == EditPosition)
14633         EditPositionDone(TRUE);
14634
14635     if (WhiteOnMove(currentMove)) {
14636         DisplayError(_("It is not Black's turn"), 0);
14637         return;
14638     }
14639
14640     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile)
14641       ExitAnalyzeMode();
14642
14643     if (gameMode == EditGame || gameMode == AnalyzeMode ||
14644         gameMode == AnalyzeFile)
14645         TruncateGame();
14646
14647     ResurrectChessProgram();    /* in case it isn't running */
14648     gameMode = MachinePlaysBlack;
14649     pausing = FALSE;
14650     ModeHighlight();
14651     SetGameInfo();
14652     snprintf(buf, MSG_SIZ, "%s %s %s", gameInfo.white, _("vs."), gameInfo.black);
14653     DisplayTitle(buf);
14654     if (first.sendName) {
14655       snprintf(buf, MSG_SIZ, "name %s\n", gameInfo.white);
14656       SendToProgram(buf, &first);
14657     }
14658     if (first.sendTime) {
14659       if (first.useColors) {
14660         SendToProgram("white\n", &first); /*gnu kludge*/
14661       }
14662       SendTimeRemaining(&first, FALSE);
14663     }
14664     if (first.useColors) {
14665       SendToProgram("black\n", &first); // [HGM] book: 'go' sent separately
14666     }
14667     bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: send go or retrieve book move
14668     SetMachineThinkingEnables();
14669     first.maybeThinking = TRUE;
14670     StartClocks();
14671
14672     if (appData.autoFlipView && flipView) {
14673       flipView = !flipView;
14674       DrawPosition(FALSE, NULL);
14675       DisplayBothClocks();       // [HGM] logo: clocks might have to be exchanged;
14676     }
14677     if(bookHit) { // [HGM] book: simulate book reply
14678         static char bookMove[MSG_SIZ]; // a bit generous?
14679
14680         programStats.nodes = programStats.depth = programStats.time =
14681         programStats.score = programStats.got_only_move = 0;
14682         sprintf(programStats.movelist, "%s (xbook)", bookHit);
14683
14684         safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
14685         strcat(bookMove, bookHit);
14686         HandleMachineMove(bookMove, &first);
14687     }
14688 }
14689
14690
14691 void
14692 DisplayTwoMachinesTitle ()
14693 {
14694     char buf[MSG_SIZ];
14695     if (appData.matchGames > 0) {
14696         if(appData.tourneyFile[0]) {
14697           snprintf(buf, MSG_SIZ, "%s %s %s (%d/%d%s)",
14698                    gameInfo.white, _("vs."), gameInfo.black,
14699                    nextGame+1, appData.matchGames+1,
14700                    appData.tourneyType>0 ? "gt" : appData.tourneyType<0 ? "sw" : "rr");
14701         } else
14702         if (first.twoMachinesColor[0] == 'w') {
14703           snprintf(buf, MSG_SIZ, "%s %s %s (%d-%d-%d)",
14704                    gameInfo.white, _("vs."),  gameInfo.black,
14705                    first.matchWins, second.matchWins,
14706                    matchGame - 1 - (first.matchWins + second.matchWins));
14707         } else {
14708           snprintf(buf, MSG_SIZ, "%s %s %s (%d-%d-%d)",
14709                    gameInfo.white, _("vs."), gameInfo.black,
14710                    second.matchWins, first.matchWins,
14711                    matchGame - 1 - (first.matchWins + second.matchWins));
14712         }
14713     } else {
14714       snprintf(buf, MSG_SIZ, "%s %s %s", gameInfo.white, _("vs."), gameInfo.black);
14715     }
14716     DisplayTitle(buf);
14717 }
14718
14719 void
14720 SettingsMenuIfReady ()
14721 {
14722   if (second.lastPing != second.lastPong) {
14723     DisplayMessage("", _("Waiting for second chess program"));
14724     ScheduleDelayedEvent(SettingsMenuIfReady, 10); // [HGM] fast: lowered from 1000
14725     return;
14726   }
14727   ThawUI();
14728   DisplayMessage("", "");
14729   SettingsPopUp(&second);
14730 }
14731
14732 int
14733 WaitForEngine (ChessProgramState *cps, DelayedEventCallback retry)
14734 {
14735     char buf[MSG_SIZ];
14736     if (cps->pr == NoProc) {
14737         StartChessProgram(cps);
14738         if (cps->protocolVersion == 1) {
14739           retry();
14740           ScheduleDelayedEvent(retry, 1); // Do this also through timeout to avoid recursive calling of 'retry'
14741         } else {
14742           /* kludge: allow timeout for initial "feature" command */
14743           if(retry != TwoMachinesEventIfReady) FreezeUI();
14744           snprintf(buf, MSG_SIZ, _("Starting %s chess program"), _(cps->which));
14745           DisplayMessage("", buf);
14746           ScheduleDelayedEvent(retry, FEATURE_TIMEOUT);
14747         }
14748         return 1;
14749     }
14750     return 0;
14751 }
14752
14753 void
14754 TwoMachinesEvent P((void))
14755 {
14756     int i;
14757     char buf[MSG_SIZ];
14758     ChessProgramState *onmove;
14759     char *bookHit = NULL;
14760     static int stalling = 0;
14761     TimeMark now;
14762     long wait;
14763
14764     if (appData.noChessProgram) return;
14765
14766     switch (gameMode) {
14767       case TwoMachinesPlay:
14768         return;
14769       case MachinePlaysWhite:
14770       case MachinePlaysBlack:
14771         if (WhiteOnMove(forwardMostMove) == (gameMode == MachinePlaysWhite)) {
14772             DisplayError(_("Wait until your turn,\nor select 'Move Now'."), 0);
14773             return;
14774         }
14775         /* fall through */
14776       case BeginningOfGame:
14777       case PlayFromGameFile:
14778       case EndOfGame:
14779         EditGameEvent();
14780         if (gameMode != EditGame) return;
14781         break;
14782       case EditPosition:
14783         EditPositionDone(TRUE);
14784         break;
14785       case AnalyzeMode:
14786       case AnalyzeFile:
14787         ExitAnalyzeMode();
14788         break;
14789       case EditGame:
14790       default:
14791         break;
14792     }
14793
14794 //    forwardMostMove = currentMove;
14795     TruncateGame(); // [HGM] vari: MachineWhite and MachineBlack do this...
14796     startingEngine = TRUE;
14797
14798     if(!ResurrectChessProgram()) return;   /* in case first program isn't running (unbalances its ping due to InitChessProgram!) */
14799
14800     if(!first.initDone && GetDelayedEvent() == TwoMachinesEventIfReady) return; // [HGM] engine #1 still waiting for feature timeout
14801     if(first.lastPing != first.lastPong) { // [HGM] wait till we are sure first engine has set up position
14802       ScheduleDelayedEvent(TwoMachinesEventIfReady, 10);
14803       return;
14804     }
14805     if(WaitForEngine(&second, TwoMachinesEventIfReady)) return; // (if needed:) started up second engine, so wait for features
14806
14807     if(!SupportedVariant(second.variants, gameInfo.variant, gameInfo.boardWidth,
14808                          gameInfo.boardHeight, gameInfo.holdingsSize, second.protocolVersion, second.tidy)) {
14809         startingEngine = matchMode = FALSE;
14810         DisplayError("second engine does not play this", 0);
14811         gameMode = TwoMachinesPlay; ModeHighlight(); // Needed to make sure menu item is unchecked
14812         EditGameEvent(); // switch back to EditGame mode
14813         return;
14814     }
14815
14816     if(!stalling) {
14817       InitChessProgram(&second, FALSE); // unbalances ping of second engine
14818       SendToProgram("force\n", &second);
14819       stalling = 1;
14820       ScheduleDelayedEvent(TwoMachinesEventIfReady, 10);
14821       return;
14822     }
14823     GetTimeMark(&now); // [HGM] matchpause: implement match pause after engine load
14824     if(appData.matchPause>10000 || appData.matchPause<10)
14825                 appData.matchPause = 10000; /* [HGM] make pause adjustable */
14826     wait = SubtractTimeMarks(&now, &pauseStart);
14827     if(wait < appData.matchPause) {
14828         ScheduleDelayedEvent(TwoMachinesEventIfReady, appData.matchPause - wait);
14829         return;
14830     }
14831     // we are now committed to starting the game
14832     stalling = 0;
14833     DisplayMessage("", "");
14834     if (startedFromSetupPosition) {
14835         SendBoard(&second, backwardMostMove);
14836     if (appData.debugMode) {
14837         fprintf(debugFP, "Two Machines\n");
14838     }
14839     }
14840     for (i = backwardMostMove; i < forwardMostMove; i++) {
14841         SendMoveToProgram(i, &second);
14842     }
14843
14844     gameMode = TwoMachinesPlay;
14845     pausing = startingEngine = FALSE;
14846     ModeHighlight(); // [HGM] logo: this triggers display update of logos
14847     SetGameInfo();
14848     DisplayTwoMachinesTitle();
14849     firstMove = TRUE;
14850     if ((first.twoMachinesColor[0] == 'w') == WhiteOnMove(forwardMostMove)) {
14851         onmove = &first;
14852     } else {
14853         onmove = &second;
14854     }
14855     if(appData.debugMode) fprintf(debugFP, "New game (%d): %s-%s (%c)\n", matchGame, first.tidy, second.tidy, first.twoMachinesColor[0]);
14856     SendToProgram(first.computerString, &first);
14857     if (first.sendName) {
14858       snprintf(buf, MSG_SIZ, "name %s\n", second.tidy);
14859       SendToProgram(buf, &first);
14860     }
14861     SendToProgram(second.computerString, &second);
14862     if (second.sendName) {
14863       snprintf(buf, MSG_SIZ, "name %s\n", first.tidy);
14864       SendToProgram(buf, &second);
14865     }
14866
14867     ResetClocks();
14868     if (!first.sendTime || !second.sendTime) {
14869         timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
14870         timeRemaining[1][forwardMostMove] = blackTimeRemaining;
14871     }
14872     if (onmove->sendTime) {
14873       if (onmove->useColors) {
14874         SendToProgram(onmove->other->twoMachinesColor, onmove); /*gnu kludge*/
14875       }
14876       SendTimeRemaining(onmove, WhiteOnMove(forwardMostMove));
14877     }
14878     if (onmove->useColors) {
14879       SendToProgram(onmove->twoMachinesColor, onmove);
14880     }
14881     bookHit = SendMoveToBookUser(forwardMostMove-1, onmove, TRUE); // [HGM] book: send go or retrieve book move
14882 //    SendToProgram("go\n", onmove);
14883     onmove->maybeThinking = TRUE;
14884     SetMachineThinkingEnables();
14885
14886     StartClocks();
14887
14888     if(bookHit) { // [HGM] book: simulate book reply
14889         static char bookMove[MSG_SIZ]; // a bit generous?
14890
14891         programStats.nodes = programStats.depth = programStats.time =
14892         programStats.score = programStats.got_only_move = 0;
14893         sprintf(programStats.movelist, "%s (xbook)", bookHit);
14894
14895         safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
14896         strcat(bookMove, bookHit);
14897         savedMessage = bookMove; // args for deferred call
14898         savedState = onmove;
14899         ScheduleDelayedEvent(DeferredBookMove, 1);
14900     }
14901 }
14902
14903 void
14904 TrainingEvent ()
14905 {
14906     if (gameMode == Training) {
14907       SetTrainingModeOff();
14908       gameMode = PlayFromGameFile;
14909       DisplayMessage("", _("Training mode off"));
14910     } else {
14911       gameMode = Training;
14912       animateTraining = appData.animate;
14913
14914       /* make sure we are not already at the end of the game */
14915       if (currentMove < forwardMostMove) {
14916         SetTrainingModeOn();
14917         DisplayMessage("", _("Training mode on"));
14918       } else {
14919         gameMode = PlayFromGameFile;
14920         DisplayError(_("Already at end of game"), 0);
14921       }
14922     }
14923     ModeHighlight();
14924 }
14925
14926 void
14927 IcsClientEvent ()
14928 {
14929     if (!appData.icsActive) return;
14930     switch (gameMode) {
14931       case IcsPlayingWhite:
14932       case IcsPlayingBlack:
14933       case IcsObserving:
14934       case IcsIdle:
14935       case BeginningOfGame:
14936       case IcsExamining:
14937         return;
14938
14939       case EditGame:
14940         break;
14941
14942       case EditPosition:
14943         EditPositionDone(TRUE);
14944         break;
14945
14946       case AnalyzeMode:
14947       case AnalyzeFile:
14948         ExitAnalyzeMode();
14949         break;
14950
14951       default:
14952         EditGameEvent();
14953         break;
14954     }
14955
14956     gameMode = IcsIdle;
14957     ModeHighlight();
14958     return;
14959 }
14960
14961 void
14962 EditGameEvent ()
14963 {
14964     int i;
14965
14966     switch (gameMode) {
14967       case Training:
14968         SetTrainingModeOff();
14969         break;
14970       case MachinePlaysWhite:
14971       case MachinePlaysBlack:
14972       case BeginningOfGame:
14973         SendToProgram("force\n", &first);
14974         SetUserThinkingEnables();
14975         break;
14976       case PlayFromGameFile:
14977         (void) StopLoadGameTimer();
14978         if (gameFileFP != NULL) {
14979             gameFileFP = NULL;
14980         }
14981         break;
14982       case EditPosition:
14983         EditPositionDone(TRUE);
14984         break;
14985       case AnalyzeMode:
14986       case AnalyzeFile:
14987         ExitAnalyzeMode();
14988         SendToProgram("force\n", &first);
14989         break;
14990       case TwoMachinesPlay:
14991         GameEnds(EndOfFile, NULL, GE_PLAYER);
14992         ResurrectChessProgram();
14993         SetUserThinkingEnables();
14994         break;
14995       case EndOfGame:
14996         ResurrectChessProgram();
14997         break;
14998       case IcsPlayingBlack:
14999       case IcsPlayingWhite:
15000         DisplayError(_("Warning: You are still playing a game"), 0);
15001         break;
15002       case IcsObserving:
15003         DisplayError(_("Warning: You are still observing a game"), 0);
15004         break;
15005       case IcsExamining:
15006         DisplayError(_("Warning: You are still examining a game"), 0);
15007         break;
15008       case IcsIdle:
15009         break;
15010       case EditGame:
15011       default:
15012         return;
15013     }
15014
15015     pausing = FALSE;
15016     StopClocks();
15017     first.offeredDraw = second.offeredDraw = 0;
15018
15019     if (gameMode == PlayFromGameFile) {
15020         whiteTimeRemaining = timeRemaining[0][currentMove];
15021         blackTimeRemaining = timeRemaining[1][currentMove];
15022         DisplayTitle("");
15023     }
15024
15025     if (gameMode == MachinePlaysWhite ||
15026         gameMode == MachinePlaysBlack ||
15027         gameMode == TwoMachinesPlay ||
15028         gameMode == EndOfGame) {
15029         i = forwardMostMove;
15030         while (i > currentMove) {
15031             SendToProgram("undo\n", &first);
15032             i--;
15033         }
15034         if(!adjustedClock) {
15035         whiteTimeRemaining = timeRemaining[0][currentMove];
15036         blackTimeRemaining = timeRemaining[1][currentMove];
15037         DisplayBothClocks();
15038         }
15039         if (whiteFlag || blackFlag) {
15040             whiteFlag = blackFlag = 0;
15041         }
15042         DisplayTitle("");
15043     }
15044
15045     gameMode = EditGame;
15046     ModeHighlight();
15047     SetGameInfo();
15048 }
15049
15050
15051 void
15052 EditPositionEvent ()
15053 {
15054     if (gameMode == EditPosition) {
15055         EditGameEvent();
15056         return;
15057     }
15058
15059     EditGameEvent();
15060     if (gameMode != EditGame) return;
15061
15062     gameMode = EditPosition;
15063     ModeHighlight();
15064     SetGameInfo();
15065     if (currentMove > 0)
15066       CopyBoard(boards[0], boards[currentMove]);
15067
15068     blackPlaysFirst = !WhiteOnMove(currentMove);
15069     ResetClocks();
15070     currentMove = forwardMostMove = backwardMostMove = 0;
15071     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
15072     DisplayMove(-1);
15073     if(!appData.pieceMenu) DisplayMessage(_("Click clock to clear board"), "");
15074 }
15075
15076 void
15077 ExitAnalyzeMode ()
15078 {
15079     /* [DM] icsEngineAnalyze - possible call from other functions */
15080     if (appData.icsEngineAnalyze) {
15081         appData.icsEngineAnalyze = FALSE;
15082
15083         DisplayMessage("",_("Close ICS engine analyze..."));
15084     }
15085     if (first.analysisSupport && first.analyzing) {
15086       SendToBoth("exit\n");
15087       first.analyzing = second.analyzing = FALSE;
15088     }
15089     thinkOutput[0] = NULLCHAR;
15090 }
15091
15092 void
15093 EditPositionDone (Boolean fakeRights)
15094 {
15095     int king = gameInfo.variant == VariantKnightmate ? WhiteUnicorn : WhiteKing;
15096
15097     startedFromSetupPosition = TRUE;
15098     InitChessProgram(&first, FALSE);
15099     if(fakeRights) { // [HGM] suppress this if we just pasted a FEN.
15100       boards[0][EP_STATUS] = EP_NONE;
15101       boards[0][CASTLING][2] = boards[0][CASTLING][5] = BOARD_WIDTH>>1;
15102       if(boards[0][0][BOARD_WIDTH>>1] == king) {
15103         boards[0][CASTLING][1] = boards[0][0][BOARD_LEFT] == WhiteRook ? BOARD_LEFT : NoRights;
15104         boards[0][CASTLING][0] = boards[0][0][BOARD_RGHT-1] == WhiteRook ? BOARD_RGHT-1 : NoRights;
15105       } else boards[0][CASTLING][2] = NoRights;
15106       if(boards[0][BOARD_HEIGHT-1][BOARD_WIDTH>>1] == WHITE_TO_BLACK king) {
15107         boards[0][CASTLING][4] = boards[0][BOARD_HEIGHT-1][BOARD_LEFT] == BlackRook ? BOARD_LEFT : NoRights;
15108         boards[0][CASTLING][3] = boards[0][BOARD_HEIGHT-1][BOARD_RGHT-1] == BlackRook ? BOARD_RGHT-1 : NoRights;
15109       } else boards[0][CASTLING][5] = NoRights;
15110       if(gameInfo.variant == VariantSChess) {
15111         int i;
15112         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) { // pieces in their original position are assumed virgin
15113           boards[0][VIRGIN][i] = 0;
15114           if(boards[0][0][i]              == FIDEArray[0][i-BOARD_LEFT]) boards[0][VIRGIN][i] |= VIRGIN_W;
15115           if(boards[0][BOARD_HEIGHT-1][i] == FIDEArray[1][i-BOARD_LEFT]) boards[0][VIRGIN][i] |= VIRGIN_B;
15116         }
15117       }
15118     }
15119     SendToProgram("force\n", &first);
15120     if (blackPlaysFirst) {
15121         safeStrCpy(moveList[0], "", sizeof(moveList[0])/sizeof(moveList[0][0]));
15122         safeStrCpy(parseList[0], "", sizeof(parseList[0])/sizeof(parseList[0][0]));
15123         currentMove = forwardMostMove = backwardMostMove = 1;
15124         CopyBoard(boards[1], boards[0]);
15125     } else {
15126         currentMove = forwardMostMove = backwardMostMove = 0;
15127     }
15128     SendBoard(&first, forwardMostMove);
15129     if (appData.debugMode) {
15130         fprintf(debugFP, "EditPosDone\n");
15131     }
15132     DisplayTitle("");
15133     DisplayMessage("", "");
15134     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
15135     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
15136     gameMode = EditGame;
15137     ModeHighlight();
15138     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
15139     ClearHighlights(); /* [AS] */
15140 }
15141
15142 /* Pause for `ms' milliseconds */
15143 /* !! Ugh, this is a kludge. Fix it sometime. --tpm */
15144 void
15145 TimeDelay (long ms)
15146 {
15147     TimeMark m1, m2;
15148
15149     GetTimeMark(&m1);
15150     do {
15151         GetTimeMark(&m2);
15152     } while (SubtractTimeMarks(&m2, &m1) < ms);
15153 }
15154
15155 /* !! Ugh, this is a kludge. Fix it sometime. --tpm */
15156 void
15157 SendMultiLineToICS (char *buf)
15158 {
15159     char temp[MSG_SIZ+1], *p;
15160     int len;
15161
15162     len = strlen(buf);
15163     if (len > MSG_SIZ)
15164       len = MSG_SIZ;
15165
15166     strncpy(temp, buf, len);
15167     temp[len] = 0;
15168
15169     p = temp;
15170     while (*p) {
15171         if (*p == '\n' || *p == '\r')
15172           *p = ' ';
15173         ++p;
15174     }
15175
15176     strcat(temp, "\n");
15177     SendToICS(temp);
15178     SendToPlayer(temp, strlen(temp));
15179 }
15180
15181 void
15182 SetWhiteToPlayEvent ()
15183 {
15184     if (gameMode == EditPosition) {
15185         blackPlaysFirst = FALSE;
15186         DisplayBothClocks();    /* works because currentMove is 0 */
15187     } else if (gameMode == IcsExamining) {
15188         SendToICS(ics_prefix);
15189         SendToICS("tomove white\n");
15190     }
15191 }
15192
15193 void
15194 SetBlackToPlayEvent ()
15195 {
15196     if (gameMode == EditPosition) {
15197         blackPlaysFirst = TRUE;
15198         currentMove = 1;        /* kludge */
15199         DisplayBothClocks();
15200         currentMove = 0;
15201     } else if (gameMode == IcsExamining) {
15202         SendToICS(ics_prefix);
15203         SendToICS("tomove black\n");
15204     }
15205 }
15206
15207 void
15208 EditPositionMenuEvent (ChessSquare selection, int x, int y)
15209 {
15210     char buf[MSG_SIZ];
15211     ChessSquare piece = boards[0][y][x];
15212     static Board erasedBoard, currentBoard, menuBoard, nullBoard;
15213     static int lastVariant;
15214
15215     if (gameMode != EditPosition && gameMode != IcsExamining) return;
15216
15217     switch (selection) {
15218       case ClearBoard:
15219         fromX = fromY = killX = killY = -1; // [HGM] abort any move entry in progress
15220         MarkTargetSquares(1);
15221         CopyBoard(currentBoard, boards[0]);
15222         CopyBoard(menuBoard, initialPosition);
15223         if (gameMode == IcsExamining && ics_type == ICS_FICS) {
15224             SendToICS(ics_prefix);
15225             SendToICS("bsetup clear\n");
15226         } else if (gameMode == IcsExamining && ics_type == ICS_ICC) {
15227             SendToICS(ics_prefix);
15228             SendToICS("clearboard\n");
15229         } else {
15230             int nonEmpty = 0;
15231             for (x = 0; x < BOARD_WIDTH; x++) { ChessSquare p = EmptySquare;
15232                 if(x == BOARD_LEFT-1 || x == BOARD_RGHT) p = (ChessSquare) 0; /* [HGM] holdings */
15233                 for (y = 0; y < BOARD_HEIGHT; y++) {
15234                     if (gameMode == IcsExamining) {
15235                         if (boards[currentMove][y][x] != EmptySquare) {
15236                           snprintf(buf, MSG_SIZ, "%sx@%c%c\n", ics_prefix,
15237                                     AAA + x, ONE + y);
15238                             SendToICS(buf);
15239                         }
15240                     } else if(boards[0][y][x] != DarkSquare) {
15241                         if(boards[0][y][x] != p) nonEmpty++;
15242                         boards[0][y][x] = p;
15243                     }
15244                 }
15245             }
15246             if(gameMode != IcsExamining) { // [HGM] editpos: cycle trough boards
15247                 int r;
15248                 for(r = 0; r < BOARD_HEIGHT; r++) {
15249                   for(x = BOARD_LEFT; x < BOARD_RGHT; x++) { // create 'menu board' by removing duplicates
15250                     ChessSquare p = menuBoard[r][x];
15251                     for(y = x + 1; y < BOARD_RGHT; y++) if(menuBoard[r][y] == p) menuBoard[r][y] = EmptySquare;
15252                   }
15253                 }
15254                 DisplayMessage("Clicking clock again restores position", "");
15255                 if(gameInfo.variant != lastVariant) lastVariant = gameInfo.variant, CopyBoard(erasedBoard, boards[0]);
15256                 if(!nonEmpty) { // asked to clear an empty board
15257                     CopyBoard(boards[0], menuBoard);
15258                 } else
15259                 if(CompareBoards(currentBoard, menuBoard)) { // asked to clear an empty board
15260                     CopyBoard(boards[0], initialPosition);
15261                 } else
15262                 if(CompareBoards(currentBoard, initialPosition) && !CompareBoards(currentBoard, erasedBoard)
15263                                                                  && !CompareBoards(nullBoard, erasedBoard)) {
15264                     CopyBoard(boards[0], erasedBoard);
15265                 } else
15266                     CopyBoard(erasedBoard, currentBoard);
15267
15268             }
15269         }
15270         if (gameMode == EditPosition) {
15271             DrawPosition(FALSE, boards[0]);
15272         }
15273         break;
15274
15275       case WhitePlay:
15276         SetWhiteToPlayEvent();
15277         break;
15278
15279       case BlackPlay:
15280         SetBlackToPlayEvent();
15281         break;
15282
15283       case EmptySquare:
15284         if (gameMode == IcsExamining) {
15285             if (x < BOARD_LEFT || x >= BOARD_RGHT) break; // [HGM] holdings
15286             snprintf(buf, MSG_SIZ, "%sx@%c%c\n", ics_prefix, AAA + x, ONE + y);
15287             SendToICS(buf);
15288         } else {
15289             if(x < BOARD_LEFT || x >= BOARD_RGHT) {
15290                 if(x == BOARD_LEFT-2) {
15291                     if(y < BOARD_HEIGHT-1-gameInfo.holdingsSize) break;
15292                     boards[0][y][1] = 0;
15293                 } else
15294                 if(x == BOARD_RGHT+1) {
15295                     if(y >= gameInfo.holdingsSize) break;
15296                     boards[0][y][BOARD_WIDTH-2] = 0;
15297                 } else break;
15298             }
15299             boards[0][y][x] = EmptySquare;
15300             DrawPosition(FALSE, boards[0]);
15301         }
15302         break;
15303
15304       case PromotePiece:
15305         if(piece >= (int)WhitePawn && piece < (int)WhiteMan ||
15306            piece >= (int)BlackPawn && piece < (int)BlackMan   ) {
15307             selection = (ChessSquare) (PROMOTED piece);
15308         } else if(piece == EmptySquare) selection = WhiteSilver;
15309         else selection = (ChessSquare)((int)piece - 1);
15310         goto defaultlabel;
15311
15312       case DemotePiece:
15313         if(piece > (int)WhiteMan && piece <= (int)WhiteKing ||
15314            piece > (int)BlackMan && piece <= (int)BlackKing   ) {
15315             selection = (ChessSquare) (DEMOTED piece);
15316         } else if(piece == EmptySquare) selection = BlackSilver;
15317         else selection = (ChessSquare)((int)piece + 1);
15318         goto defaultlabel;
15319
15320       case WhiteQueen:
15321       case BlackQueen:
15322         if(gameInfo.variant == VariantShatranj ||
15323            gameInfo.variant == VariantXiangqi  ||
15324            gameInfo.variant == VariantCourier  ||
15325            gameInfo.variant == VariantASEAN    ||
15326            gameInfo.variant == VariantMakruk     )
15327             selection = (ChessSquare)((int)selection - (int)WhiteQueen + (int)WhiteFerz);
15328         goto defaultlabel;
15329
15330       case WhiteKing:
15331       case BlackKing:
15332         if(gameInfo.variant == VariantXiangqi)
15333             selection = (ChessSquare)((int)selection - (int)WhiteKing + (int)WhiteWazir);
15334         if(gameInfo.variant == VariantKnightmate)
15335             selection = (ChessSquare)((int)selection - (int)WhiteKing + (int)WhiteUnicorn);
15336       default:
15337         defaultlabel:
15338         if (gameMode == IcsExamining) {
15339             if (x < BOARD_LEFT || x >= BOARD_RGHT) break; // [HGM] holdings
15340             snprintf(buf, MSG_SIZ, "%s%c@%c%c\n", ics_prefix,
15341                      PieceToChar(selection), AAA + x, ONE + y);
15342             SendToICS(buf);
15343         } else {
15344             if(x < BOARD_LEFT || x >= BOARD_RGHT) {
15345                 int n;
15346                 if(x == BOARD_LEFT-2 && selection >= BlackPawn) {
15347                     n = PieceToNumber(selection - BlackPawn);
15348                     if(n >= gameInfo.holdingsSize) { n = 0; selection = BlackPawn; }
15349                     boards[0][BOARD_HEIGHT-1-n][0] = selection;
15350                     boards[0][BOARD_HEIGHT-1-n][1]++;
15351                 } else
15352                 if(x == BOARD_RGHT+1 && selection < BlackPawn) {
15353                     n = PieceToNumber(selection);
15354                     if(n >= gameInfo.holdingsSize) { n = 0; selection = WhitePawn; }
15355                     boards[0][n][BOARD_WIDTH-1] = selection;
15356                     boards[0][n][BOARD_WIDTH-2]++;
15357                 }
15358             } else
15359             boards[0][y][x] = selection;
15360             DrawPosition(TRUE, boards[0]);
15361             ClearHighlights();
15362             fromX = fromY = -1;
15363         }
15364         break;
15365     }
15366 }
15367
15368
15369 void
15370 DropMenuEvent (ChessSquare selection, int x, int y)
15371 {
15372     ChessMove moveType;
15373
15374     switch (gameMode) {
15375       case IcsPlayingWhite:
15376       case MachinePlaysBlack:
15377         if (!WhiteOnMove(currentMove)) {
15378             DisplayMoveError(_("It is Black's turn"));
15379             return;
15380         }
15381         moveType = WhiteDrop;
15382         break;
15383       case IcsPlayingBlack:
15384       case MachinePlaysWhite:
15385         if (WhiteOnMove(currentMove)) {
15386             DisplayMoveError(_("It is White's turn"));
15387             return;
15388         }
15389         moveType = BlackDrop;
15390         break;
15391       case EditGame:
15392         moveType = WhiteOnMove(currentMove) ? WhiteDrop : BlackDrop;
15393         break;
15394       default:
15395         return;
15396     }
15397
15398     if (moveType == BlackDrop && selection < BlackPawn) {
15399       selection = (ChessSquare) ((int) selection
15400                                  + (int) BlackPawn - (int) WhitePawn);
15401     }
15402     if (boards[currentMove][y][x] != EmptySquare) {
15403         DisplayMoveError(_("That square is occupied"));
15404         return;
15405     }
15406
15407     FinishMove(moveType, (int) selection, DROP_RANK, x, y, NULLCHAR);
15408 }
15409
15410 void
15411 AcceptEvent ()
15412 {
15413     /* Accept a pending offer of any kind from opponent */
15414
15415     if (appData.icsActive) {
15416         SendToICS(ics_prefix);
15417         SendToICS("accept\n");
15418     } else if (cmailMsgLoaded) {
15419         if (currentMove == cmailOldMove &&
15420             commentList[cmailOldMove] != NULL &&
15421             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
15422                    "Black offers a draw" : "White offers a draw")) {
15423             TruncateGame();
15424             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
15425             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_ACCEPT;
15426         } else {
15427             DisplayError(_("There is no pending offer on this move"), 0);
15428             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
15429         }
15430     } else {
15431         /* Not used for offers from chess program */
15432     }
15433 }
15434
15435 void
15436 DeclineEvent ()
15437 {
15438     /* Decline a pending offer of any kind from opponent */
15439
15440     if (appData.icsActive) {
15441         SendToICS(ics_prefix);
15442         SendToICS("decline\n");
15443     } else if (cmailMsgLoaded) {
15444         if (currentMove == cmailOldMove &&
15445             commentList[cmailOldMove] != NULL &&
15446             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
15447                    "Black offers a draw" : "White offers a draw")) {
15448 #ifdef NOTDEF
15449             AppendComment(cmailOldMove, "Draw declined", TRUE);
15450             DisplayComment(cmailOldMove - 1, "Draw declined");
15451 #endif /*NOTDEF*/
15452         } else {
15453             DisplayError(_("There is no pending offer on this move"), 0);
15454         }
15455     } else {
15456         /* Not used for offers from chess program */
15457     }
15458 }
15459
15460 void
15461 RematchEvent ()
15462 {
15463     /* Issue ICS rematch command */
15464     if (appData.icsActive) {
15465         SendToICS(ics_prefix);
15466         SendToICS("rematch\n");
15467     }
15468 }
15469
15470 void
15471 CallFlagEvent ()
15472 {
15473     /* Call your opponent's flag (claim a win on time) */
15474     if (appData.icsActive) {
15475         SendToICS(ics_prefix);
15476         SendToICS("flag\n");
15477     } else {
15478         switch (gameMode) {
15479           default:
15480             return;
15481           case MachinePlaysWhite:
15482             if (whiteFlag) {
15483                 if (blackFlag)
15484                   GameEnds(GameIsDrawn, "Both players ran out of time",
15485                            GE_PLAYER);
15486                 else
15487                   GameEnds(BlackWins, "Black wins on time", GE_PLAYER);
15488             } else {
15489                 DisplayError(_("Your opponent is not out of time"), 0);
15490             }
15491             break;
15492           case MachinePlaysBlack:
15493             if (blackFlag) {
15494                 if (whiteFlag)
15495                   GameEnds(GameIsDrawn, "Both players ran out of time",
15496                            GE_PLAYER);
15497                 else
15498                   GameEnds(WhiteWins, "White wins on time", GE_PLAYER);
15499             } else {
15500                 DisplayError(_("Your opponent is not out of time"), 0);
15501             }
15502             break;
15503         }
15504     }
15505 }
15506
15507 void
15508 ClockClick (int which)
15509 {       // [HGM] code moved to back-end from winboard.c
15510         if(which) { // black clock
15511           if (gameMode == EditPosition || gameMode == IcsExamining) {
15512             if(!appData.pieceMenu && blackPlaysFirst) EditPositionMenuEvent(ClearBoard, 0, 0);
15513             SetBlackToPlayEvent();
15514           } else if ((gameMode == AnalyzeMode || gameMode == EditGame ||
15515                       gameMode == MachinePlaysBlack && PosFlags(0) & F_NULL_MOVE && !blackFlag && !shiftKey) && WhiteOnMove(currentMove)) {
15516           UserMoveEvent((int)EmptySquare, DROP_RANK, 0, 0, 0); // [HGM] multi-move: if not out of time, enters null move
15517           } else if (shiftKey) {
15518             AdjustClock(which, -1);
15519           } else if (gameMode == IcsPlayingWhite ||
15520                      gameMode == MachinePlaysBlack) {
15521             CallFlagEvent();
15522           }
15523         } else { // white clock
15524           if (gameMode == EditPosition || gameMode == IcsExamining) {
15525             if(!appData.pieceMenu && !blackPlaysFirst) EditPositionMenuEvent(ClearBoard, 0, 0);
15526             SetWhiteToPlayEvent();
15527           } else if ((gameMode == AnalyzeMode || gameMode == EditGame ||
15528                       gameMode == MachinePlaysWhite && PosFlags(0) & F_NULL_MOVE && !whiteFlag && !shiftKey) && !WhiteOnMove(currentMove)) {
15529           UserMoveEvent((int)EmptySquare, DROP_RANK, 0, 0, 0); // [HGM] multi-move
15530           } else if (shiftKey) {
15531             AdjustClock(which, -1);
15532           } else if (gameMode == IcsPlayingBlack ||
15533                    gameMode == MachinePlaysWhite) {
15534             CallFlagEvent();
15535           }
15536         }
15537 }
15538
15539 void
15540 DrawEvent ()
15541 {
15542     /* Offer draw or accept pending draw offer from opponent */
15543
15544     if (appData.icsActive) {
15545         /* Note: tournament rules require draw offers to be
15546            made after you make your move but before you punch
15547            your clock.  Currently ICS doesn't let you do that;
15548            instead, you immediately punch your clock after making
15549            a move, but you can offer a draw at any time. */
15550
15551         SendToICS(ics_prefix);
15552         SendToICS("draw\n");
15553         userOfferedDraw = TRUE; // [HGM] drawclaim: also set flag in ICS play
15554     } else if (cmailMsgLoaded) {
15555         if (currentMove == cmailOldMove &&
15556             commentList[cmailOldMove] != NULL &&
15557             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
15558                    "Black offers a draw" : "White offers a draw")) {
15559             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
15560             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_ACCEPT;
15561         } else if (currentMove == cmailOldMove + 1) {
15562             char *offer = WhiteOnMove(cmailOldMove) ?
15563               "White offers a draw" : "Black offers a draw";
15564             AppendComment(currentMove, offer, TRUE);
15565             DisplayComment(currentMove - 1, offer);
15566             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_DRAW;
15567         } else {
15568             DisplayError(_("You must make your move before offering a draw"), 0);
15569             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
15570         }
15571     } else if (first.offeredDraw) {
15572         GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
15573     } else {
15574         if (first.sendDrawOffers) {
15575             SendToProgram("draw\n", &first);
15576             userOfferedDraw = TRUE;
15577         }
15578     }
15579 }
15580
15581 void
15582 AdjournEvent ()
15583 {
15584     /* Offer Adjourn or accept pending Adjourn offer from opponent */
15585
15586     if (appData.icsActive) {
15587         SendToICS(ics_prefix);
15588         SendToICS("adjourn\n");
15589     } else {
15590         /* Currently GNU Chess doesn't offer or accept Adjourns */
15591     }
15592 }
15593
15594
15595 void
15596 AbortEvent ()
15597 {
15598     /* Offer Abort or accept pending Abort offer from opponent */
15599
15600     if (appData.icsActive) {
15601         SendToICS(ics_prefix);
15602         SendToICS("abort\n");
15603     } else {
15604         GameEnds(GameUnfinished, "Game aborted", GE_PLAYER);
15605     }
15606 }
15607
15608 void
15609 ResignEvent ()
15610 {
15611     /* Resign.  You can do this even if it's not your turn. */
15612
15613     if (appData.icsActive) {
15614         SendToICS(ics_prefix);
15615         SendToICS("resign\n");
15616     } else {
15617         switch (gameMode) {
15618           case MachinePlaysWhite:
15619             GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
15620             break;
15621           case MachinePlaysBlack:
15622             GameEnds(BlackWins, "White resigns", GE_PLAYER);
15623             break;
15624           case EditGame:
15625             if (cmailMsgLoaded) {
15626                 TruncateGame();
15627                 if (WhiteOnMove(cmailOldMove)) {
15628                     GameEnds(BlackWins, "White resigns", GE_PLAYER);
15629                 } else {
15630                     GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
15631                 }
15632                 cmailMoveType[lastLoadGameNumber - 1] = CMAIL_RESIGN;
15633             }
15634             break;
15635           default:
15636             break;
15637         }
15638     }
15639 }
15640
15641
15642 void
15643 StopObservingEvent ()
15644 {
15645     /* Stop observing current games */
15646     SendToICS(ics_prefix);
15647     SendToICS("unobserve\n");
15648 }
15649
15650 void
15651 StopExaminingEvent ()
15652 {
15653     /* Stop observing current game */
15654     SendToICS(ics_prefix);
15655     SendToICS("unexamine\n");
15656 }
15657
15658 void
15659 ForwardInner (int target)
15660 {
15661     int limit; int oldSeekGraphUp = seekGraphUp;
15662
15663     if (appData.debugMode)
15664         fprintf(debugFP, "ForwardInner(%d), current %d, forward %d\n",
15665                 target, currentMove, forwardMostMove);
15666
15667     if (gameMode == EditPosition)
15668       return;
15669
15670     seekGraphUp = FALSE;
15671     MarkTargetSquares(1);
15672     fromX = fromY = killX = killY = -1; // [HGM] abort any move entry in progress
15673
15674     if (gameMode == PlayFromGameFile && !pausing)
15675       PauseEvent();
15676
15677     if (gameMode == IcsExamining && pausing)
15678       limit = pauseExamForwardMostMove;
15679     else
15680       limit = forwardMostMove;
15681
15682     if (target > limit) target = limit;
15683
15684     if (target > 0 && moveList[target - 1][0]) {
15685         int fromX, fromY, toX, toY;
15686         toX = moveList[target - 1][2] - AAA;
15687         toY = moveList[target - 1][3] - ONE;
15688         if (moveList[target - 1][1] == '@') {
15689             if (appData.highlightLastMove) {
15690                 SetHighlights(-1, -1, toX, toY);
15691             }
15692         } else {
15693             int viaX = moveList[target - 1][5] - AAA;
15694             int viaY = moveList[target - 1][6] - ONE;
15695             fromX = moveList[target - 1][0] - AAA;
15696             fromY = moveList[target - 1][1] - ONE;
15697             if (target == currentMove + 1) {
15698                 if(moveList[target - 1][4] == ';') { // multi-leg
15699                     ChessSquare piece = boards[currentMove][viaY][viaX];
15700                     AnimateMove(boards[currentMove], fromX, fromY, viaX, viaY);
15701                     boards[currentMove][viaY][viaX] = boards[currentMove][fromY][fromX];
15702                     AnimateMove(boards[currentMove], viaX, viaY, toX, toY);
15703                     boards[currentMove][viaY][viaX] = piece;
15704                 } else
15705                 AnimateMove(boards[currentMove], fromX, fromY, toX, toY);
15706             }
15707             if (appData.highlightLastMove) {
15708                 SetHighlights(fromX, fromY, toX, toY);
15709             }
15710         }
15711     }
15712     if (gameMode == EditGame || gameMode == AnalyzeMode ||
15713         gameMode == Training || gameMode == PlayFromGameFile ||
15714         gameMode == AnalyzeFile) {
15715         while (currentMove < target) {
15716             if(second.analyzing) SendMoveToProgram(currentMove, &second);
15717             SendMoveToProgram(currentMove++, &first);
15718         }
15719     } else {
15720         currentMove = target;
15721     }
15722
15723     if (gameMode == EditGame || gameMode == EndOfGame) {
15724         whiteTimeRemaining = timeRemaining[0][currentMove];
15725         blackTimeRemaining = timeRemaining[1][currentMove];
15726     }
15727     DisplayBothClocks();
15728     DisplayMove(currentMove - 1);
15729     DrawPosition(oldSeekGraphUp, boards[currentMove]);
15730     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
15731     if ( !matchMode && gameMode != Training) { // [HGM] PV info: routine tests if empty
15732         DisplayComment(currentMove - 1, commentList[currentMove]);
15733     }
15734     ClearMap(); // [HGM] exclude: invalidate map
15735 }
15736
15737
15738 void
15739 ForwardEvent ()
15740 {
15741     if (gameMode == IcsExamining && !pausing) {
15742         SendToICS(ics_prefix);
15743         SendToICS("forward\n");
15744     } else {
15745         ForwardInner(currentMove + 1);
15746     }
15747 }
15748
15749 void
15750 ToEndEvent ()
15751 {
15752     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
15753         /* to optimze, we temporarily turn off analysis mode while we feed
15754          * the remaining moves to the engine. Otherwise we get analysis output
15755          * after each move.
15756          */
15757         if (first.analysisSupport) {
15758           SendToProgram("exit\nforce\n", &first);
15759           first.analyzing = FALSE;
15760         }
15761     }
15762
15763     if (gameMode == IcsExamining && !pausing) {
15764         SendToICS(ics_prefix);
15765         SendToICS("forward 999999\n");
15766     } else {
15767         ForwardInner(forwardMostMove);
15768     }
15769
15770     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
15771         /* we have fed all the moves, so reactivate analysis mode */
15772         SendToProgram("analyze\n", &first);
15773         first.analyzing = TRUE;
15774         /*first.maybeThinking = TRUE;*/
15775         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
15776     }
15777 }
15778
15779 void
15780 BackwardInner (int target)
15781 {
15782     int full_redraw = TRUE; /* [AS] Was FALSE, had to change it! */
15783
15784     if (appData.debugMode)
15785         fprintf(debugFP, "BackwardInner(%d), current %d, forward %d\n",
15786                 target, currentMove, forwardMostMove);
15787
15788     if (gameMode == EditPosition) return;
15789     seekGraphUp = FALSE;
15790     MarkTargetSquares(1);
15791     fromX = fromY = killX = killY = -1; // [HGM] abort any move entry in progress
15792     if (currentMove <= backwardMostMove) {
15793         ClearHighlights();
15794         DrawPosition(full_redraw, boards[currentMove]);
15795         return;
15796     }
15797     if (gameMode == PlayFromGameFile && !pausing)
15798       PauseEvent();
15799
15800     if (moveList[target][0]) {
15801         int fromX, fromY, toX, toY;
15802         toX = moveList[target][2] - AAA;
15803         toY = moveList[target][3] - ONE;
15804         if (moveList[target][1] == '@') {
15805             if (appData.highlightLastMove) {
15806                 SetHighlights(-1, -1, toX, toY);
15807             }
15808         } else {
15809             fromX = moveList[target][0] - AAA;
15810             fromY = moveList[target][1] - ONE;
15811             if (target == currentMove - 1) {
15812                 AnimateMove(boards[currentMove], toX, toY, fromX, fromY);
15813             }
15814             if (appData.highlightLastMove) {
15815                 SetHighlights(fromX, fromY, toX, toY);
15816             }
15817         }
15818     }
15819     if (gameMode == EditGame || gameMode==AnalyzeMode ||
15820         gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
15821         while (currentMove > target) {
15822             if(moveList[currentMove-1][1] == '@' && moveList[currentMove-1][0] == '@') {
15823                 // null move cannot be undone. Reload program with move history before it.
15824                 int i;
15825                 for(i=target; i>backwardMostMove; i--) { // seek back to start or previous null move
15826                     if(moveList[i-1][1] == '@' && moveList[i-1][0] == '@') break;
15827                 }
15828                 SendBoard(&first, i);
15829               if(second.analyzing) SendBoard(&second, i);
15830                 for(currentMove=i; currentMove<target; currentMove++) {
15831                     SendMoveToProgram(currentMove, &first);
15832                     if(second.analyzing) SendMoveToProgram(currentMove, &second);
15833                 }
15834                 break;
15835             }
15836             SendToBoth("undo\n");
15837             currentMove--;
15838         }
15839     } else {
15840         currentMove = target;
15841     }
15842
15843     if (gameMode == EditGame || gameMode == EndOfGame) {
15844         whiteTimeRemaining = timeRemaining[0][currentMove];
15845         blackTimeRemaining = timeRemaining[1][currentMove];
15846     }
15847     DisplayBothClocks();
15848     DisplayMove(currentMove - 1);
15849     DrawPosition(full_redraw, boards[currentMove]);
15850     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
15851     // [HGM] PV info: routine tests if comment empty
15852     DisplayComment(currentMove - 1, commentList[currentMove]);
15853     ClearMap(); // [HGM] exclude: invalidate map
15854 }
15855
15856 void
15857 BackwardEvent ()
15858 {
15859     if (gameMode == IcsExamining && !pausing) {
15860         SendToICS(ics_prefix);
15861         SendToICS("backward\n");
15862     } else {
15863         BackwardInner(currentMove - 1);
15864     }
15865 }
15866
15867 void
15868 ToStartEvent ()
15869 {
15870     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
15871         /* to optimize, we temporarily turn off analysis mode while we undo
15872          * all the moves. Otherwise we get analysis output after each undo.
15873          */
15874         if (first.analysisSupport) {
15875           SendToProgram("exit\nforce\n", &first);
15876           first.analyzing = FALSE;
15877         }
15878     }
15879
15880     if (gameMode == IcsExamining && !pausing) {
15881         SendToICS(ics_prefix);
15882         SendToICS("backward 999999\n");
15883     } else {
15884         BackwardInner(backwardMostMove);
15885     }
15886
15887     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
15888         /* we have fed all the moves, so reactivate analysis mode */
15889         SendToProgram("analyze\n", &first);
15890         first.analyzing = TRUE;
15891         /*first.maybeThinking = TRUE;*/
15892         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
15893     }
15894 }
15895
15896 void
15897 ToNrEvent (int to)
15898 {
15899   if (gameMode == PlayFromGameFile && !pausing) PauseEvent();
15900   if (to >= forwardMostMove) to = forwardMostMove;
15901   if (to <= backwardMostMove) to = backwardMostMove;
15902   if (to < currentMove) {
15903     BackwardInner(to);
15904   } else {
15905     ForwardInner(to);
15906   }
15907 }
15908
15909 void
15910 RevertEvent (Boolean annotate)
15911 {
15912     if(PopTail(annotate)) { // [HGM] vari: restore old game tail
15913         return;
15914     }
15915     if (gameMode != IcsExamining) {
15916         DisplayError(_("You are not examining a game"), 0);
15917         return;
15918     }
15919     if (pausing) {
15920         DisplayError(_("You can't revert while pausing"), 0);
15921         return;
15922     }
15923     SendToICS(ics_prefix);
15924     SendToICS("revert\n");
15925 }
15926
15927 void
15928 RetractMoveEvent ()
15929 {
15930     switch (gameMode) {
15931       case MachinePlaysWhite:
15932       case MachinePlaysBlack:
15933         if (WhiteOnMove(forwardMostMove) == (gameMode == MachinePlaysWhite)) {
15934             DisplayError(_("Wait until your turn,\nor select 'Move Now'."), 0);
15935             return;
15936         }
15937         if (forwardMostMove < 2) return;
15938         currentMove = forwardMostMove = forwardMostMove - 2;
15939         whiteTimeRemaining = timeRemaining[0][currentMove];
15940         blackTimeRemaining = timeRemaining[1][currentMove];
15941         DisplayBothClocks();
15942         DisplayMove(currentMove - 1);
15943         ClearHighlights();/*!! could figure this out*/
15944         DrawPosition(TRUE, boards[currentMove]); /* [AS] Changed to full redraw! */
15945         SendToProgram("remove\n", &first);
15946         /*first.maybeThinking = TRUE;*/ /* GNU Chess does not ponder here */
15947         break;
15948
15949       case BeginningOfGame:
15950       default:
15951         break;
15952
15953       case IcsPlayingWhite:
15954       case IcsPlayingBlack:
15955         if (WhiteOnMove(forwardMostMove) == (gameMode == IcsPlayingWhite)) {
15956             SendToICS(ics_prefix);
15957             SendToICS("takeback 2\n");
15958         } else {
15959             SendToICS(ics_prefix);
15960             SendToICS("takeback 1\n");
15961         }
15962         break;
15963     }
15964 }
15965
15966 void
15967 MoveNowEvent ()
15968 {
15969     ChessProgramState *cps;
15970
15971     switch (gameMode) {
15972       case MachinePlaysWhite:
15973         if (!WhiteOnMove(forwardMostMove)) {
15974             DisplayError(_("It is your turn"), 0);
15975             return;
15976         }
15977         cps = &first;
15978         break;
15979       case MachinePlaysBlack:
15980         if (WhiteOnMove(forwardMostMove)) {
15981             DisplayError(_("It is your turn"), 0);
15982             return;
15983         }
15984         cps = &first;
15985         break;
15986       case TwoMachinesPlay:
15987         if (WhiteOnMove(forwardMostMove) ==
15988             (first.twoMachinesColor[0] == 'w')) {
15989             cps = &first;
15990         } else {
15991             cps = &second;
15992         }
15993         break;
15994       case BeginningOfGame:
15995       default:
15996         return;
15997     }
15998     SendToProgram("?\n", cps);
15999 }
16000
16001 void
16002 TruncateGameEvent ()
16003 {
16004     EditGameEvent();
16005     if (gameMode != EditGame) return;
16006     TruncateGame();
16007 }
16008
16009 void
16010 TruncateGame ()
16011 {
16012     CleanupTail(); // [HGM] vari: only keep current variation if we explicitly truncate
16013     if (forwardMostMove > currentMove) {
16014         if (gameInfo.resultDetails != NULL) {
16015             free(gameInfo.resultDetails);
16016             gameInfo.resultDetails = NULL;
16017             gameInfo.result = GameUnfinished;
16018         }
16019         forwardMostMove = currentMove;
16020         HistorySet(parseList, backwardMostMove, forwardMostMove,
16021                    currentMove-1);
16022     }
16023 }
16024
16025 void
16026 HintEvent ()
16027 {
16028     if (appData.noChessProgram) return;
16029     switch (gameMode) {
16030       case MachinePlaysWhite:
16031         if (WhiteOnMove(forwardMostMove)) {
16032             DisplayError(_("Wait until your turn."), 0);
16033             return;
16034         }
16035         break;
16036       case BeginningOfGame:
16037       case MachinePlaysBlack:
16038         if (!WhiteOnMove(forwardMostMove)) {
16039             DisplayError(_("Wait until your turn."), 0);
16040             return;
16041         }
16042         break;
16043       default:
16044         DisplayError(_("No hint available"), 0);
16045         return;
16046     }
16047     SendToProgram("hint\n", &first);
16048     hintRequested = TRUE;
16049 }
16050
16051 int
16052 SaveSelected (FILE *g, int dummy, char *dummy2)
16053 {
16054     ListGame * lg = (ListGame *) gameList.head;
16055     int nItem, cnt=0;
16056     FILE *f;
16057
16058     if( !(f = GameFile()) || ((ListGame *) gameList.tailPred)->number <= 0 ) {
16059         DisplayError(_("Game list not loaded or empty"), 0);
16060         return 0;
16061     }
16062
16063     creatingBook = TRUE; // suppresses stuff during load game
16064
16065     /* Get list size */
16066     for (nItem = 1; nItem <= ((ListGame *) gameList.tailPred)->number; nItem++){
16067         if(lg->position >= 0) { // selected?
16068             LoadGame(f, nItem, "", TRUE);
16069             SaveGamePGN2(g); // leaves g open
16070             cnt++; DoEvents();
16071         }
16072         lg = (ListGame *) lg->node.succ;
16073     }
16074
16075     fclose(g);
16076     creatingBook = FALSE;
16077
16078     return cnt;
16079 }
16080
16081 void
16082 CreateBookEvent ()
16083 {
16084     ListGame * lg = (ListGame *) gameList.head;
16085     FILE *f, *g;
16086     int nItem;
16087     static int secondTime = FALSE;
16088
16089     if( !(f = GameFile()) || ((ListGame *) gameList.tailPred)->number <= 0 ) {
16090         DisplayError(_("Game list not loaded or empty"), 0);
16091         return;
16092     }
16093
16094     if(!secondTime && (g = fopen(appData.polyglotBook, "r"))) {
16095         fclose(g);
16096         secondTime++;
16097         DisplayNote(_("Book file exists! Try again for overwrite."));
16098         return;
16099     }
16100
16101     creatingBook = TRUE;
16102     secondTime = FALSE;
16103
16104     /* Get list size */
16105     for (nItem = 1; nItem <= ((ListGame *) gameList.tailPred)->number; nItem++){
16106         if(lg->position >= 0) {
16107             LoadGame(f, nItem, "", TRUE);
16108             AddGameToBook(TRUE);
16109             DoEvents();
16110         }
16111         lg = (ListGame *) lg->node.succ;
16112     }
16113
16114     creatingBook = FALSE;
16115     FlushBook();
16116 }
16117
16118 void
16119 BookEvent ()
16120 {
16121     if (appData.noChessProgram) return;
16122     switch (gameMode) {
16123       case MachinePlaysWhite:
16124         if (WhiteOnMove(forwardMostMove)) {
16125             DisplayError(_("Wait until your turn."), 0);
16126             return;
16127         }
16128         break;
16129       case BeginningOfGame:
16130       case MachinePlaysBlack:
16131         if (!WhiteOnMove(forwardMostMove)) {
16132             DisplayError(_("Wait until your turn."), 0);
16133             return;
16134         }
16135         break;
16136       case EditPosition:
16137         EditPositionDone(TRUE);
16138         break;
16139       case TwoMachinesPlay:
16140         return;
16141       default:
16142         break;
16143     }
16144     SendToProgram("bk\n", &first);
16145     bookOutput[0] = NULLCHAR;
16146     bookRequested = TRUE;
16147 }
16148
16149 void
16150 AboutGameEvent ()
16151 {
16152     char *tags = PGNTags(&gameInfo);
16153     TagsPopUp(tags, CmailMsg());
16154     free(tags);
16155 }
16156
16157 /* end button procedures */
16158
16159 void
16160 PrintPosition (FILE *fp, int move)
16161 {
16162     int i, j;
16163
16164     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
16165         for (j = BOARD_LEFT; j < BOARD_RGHT; j++) {
16166             char c = PieceToChar(boards[move][i][j]);
16167             fputc(c == 'x' ? '.' : c, fp);
16168             fputc(j == BOARD_RGHT - 1 ? '\n' : ' ', fp);
16169         }
16170     }
16171     if ((gameMode == EditPosition) ? !blackPlaysFirst : (move % 2 == 0))
16172       fprintf(fp, "white to play\n");
16173     else
16174       fprintf(fp, "black to play\n");
16175 }
16176
16177 void
16178 PrintOpponents (FILE *fp)
16179 {
16180     if (gameInfo.white != NULL) {
16181         fprintf(fp, "\t%s vs. %s\n", gameInfo.white, gameInfo.black);
16182     } else {
16183         fprintf(fp, "\n");
16184     }
16185 }
16186
16187 /* Find last component of program's own name, using some heuristics */
16188 void
16189 TidyProgramName (char *prog, char *host, char buf[MSG_SIZ])
16190 {
16191     char *p, *q, c;
16192     int local = (strcmp(host, "localhost") == 0);
16193     while (!local && (p = strchr(prog, ';')) != NULL) {
16194         p++;
16195         while (*p == ' ') p++;
16196         prog = p;
16197     }
16198     if (*prog == '"' || *prog == '\'') {
16199         q = strchr(prog + 1, *prog);
16200     } else {
16201         q = strchr(prog, ' ');
16202     }
16203     if (q == NULL) q = prog + strlen(prog);
16204     p = q;
16205     while (p >= prog && *p != '/' && *p != '\\') p--;
16206     p++;
16207     if(p == prog && *p == '"') p++;
16208     c = *q; *q = 0;
16209     if (q - p >= 4 && StrCaseCmp(q - 4, ".exe") == 0) *q = c, q -= 4; else *q = c;
16210     memcpy(buf, p, q - p);
16211     buf[q - p] = NULLCHAR;
16212     if (!local) {
16213         strcat(buf, "@");
16214         strcat(buf, host);
16215     }
16216 }
16217
16218 char *
16219 TimeControlTagValue ()
16220 {
16221     char buf[MSG_SIZ];
16222     if (!appData.clockMode) {
16223       safeStrCpy(buf, "-", sizeof(buf)/sizeof(buf[0]));
16224     } else if (movesPerSession > 0) {
16225       snprintf(buf, MSG_SIZ, "%d/%ld", movesPerSession, timeControl/1000);
16226     } else if (timeIncrement == 0) {
16227       snprintf(buf, MSG_SIZ, "%ld", timeControl/1000);
16228     } else {
16229       snprintf(buf, MSG_SIZ, "%ld+%ld", timeControl/1000, timeIncrement/1000);
16230     }
16231     return StrSave(buf);
16232 }
16233
16234 void
16235 SetGameInfo ()
16236 {
16237     /* This routine is used only for certain modes */
16238     VariantClass v = gameInfo.variant;
16239     ChessMove r = GameUnfinished;
16240     char *p = NULL;
16241
16242     if(keepInfo) return;
16243
16244     if(gameMode == EditGame) { // [HGM] vari: do not erase result on EditGame
16245         r = gameInfo.result;
16246         p = gameInfo.resultDetails;
16247         gameInfo.resultDetails = NULL;
16248     }
16249     ClearGameInfo(&gameInfo);
16250     gameInfo.variant = v;
16251
16252     switch (gameMode) {
16253       case MachinePlaysWhite:
16254         gameInfo.event = StrSave( appData.pgnEventHeader );
16255         gameInfo.site = StrSave(HostName());
16256         gameInfo.date = PGNDate();
16257         gameInfo.round = StrSave("-");
16258         gameInfo.white = StrSave(first.tidy);
16259         gameInfo.black = StrSave(UserName());
16260         gameInfo.timeControl = TimeControlTagValue();
16261         break;
16262
16263       case MachinePlaysBlack:
16264         gameInfo.event = StrSave( appData.pgnEventHeader );
16265         gameInfo.site = StrSave(HostName());
16266         gameInfo.date = PGNDate();
16267         gameInfo.round = StrSave("-");
16268         gameInfo.white = StrSave(UserName());
16269         gameInfo.black = StrSave(first.tidy);
16270         gameInfo.timeControl = TimeControlTagValue();
16271         break;
16272
16273       case TwoMachinesPlay:
16274         gameInfo.event = StrSave( appData.pgnEventHeader );
16275         gameInfo.site = StrSave(HostName());
16276         gameInfo.date = PGNDate();
16277         if (roundNr > 0) {
16278             char buf[MSG_SIZ];
16279             snprintf(buf, MSG_SIZ, "%d", roundNr);
16280             gameInfo.round = StrSave(buf);
16281         } else {
16282             gameInfo.round = StrSave("-");
16283         }
16284         if (first.twoMachinesColor[0] == 'w') {
16285             gameInfo.white = StrSave(appData.pgnName[0][0] ? appData.pgnName[0] : first.tidy);
16286             gameInfo.black = StrSave(appData.pgnName[1][0] ? appData.pgnName[1] : second.tidy);
16287         } else {
16288             gameInfo.white = StrSave(appData.pgnName[1][0] ? appData.pgnName[1] : second.tidy);
16289             gameInfo.black = StrSave(appData.pgnName[0][0] ? appData.pgnName[0] : first.tidy);
16290         }
16291         gameInfo.timeControl = TimeControlTagValue();
16292         break;
16293
16294       case EditGame:
16295         gameInfo.event = StrSave("Edited game");
16296         gameInfo.site = StrSave(HostName());
16297         gameInfo.date = PGNDate();
16298         gameInfo.round = StrSave("-");
16299         gameInfo.white = StrSave("-");
16300         gameInfo.black = StrSave("-");
16301         gameInfo.result = r;
16302         gameInfo.resultDetails = p;
16303         break;
16304
16305       case EditPosition:
16306         gameInfo.event = StrSave("Edited position");
16307         gameInfo.site = StrSave(HostName());
16308         gameInfo.date = PGNDate();
16309         gameInfo.round = StrSave("-");
16310         gameInfo.white = StrSave("-");
16311         gameInfo.black = StrSave("-");
16312         break;
16313
16314       case IcsPlayingWhite:
16315       case IcsPlayingBlack:
16316       case IcsObserving:
16317       case IcsExamining:
16318         break;
16319
16320       case PlayFromGameFile:
16321         gameInfo.event = StrSave("Game from non-PGN file");
16322         gameInfo.site = StrSave(HostName());
16323         gameInfo.date = PGNDate();
16324         gameInfo.round = StrSave("-");
16325         gameInfo.white = StrSave("?");
16326         gameInfo.black = StrSave("?");
16327         break;
16328
16329       default:
16330         break;
16331     }
16332 }
16333
16334 void
16335 ReplaceComment (int index, char *text)
16336 {
16337     int len;
16338     char *p;
16339     float score;
16340
16341     if(index && sscanf(text, "%f/%d", &score, &len) == 2 &&
16342        pvInfoList[index-1].depth == len &&
16343        fabs(pvInfoList[index-1].score - score*100.) < 0.5 &&
16344        (p = strchr(text, '\n'))) text = p; // [HGM] strip off first line with PV info, if any
16345     while (*text == '\n') text++;
16346     len = strlen(text);
16347     while (len > 0 && text[len - 1] == '\n') len--;
16348
16349     if (commentList[index] != NULL)
16350       free(commentList[index]);
16351
16352     if (len == 0) {
16353         commentList[index] = NULL;
16354         return;
16355     }
16356   if( *text == '{' && strchr(text, '}') || // [HGM] braces: if certainy malformed, put braces
16357       *text == '[' && strchr(text, ']') || // otherwise hope the user knows what he is doing
16358       *text == '(' && strchr(text, ')')) { // (perhaps check if this parses as comment-only?)
16359     commentList[index] = (char *) malloc(len + 2);
16360     strncpy(commentList[index], text, len);
16361     commentList[index][len] = '\n';
16362     commentList[index][len + 1] = NULLCHAR;
16363   } else {
16364     // [HGM] braces: if text does not start with known OK delimiter, put braces around it.
16365     char *p;
16366     commentList[index] = (char *) malloc(len + 7);
16367     safeStrCpy(commentList[index], "{\n", 3);
16368     safeStrCpy(commentList[index]+2, text, len+1);
16369     commentList[index][len+2] = NULLCHAR;
16370     while(p = strchr(commentList[index], '}')) *p = ')'; // kill all } to make it one comment
16371     strcat(commentList[index], "\n}\n");
16372   }
16373 }
16374
16375 void
16376 CrushCRs (char *text)
16377 {
16378   char *p = text;
16379   char *q = text;
16380   char ch;
16381
16382   do {
16383     ch = *p++;
16384     if (ch == '\r') continue;
16385     *q++ = ch;
16386   } while (ch != '\0');
16387 }
16388
16389 void
16390 AppendComment (int index, char *text, Boolean addBraces)
16391 /* addBraces  tells if we should add {} */
16392 {
16393     int oldlen, len;
16394     char *old;
16395
16396 if(appData.debugMode) fprintf(debugFP, "Append: in='%s' %d\n", text, addBraces);
16397     if(addBraces == 3) addBraces = 0; else // force appending literally
16398     text = GetInfoFromComment( index, text ); /* [HGM] PV time: strip PV info from comment */
16399
16400     CrushCRs(text);
16401     while (*text == '\n') text++;
16402     len = strlen(text);
16403     while (len > 0 && text[len - 1] == '\n') len--;
16404     text[len] = NULLCHAR;
16405
16406     if (len == 0) return;
16407
16408     if (commentList[index] != NULL) {
16409       Boolean addClosingBrace = addBraces;
16410         old = commentList[index];
16411         oldlen = strlen(old);
16412         while(commentList[index][oldlen-1] ==  '\n')
16413           commentList[index][--oldlen] = NULLCHAR;
16414         commentList[index] = (char *) malloc(oldlen + len + 6); // might waste 4
16415         safeStrCpy(commentList[index], old, oldlen + len + 6);
16416         free(old);
16417         // [HGM] braces: join "{A\n}\n" + "{\nB}" as "{A\nB\n}"
16418         if(commentList[index][oldlen-1] == '}' && (text[0] == '{' || addBraces == TRUE)) {
16419           if(addBraces == TRUE) addBraces = FALSE; else { text++; len--; }
16420           while (*text == '\n') { text++; len--; }
16421           commentList[index][--oldlen] = NULLCHAR;
16422       }
16423         if(addBraces) strcat(commentList[index], addBraces == 2 ? "\n(" : "\n{\n");
16424         else          strcat(commentList[index], "\n");
16425         strcat(commentList[index], text);
16426         if(addClosingBrace) strcat(commentList[index], addClosingBrace == 2 ? ")\n" : "\n}\n");
16427         else          strcat(commentList[index], "\n");
16428     } else {
16429         commentList[index] = (char *) malloc(len + 6); // perhaps wastes 4...
16430         if(addBraces)
16431           safeStrCpy(commentList[index], addBraces == 2 ? "(" : "{\n", 3);
16432         else commentList[index][0] = NULLCHAR;
16433         strcat(commentList[index], text);
16434         strcat(commentList[index], addBraces == 2 ? ")\n" : "\n");
16435         if(addBraces == TRUE) strcat(commentList[index], "}\n");
16436     }
16437 }
16438
16439 static char *
16440 FindStr (char * text, char * sub_text)
16441 {
16442     char * result = strstr( text, sub_text );
16443
16444     if( result != NULL ) {
16445         result += strlen( sub_text );
16446     }
16447
16448     return result;
16449 }
16450
16451 /* [AS] Try to extract PV info from PGN comment */
16452 /* [HGM] PV time: and then remove it, to prevent it appearing twice */
16453 char *
16454 GetInfoFromComment (int index, char * text)
16455 {
16456     char * sep = text, *p;
16457
16458     if( text != NULL && index > 0 ) {
16459         int score = 0;
16460         int depth = 0;
16461         int time = -1, sec = 0, deci;
16462         char * s_eval = FindStr( text, "[%eval " );
16463         char * s_emt = FindStr( text, "[%emt " );
16464 #if 0
16465         if( s_eval != NULL || s_emt != NULL ) {
16466 #else
16467         if(0) { // [HGM] this code is not finished, and could actually be detrimental
16468 #endif
16469             /* New style */
16470             char delim;
16471
16472             if( s_eval != NULL ) {
16473                 if( sscanf( s_eval, "%d,%d%c", &score, &depth, &delim ) != 3 ) {
16474                     return text;
16475                 }
16476
16477                 if( delim != ']' ) {
16478                     return text;
16479                 }
16480             }
16481
16482             if( s_emt != NULL ) {
16483             }
16484                 return text;
16485         }
16486         else {
16487             /* We expect something like: [+|-]nnn.nn/dd */
16488             int score_lo = 0;
16489
16490             if(*text != '{') return text; // [HGM] braces: must be normal comment
16491
16492             sep = strchr( text, '/' );
16493             if( sep == NULL || sep < (text+4) ) {
16494                 return text;
16495             }
16496
16497             p = text;
16498             if(!strncmp(p+1, "final score ", 12)) p += 12, index++; else
16499             if(p[1] == '(') { // comment starts with PV
16500                p = strchr(p, ')'); // locate end of PV
16501                if(p == NULL || sep < p+5) return text;
16502                // at this point we have something like "{(.*) +0.23/6 ..."
16503                p = text; while(*++p != ')') p[-1] = *p; p[-1] = ')';
16504                *p = '\n'; while(*p == ' ' || *p == '\n') p++; *--p = '{';
16505                // we now moved the brace to behind the PV: "(.*) {+0.23/6 ..."
16506             }
16507             time = -1; sec = -1; deci = -1;
16508             if( sscanf( p+1, "%d.%d/%d %d:%d", &score, &score_lo, &depth, &time, &sec ) != 5 &&
16509                 sscanf( p+1, "%d.%d/%d %d.%d", &score, &score_lo, &depth, &time, &deci ) != 5 &&
16510                 sscanf( p+1, "%d.%d/%d %d", &score, &score_lo, &depth, &time ) != 4 &&
16511                 sscanf( p+1, "%d.%d/%d", &score, &score_lo, &depth ) != 3   ) {
16512                 return text;
16513             }
16514
16515             if( score_lo < 0 || score_lo >= 100 ) {
16516                 return text;
16517             }
16518
16519             if(sec >= 0) time = 600*time + 10*sec; else
16520             if(deci >= 0) time = 10*time + deci; else time *= 10; // deci-sec
16521
16522             score = score > 0 || !score & p[1] != '-' ? score*100 + score_lo : score*100 - score_lo;
16523
16524             /* [HGM] PV time: now locate end of PV info */
16525             while( *++sep >= '0' && *sep <= '9'); // strip depth
16526             if(time >= 0)
16527             while( *++sep >= '0' && *sep <= '9' || *sep == '\n'); // strip time
16528             if(sec >= 0)
16529             while( *++sep >= '0' && *sep <= '9'); // strip seconds
16530             if(deci >= 0)
16531             while( *++sep >= '0' && *sep <= '9'); // strip fractional seconds
16532             while(*sep == ' ' || *sep == '\n' || *sep == '\r') sep++;
16533         }
16534
16535         if( depth <= 0 ) {
16536             return text;
16537         }
16538
16539         if( time < 0 ) {
16540             time = -1;
16541         }
16542
16543         pvInfoList[index-1].depth = depth;
16544         pvInfoList[index-1].score = score;
16545         pvInfoList[index-1].time  = 10*time; // centi-sec
16546         if(*sep == '}') *sep = 0; else *--sep = '{';
16547         if(p != text) { while(*p++ = *sep++); sep = text; } // squeeze out space between PV and comment, and return both
16548     }
16549     return sep;
16550 }
16551
16552 void
16553 SendToProgram (char *message, ChessProgramState *cps)
16554 {
16555     int count, outCount, error;
16556     char buf[MSG_SIZ];
16557
16558     if (cps->pr == NoProc) return;
16559     Attention(cps);
16560
16561     if (appData.debugMode) {
16562         TimeMark now;
16563         GetTimeMark(&now);
16564         fprintf(debugFP, "%ld >%-6s: %s",
16565                 SubtractTimeMarks(&now, &programStartTime),
16566                 cps->which, message);
16567         if(serverFP)
16568             fprintf(serverFP, "%ld >%-6s: %s",
16569                 SubtractTimeMarks(&now, &programStartTime),
16570                 cps->which, message), fflush(serverFP);
16571     }
16572
16573     count = strlen(message);
16574     outCount = OutputToProcess(cps->pr, message, count, &error);
16575     if (outCount < count && !exiting
16576                          && !endingGame) { /* [HGM] crash: to not hang GameEnds() writing to deceased engines */
16577       if(!cps->initDone) return; // [HGM] should not generate fatal error during engine load
16578       snprintf(buf, MSG_SIZ, _("Error writing to %s chess program"), _(cps->which));
16579         if(gameInfo.resultDetails==NULL) { /* [HGM] crash: if game in progress, give reason for abort */
16580             if((signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
16581                 snprintf(buf, MSG_SIZ, _("%s program exits in draw position (%s)"), _(cps->which), cps->program);
16582                 if(matchMode && appData.tourneyFile[0]) { cps->pr = NoProc; GameEnds(GameIsDrawn, buf, GE_XBOARD); return; }
16583                 gameInfo.result = GameIsDrawn; /* [HGM] accept exit as draw claim */
16584             } else {
16585                 ChessMove res = cps->twoMachinesColor[0]=='w' ? BlackWins : WhiteWins;
16586                 if(matchMode && appData.tourneyFile[0]) { cps->pr = NoProc; GameEnds(res, buf, GE_XBOARD); return; }
16587                 gameInfo.result = res;
16588             }
16589             gameInfo.resultDetails = StrSave(buf);
16590         }
16591         if(matchMode && appData.tourneyFile[0]) { cps->pr = NoProc; return; }
16592         if(!cps->userError || !appData.popupExitMessage) DisplayFatalError(buf, error, 1); else errorExitStatus = 1;
16593     }
16594 }
16595
16596 void
16597 ReceiveFromProgram (InputSourceRef isr, VOIDSTAR closure, char *message, int count, int error)
16598 {
16599     char *end_str;
16600     char buf[MSG_SIZ];
16601     ChessProgramState *cps = (ChessProgramState *)closure;
16602
16603     if (isr != cps->isr) return; /* Killed intentionally */
16604     if (count <= 0) {
16605         if (count == 0) {
16606             RemoveInputSource(cps->isr);
16607             snprintf(buf, MSG_SIZ, _("Error: %s chess program (%s) exited unexpectedly"),
16608                     _(cps->which), cps->program);
16609             if(LoadError(cps->userError ? NULL : buf, cps)) return; // [HGM] should not generate fatal error during engine load
16610             if(gameInfo.resultDetails==NULL) { /* [HGM] crash: if game in progress, give reason for abort */
16611                 if((signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
16612                     snprintf(buf, MSG_SIZ, _("%s program exits in draw position (%s)"), _(cps->which), cps->program);
16613                     if(matchMode && appData.tourneyFile[0]) { cps->pr = NoProc; GameEnds(GameIsDrawn, buf, GE_XBOARD); return; }
16614                     gameInfo.result = GameIsDrawn; /* [HGM] accept exit as draw claim */
16615                 } else {
16616                     ChessMove res = cps->twoMachinesColor[0]=='w' ? BlackWins : WhiteWins;
16617                     if(matchMode && appData.tourneyFile[0]) { cps->pr = NoProc; GameEnds(res, buf, GE_XBOARD); return; }
16618                     gameInfo.result = res;
16619                 }
16620                 gameInfo.resultDetails = StrSave(buf);
16621             }
16622             if(matchMode && appData.tourneyFile[0]) { cps->pr = NoProc; return; }
16623             if(!cps->userError || !appData.popupExitMessage) DisplayFatalError(buf, 0, 1); else errorExitStatus = 1;
16624         } else {
16625             snprintf(buf, MSG_SIZ, _("Error reading from %s chess program (%s)"),
16626                     _(cps->which), cps->program);
16627             RemoveInputSource(cps->isr);
16628
16629             /* [AS] Program is misbehaving badly... kill it */
16630             if( count == -2 ) {
16631                 DestroyChildProcess( cps->pr, 9 );
16632                 cps->pr = NoProc;
16633             }
16634
16635             if(!cps->userError || !appData.popupExitMessage) DisplayFatalError(buf, error, 1); else errorExitStatus = 1;
16636         }
16637         return;
16638     }
16639
16640     if ((end_str = strchr(message, '\r')) != NULL)
16641       *end_str = NULLCHAR;
16642     if ((end_str = strchr(message, '\n')) != NULL)
16643       *end_str = NULLCHAR;
16644
16645     if (appData.debugMode) {
16646         TimeMark now; int print = 1;
16647         char *quote = ""; char c; int i;
16648
16649         if(appData.engineComments != 1) { /* [HGM] debug: decide if protocol-violating output is written */
16650                 char start = message[0];
16651                 if(start >='A' && start <= 'Z') start += 'a' - 'A'; // be tolerant to capitalizing
16652                 if(sscanf(message, "%d%c%d%d%d", &i, &c, &i, &i, &i) != 5 &&
16653                    sscanf(message, "move %c", &c)!=1  && sscanf(message, "offer%c", &c)!=1 &&
16654                    sscanf(message, "resign%c", &c)!=1 && sscanf(message, "feature %c", &c)!=1 &&
16655                    sscanf(message, "error %c", &c)!=1 && sscanf(message, "illegal %c", &c)!=1 &&
16656                    sscanf(message, "tell%c", &c)!=1   && sscanf(message, "0-1 %c", &c)!=1 &&
16657                    sscanf(message, "1-0 %c", &c)!=1   && sscanf(message, "1/2-1/2 %c", &c)!=1 &&
16658                    sscanf(message, "setboard %c", &c)!=1   && sscanf(message, "setup %c", &c)!=1 &&
16659                    sscanf(message, "hint: %c", &c)!=1 &&
16660                    sscanf(message, "pong %c", &c)!=1   && start != '#') {
16661                     quote = appData.engineComments == 2 ? "# " : "### NON-COMPLIANT! ### ";
16662                     print = (appData.engineComments >= 2);
16663                 }
16664                 message[0] = start; // restore original message
16665         }
16666         if(print) {
16667                 GetTimeMark(&now);
16668                 fprintf(debugFP, "%ld <%-6s: %s%s\n",
16669                         SubtractTimeMarks(&now, &programStartTime), cps->which,
16670                         quote,
16671                         message);
16672                 if(serverFP)
16673                     fprintf(serverFP, "%ld <%-6s: %s%s\n",
16674                         SubtractTimeMarks(&now, &programStartTime), cps->which,
16675                         quote,
16676                         message), fflush(serverFP);
16677         }
16678     }
16679
16680     /* [DM] if icsEngineAnalyze is active we block all whisper and kibitz output, because nobody want to see this */
16681     if (appData.icsEngineAnalyze) {
16682         if (strstr(message, "whisper") != NULL ||
16683              strstr(message, "kibitz") != NULL ||
16684             strstr(message, "tellics") != NULL) return;
16685     }
16686
16687     HandleMachineMove(message, cps);
16688 }
16689
16690
16691 void
16692 SendTimeControl (ChessProgramState *cps, int mps, long tc, int inc, int sd, int st)
16693 {
16694     char buf[MSG_SIZ];
16695     int seconds;
16696
16697     if( timeControl_2 > 0 ) {
16698         if( (gameMode == MachinePlaysBlack) || (gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b') ) {
16699             tc = timeControl_2;
16700         }
16701     }
16702     tc  /= cps->timeOdds; /* [HGM] time odds: apply before telling engine */
16703     inc /= cps->timeOdds;
16704     st  /= cps->timeOdds;
16705
16706     seconds = (tc / 1000) % 60; /* [HGM] displaced to after applying odds */
16707
16708     if (st > 0) {
16709       /* Set exact time per move, normally using st command */
16710       if (cps->stKludge) {
16711         /* GNU Chess 4 has no st command; uses level in a nonstandard way */
16712         seconds = st % 60;
16713         if (seconds == 0) {
16714           snprintf(buf, MSG_SIZ, "level 1 %d\n", st/60);
16715         } else {
16716           snprintf(buf, MSG_SIZ, "level 1 %d:%02d\n", st/60, seconds);
16717         }
16718       } else {
16719         snprintf(buf, MSG_SIZ, "st %d\n", st);
16720       }
16721     } else {
16722       /* Set conventional or incremental time control, using level command */
16723       if (seconds == 0) {
16724         /* Note old gnuchess bug -- minutes:seconds used to not work.
16725            Fixed in later versions, but still avoid :seconds
16726            when seconds is 0. */
16727         snprintf(buf, MSG_SIZ, "level %d %ld %g\n", mps, tc/60000, inc/1000.);
16728       } else {
16729         snprintf(buf, MSG_SIZ, "level %d %ld:%02d %g\n", mps, tc/60000,
16730                  seconds, inc/1000.);
16731       }
16732     }
16733     SendToProgram(buf, cps);
16734
16735     /* Orthoganally (except for GNU Chess 4), limit time to st seconds */
16736     /* Orthogonally, limit search to given depth */
16737     if (sd > 0) {
16738       if (cps->sdKludge) {
16739         snprintf(buf, MSG_SIZ, "depth\n%d\n", sd);
16740       } else {
16741         snprintf(buf, MSG_SIZ, "sd %d\n", sd);
16742       }
16743       SendToProgram(buf, cps);
16744     }
16745
16746     if(cps->nps >= 0) { /* [HGM] nps */
16747         if(cps->supportsNPS == FALSE)
16748           cps->nps = -1; // don't use if engine explicitly says not supported!
16749         else {
16750           snprintf(buf, MSG_SIZ, "nps %d\n", cps->nps);
16751           SendToProgram(buf, cps);
16752         }
16753     }
16754 }
16755
16756 ChessProgramState *
16757 WhitePlayer ()
16758 /* [HGM] return pointer to 'first' or 'second', depending on who plays white */
16759 {
16760     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b' ||
16761        gameMode == BeginningOfGame || gameMode == MachinePlaysBlack)
16762         return &second;
16763     return &first;
16764 }
16765
16766 void
16767 SendTimeRemaining (ChessProgramState *cps, int machineWhite)
16768 {
16769     char message[MSG_SIZ];
16770     long time, otime;
16771
16772     /* Note: this routine must be called when the clocks are stopped
16773        or when they have *just* been set or switched; otherwise
16774        it will be off by the time since the current tick started.
16775     */
16776     if (machineWhite) {
16777         time = whiteTimeRemaining / 10;
16778         otime = blackTimeRemaining / 10;
16779     } else {
16780         time = blackTimeRemaining / 10;
16781         otime = whiteTimeRemaining / 10;
16782     }
16783     /* [HGM] translate opponent's time by time-odds factor */
16784     otime = (otime * cps->other->timeOdds) / cps->timeOdds;
16785
16786     if (time <= 0) time = 1;
16787     if (otime <= 0) otime = 1;
16788
16789     snprintf(message, MSG_SIZ, "time %ld\n", time);
16790     SendToProgram(message, cps);
16791
16792     snprintf(message, MSG_SIZ, "otim %ld\n", otime);
16793     SendToProgram(message, cps);
16794 }
16795
16796 char *
16797 EngineDefinedVariant (ChessProgramState *cps, int n)
16798 {   // return name of n-th unknown variant that engine supports
16799     static char buf[MSG_SIZ];
16800     char *p, *s = cps->variants;
16801     if(!s) return NULL;
16802     do { // parse string from variants feature
16803       VariantClass v;
16804         p = strchr(s, ',');
16805         if(p) *p = NULLCHAR;
16806       v = StringToVariant(s);
16807       if(v == VariantNormal && strcmp(s, "normal") && !strstr(s, "_normal")) v = VariantUnknown; // garbage is recognized as normal
16808         if(v == VariantUnknown) { // non-standard variant in list of engine-supported variants
16809             if(!strcmp(s, "tenjiku") || !strcmp(s, "dai") || !strcmp(s, "dada") || // ignore Alien-Edition variants
16810                !strcmp(s, "maka") || !strcmp(s, "tai") || !strcmp(s, "kyoku") ||
16811                !strcmp(s, "checkers") || !strcmp(s, "go") || !strcmp(s, "reversi") ||
16812                !strcmp(s, "dark") || !strcmp(s, "alien") || !strcmp(s, "multi") || !strcmp(s, "amazons") ) n++;
16813             if(--n < 0) safeStrCpy(buf, s, MSG_SIZ);
16814         }
16815         if(p) *p++ = ',';
16816         if(n < 0) return buf;
16817     } while(s = p);
16818     return NULL;
16819 }
16820
16821 int
16822 BoolFeature (char **p, char *name, int *loc, ChessProgramState *cps)
16823 {
16824   char buf[MSG_SIZ];
16825   int len = strlen(name);
16826   int val;
16827
16828   if (strncmp((*p), name, len) == 0 && (*p)[len] == '=') {
16829     (*p) += len + 1;
16830     sscanf(*p, "%d", &val);
16831     *loc = (val != 0);
16832     while (**p && **p != ' ')
16833       (*p)++;
16834     snprintf(buf, MSG_SIZ, "accepted %s\n", name);
16835     SendToProgram(buf, cps);
16836     return TRUE;
16837   }
16838   return FALSE;
16839 }
16840
16841 int
16842 IntFeature (char **p, char *name, int *loc, ChessProgramState *cps)
16843 {
16844   char buf[MSG_SIZ];
16845   int len = strlen(name);
16846   if (strncmp((*p), name, len) == 0 && (*p)[len] == '=') {
16847     (*p) += len + 1;
16848     sscanf(*p, "%d", loc);
16849     while (**p && **p != ' ') (*p)++;
16850     snprintf(buf, MSG_SIZ, "accepted %s\n", name);
16851     SendToProgram(buf, cps);
16852     return TRUE;
16853   }
16854   return FALSE;
16855 }
16856
16857 int
16858 StringFeature (char **p, char *name, char **loc, ChessProgramState *cps)
16859 {
16860   char buf[MSG_SIZ];
16861   int len = strlen(name);
16862   if (strncmp((*p), name, len) == 0
16863       && (*p)[len] == '=' && (*p)[len+1] == '\"') {
16864     (*p) += len + 2;
16865     ASSIGN(*loc, *p); // kludge alert: assign rest of line just to be sure allocation is large enough so that sscanf below always fits
16866     sscanf(*p, "%[^\"]", *loc);
16867     while (**p && **p != '\"') (*p)++;
16868     if (**p == '\"') (*p)++;
16869     snprintf(buf, MSG_SIZ, "accepted %s\n", name);
16870     SendToProgram(buf, cps);
16871     return TRUE;
16872   }
16873   return FALSE;
16874 }
16875
16876 int
16877 ParseOption (Option *opt, ChessProgramState *cps)
16878 // [HGM] options: process the string that defines an engine option, and determine
16879 // name, type, default value, and allowed value range
16880 {
16881         char *p, *q, buf[MSG_SIZ];
16882         int n, min = (-1)<<31, max = 1<<31, def;
16883
16884         if(p = strstr(opt->name, " -spin ")) {
16885             if((n = sscanf(p, " -spin %d %d %d", &def, &min, &max)) < 3 ) return FALSE;
16886             if(max < min) max = min; // enforce consistency
16887             if(def < min) def = min;
16888             if(def > max) def = max;
16889             opt->value = def;
16890             opt->min = min;
16891             opt->max = max;
16892             opt->type = Spin;
16893         } else if((p = strstr(opt->name, " -slider "))) {
16894             // for now -slider is a synonym for -spin, to already provide compatibility with future polyglots
16895             if((n = sscanf(p, " -slider %d %d %d", &def, &min, &max)) < 3 ) return FALSE;
16896             if(max < min) max = min; // enforce consistency
16897             if(def < min) def = min;
16898             if(def > max) def = max;
16899             opt->value = def;
16900             opt->min = min;
16901             opt->max = max;
16902             opt->type = Spin; // Slider;
16903         } else if((p = strstr(opt->name, " -string "))) {
16904             opt->textValue = p+9;
16905             opt->type = TextBox;
16906         } else if((p = strstr(opt->name, " -file "))) {
16907             // for now -file is a synonym for -string, to already provide compatibility with future polyglots
16908             opt->textValue = p+7;
16909             opt->type = FileName; // FileName;
16910         } else if((p = strstr(opt->name, " -path "))) {
16911             // for now -file is a synonym for -string, to already provide compatibility with future polyglots
16912             opt->textValue = p+7;
16913             opt->type = PathName; // PathName;
16914         } else if(p = strstr(opt->name, " -check ")) {
16915             if(sscanf(p, " -check %d", &def) < 1) return FALSE;
16916             opt->value = (def != 0);
16917             opt->type = CheckBox;
16918         } else if(p = strstr(opt->name, " -combo ")) {
16919             opt->textValue = (char*) (opt->choice = &cps->comboList[cps->comboCnt]); // cheat with pointer type
16920             cps->comboList[cps->comboCnt++] = q = p+8; // holds possible choices
16921             if(*q == '*') cps->comboList[cps->comboCnt-1]++;
16922             opt->value = n = 0;
16923             while(q = StrStr(q, " /// ")) {
16924                 n++; *q = 0;    // count choices, and null-terminate each of them
16925                 q += 5;
16926                 if(*q == '*') { // remember default, which is marked with * prefix
16927                     q++;
16928                     opt->value = n;
16929                 }
16930                 cps->comboList[cps->comboCnt++] = q;
16931             }
16932             cps->comboList[cps->comboCnt++] = NULL;
16933             opt->max = n + 1;
16934             opt->type = ComboBox;
16935         } else if(p = strstr(opt->name, " -button")) {
16936             opt->type = Button;
16937         } else if(p = strstr(opt->name, " -save")) {
16938             opt->type = SaveButton;
16939         } else return FALSE;
16940         *p = 0; // terminate option name
16941         // now look if the command-line options define a setting for this engine option.
16942         if(cps->optionSettings && cps->optionSettings[0])
16943             p = strstr(cps->optionSettings, opt->name); else p = NULL;
16944         if(p && (p == cps->optionSettings || p[-1] == ',')) {
16945           snprintf(buf, MSG_SIZ, "option %s", p);
16946                 if(p = strstr(buf, ",")) *p = 0;
16947                 if(q = strchr(buf, '=')) switch(opt->type) {
16948                     case ComboBox:
16949                         for(n=0; n<opt->max; n++)
16950                             if(!strcmp(((char**)opt->textValue)[n], q+1)) opt->value = n;
16951                         break;
16952                     case TextBox:
16953                         safeStrCpy(opt->textValue, q+1, MSG_SIZ - (opt->textValue - opt->name));
16954                         break;
16955                     case Spin:
16956                     case CheckBox:
16957                         opt->value = atoi(q+1);
16958                     default:
16959                         break;
16960                 }
16961                 strcat(buf, "\n");
16962                 SendToProgram(buf, cps);
16963         }
16964         return TRUE;
16965 }
16966
16967 void
16968 FeatureDone (ChessProgramState *cps, int val)
16969 {
16970   DelayedEventCallback cb = GetDelayedEvent();
16971   if ((cb == InitBackEnd3 && cps == &first) ||
16972       (cb == SettingsMenuIfReady && cps == &second) ||
16973       (cb == LoadEngine) ||
16974       (cb == TwoMachinesEventIfReady)) {
16975     CancelDelayedEvent();
16976     ScheduleDelayedEvent(cb, val ? 1 : 3600000);
16977   }
16978   cps->initDone = val;
16979   if(val) cps->reload = FALSE;
16980 }
16981
16982 /* Parse feature command from engine */
16983 void
16984 ParseFeatures (char *args, ChessProgramState *cps)
16985 {
16986   char *p = args;
16987   char *q = NULL;
16988   int val;
16989   char buf[MSG_SIZ];
16990
16991   for (;;) {
16992     while (*p == ' ') p++;
16993     if (*p == NULLCHAR) return;
16994
16995     if (BoolFeature(&p, "setboard", &cps->useSetboard, cps)) continue;
16996     if (BoolFeature(&p, "xedit", &cps->extendedEdit, cps)) continue;
16997     if (BoolFeature(&p, "time", &cps->sendTime, cps)) continue;
16998     if (BoolFeature(&p, "draw", &cps->sendDrawOffers, cps)) continue;
16999     if (BoolFeature(&p, "sigint", &cps->useSigint, cps)) continue;
17000     if (BoolFeature(&p, "sigterm", &cps->useSigterm, cps)) continue;
17001     if (BoolFeature(&p, "reuse", &val, cps)) {
17002       /* Engine can disable reuse, but can't enable it if user said no */
17003       if (!val) cps->reuse = FALSE;
17004       continue;
17005     }
17006     if (BoolFeature(&p, "analyze", &cps->analysisSupport, cps)) continue;
17007     if (StringFeature(&p, "myname", &cps->tidy, cps)) {
17008       if (gameMode == TwoMachinesPlay) {
17009         DisplayTwoMachinesTitle();
17010       } else {
17011         DisplayTitle("");
17012       }
17013       continue;
17014     }
17015     if (StringFeature(&p, "variants", &cps->variants, cps)) continue;
17016     if (BoolFeature(&p, "san", &cps->useSAN, cps)) continue;
17017     if (BoolFeature(&p, "ping", &cps->usePing, cps)) continue;
17018     if (BoolFeature(&p, "playother", &cps->usePlayother, cps)) continue;
17019     if (BoolFeature(&p, "colors", &cps->useColors, cps)) continue;
17020     if (BoolFeature(&p, "usermove", &cps->useUsermove, cps)) continue;
17021     if (BoolFeature(&p, "exclude", &cps->excludeMoves, cps)) continue;
17022     if (BoolFeature(&p, "ics", &cps->sendICS, cps)) continue;
17023     if (BoolFeature(&p, "name", &cps->sendName, cps)) continue;
17024     if (BoolFeature(&p, "pause", &cps->pause, cps)) continue; // [HGM] pause
17025     if (IntFeature(&p, "done", &val, cps)) {
17026       FeatureDone(cps, val);
17027       continue;
17028     }
17029     /* Added by Tord: */
17030     if (BoolFeature(&p, "fen960", &cps->useFEN960, cps)) continue;
17031     if (BoolFeature(&p, "oocastle", &cps->useOOCastle, cps)) continue;
17032     /* End of additions by Tord */
17033
17034     /* [HGM] added features: */
17035     if (BoolFeature(&p, "highlight", &cps->highlight, cps)) continue;
17036     if (BoolFeature(&p, "debug", &cps->debug, cps)) continue;
17037     if (BoolFeature(&p, "nps", &cps->supportsNPS, cps)) continue;
17038     if (IntFeature(&p, "level", &cps->maxNrOfSessions, cps)) continue;
17039     if (BoolFeature(&p, "memory", &cps->memSize, cps)) continue;
17040     if (BoolFeature(&p, "smp", &cps->maxCores, cps)) continue;
17041     if (StringFeature(&p, "egt", &cps->egtFormats, cps)) continue;
17042     if (StringFeature(&p, "option", &q, cps)) { // read to freshly allocated temp buffer first
17043         if(cps->reload) { FREE(q); q = NULL; continue; } // we are reloading because of xreuse
17044         FREE(cps->option[cps->nrOptions].name);
17045         cps->option[cps->nrOptions].name = q; q = NULL;
17046         if(!ParseOption(&(cps->option[cps->nrOptions++]), cps)) { // [HGM] options: add option feature
17047           snprintf(buf, MSG_SIZ, "rejected option %s\n", cps->option[--cps->nrOptions].name);
17048             SendToProgram(buf, cps);
17049             continue;
17050         }
17051         if(cps->nrOptions >= MAX_OPTIONS) {
17052             cps->nrOptions--;
17053             snprintf(buf, MSG_SIZ, _("%s engine has too many options\n"), _(cps->which));
17054             DisplayError(buf, 0);
17055         }
17056         continue;
17057     }
17058     /* End of additions by HGM */
17059
17060     /* unknown feature: complain and skip */
17061     q = p;
17062     while (*q && *q != '=') q++;
17063     snprintf(buf, MSG_SIZ,"rejected %.*s\n", (int)(q-p), p);
17064     SendToProgram(buf, cps);
17065     p = q;
17066     if (*p == '=') {
17067       p++;
17068       if (*p == '\"') {
17069         p++;
17070         while (*p && *p != '\"') p++;
17071         if (*p == '\"') p++;
17072       } else {
17073         while (*p && *p != ' ') p++;
17074       }
17075     }
17076   }
17077
17078 }
17079
17080 void
17081 PeriodicUpdatesEvent (int newState)
17082 {
17083     if (newState == appData.periodicUpdates)
17084       return;
17085
17086     appData.periodicUpdates=newState;
17087
17088     /* Display type changes, so update it now */
17089 //    DisplayAnalysis();
17090
17091     /* Get the ball rolling again... */
17092     if (newState) {
17093         AnalysisPeriodicEvent(1);
17094         StartAnalysisClock();
17095     }
17096 }
17097
17098 void
17099 PonderNextMoveEvent (int newState)
17100 {
17101     if (newState == appData.ponderNextMove) return;
17102     if (gameMode == EditPosition) EditPositionDone(TRUE);
17103     if (newState) {
17104         SendToProgram("hard\n", &first);
17105         if (gameMode == TwoMachinesPlay) {
17106             SendToProgram("hard\n", &second);
17107         }
17108     } else {
17109         SendToProgram("easy\n", &first);
17110         thinkOutput[0] = NULLCHAR;
17111         if (gameMode == TwoMachinesPlay) {
17112             SendToProgram("easy\n", &second);
17113         }
17114     }
17115     appData.ponderNextMove = newState;
17116 }
17117
17118 void
17119 NewSettingEvent (int option, int *feature, char *command, int value)
17120 {
17121     char buf[MSG_SIZ];
17122
17123     if (gameMode == EditPosition) EditPositionDone(TRUE);
17124     snprintf(buf, MSG_SIZ,"%s%s %d\n", (option ? "option ": ""), command, value);
17125     if(feature == NULL || *feature) SendToProgram(buf, &first);
17126     if (gameMode == TwoMachinesPlay) {
17127         if(feature == NULL || feature[(int*)&second - (int*)&first]) SendToProgram(buf, &second);
17128     }
17129 }
17130
17131 void
17132 ShowThinkingEvent ()
17133 // [HGM] thinking: this routine is now also called from "Options -> Engine..." popup
17134 {
17135     static int oldState = 2; // kludge alert! Neither true nor fals, so first time oldState is always updated
17136     int newState = appData.showThinking
17137         // [HGM] thinking: other features now need thinking output as well
17138         || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp();
17139
17140     if (oldState == newState) return;
17141     oldState = newState;
17142     if (gameMode == EditPosition) EditPositionDone(TRUE);
17143     if (oldState) {
17144         SendToProgram("post\n", &first);
17145         if (gameMode == TwoMachinesPlay) {
17146             SendToProgram("post\n", &second);
17147         }
17148     } else {
17149         SendToProgram("nopost\n", &first);
17150         thinkOutput[0] = NULLCHAR;
17151         if (gameMode == TwoMachinesPlay) {
17152             SendToProgram("nopost\n", &second);
17153         }
17154     }
17155 //    appData.showThinking = newState; // [HGM] thinking: responsible option should already have be changed when calling this routine!
17156 }
17157
17158 void
17159 AskQuestionEvent (char *title, char *question, char *replyPrefix, char *which)
17160 {
17161   ProcRef pr = (which[0] == '1') ? first.pr : second.pr;
17162   if (pr == NoProc) return;
17163   AskQuestion(title, question, replyPrefix, pr);
17164 }
17165
17166 void
17167 TypeInEvent (char firstChar)
17168 {
17169     if ((gameMode == BeginningOfGame && !appData.icsActive) ||
17170         gameMode == MachinePlaysWhite || gameMode == MachinePlaysBlack ||
17171         gameMode == AnalyzeMode || gameMode == EditGame ||
17172         gameMode == EditPosition || gameMode == IcsExamining ||
17173         gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack ||
17174         isdigit(firstChar) && // [HGM] movenum: allow typing in of move nr in 'passive' modes
17175                 ( gameMode == AnalyzeFile || gameMode == PlayFromGameFile ||
17176                   gameMode == IcsObserving || gameMode == TwoMachinesPlay    ) ||
17177         gameMode == Training) PopUpMoveDialog(firstChar);
17178 }
17179
17180 void
17181 TypeInDoneEvent (char *move)
17182 {
17183         Board board;
17184         int n, fromX, fromY, toX, toY;
17185         char promoChar;
17186         ChessMove moveType;
17187
17188         // [HGM] FENedit
17189         if(gameMode == EditPosition && ParseFEN(board, &n, move, TRUE) ) {
17190                 EditPositionPasteFEN(move);
17191                 return;
17192         }
17193         // [HGM] movenum: allow move number to be typed in any mode
17194         if(sscanf(move, "%d", &n) == 1 && n != 0 ) {
17195           ToNrEvent(2*n-1);
17196           return;
17197         }
17198         // undocumented kludge: allow command-line option to be typed in!
17199         // (potentially fatal, and does not implement the effect of the option.)
17200         // should only be used for options that are values on which future decisions will be made,
17201         // and definitely not on options that would be used during initialization.
17202         if(strstr(move, "!!! -") == move) {
17203             ParseArgsFromString(move+4);
17204             return;
17205         }
17206
17207       if (gameMode != EditGame && currentMove != forwardMostMove &&
17208         gameMode != Training) {
17209         DisplayMoveError(_("Displayed move is not current"));
17210       } else {
17211         int ok = ParseOneMove(move, gameMode == EditPosition ? blackPlaysFirst : currentMove,
17212           &moveType, &fromX, &fromY, &toX, &toY, &promoChar);
17213         if(!ok && move[0] >= 'a') { move[0] += 'A' - 'a'; ok = 2; } // [HGM] try also capitalized
17214         if (ok==1 || ok && ParseOneMove(move, gameMode == EditPosition ? blackPlaysFirst : currentMove,
17215           &moveType, &fromX, &fromY, &toX, &toY, &promoChar)) {
17216           UserMoveEvent(fromX, fromY, toX, toY, promoChar);
17217         } else {
17218           DisplayMoveError(_("Could not parse move"));
17219         }
17220       }
17221 }
17222
17223 void
17224 DisplayMove (int moveNumber)
17225 {
17226     char message[MSG_SIZ];
17227     char res[MSG_SIZ];
17228     char cpThinkOutput[MSG_SIZ];
17229
17230     if(appData.noGUI) return; // [HGM] fast: suppress display of moves
17231
17232     if (moveNumber == forwardMostMove - 1 ||
17233         gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
17234
17235         safeStrCpy(cpThinkOutput, thinkOutput, sizeof(cpThinkOutput)/sizeof(cpThinkOutput[0]));
17236
17237         if (strchr(cpThinkOutput, '\n')) {
17238             *strchr(cpThinkOutput, '\n') = NULLCHAR;
17239         }
17240     } else {
17241         *cpThinkOutput = NULLCHAR;
17242     }
17243
17244     /* [AS] Hide thinking from human user */
17245     if( appData.hideThinkingFromHuman && gameMode != TwoMachinesPlay ) {
17246         *cpThinkOutput = NULLCHAR;
17247         if( thinkOutput[0] != NULLCHAR ) {
17248             int i;
17249
17250             for( i=0; i<=hiddenThinkOutputState; i++ ) {
17251                 cpThinkOutput[i] = '.';
17252             }
17253             cpThinkOutput[i] = NULLCHAR;
17254             hiddenThinkOutputState = (hiddenThinkOutputState + 1) % 3;
17255         }
17256     }
17257
17258     if (moveNumber == forwardMostMove - 1 &&
17259         gameInfo.resultDetails != NULL) {
17260         if (gameInfo.resultDetails[0] == NULLCHAR) {
17261           snprintf(res, MSG_SIZ, " %s", PGNResult(gameInfo.result));
17262         } else {
17263           snprintf(res, MSG_SIZ, " {%s} %s",
17264                     T_(gameInfo.resultDetails), PGNResult(gameInfo.result));
17265         }
17266     } else {
17267         res[0] = NULLCHAR;
17268     }
17269
17270     if (moveNumber < 0 || parseList[moveNumber][0] == NULLCHAR) {
17271         DisplayMessage(res, cpThinkOutput);
17272     } else {
17273       snprintf(message, MSG_SIZ, "%d.%s%s%s", moveNumber / 2 + 1,
17274                 WhiteOnMove(moveNumber) ? " " : ".. ",
17275                 parseList[moveNumber], res);
17276         DisplayMessage(message, cpThinkOutput);
17277     }
17278 }
17279
17280 void
17281 DisplayComment (int moveNumber, char *text)
17282 {
17283     char title[MSG_SIZ];
17284
17285     if (moveNumber < 0 || parseList[moveNumber][0] == NULLCHAR) {
17286       safeStrCpy(title, "Comment", sizeof(title)/sizeof(title[0]));
17287     } else {
17288       snprintf(title,MSG_SIZ, "Comment on %d.%s%s", moveNumber / 2 + 1,
17289               WhiteOnMove(moveNumber) ? " " : ".. ",
17290               parseList[moveNumber]);
17291     }
17292     if (text != NULL && (appData.autoDisplayComment || commentUp))
17293         CommentPopUp(title, text);
17294 }
17295
17296 /* This routine sends a ^C interrupt to gnuchess, to awaken it if it
17297  * might be busy thinking or pondering.  It can be omitted if your
17298  * gnuchess is configured to stop thinking immediately on any user
17299  * input.  However, that gnuchess feature depends on the FIONREAD
17300  * ioctl, which does not work properly on some flavors of Unix.
17301  */
17302 void
17303 Attention (ChessProgramState *cps)
17304 {
17305 #if ATTENTION
17306     if (!cps->useSigint) return;
17307     if (appData.noChessProgram || (cps->pr == NoProc)) return;
17308     switch (gameMode) {
17309       case MachinePlaysWhite:
17310       case MachinePlaysBlack:
17311       case TwoMachinesPlay:
17312       case IcsPlayingWhite:
17313       case IcsPlayingBlack:
17314       case AnalyzeMode:
17315       case AnalyzeFile:
17316         /* Skip if we know it isn't thinking */
17317         if (!cps->maybeThinking) return;
17318         if (appData.debugMode)
17319           fprintf(debugFP, "Interrupting %s\n", cps->which);
17320         InterruptChildProcess(cps->pr);
17321         cps->maybeThinking = FALSE;
17322         break;
17323       default:
17324         break;
17325     }
17326 #endif /*ATTENTION*/
17327 }
17328
17329 int
17330 CheckFlags ()
17331 {
17332     if (whiteTimeRemaining <= 0) {
17333         if (!whiteFlag) {
17334             whiteFlag = TRUE;
17335             if (appData.icsActive) {
17336                 if (appData.autoCallFlag &&
17337                     gameMode == IcsPlayingBlack && !blackFlag) {
17338                   SendToICS(ics_prefix);
17339                   SendToICS("flag\n");
17340                 }
17341             } else {
17342                 if (blackFlag) {
17343                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Both flags fell"));
17344                 } else {
17345                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("White's flag fell"));
17346                     if (appData.autoCallFlag) {
17347                         GameEnds(BlackWins, "Black wins on time", GE_XBOARD);
17348                         return TRUE;
17349                     }
17350                 }
17351             }
17352         }
17353     }
17354     if (blackTimeRemaining <= 0) {
17355         if (!blackFlag) {
17356             blackFlag = TRUE;
17357             if (appData.icsActive) {
17358                 if (appData.autoCallFlag &&
17359                     gameMode == IcsPlayingWhite && !whiteFlag) {
17360                   SendToICS(ics_prefix);
17361                   SendToICS("flag\n");
17362                 }
17363             } else {
17364                 if (whiteFlag) {
17365                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Both flags fell"));
17366                 } else {
17367                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Black's flag fell"));
17368                     if (appData.autoCallFlag) {
17369                         GameEnds(WhiteWins, "White wins on time", GE_XBOARD);
17370                         return TRUE;
17371                     }
17372                 }
17373             }
17374         }
17375     }
17376     return FALSE;
17377 }
17378
17379 void
17380 CheckTimeControl ()
17381 {
17382     if (!appData.clockMode || appData.icsActive || searchTime || // [HGM] st: no inc in st mode
17383         gameMode == PlayFromGameFile || forwardMostMove == 0) return;
17384
17385     /*
17386      * add time to clocks when time control is achieved ([HGM] now also used for increment)
17387      */
17388     if ( !WhiteOnMove(forwardMostMove) ) {
17389         /* White made time control */
17390         lastWhite -= whiteTimeRemaining; // [HGM] contains start time, socalculate thinking time
17391         whiteTimeRemaining += GetTimeQuota((forwardMostMove-whiteStartMove-1)/2, lastWhite, whiteTC)
17392         /* [HGM] time odds: correct new time quota for time odds! */
17393                                             / WhitePlayer()->timeOdds;
17394         lastBlack = blackTimeRemaining; // [HGM] leave absolute time (after quota), so next switch we can us it to calculate thinking time
17395     } else {
17396         lastBlack -= blackTimeRemaining;
17397         /* Black made time control */
17398         blackTimeRemaining += GetTimeQuota((forwardMostMove-blackStartMove-1)/2, lastBlack, blackTC)
17399                                             / WhitePlayer()->other->timeOdds;
17400         lastWhite = whiteTimeRemaining;
17401     }
17402 }
17403
17404 void
17405 DisplayBothClocks ()
17406 {
17407     int wom = gameMode == EditPosition ?
17408       !blackPlaysFirst : WhiteOnMove(currentMove);
17409     DisplayWhiteClock(whiteTimeRemaining, wom);
17410     DisplayBlackClock(blackTimeRemaining, !wom);
17411 }
17412
17413
17414 /* Timekeeping seems to be a portability nightmare.  I think everyone
17415    has ftime(), but I'm really not sure, so I'm including some ifdefs
17416    to use other calls if you don't.  Clocks will be less accurate if
17417    you have neither ftime nor gettimeofday.
17418 */
17419
17420 /* VS 2008 requires the #include outside of the function */
17421 #if !HAVE_GETTIMEOFDAY && HAVE_FTIME
17422 #include <sys/timeb.h>
17423 #endif
17424
17425 /* Get the current time as a TimeMark */
17426 void
17427 GetTimeMark (TimeMark *tm)
17428 {
17429 #if HAVE_GETTIMEOFDAY
17430
17431     struct timeval timeVal;
17432     struct timezone timeZone;
17433
17434     gettimeofday(&timeVal, &timeZone);
17435     tm->sec = (long) timeVal.tv_sec;
17436     tm->ms = (int) (timeVal.tv_usec / 1000L);
17437
17438 #else /*!HAVE_GETTIMEOFDAY*/
17439 #if HAVE_FTIME
17440
17441 // include <sys/timeb.h> / moved to just above start of function
17442     struct timeb timeB;
17443
17444     ftime(&timeB);
17445     tm->sec = (long) timeB.time;
17446     tm->ms = (int) timeB.millitm;
17447
17448 #else /*!HAVE_FTIME && !HAVE_GETTIMEOFDAY*/
17449     tm->sec = (long) time(NULL);
17450     tm->ms = 0;
17451 #endif
17452 #endif
17453 }
17454
17455 /* Return the difference in milliseconds between two
17456    time marks.  We assume the difference will fit in a long!
17457 */
17458 long
17459 SubtractTimeMarks (TimeMark *tm2, TimeMark *tm1)
17460 {
17461     return 1000L*(tm2->sec - tm1->sec) +
17462            (long) (tm2->ms - tm1->ms);
17463 }
17464
17465
17466 /*
17467  * Code to manage the game clocks.
17468  *
17469  * In tournament play, black starts the clock and then white makes a move.
17470  * We give the human user a slight advantage if he is playing white---the
17471  * clocks don't run until he makes his first move, so it takes zero time.
17472  * Also, we don't account for network lag, so we could get out of sync
17473  * with GNU Chess's clock -- but then, referees are always right.
17474  */
17475
17476 static TimeMark tickStartTM;
17477 static long intendedTickLength;
17478
17479 long
17480 NextTickLength (long timeRemaining)
17481 {
17482     long nominalTickLength, nextTickLength;
17483
17484     if (timeRemaining > 0L && timeRemaining <= 10000L)
17485       nominalTickLength = 100L;
17486     else
17487       nominalTickLength = 1000L;
17488     nextTickLength = timeRemaining % nominalTickLength;
17489     if (nextTickLength <= 0) nextTickLength += nominalTickLength;
17490
17491     return nextTickLength;
17492 }
17493
17494 /* Adjust clock one minute up or down */
17495 void
17496 AdjustClock (Boolean which, int dir)
17497 {
17498     if(appData.autoCallFlag) { DisplayError(_("Clock adjustment not allowed in auto-flag mode"), 0); return; }
17499     if(which) blackTimeRemaining += 60000*dir;
17500     else      whiteTimeRemaining += 60000*dir;
17501     DisplayBothClocks();
17502     adjustedClock = TRUE;
17503 }
17504
17505 /* Stop clocks and reset to a fresh time control */
17506 void
17507 ResetClocks ()
17508 {
17509     (void) StopClockTimer();
17510     if (appData.icsActive) {
17511         whiteTimeRemaining = blackTimeRemaining = 0;
17512     } else if (searchTime) {
17513         whiteTimeRemaining = 1000*searchTime / WhitePlayer()->timeOdds;
17514         blackTimeRemaining = 1000*searchTime / WhitePlayer()->other->timeOdds;
17515     } else { /* [HGM] correct new time quote for time odds */
17516         whiteTC = blackTC = fullTimeControlString;
17517         whiteTimeRemaining = GetTimeQuota(-1, 0, whiteTC) / WhitePlayer()->timeOdds;
17518         blackTimeRemaining = GetTimeQuota(-1, 0, blackTC) / WhitePlayer()->other->timeOdds;
17519     }
17520     if (whiteFlag || blackFlag) {
17521         DisplayTitle("");
17522         whiteFlag = blackFlag = FALSE;
17523     }
17524     lastWhite = lastBlack = whiteStartMove = blackStartMove = 0;
17525     DisplayBothClocks();
17526     adjustedClock = FALSE;
17527 }
17528
17529 #define FUDGE 25 /* 25ms = 1/40 sec; should be plenty even for 50 Hz clocks */
17530
17531 /* Decrement running clock by amount of time that has passed */
17532 void
17533 DecrementClocks ()
17534 {
17535     long timeRemaining;
17536     long lastTickLength, fudge;
17537     TimeMark now;
17538
17539     if (!appData.clockMode) return;
17540     if (gameMode==AnalyzeMode || gameMode == AnalyzeFile) return;
17541
17542     GetTimeMark(&now);
17543
17544     lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
17545
17546     /* Fudge if we woke up a little too soon */
17547     fudge = intendedTickLength - lastTickLength;
17548     if (fudge < 0 || fudge > FUDGE) fudge = 0;
17549
17550     if (WhiteOnMove(forwardMostMove)) {
17551         if(whiteNPS >= 0) lastTickLength = 0;
17552         timeRemaining = whiteTimeRemaining -= lastTickLength;
17553         if(timeRemaining < 0 && !appData.icsActive) {
17554             GetTimeQuota((forwardMostMove-whiteStartMove-1)/2, 0, whiteTC); // sets suddenDeath & nextSession;
17555             if(suddenDeath) { // [HGM] if we run out of a non-last incremental session, go to the next
17556                 whiteStartMove = forwardMostMove; whiteTC = nextSession;
17557                 lastWhite= timeRemaining = whiteTimeRemaining += GetTimeQuota(-1, 0, whiteTC);
17558             }
17559         }
17560         DisplayWhiteClock(whiteTimeRemaining - fudge,
17561                           WhiteOnMove(currentMove < forwardMostMove ? currentMove : forwardMostMove));
17562     } else {
17563         if(blackNPS >= 0) lastTickLength = 0;
17564         timeRemaining = blackTimeRemaining -= lastTickLength;
17565         if(timeRemaining < 0 && !appData.icsActive) { // [HGM] if we run out of a non-last incremental session, go to the next
17566             GetTimeQuota((forwardMostMove-blackStartMove-1)/2, 0, blackTC);
17567             if(suddenDeath) {
17568                 blackStartMove = forwardMostMove;
17569                 lastBlack = timeRemaining = blackTimeRemaining += GetTimeQuota(-1, 0, blackTC=nextSession);
17570             }
17571         }
17572         DisplayBlackClock(blackTimeRemaining - fudge,
17573                           !WhiteOnMove(currentMove < forwardMostMove ? currentMove : forwardMostMove));
17574     }
17575     if (CheckFlags()) return;
17576
17577     if(twoBoards) { // count down secondary board's clocks as well
17578         activePartnerTime -= lastTickLength;
17579         partnerUp = 1;
17580         if(activePartner == 'W')
17581             DisplayWhiteClock(activePartnerTime, TRUE); // the counting clock is always the highlighted one!
17582         else
17583             DisplayBlackClock(activePartnerTime, TRUE);
17584         partnerUp = 0;
17585     }
17586
17587     tickStartTM = now;
17588     intendedTickLength = NextTickLength(timeRemaining - fudge) + fudge;
17589     StartClockTimer(intendedTickLength);
17590
17591     /* if the time remaining has fallen below the alarm threshold, sound the
17592      * alarm. if the alarm has sounded and (due to a takeback or time control
17593      * with increment) the time remaining has increased to a level above the
17594      * threshold, reset the alarm so it can sound again.
17595      */
17596
17597     if (appData.icsActive && appData.icsAlarm) {
17598
17599         /* make sure we are dealing with the user's clock */
17600         if (!( ((gameMode == IcsPlayingWhite) && WhiteOnMove(currentMove)) ||
17601                ((gameMode == IcsPlayingBlack) && !WhiteOnMove(currentMove))
17602            )) return;
17603
17604         if (alarmSounded && (timeRemaining > appData.icsAlarmTime)) {
17605             alarmSounded = FALSE;
17606         } else if (!alarmSounded && (timeRemaining <= appData.icsAlarmTime)) {
17607             PlayAlarmSound();
17608             alarmSounded = TRUE;
17609         }
17610     }
17611 }
17612
17613
17614 /* A player has just moved, so stop the previously running
17615    clock and (if in clock mode) start the other one.
17616    We redisplay both clocks in case we're in ICS mode, because
17617    ICS gives us an update to both clocks after every move.
17618    Note that this routine is called *after* forwardMostMove
17619    is updated, so the last fractional tick must be subtracted
17620    from the color that is *not* on move now.
17621 */
17622 void
17623 SwitchClocks (int newMoveNr)
17624 {
17625     long lastTickLength;
17626     TimeMark now;
17627     int flagged = FALSE;
17628
17629     GetTimeMark(&now);
17630
17631     if (StopClockTimer() && appData.clockMode) {
17632         lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
17633         if (!WhiteOnMove(forwardMostMove)) {
17634             if(blackNPS >= 0) lastTickLength = 0;
17635             blackTimeRemaining -= lastTickLength;
17636            /* [HGM] PGNtime: save time for PGN file if engine did not give it */
17637 //         if(pvInfoList[forwardMostMove].time == -1)
17638                  pvInfoList[forwardMostMove].time =               // use GUI time
17639                       (timeRemaining[1][forwardMostMove-1] - blackTimeRemaining)/10;
17640         } else {
17641            if(whiteNPS >= 0) lastTickLength = 0;
17642            whiteTimeRemaining -= lastTickLength;
17643            /* [HGM] PGNtime: save time for PGN file if engine did not give it */
17644 //         if(pvInfoList[forwardMostMove].time == -1)
17645                  pvInfoList[forwardMostMove].time =
17646                       (timeRemaining[0][forwardMostMove-1] - whiteTimeRemaining)/10;
17647         }
17648         flagged = CheckFlags();
17649     }
17650     forwardMostMove = newMoveNr; // [HGM] race: change stm when no timer interrupt scheduled
17651     CheckTimeControl();
17652
17653     if (flagged || !appData.clockMode) return;
17654
17655     switch (gameMode) {
17656       case MachinePlaysBlack:
17657       case MachinePlaysWhite:
17658       case BeginningOfGame:
17659         if (pausing) return;
17660         break;
17661
17662       case EditGame:
17663       case PlayFromGameFile:
17664       case IcsExamining:
17665         return;
17666
17667       default:
17668         break;
17669     }
17670
17671     if (searchTime) { // [HGM] st: set clock of player that has to move to max time
17672         if(WhiteOnMove(forwardMostMove))
17673              whiteTimeRemaining = 1000*searchTime / WhitePlayer()->timeOdds;
17674         else blackTimeRemaining = 1000*searchTime / WhitePlayer()->other->timeOdds;
17675     }
17676
17677     tickStartTM = now;
17678     intendedTickLength = NextTickLength(WhiteOnMove(forwardMostMove) ?
17679       whiteTimeRemaining : blackTimeRemaining);
17680     StartClockTimer(intendedTickLength);
17681 }
17682
17683
17684 /* Stop both clocks */
17685 void
17686 StopClocks ()
17687 {
17688     long lastTickLength;
17689     TimeMark now;
17690
17691     if (!StopClockTimer()) return;
17692     if (!appData.clockMode) return;
17693
17694     GetTimeMark(&now);
17695
17696     lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
17697     if (WhiteOnMove(forwardMostMove)) {
17698         if(whiteNPS >= 0) lastTickLength = 0;
17699         whiteTimeRemaining -= lastTickLength;
17700         DisplayWhiteClock(whiteTimeRemaining, WhiteOnMove(currentMove));
17701     } else {
17702         if(blackNPS >= 0) lastTickLength = 0;
17703         blackTimeRemaining -= lastTickLength;
17704         DisplayBlackClock(blackTimeRemaining, !WhiteOnMove(currentMove));
17705     }
17706     CheckFlags();
17707 }
17708
17709 /* Start clock of player on move.  Time may have been reset, so
17710    if clock is already running, stop and restart it. */
17711 void
17712 StartClocks ()
17713 {
17714     (void) StopClockTimer(); /* in case it was running already */
17715     DisplayBothClocks();
17716     if (CheckFlags()) return;
17717
17718     if (!appData.clockMode) return;
17719     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) return;
17720
17721     GetTimeMark(&tickStartTM);
17722     intendedTickLength = NextTickLength(WhiteOnMove(forwardMostMove) ?
17723       whiteTimeRemaining : blackTimeRemaining);
17724
17725    /* [HGM] nps: figure out nps factors, by determining which engine plays white and/or black once and for all */
17726     whiteNPS = blackNPS = -1;
17727     if(gameMode == MachinePlaysWhite || gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'w'
17728        || appData.zippyPlay && gameMode == IcsPlayingBlack) // first (perhaps only) engine has white
17729         whiteNPS = first.nps;
17730     if(gameMode == MachinePlaysBlack || gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b'
17731        || appData.zippyPlay && gameMode == IcsPlayingWhite) // first (perhaps only) engine has black
17732         blackNPS = first.nps;
17733     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b') // second only used in Two-Machines mode
17734         whiteNPS = second.nps;
17735     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'w')
17736         blackNPS = second.nps;
17737     if(appData.debugMode) fprintf(debugFP, "nps: w=%d, b=%d\n", whiteNPS, blackNPS);
17738
17739     StartClockTimer(intendedTickLength);
17740 }
17741
17742 char *
17743 TimeString (long ms)
17744 {
17745     long second, minute, hour, day;
17746     char *sign = "";
17747     static char buf[32];
17748
17749     if (ms > 0 && ms <= 9900) {
17750       /* convert milliseconds to tenths, rounding up */
17751       double tenths = floor( ((double)(ms + 99L)) / 100.00 );
17752
17753       snprintf(buf,sizeof(buf)/sizeof(buf[0]), " %03.1f ", tenths/10.0);
17754       return buf;
17755     }
17756
17757     /* convert milliseconds to seconds, rounding up */
17758     /* use floating point to avoid strangeness of integer division
17759        with negative dividends on many machines */
17760     second = (long) floor(((double) (ms + 999L)) / 1000.0);
17761
17762     if (second < 0) {
17763         sign = "-";
17764         second = -second;
17765     }
17766
17767     day = second / (60 * 60 * 24);
17768     second = second % (60 * 60 * 24);
17769     hour = second / (60 * 60);
17770     second = second % (60 * 60);
17771     minute = second / 60;
17772     second = second % 60;
17773
17774     if (day > 0)
17775       snprintf(buf, sizeof(buf)/sizeof(buf[0]), " %s%ld:%02ld:%02ld:%02ld ",
17776               sign, day, hour, minute, second);
17777     else if (hour > 0)
17778       snprintf(buf, sizeof(buf)/sizeof(buf[0]), " %s%ld:%02ld:%02ld ", sign, hour, minute, second);
17779     else
17780       snprintf(buf, sizeof(buf)/sizeof(buf[0]), " %s%2ld:%02ld ", sign, minute, second);
17781
17782     return buf;
17783 }
17784
17785
17786 /*
17787  * This is necessary because some C libraries aren't ANSI C compliant yet.
17788  */
17789 char *
17790 StrStr (char *string, char *match)
17791 {
17792     int i, length;
17793
17794     length = strlen(match);
17795
17796     for (i = strlen(string) - length; i >= 0; i--, string++)
17797       if (!strncmp(match, string, length))
17798         return string;
17799
17800     return NULL;
17801 }
17802
17803 char *
17804 StrCaseStr (char *string, char *match)
17805 {
17806     int i, j, length;
17807
17808     length = strlen(match);
17809
17810     for (i = strlen(string) - length; i >= 0; i--, string++) {
17811         for (j = 0; j < length; j++) {
17812             if (ToLower(match[j]) != ToLower(string[j]))
17813               break;
17814         }
17815         if (j == length) return string;
17816     }
17817
17818     return NULL;
17819 }
17820
17821 #ifndef _amigados
17822 int
17823 StrCaseCmp (char *s1, char *s2)
17824 {
17825     char c1, c2;
17826
17827     for (;;) {
17828         c1 = ToLower(*s1++);
17829         c2 = ToLower(*s2++);
17830         if (c1 > c2) return 1;
17831         if (c1 < c2) return -1;
17832         if (c1 == NULLCHAR) return 0;
17833     }
17834 }
17835
17836
17837 int
17838 ToLower (int c)
17839 {
17840     return isupper(c) ? tolower(c) : c;
17841 }
17842
17843
17844 int
17845 ToUpper (int c)
17846 {
17847     return islower(c) ? toupper(c) : c;
17848 }
17849 #endif /* !_amigados    */
17850
17851 char *
17852 StrSave (char *s)
17853 {
17854   char *ret;
17855
17856   if ((ret = (char *) malloc(strlen(s) + 1)))
17857     {
17858       safeStrCpy(ret, s, strlen(s)+1);
17859     }
17860   return ret;
17861 }
17862
17863 char *
17864 StrSavePtr (char *s, char **savePtr)
17865 {
17866     if (*savePtr) {
17867         free(*savePtr);
17868     }
17869     if ((*savePtr = (char *) malloc(strlen(s) + 1))) {
17870       safeStrCpy(*savePtr, s, strlen(s)+1);
17871     }
17872     return(*savePtr);
17873 }
17874
17875 char *
17876 PGNDate ()
17877 {
17878     time_t clock;
17879     struct tm *tm;
17880     char buf[MSG_SIZ];
17881
17882     clock = time((time_t *)NULL);
17883     tm = localtime(&clock);
17884     snprintf(buf, MSG_SIZ, "%04d.%02d.%02d",
17885             tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday);
17886     return StrSave(buf);
17887 }
17888
17889
17890 char *
17891 PositionToFEN (int move, char *overrideCastling, int moveCounts)
17892 {
17893     int i, j, fromX, fromY, toX, toY;
17894     int whiteToPlay;
17895     char buf[MSG_SIZ];
17896     char *p, *q;
17897     int emptycount;
17898     ChessSquare piece;
17899
17900     whiteToPlay = (gameMode == EditPosition) ?
17901       !blackPlaysFirst : (move % 2 == 0);
17902     p = buf;
17903
17904     /* Piece placement data */
17905     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
17906         if(MSG_SIZ - (p - buf) < BOARD_RGHT - BOARD_LEFT + 20) { *p = 0; return StrSave(buf); }
17907         emptycount = 0;
17908         for (j = BOARD_LEFT; j < BOARD_RGHT; j++) {
17909             if (boards[move][i][j] == EmptySquare) {
17910                 emptycount++;
17911             } else { ChessSquare piece = boards[move][i][j];
17912                 if (emptycount > 0) {
17913                     if(emptycount<10) /* [HGM] can be >= 10 */
17914                         *p++ = '0' + emptycount;
17915                     else { *p++ = '0' + emptycount/10; *p++ = '0' + emptycount%10; }
17916                     emptycount = 0;
17917                 }
17918                 if(PieceToChar(piece) == '+') {
17919                     /* [HGM] write promoted pieces as '+<unpromoted>' (Shogi) */
17920                     *p++ = '+';
17921                     piece = (ChessSquare)(CHUDEMOTED piece);
17922                 }
17923                 *p++ = (piece == DarkSquare ? '*' : PieceToChar(piece));
17924                 if(*p = PieceSuffix(piece)) p++;
17925                 if(p[-1] == '~') {
17926                     /* [HGM] flag promoted pieces as '<promoted>~' (Crazyhouse) */
17927                     p[-1] = PieceToChar((ChessSquare)(CHUDEMOTED piece));
17928                     *p++ = '~';
17929                 }
17930             }
17931         }
17932         if (emptycount > 0) {
17933             if(emptycount<10) /* [HGM] can be >= 10 */
17934                 *p++ = '0' + emptycount;
17935             else { *p++ = '0' + emptycount/10; *p++ = '0' + emptycount%10; }
17936             emptycount = 0;
17937         }
17938         *p++ = '/';
17939     }
17940     *(p - 1) = ' ';
17941
17942     /* [HGM] print Crazyhouse or Shogi holdings */
17943     if( gameInfo.holdingsWidth ) {
17944         *(p-1) = '['; /* if we wanted to support BFEN, this could be '/' */
17945         q = p;
17946         for(i=0; i<gameInfo.holdingsSize; i++) { /* white holdings */
17947             piece = boards[move][i][BOARD_WIDTH-1];
17948             if( piece != EmptySquare )
17949               for(j=0; j<(int) boards[move][i][BOARD_WIDTH-2]; j++)
17950                   *p++ = PieceToChar(piece);
17951         }
17952         for(i=0; i<gameInfo.holdingsSize; i++) { /* black holdings */
17953             piece = boards[move][BOARD_HEIGHT-i-1][0];
17954             if( piece != EmptySquare )
17955               for(j=0; j<(int) boards[move][BOARD_HEIGHT-i-1][1]; j++)
17956                   *p++ = PieceToChar(piece);
17957         }
17958
17959         if( q == p ) *p++ = '-';
17960         *p++ = ']';
17961         *p++ = ' ';
17962     }
17963
17964     /* Active color */
17965     *p++ = whiteToPlay ? 'w' : 'b';
17966     *p++ = ' ';
17967
17968   if(q = overrideCastling) { // [HGM] FRC: override castling & e.p fields for non-compliant engines
17969     while(*p++ = *q++); if(q != overrideCastling+1) p[-1] = ' '; else --p;
17970   } else {
17971   if(nrCastlingRights) {
17972      int handW=0, handB=0;
17973      if(gameInfo.variant == VariantSChess) { // for S-Chess, all virgin backrank pieces must be listed
17974         for(i=0; i<BOARD_HEIGHT; i++) handW += boards[move][i][BOARD_RGHT]; // count white held pieces
17975         for(i=0; i<BOARD_HEIGHT; i++) handB += boards[move][i][BOARD_LEFT-1]; // count black held pieces
17976      }
17977      q = p;
17978      if(appData.fischerCastling) {
17979         if(handW) { // in shuffle S-Chess simply dump all virgin pieces
17980            for(i=BOARD_RGHT-1; i>=BOARD_LEFT; i--)
17981                if(boards[move][VIRGIN][i] & VIRGIN_W) *p++ = i + AAA + 'A' - 'a';
17982         } else {
17983        /* [HGM] write directly from rights */
17984            if(boards[move][CASTLING][2] != NoRights &&
17985               boards[move][CASTLING][0] != NoRights   )
17986                 *p++ = boards[move][CASTLING][0] + AAA + 'A' - 'a';
17987            if(boards[move][CASTLING][2] != NoRights &&
17988               boards[move][CASTLING][1] != NoRights   )
17989                 *p++ = boards[move][CASTLING][1] + AAA + 'A' - 'a';
17990         }
17991         if(handB) {
17992            for(i=BOARD_RGHT-1; i>=BOARD_LEFT; i--)
17993                if(boards[move][VIRGIN][i] & VIRGIN_B) *p++ = i + AAA;
17994         } else {
17995            if(boards[move][CASTLING][5] != NoRights &&
17996               boards[move][CASTLING][3] != NoRights   )
17997                 *p++ = boards[move][CASTLING][3] + AAA;
17998            if(boards[move][CASTLING][5] != NoRights &&
17999               boards[move][CASTLING][4] != NoRights   )
18000                 *p++ = boards[move][CASTLING][4] + AAA;
18001         }
18002      } else {
18003
18004         /* [HGM] write true castling rights */
18005         if( nrCastlingRights == 6 ) {
18006             int q, k=0;
18007             if(boards[move][CASTLING][0] == BOARD_RGHT-1 &&
18008                boards[move][CASTLING][2] != NoRights  ) k = 1, *p++ = 'K';
18009             q = (boards[move][CASTLING][1] == BOARD_LEFT &&
18010                  boards[move][CASTLING][2] != NoRights  );
18011             if(handW) { // for S-Chess with pieces in hand, list virgin pieces between K and Q
18012                 for(i=BOARD_RGHT-1-k; i>=BOARD_LEFT+q; i--)
18013                     if((boards[move][0][i] != WhiteKing || k+q == 0) &&
18014                         boards[move][VIRGIN][i] & VIRGIN_W) *p++ = i + AAA + 'A' - 'a';
18015             }
18016             if(q) *p++ = 'Q';
18017             k = 0;
18018             if(boards[move][CASTLING][3] == BOARD_RGHT-1 &&
18019                boards[move][CASTLING][5] != NoRights  ) k = 1, *p++ = 'k';
18020             q = (boards[move][CASTLING][4] == BOARD_LEFT &&
18021                  boards[move][CASTLING][5] != NoRights  );
18022             if(handB) {
18023                 for(i=BOARD_RGHT-1-k; i>=BOARD_LEFT+q; i--)
18024                     if((boards[move][BOARD_HEIGHT-1][i] != BlackKing || k+q == 0) &&
18025                         boards[move][VIRGIN][i] & VIRGIN_B) *p++ = i + AAA;
18026             }
18027             if(q) *p++ = 'q';
18028         }
18029      }
18030      if (q == p) *p++ = '-'; /* No castling rights */
18031      *p++ = ' ';
18032   }
18033
18034   if(gameInfo.variant != VariantShogi    && gameInfo.variant != VariantXiangqi &&
18035      gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier &&
18036      gameInfo.variant != VariantMakruk   && gameInfo.variant != VariantASEAN ) {
18037     /* En passant target square */
18038     if (move > backwardMostMove) {
18039         fromX = moveList[move - 1][0] - AAA;
18040         fromY = moveList[move - 1][1] - ONE;
18041         toX = moveList[move - 1][2] - AAA;
18042         toY = moveList[move - 1][3] - ONE;
18043         if (fromY == (whiteToPlay ? BOARD_HEIGHT-2 : 1) &&
18044             toY == (whiteToPlay ? BOARD_HEIGHT-4 : 3) &&
18045             boards[move][toY][toX] == (whiteToPlay ? BlackPawn : WhitePawn) &&
18046             fromX == toX) {
18047             /* 2-square pawn move just happened */
18048             *p++ = toX + AAA;
18049             *p++ = whiteToPlay ? '6'+BOARD_HEIGHT-8 : '3';
18050         } else {
18051             *p++ = '-';
18052         }
18053     } else if(move == backwardMostMove) {
18054         // [HGM] perhaps we should always do it like this, and forget the above?
18055         if((signed char)boards[move][EP_STATUS] >= 0) {
18056             *p++ = boards[move][EP_STATUS] + AAA;
18057             *p++ = whiteToPlay ? '6'+BOARD_HEIGHT-8 : '3';
18058         } else {
18059             *p++ = '-';
18060         }
18061     } else {
18062         *p++ = '-';
18063     }
18064     *p++ = ' ';
18065   }
18066   }
18067
18068     if(moveCounts)
18069     {   int i = 0, j=move;
18070
18071         /* [HGM] find reversible plies */
18072         if (appData.debugMode) { int k;
18073             fprintf(debugFP, "write FEN 50-move: %d %d %d\n", initialRulePlies, forwardMostMove, backwardMostMove);
18074             for(k=backwardMostMove; k<=forwardMostMove; k++)
18075                 fprintf(debugFP, "e%d. p=%d\n", k, (signed char)boards[k][EP_STATUS]);
18076
18077         }
18078
18079         while(j > backwardMostMove && (signed char)boards[j][EP_STATUS] <= EP_NONE) j--,i++;
18080         if( j == backwardMostMove ) i += initialRulePlies;
18081         sprintf(p, "%d ", i);
18082         p += i>=100 ? 4 : i >= 10 ? 3 : 2;
18083
18084         /* Fullmove number */
18085         sprintf(p, "%d", (move / 2) + 1);
18086     } else *--p = NULLCHAR;
18087
18088     return StrSave(buf);
18089 }
18090
18091 Boolean
18092 ParseFEN (Board board, int *blackPlaysFirst, char *fen, Boolean autoSize)
18093 {
18094     int i, j, k, w=0, subst=0, shuffle=0, wKingRank = -1, bKingRank = -1;
18095     char *p, c;
18096     int emptycount, virgin[BOARD_FILES];
18097     ChessSquare piece, king = (gameInfo.variant == VariantKnightmate ? WhiteUnicorn : WhiteKing);
18098
18099     p = fen;
18100
18101     /* Piece placement data */
18102     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
18103         j = 0;
18104         for (;;) {
18105             if (*p == '/' || *p == ' ' || *p == '[' ) {
18106                 if(j > w) w = j;
18107                 emptycount = gameInfo.boardWidth - j;
18108                 while (emptycount--)
18109                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
18110                 if (*p == '/') p++;
18111                 else if(autoSize) { // we stumbled unexpectedly into end of board
18112                     for(k=i; k<BOARD_HEIGHT; k++) { // too few ranks; shift towards bottom
18113                         for(j=0; j<BOARD_WIDTH; j++) board[k-i][j] = board[k][j];
18114                     }
18115                     appData.NrRanks = gameInfo.boardHeight - i; i=0;
18116                 }
18117                 break;
18118 #if(BOARD_FILES >= 10)*0
18119             } else if(*p=='x' || *p=='X') { /* [HGM] X means 10 */
18120                 p++; emptycount=10;
18121                 if (j + emptycount > gameInfo.boardWidth) return FALSE;
18122                 while (emptycount--)
18123                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
18124 #endif
18125             } else if (*p == '*') {
18126                 board[i][(j++)+gameInfo.holdingsWidth] = DarkSquare; p++;
18127             } else if (isdigit(*p)) {
18128                 emptycount = *p++ - '0';
18129                 while(isdigit(*p)) emptycount = 10*emptycount + *p++ - '0'; /* [HGM] allow > 9 */
18130                 if (j + emptycount > gameInfo.boardWidth) return FALSE;
18131                 while (emptycount--)
18132                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
18133             } else if (*p == '<') {
18134                 if(i == BOARD_HEIGHT-1) shuffle = 1;
18135                 else if (i != 0 || !shuffle) return FALSE;
18136                 p++;
18137             } else if (shuffle && *p == '>') {
18138                 p++; // for now ignore closing shuffle range, and assume rank-end
18139             } else if (*p == '?') {
18140                 if (j >= gameInfo.boardWidth) return FALSE;
18141                 if (i != 0  && i != BOARD_HEIGHT-1) return FALSE; // only on back-rank
18142                 board[i][(j++)+gameInfo.holdingsWidth] = ClearBoard; p++; subst++; // placeHolder
18143             } else if (*p == '+' || isalpha(*p)) {
18144                 char *q, *s = SUFFIXES;
18145                 if (j >= gameInfo.boardWidth) return FALSE;
18146                 if(*p=='+') {
18147                     char c = *++p;
18148                     if(q = strchr(s, p[1])) p++;
18149                     piece = CharToPiece(c + (q ? 64*(q - s + 1) : 0));
18150                     if(piece == EmptySquare) return FALSE; /* unknown piece */
18151                     piece = (ChessSquare) (CHUPROMOTED piece ); p++;
18152                     if(PieceToChar(piece) != '+') return FALSE; /* unpromotable piece */
18153                 } else {
18154                     char c = *p++;
18155                     if(q = strchr(s, *p)) p++;
18156                     piece = CharToPiece(c + (q ? 64*(q - s + 1) : 0));
18157                 }
18158
18159                 if(piece==EmptySquare) return FALSE; /* unknown piece */
18160                 if(*p == '~') { /* [HGM] make it a promoted piece for Crazyhouse */
18161                     piece = (ChessSquare) (PROMOTED piece);
18162                     if(PieceToChar(piece) != '~') return FALSE; /* cannot be a promoted piece */
18163                     p++;
18164                 }
18165                 board[i][(j++)+gameInfo.holdingsWidth] = piece;
18166                 if(piece == king) wKingRank = i;
18167                 if(piece == WHITE_TO_BLACK king) bKingRank = i;
18168             } else {
18169                 return FALSE;
18170             }
18171         }
18172     }
18173     while (*p == '/' || *p == ' ') p++;
18174
18175     if(autoSize) appData.NrFiles = w, InitPosition(TRUE);
18176
18177     /* [HGM] by default clear Crazyhouse holdings, if present */
18178     if(gameInfo.holdingsWidth) {
18179        for(i=0; i<BOARD_HEIGHT; i++) {
18180            board[i][0]             = EmptySquare; /* black holdings */
18181            board[i][BOARD_WIDTH-1] = EmptySquare; /* white holdings */
18182            board[i][1]             = (ChessSquare) 0; /* black counts */
18183            board[i][BOARD_WIDTH-2] = (ChessSquare) 0; /* white counts */
18184        }
18185     }
18186
18187     /* [HGM] look for Crazyhouse holdings here */
18188     while(*p==' ') p++;
18189     if( gameInfo.holdingsWidth && p[-1] == '/' || *p == '[') {
18190         int swap=0, wcnt=0, bcnt=0;
18191         if(*p == '[') p++;
18192         if(*p == '<') swap++, p++;
18193         if(*p == '-' ) p++; /* empty holdings */ else {
18194             if( !gameInfo.holdingsWidth ) return FALSE; /* no room to put holdings! */
18195             /* if we would allow FEN reading to set board size, we would   */
18196             /* have to add holdings and shift the board read so far here   */
18197             while( (piece = CharToPiece(*p) ) != EmptySquare ) {
18198                 p++;
18199                 if((int) piece >= (int) BlackPawn ) {
18200                     i = (int)piece - (int)BlackPawn;
18201                     i = PieceToNumber((ChessSquare)i);
18202                     if( i >= gameInfo.holdingsSize ) return FALSE;
18203                     board[BOARD_HEIGHT-1-i][0] = piece; /* black holdings */
18204                     board[BOARD_HEIGHT-1-i][1]++;       /* black counts   */
18205                     bcnt++;
18206                 } else {
18207                     i = (int)piece - (int)WhitePawn;
18208                     i = PieceToNumber((ChessSquare)i);
18209                     if( i >= gameInfo.holdingsSize ) return FALSE;
18210                     board[i][BOARD_WIDTH-1] = piece;    /* white holdings */
18211                     board[i][BOARD_WIDTH-2]++;          /* black holdings */
18212                     wcnt++;
18213                 }
18214             }
18215             if(subst) { // substitute back-rank question marks by holdings pieces
18216                 for(j=BOARD_LEFT; j<BOARD_RGHT; j++) {
18217                     int k, m, n = bcnt + 1;
18218                     if(board[0][j] == ClearBoard) {
18219                         if(!wcnt) return FALSE;
18220                         n = rand() % wcnt;
18221                         for(k=0, m=n; k<gameInfo.holdingsSize; k++) if((m -= board[k][BOARD_WIDTH-2]) < 0) {
18222                             board[0][j] = board[k][BOARD_WIDTH-1]; wcnt--;
18223                             if(--board[k][BOARD_WIDTH-2] == 0) board[k][BOARD_WIDTH-1] = EmptySquare;
18224                             break;
18225                         }
18226                     }
18227                     if(board[BOARD_HEIGHT-1][j] == ClearBoard) {
18228                         if(!bcnt) return FALSE;
18229                         if(n >= bcnt) n = rand() % bcnt; // use same randomization for black and white if possible
18230                         for(k=0, m=n; k<gameInfo.holdingsSize; k++) if((n -= board[BOARD_HEIGHT-1-k][1]) < 0) {
18231                             board[BOARD_HEIGHT-1][j] = board[BOARD_HEIGHT-1-k][0]; bcnt--;
18232                             if(--board[BOARD_HEIGHT-1-k][1] == 0) board[BOARD_HEIGHT-1-k][0] = EmptySquare;
18233                             break;
18234                         }
18235                     }
18236                 }
18237                 subst = 0;
18238             }
18239         }
18240         if(*p == ']') p++;
18241     }
18242
18243     if(subst) return FALSE; // substitution requested, but no holdings
18244
18245     while(*p == ' ') p++;
18246
18247     /* Active color */
18248     c = *p++;
18249     if(appData.colorNickNames) {
18250       if( c == appData.colorNickNames[0] ) c = 'w'; else
18251       if( c == appData.colorNickNames[1] ) c = 'b';
18252     }
18253     switch (c) {
18254       case 'w':
18255         *blackPlaysFirst = FALSE;
18256         break;
18257       case 'b':
18258         *blackPlaysFirst = TRUE;
18259         break;
18260       default:
18261         return FALSE;
18262     }
18263
18264     /* [HGM] We NO LONGER ignore the rest of the FEN notation */
18265     /* return the extra info in global variiables             */
18266
18267     while(*p==' ') p++;
18268
18269     if(!isdigit(*p) && *p != '-') { // we seem to have castling rights. Make sure they are on the rank the King actually is.
18270         if(wKingRank >= 0) for(i=0; i<3; i++) castlingRank[i] = wKingRank;
18271         if(bKingRank >= 0) for(i=3; i<6; i++) castlingRank[i] = bKingRank;
18272     }
18273
18274     /* set defaults in case FEN is incomplete */
18275     board[EP_STATUS] = EP_UNKNOWN;
18276     for(i=0; i<nrCastlingRights; i++ ) {
18277         board[CASTLING][i] =
18278             appData.fischerCastling ? NoRights : initialRights[i];
18279     }   /* assume possible unless obviously impossible */
18280     if(initialRights[0]!=NoRights && board[castlingRank[0]][initialRights[0]] != WhiteRook) board[CASTLING][0] = NoRights;
18281     if(initialRights[1]!=NoRights && board[castlingRank[1]][initialRights[1]] != WhiteRook) board[CASTLING][1] = NoRights;
18282     if(initialRights[2]!=NoRights && board[castlingRank[2]][initialRights[2]] != WhiteUnicorn
18283                                   && board[castlingRank[2]][initialRights[2]] != WhiteKing) board[CASTLING][2] = NoRights;
18284     if(initialRights[3]!=NoRights && board[castlingRank[3]][initialRights[3]] != BlackRook) board[CASTLING][3] = NoRights;
18285     if(initialRights[4]!=NoRights && board[castlingRank[4]][initialRights[4]] != BlackRook) board[CASTLING][4] = NoRights;
18286     if(initialRights[5]!=NoRights && board[castlingRank[5]][initialRights[5]] != BlackUnicorn
18287                                   && board[castlingRank[5]][initialRights[5]] != BlackKing) board[CASTLING][5] = NoRights;
18288     FENrulePlies = 0;
18289
18290     if(nrCastlingRights) {
18291       int fischer = 0;
18292       if(gameInfo.variant == VariantSChess) for(i=0; i<BOARD_FILES; i++) virgin[i] = 0;
18293       if(*p >= 'A' && *p <= 'Z' || *p >= 'a' && *p <= 'z' || *p=='-') {
18294           /* castling indicator present, so default becomes no castlings */
18295           for(i=0; i<nrCastlingRights; i++ ) {
18296                  board[CASTLING][i] = NoRights;
18297           }
18298       }
18299       while(*p=='K' || *p=='Q' || *p=='k' || *p=='q' || *p=='-' ||
18300              (appData.fischerCastling || gameInfo.variant == VariantSChess) &&
18301              ( *p >= 'a' && *p < 'a' + gameInfo.boardWidth) ||
18302              ( *p >= 'A' && *p < 'A' + gameInfo.boardWidth)   ) {
18303         int c = *p++, whiteKingFile=NoRights, blackKingFile=NoRights;
18304
18305         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) {
18306             if(board[castlingRank[5]][i] == BlackKing) blackKingFile = i;
18307             if(board[castlingRank[2]][i] == WhiteKing) whiteKingFile = i;
18308         }
18309         if(gameInfo.variant == VariantTwoKings || gameInfo.variant == VariantKnightmate)
18310             whiteKingFile = blackKingFile = BOARD_WIDTH >> 1; // for these variant scanning fails
18311         if(whiteKingFile == NoRights || board[0][whiteKingFile] != WhiteUnicorn
18312                                      && board[0][whiteKingFile] != WhiteKing) whiteKingFile = NoRights;
18313         if(blackKingFile == NoRights || board[BOARD_HEIGHT-1][blackKingFile] != BlackUnicorn
18314                                      && board[BOARD_HEIGHT-1][blackKingFile] != BlackKing) blackKingFile = NoRights;
18315         switch(c) {
18316           case'K':
18317               for(i=BOARD_RGHT-1; board[castlingRank[2]][i]!=WhiteRook && i>whiteKingFile; i--);
18318               board[CASTLING][0] = i != whiteKingFile ? i : NoRights;
18319               board[CASTLING][2] = whiteKingFile;
18320               if(board[CASTLING][0] != NoRights) virgin[board[CASTLING][0]] |= VIRGIN_W;
18321               if(board[CASTLING][2] != NoRights) virgin[board[CASTLING][2]] |= VIRGIN_W;
18322               if(whiteKingFile != BOARD_WIDTH>>1|| i != BOARD_RGHT-1) fischer = 1;
18323               break;
18324           case'Q':
18325               for(i=BOARD_LEFT;  i<BOARD_RGHT && board[castlingRank[2]][i]!=WhiteRook && i<whiteKingFile; i++);
18326               board[CASTLING][1] = i != whiteKingFile ? i : NoRights;
18327               board[CASTLING][2] = whiteKingFile;
18328               if(board[CASTLING][1] != NoRights) virgin[board[CASTLING][1]] |= VIRGIN_W;
18329               if(board[CASTLING][2] != NoRights) virgin[board[CASTLING][2]] |= VIRGIN_W;
18330               if(whiteKingFile != BOARD_WIDTH>>1|| i != BOARD_LEFT) fischer = 1;
18331               break;
18332           case'k':
18333               for(i=BOARD_RGHT-1; board[castlingRank[5]][i]!=BlackRook && i>blackKingFile; i--);
18334               board[CASTLING][3] = i != blackKingFile ? i : NoRights;
18335               board[CASTLING][5] = blackKingFile;
18336               if(board[CASTLING][3] != NoRights) virgin[board[CASTLING][3]] |= VIRGIN_B;
18337               if(board[CASTLING][5] != NoRights) virgin[board[CASTLING][5]] |= VIRGIN_B;
18338               if(blackKingFile != BOARD_WIDTH>>1|| i != BOARD_RGHT-1) fischer = 1;
18339               break;
18340           case'q':
18341               for(i=BOARD_LEFT; i<BOARD_RGHT && board[castlingRank[5]][i]!=BlackRook && i<blackKingFile; i++);
18342               board[CASTLING][4] = i != blackKingFile ? i : NoRights;
18343               board[CASTLING][5] = blackKingFile;
18344               if(board[CASTLING][4] != NoRights) virgin[board[CASTLING][4]] |= VIRGIN_B;
18345               if(board[CASTLING][5] != NoRights) virgin[board[CASTLING][5]] |= VIRGIN_B;
18346               if(blackKingFile != BOARD_WIDTH>>1|| i != BOARD_LEFT) fischer = 1;
18347           case '-':
18348               break;
18349           default: /* FRC castlings */
18350               if(c >= 'a') { /* black rights */
18351                   if(gameInfo.variant == VariantSChess) { virgin[c-AAA] |= VIRGIN_B; break; } // in S-Chess castlings are always kq, so just virginity
18352                   for(i=BOARD_LEFT; i<BOARD_RGHT; i++)
18353                     if(board[BOARD_HEIGHT-1][i] == BlackKing) break;
18354                   if(i == BOARD_RGHT) break;
18355                   board[CASTLING][5] = i;
18356                   c -= AAA;
18357                   if(board[BOARD_HEIGHT-1][c] <  BlackPawn ||
18358                      board[BOARD_HEIGHT-1][c] >= BlackKing   ) break;
18359                   if(c > i)
18360                       board[CASTLING][3] = c;
18361                   else
18362                       board[CASTLING][4] = c;
18363               } else { /* white rights */
18364                   if(gameInfo.variant == VariantSChess) { virgin[c-AAA-'A'+'a'] |= VIRGIN_W; break; } // in S-Chess castlings are always KQ
18365                   for(i=BOARD_LEFT; i<BOARD_RGHT; i++)
18366                     if(board[0][i] == WhiteKing) break;
18367                   if(i == BOARD_RGHT) break;
18368                   board[CASTLING][2] = i;
18369                   c -= AAA - 'a' + 'A';
18370                   if(board[0][c] >= WhiteKing) break;
18371                   if(c > i)
18372                       board[CASTLING][0] = c;
18373                   else
18374                       board[CASTLING][1] = c;
18375               }
18376         }
18377       }
18378       for(i=0; i<nrCastlingRights; i++)
18379         if(board[CASTLING][i] != NoRights) initialRights[i] = board[CASTLING][i];
18380       if(gameInfo.variant == VariantSChess)
18381         for(i=0; i<BOARD_FILES; i++) board[VIRGIN][i] = shuffle ? VIRGIN_W | VIRGIN_B : virgin[i]; // when shuffling assume all virgin
18382       if(fischer && shuffle) appData.fischerCastling = TRUE;
18383     if (appData.debugMode) {
18384         fprintf(debugFP, "FEN castling rights:");
18385         for(i=0; i<nrCastlingRights; i++)
18386         fprintf(debugFP, " %d", board[CASTLING][i]);
18387         fprintf(debugFP, "\n");
18388     }
18389
18390       while(*p==' ') p++;
18391     }
18392
18393     if(shuffle) SetUpShuffle(board, appData.defaultFrcPosition);
18394
18395     /* read e.p. field in games that know e.p. capture */
18396     if(gameInfo.variant != VariantShogi    && gameInfo.variant != VariantXiangqi &&
18397        gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier &&
18398        gameInfo.variant != VariantMakruk && gameInfo.variant != VariantASEAN ) {
18399       if(*p=='-') {
18400         p++; board[EP_STATUS] = EP_NONE;
18401       } else {
18402          char c = *p++ - AAA;
18403
18404          if(c < BOARD_LEFT || c >= BOARD_RGHT) return TRUE;
18405          if(*p >= '0' && *p <='9') p++;
18406          board[EP_STATUS] = c;
18407       }
18408     }
18409
18410
18411     if(sscanf(p, "%d", &i) == 1) {
18412         FENrulePlies = i; /* 50-move ply counter */
18413         /* (The move number is still ignored)    */
18414     }
18415
18416     return TRUE;
18417 }
18418
18419 void
18420 EditPositionPasteFEN (char *fen)
18421 {
18422   if (fen != NULL) {
18423     Board initial_position;
18424
18425     if (!ParseFEN(initial_position, &blackPlaysFirst, fen, TRUE)) {
18426       DisplayError(_("Bad FEN position in clipboard"), 0);
18427       return ;
18428     } else {
18429       int savedBlackPlaysFirst = blackPlaysFirst;
18430       EditPositionEvent();
18431       blackPlaysFirst = savedBlackPlaysFirst;
18432       CopyBoard(boards[0], initial_position);
18433       initialRulePlies = FENrulePlies; /* [HGM] copy FEN attributes as well */
18434       EditPositionDone(FALSE); // [HGM] fake: do not fake rights if we had FEN
18435       DisplayBothClocks();
18436       DrawPosition(FALSE, boards[currentMove]);
18437     }
18438   }
18439 }
18440
18441 static char cseq[12] = "\\   ";
18442
18443 Boolean
18444 set_cont_sequence (char *new_seq)
18445 {
18446     int len;
18447     Boolean ret;
18448
18449     // handle bad attempts to set the sequence
18450         if (!new_seq)
18451                 return 0; // acceptable error - no debug
18452
18453     len = strlen(new_seq);
18454     ret = (len > 0) && (len < sizeof(cseq));
18455     if (ret)
18456       safeStrCpy(cseq, new_seq, sizeof(cseq)/sizeof(cseq[0]));
18457     else if (appData.debugMode)
18458       fprintf(debugFP, "Invalid continuation sequence \"%s\"  (maximum length is: %u)\n", new_seq, (unsigned) sizeof(cseq)-1);
18459     return ret;
18460 }
18461
18462 /*
18463     reformat a source message so words don't cross the width boundary.  internal
18464     newlines are not removed.  returns the wrapped size (no null character unless
18465     included in source message).  If dest is NULL, only calculate the size required
18466     for the dest buffer.  lp argument indicats line position upon entry, and it's
18467     passed back upon exit.
18468 */
18469 int
18470 wrap (char *dest, char *src, int count, int width, int *lp)
18471 {
18472     int len, i, ansi, cseq_len, line, old_line, old_i, old_len, clen;
18473
18474     cseq_len = strlen(cseq);
18475     old_line = line = *lp;
18476     ansi = len = clen = 0;
18477
18478     for (i=0; i < count; i++)
18479     {
18480         if (src[i] == '\033')
18481             ansi = 1;
18482
18483         // if we hit the width, back up
18484         if (!ansi && (line >= width) && src[i] != '\n' && src[i] != ' ')
18485         {
18486             // store i & len in case the word is too long
18487             old_i = i, old_len = len;
18488
18489             // find the end of the last word
18490             while (i && src[i] != ' ' && src[i] != '\n')
18491             {
18492                 i--;
18493                 len--;
18494             }
18495
18496             // word too long?  restore i & len before splitting it
18497             if ((old_i-i+clen) >= width)
18498             {
18499                 i = old_i;
18500                 len = old_len;
18501             }
18502
18503             // extra space?
18504             if (i && src[i-1] == ' ')
18505                 len--;
18506
18507             if (src[i] != ' ' && src[i] != '\n')
18508             {
18509                 i--;
18510                 if (len)
18511                     len--;
18512             }
18513
18514             // now append the newline and continuation sequence
18515             if (dest)
18516                 dest[len] = '\n';
18517             len++;
18518             if (dest)
18519                 strncpy(dest+len, cseq, cseq_len);
18520             len += cseq_len;
18521             line = cseq_len;
18522             clen = cseq_len;
18523             continue;
18524         }
18525
18526         if (dest)
18527             dest[len] = src[i];
18528         len++;
18529         if (!ansi)
18530             line++;
18531         if (src[i] == '\n')
18532             line = 0;
18533         if (src[i] == 'm')
18534             ansi = 0;
18535     }
18536     if (dest && appData.debugMode)
18537     {
18538         fprintf(debugFP, "wrap(count:%d,width:%d,line:%d,len:%d,*lp:%d,src: ",
18539             count, width, line, len, *lp);
18540         show_bytes(debugFP, src, count);
18541         fprintf(debugFP, "\ndest: ");
18542         show_bytes(debugFP, dest, len);
18543         fprintf(debugFP, "\n");
18544     }
18545     *lp = dest ? line : old_line;
18546
18547     return len;
18548 }
18549
18550 // [HGM] vari: routines for shelving variations
18551 Boolean modeRestore = FALSE;
18552
18553 void
18554 PushInner (int firstMove, int lastMove)
18555 {
18556         int i, j, nrMoves = lastMove - firstMove;
18557
18558         // push current tail of game on stack
18559         savedResult[storedGames] = gameInfo.result;
18560         savedDetails[storedGames] = gameInfo.resultDetails;
18561         gameInfo.resultDetails = NULL;
18562         savedFirst[storedGames] = firstMove;
18563         savedLast [storedGames] = lastMove;
18564         savedFramePtr[storedGames] = framePtr;
18565         framePtr -= nrMoves; // reserve space for the boards
18566         for(i=nrMoves; i>=1; i--) { // copy boards to stack, working downwards, in case of overlap
18567             CopyBoard(boards[framePtr+i], boards[firstMove+i]);
18568             for(j=0; j<MOVE_LEN; j++)
18569                 moveList[framePtr+i][j] = moveList[firstMove+i-1][j];
18570             for(j=0; j<2*MOVE_LEN; j++)
18571                 parseList[framePtr+i][j] = parseList[firstMove+i-1][j];
18572             timeRemaining[0][framePtr+i] = timeRemaining[0][firstMove+i];
18573             timeRemaining[1][framePtr+i] = timeRemaining[1][firstMove+i];
18574             pvInfoList[framePtr+i] = pvInfoList[firstMove+i-1];
18575             pvInfoList[firstMove+i-1].depth = 0;
18576             commentList[framePtr+i] = commentList[firstMove+i];
18577             commentList[firstMove+i] = NULL;
18578         }
18579
18580         storedGames++;
18581         forwardMostMove = firstMove; // truncate game so we can start variation
18582 }
18583
18584 void
18585 PushTail (int firstMove, int lastMove)
18586 {
18587         if(appData.icsActive) { // only in local mode
18588                 forwardMostMove = currentMove; // mimic old ICS behavior
18589                 return;
18590         }
18591         if(storedGames >= MAX_VARIATIONS-2) return; // leave one for PV-walk
18592
18593         PushInner(firstMove, lastMove);
18594         if(storedGames == 1) GreyRevert(FALSE);
18595         if(gameMode == PlayFromGameFile) gameMode = EditGame, modeRestore = TRUE;
18596 }
18597
18598 void
18599 PopInner (Boolean annotate)
18600 {
18601         int i, j, nrMoves;
18602         char buf[8000], moveBuf[20];
18603
18604         ToNrEvent(savedFirst[storedGames-1]); // sets currentMove
18605         storedGames--; // do this after ToNrEvent, to make sure HistorySet will refresh entire game after PopInner returns
18606         nrMoves = savedLast[storedGames] - currentMove;
18607         if(annotate) {
18608                 int cnt = 10;
18609                 if(!WhiteOnMove(currentMove))
18610                   snprintf(buf, sizeof(buf)/sizeof(buf[0]),"(%d...", (currentMove+2)>>1);
18611                 else safeStrCpy(buf, "(", sizeof(buf)/sizeof(buf[0]));
18612                 for(i=currentMove; i<forwardMostMove; i++) {
18613                         if(WhiteOnMove(i))
18614                           snprintf(moveBuf, sizeof(moveBuf)/sizeof(moveBuf[0]), " %d. %s", (i+2)>>1, SavePart(parseList[i]));
18615                         else snprintf(moveBuf, sizeof(moveBuf)/sizeof(moveBuf[0])," %s", SavePart(parseList[i]));
18616                         strcat(buf, moveBuf);
18617                         if(commentList[i]) { strcat(buf, " "); strcat(buf, commentList[i]); }
18618                         if(!--cnt) { strcat(buf, "\n"); cnt = 10; }
18619                 }
18620                 strcat(buf, ")");
18621         }
18622         for(i=1; i<=nrMoves; i++) { // copy last variation back
18623             CopyBoard(boards[currentMove+i], boards[framePtr+i]);
18624             for(j=0; j<MOVE_LEN; j++)
18625                 moveList[currentMove+i-1][j] = moveList[framePtr+i][j];
18626             for(j=0; j<2*MOVE_LEN; j++)
18627                 parseList[currentMove+i-1][j] = parseList[framePtr+i][j];
18628             timeRemaining[0][currentMove+i] = timeRemaining[0][framePtr+i];
18629             timeRemaining[1][currentMove+i] = timeRemaining[1][framePtr+i];
18630             pvInfoList[currentMove+i-1] = pvInfoList[framePtr+i];
18631             if(commentList[currentMove+i]) free(commentList[currentMove+i]);
18632             commentList[currentMove+i] = commentList[framePtr+i];
18633             commentList[framePtr+i] = NULL;
18634         }
18635         if(annotate) AppendComment(currentMove+1, buf, FALSE);
18636         framePtr = savedFramePtr[storedGames];
18637         gameInfo.result = savedResult[storedGames];
18638         if(gameInfo.resultDetails != NULL) {
18639             free(gameInfo.resultDetails);
18640       }
18641         gameInfo.resultDetails = savedDetails[storedGames];
18642         forwardMostMove = currentMove + nrMoves;
18643 }
18644
18645 Boolean
18646 PopTail (Boolean annotate)
18647 {
18648         if(appData.icsActive) return FALSE; // only in local mode
18649         if(!storedGames) return FALSE; // sanity
18650         CommentPopDown(); // make sure no stale variation comments to the destroyed line can remain open
18651
18652         PopInner(annotate);
18653         if(currentMove < forwardMostMove) ForwardEvent(); else
18654         HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
18655
18656         if(storedGames == 0) { GreyRevert(TRUE); if(modeRestore) modeRestore = FALSE, gameMode = PlayFromGameFile; }
18657         return TRUE;
18658 }
18659
18660 void
18661 CleanupTail ()
18662 {       // remove all shelved variations
18663         int i;
18664         for(i=0; i<storedGames; i++) {
18665             if(savedDetails[i])
18666                 free(savedDetails[i]);
18667             savedDetails[i] = NULL;
18668         }
18669         for(i=framePtr; i<MAX_MOVES; i++) {
18670                 if(commentList[i]) free(commentList[i]);
18671                 commentList[i] = NULL;
18672         }
18673         framePtr = MAX_MOVES-1;
18674         storedGames = 0;
18675 }
18676
18677 void
18678 LoadVariation (int index, char *text)
18679 {       // [HGM] vari: shelve previous line and load new variation, parsed from text around text[index]
18680         char *p = text, *start = NULL, *end = NULL, wait = NULLCHAR;
18681         int level = 0, move;
18682
18683         if(gameMode != EditGame && gameMode != AnalyzeMode && gameMode != PlayFromGameFile) return;
18684         // first find outermost bracketing variation
18685         while(*p) { // hope I got this right... Non-nesting {} and [] can screen each other and nesting ()
18686             if(!wait) { // while inside [] pr {}, ignore everyting except matching closing ]}
18687                 if(*p == '{') wait = '}'; else
18688                 if(*p == '[') wait = ']'; else
18689                 if(*p == '(' && level++ == 0 && p-text < index) start = p+1;
18690                 if(*p == ')' && level > 0 && --level == 0 && p-text > index && end == NULL) end = p-1;
18691             }
18692             if(*p == wait) wait = NULLCHAR; // closing ]} found
18693             p++;
18694         }
18695         if(!start || !end) return; // no variation found, or syntax error in PGN: ignore click
18696         if(appData.debugMode) fprintf(debugFP, "at move %d load variation '%s'\n", currentMove, start);
18697         end[1] = NULLCHAR; // clip off comment beyond variation
18698         ToNrEvent(currentMove-1);
18699         PushTail(currentMove, forwardMostMove); // shelve main variation. This truncates game
18700         // kludge: use ParsePV() to append variation to game
18701         move = currentMove;
18702         ParsePV(start, TRUE, TRUE);
18703         forwardMostMove = endPV; endPV = -1; currentMove = move; // cleanup what ParsePV did
18704         ClearPremoveHighlights();
18705         CommentPopDown();
18706         ToNrEvent(currentMove+1);
18707 }
18708
18709 void
18710 LoadTheme ()
18711 {
18712     char *p, *q, buf[MSG_SIZ];
18713     if(engineLine && engineLine[0]) { // a theme was selected from the listbox
18714         snprintf(buf, MSG_SIZ, "-theme %s", engineLine);
18715         ParseArgsFromString(buf);
18716         ActivateTheme(TRUE); // also redo colors
18717         return;
18718     }
18719     p = nickName;
18720     if(*p && !strchr(p, '"')) // theme name specified and well-formed; add settings to theme list
18721     {
18722         int len;
18723         q = appData.themeNames;
18724         snprintf(buf, MSG_SIZ, "\"%s\"", nickName);
18725       if(appData.useBitmaps) {
18726         snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), " -ubt true -lbtf \"%s\" -dbtf \"%s\" -lbtm %d -dbtm %d",
18727                 appData.liteBackTextureFile, appData.darkBackTextureFile,
18728                 appData.liteBackTextureMode,
18729                 appData.darkBackTextureMode );
18730       } else {
18731         snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), " -ubt false -lsc %s -dsc %s",
18732                 Col2Text(2),   // lightSquareColor
18733                 Col2Text(3) ); // darkSquareColor
18734       }
18735       if(appData.useBorder) {
18736         snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), " -ub true -border \"%s\"",
18737                 appData.border);
18738       } else {
18739         snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), " -ub false");
18740       }
18741       if(appData.useFont) {
18742         snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), " -upf true -pf \"%s\" -fptc \"%s\" -fpfcw %s -fpbcb %s",
18743                 appData.renderPiecesWithFont,
18744                 appData.fontToPieceTable,
18745                 Col2Text(9),    // appData.fontBackColorWhite
18746                 Col2Text(10) ); // appData.fontForeColorBlack
18747       } else {
18748         snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), " -upf false -pid \"%s\"",
18749                 appData.pieceDirectory);
18750         if(!appData.pieceDirectory[0])
18751           snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), " -wpc %s -bpc %s",
18752                 Col2Text(0),   // whitePieceColor
18753                 Col2Text(1) ); // blackPieceColor
18754       }
18755       snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), " -hsc %s -phc %s\n",
18756                 Col2Text(4),   // highlightSquareColor
18757                 Col2Text(5) ); // premoveHighlightColor
18758         appData.themeNames = malloc(len = strlen(q) + strlen(buf) + 1);
18759         if(insert != q) insert[-1] = NULLCHAR;
18760         snprintf(appData.themeNames, len, "%s\n%s%s", q, buf, insert);
18761         if(q)   free(q);
18762     }
18763     ActivateTheme(FALSE);
18764 }