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, 2016 Free
   9  * Software Foundation, Inc.
  10  *
  11  * Enhancements Copyright 2005 Alessandro Scotti
  12  *
  13  * The following terms apply to Digital Equipment Corporation's copyright
  14  * interest in XBoard:
  15  * ------------------------------------------------------------------------
  16  * All Rights Reserved
  17  *
  18  * Permission to use, copy, modify, and distribute this software and its
  19  * documentation for any purpose and without fee is hereby granted,
  20  * provided that the above copyright notice appear in all copies and that
  21  * both that copyright notice and this permission notice appear in
  22  * supporting documentation, and that the name of Digital not be
  23  * used in advertising or publicity pertaining to distribution of the
  24  * software without specific, written prior permission.
  25  *
  26  * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  27  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  28  * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  29  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  30  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  31  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  32  * SOFTWARE.
  33  * ------------------------------------------------------------------------
  34  *
  35  * The following terms apply to the enhanced version of XBoard
  36  * distributed by the Free Software Foundation:
  37  * ------------------------------------------------------------------------
  38  *
  39  * GNU XBoard is free software: you can redistribute it and/or modify
  40  * it under the terms of the GNU General Public License as published by
  41  * the Free Software Foundation, either version 3 of the License, or (at
  42  * your option) any later version.
  43  *
  44  * GNU XBoard is distributed in the hope that it will be useful, but
  45  * WITHOUT ANY WARRANTY; without even the implied warranty of
  46  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  47  * General Public License for more details.
  48  *
  49  * You should have received a copy of the GNU General Public License
  50  * along with this program. If not, see http://www.gnu.org/licenses/.  *
  51  *
  52  *------------------------------------------------------------------------
  53  ** See the file ChangeLog for a revision history.  */
  54
  55 /* [AS] Also useful here for debugging */
  56 #ifdef WIN32
  57 #include <windows.h>
  58
  59     int flock(int f, int code);
  60 #   define LOCK_EX 2
  61 #   define SLASH '\\'
  62
  63 #   ifdef ARC_64BIT
  64 #       define EGBB_NAME "egbbdll64.dll"
  65 #   else
  66 #       define EGBB_NAME "egbbdll.dll"
  67 #   endif
  68
  69 #else
  70
  71 #   include <sys/file.h>
  72 #   define SLASH '/'
  73
  74 #   include <dlfcn.h>
  75 #   ifdef ARC_64BIT
  76 #       define EGBB_NAME "egbbso64.so"
  77 #   else
  78 #       define EGBB_NAME "egbbso.so"
  79 #   endif
  80     // kludge to allow Windows code in back-end by converting it to corresponding Linux code
  81 #   define CDECL
  82 #   define HMODULE void *
  83 #   define LoadLibrary(x) dlopen(x, RTLD_LAZY)
  84 #   define GetProcAddress dlsym
  85
  86 #endif
  87
  88 #include "config.h"
  89
  90 #include <assert.h>
  91 #include <stdio.h>
  92 #include <ctype.h>
  93 #include <errno.h>
  94 #include <sys/types.h>
  95 #include <sys/stat.h>
  96 #include <math.h>
  97 #include <ctype.h>
  98
  99 #if STDC_HEADERS
 100 # include <stdlib.h>
 101 # include <string.h>
 102 # include <stdarg.h>
 103 #else /* not STDC_HEADERS */
 104 # if HAVE_STRING_H
 105 #  include <string.h>
 106 # else /* not HAVE_STRING_H */
 107 #  include <strings.h>
 108 # endif /* not HAVE_STRING_H */
 109 #endif /* not STDC_HEADERS */
 110
 111 #if HAVE_SYS_FCNTL_H
 112 # include <sys/fcntl.h>
 113 #else /* not HAVE_SYS_FCNTL_H */
 114 # if HAVE_FCNTL_H
 115 #  include <fcntl.h>
 116 # endif /* HAVE_FCNTL_H */
 117 #endif /* not HAVE_SYS_FCNTL_H */
 118
 119 #if TIME_WITH_SYS_TIME
 120 # include <sys/time.h>
 121 # include <time.h>
 122 #else
 123 # if HAVE_SYS_TIME_H
 124 #  include <sys/time.h>
 125 # else
 126 #  include <time.h>
 127 # endif
 128 #endif
 129
 130 #if defined(_amigados) && !defined(__GNUC__)
 131 struct timezone {
 132     int tz_minuteswest;
 133     int tz_dsttime;
 134 };
 135 extern int gettimeofday(struct timeval *, struct timezone *);
 136 #endif
 137
 138 #if HAVE_UNISTD_H
 139 # include <unistd.h>
 140 #endif
 141
 142 #include "common.h"
 143 #include "frontend.h"
 144 #include "backend.h"
 145 #include "parser.h"
 146 #include "moves.h"
 147 #if ZIPPY
 148 # include "zippy.h"
 149 #endif
 150 #include "backendz.h"
 151 #include "evalgraph.h"
 152 #include "engineoutput.h"
 153 #include "gettext.h"
 154
 155 #ifdef ENABLE_NLS
 156 # define _(s) gettext (s)
 157 # define N_(s) gettext_noop (s)
 158 # define T_(s) gettext(s)
 159 #else
 160 # ifdef WIN32
 161 #   define _(s) T_(s)
 162 #   define N_(s) s
 163 # else
 164 #   define _(s) (s)
 165 #   define N_(s) s
 166 #   define T_(s) s
 167 # endif
 168 #endif
 169
 170
 171 int establish P((void));
 172 void read_from_player P((InputSourceRef isr, VOIDSTAR closure,
 173                          char *buf, int count, int error));
 174 void read_from_ics P((InputSourceRef isr, VOIDSTAR closure,
 175                       char *buf, int count, int error));
 176 void SendToICS P((char *s));
 177 void SendToICSDelayed P((char *s, long msdelay));
 178 void SendMoveToICS P((ChessMove moveType, int fromX, int fromY, int toX, int toY, char promoChar));
 179 void HandleMachineMove P((char *message, ChessProgramState *cps));
 180 int AutoPlayOneMove P((void));
 181 int LoadGameOneMove P((ChessMove readAhead));
 182 int LoadGameFromFile P((char *filename, int n, char *title, int useList));
 183 int LoadPositionFromFile P((char *filename, int n, char *title));
 184 int SavePositionToFile P((char *filename));
 185 void MakeMove P((int fromX, int fromY, int toX, int toY, int promoChar));
 186 void ShowMove P((int fromX, int fromY, int toX, int toY));
 187 int FinishMove P((ChessMove moveType, int fromX, int fromY, int toX, int toY,
 188                    /*char*/int promoChar));
 189 void BackwardInner P((int target));
 190 void ForwardInner P((int target));
 191 int Adjudicate P((ChessProgramState *cps));
 192 void GameEnds P((ChessMove result, char *resultDetails, int whosays));
 193 void EditPositionDone P((Boolean fakeRights));
 194 void PrintOpponents P((FILE *fp));
 195 void PrintPosition P((FILE *fp, int move));
 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 (int 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 char promoRestrict[MSG_SIZ];
 447
 448 ChessProgramState first, second, pairing;
 449
 450 /* premove variables */
 451 int premoveToX = 0;
 452 int premoveToY = 0;
 453 int premoveFromX = 0;
 454 int premoveFromY = 0;
 455 int premovePromoChar = 0;
 456 int gotPremove = 0;
 457 Boolean alarmSounded;
 458 /* end premove variables */
 459
 460 char *ics_prefix = "$";
 461 enum ICS_TYPE ics_type = ICS_GENERIC;
 462
 463 int currentMove = 0, forwardMostMove = 0, backwardMostMove = 0;
 464 int pauseExamForwardMostMove = 0;
 465 int nCmailGames = 0, nCmailResults = 0, nCmailMovesRegistered = 0;
 466 int cmailMoveRegistered[CMAIL_MAX_GAMES], cmailResult[CMAIL_MAX_GAMES];
 467 int cmailMsgLoaded = FALSE, cmailMailedMove = FALSE;
 468 int cmailOldMove = -1, firstMove = TRUE, flipView = FALSE;
 469 int blackPlaysFirst = FALSE, startedFromSetupPosition = FALSE;
 470 int searchTime = 0, pausing = FALSE, pauseExamInvalid = FALSE;
 471 int whiteFlag = FALSE, blackFlag = FALSE;
 472 int userOfferedDraw = FALSE;
 473 int ics_user_moved = 0, ics_gamenum = -1, ics_getting_history = H_FALSE;
 474 int matchMode = FALSE, hintRequested = FALSE, bookRequested = FALSE;
 475 int cmailMoveType[CMAIL_MAX_GAMES];
 476 long ics_clock_paused = 0;
 477 ProcRef icsPR = NoProc, cmailPR = NoProc;
 478 InputSourceRef telnetISR = NULL, fromUserISR = NULL, cmailISR = NULL;
 479 GameMode gameMode = BeginningOfGame;
 480 char moveList[MAX_MOVES][MOVE_LEN], parseList[MAX_MOVES][MOVE_LEN * 2];
 481 char *commentList[MAX_MOVES], *cmailCommentList[CMAIL_MAX_GAMES];
 482 ChessProgramStats_Move pvInfoList[MAX_MOVES]; /* [AS] Info about engine thinking */
 483 int hiddenThinkOutputState = 0; /* [AS] */
 484 int adjudicateLossThreshold = 0; /* [AS] Automatic adjudication */
 485 int adjudicateLossPlies = 6;
 486 char white_holding[64], black_holding[64];
 487 TimeMark lastNodeCountTime;
 488 long lastNodeCount=0;
 489 int shiftKey, controlKey; // [HGM] set by mouse handler
 490
 491 int have_sent_ICS_logon = 0;
 492 int movesPerSession;
 493 int suddenDeath, whiteStartMove, blackStartMove; /* [HGM] for implementation of 'any per time' sessions, as in first part of byoyomi TC */
 494 long whiteTimeRemaining, blackTimeRemaining, timeControl, timeIncrement, lastWhite, lastBlack, activePartnerTime;
 495 Boolean adjustedClock;
 496 long timeControl_2; /* [AS] Allow separate time controls */
 497 char *fullTimeControlString = NULL, *nextSession, *whiteTC, *blackTC, activePartner; /* [HGM] secondary TC: merge of MPS, TC and inc */
 498 long timeRemaining[2][MAX_MOVES];
 499 int matchGame = 0, nextGame = 0, roundNr = 0;
 500 Boolean waitingForGame = FALSE, startingEngine = FALSE;
 501 TimeMark programStartTime, pauseStart;
 502 char ics_handle[MSG_SIZ];
 503 int have_set_title = 0;
 504
 505 /* animateTraining preserves the state of appData.animate
 506  * when Training mode is activated. This allows the
 507  * response to be animated when appData.animate == TRUE and
 508  * appData.animateDragging == TRUE.
 509  */
 510 Boolean animateTraining;
 511
 512 GameInfo gameInfo;
 513
 514 AppData appData;
 515
 516 Board boards[MAX_MOVES];
 517 /* [HGM] Following 7 needed for accurate legality tests: */
 518 signed char  castlingRank[BOARD_FILES]; // and corresponding ranks
 519 unsigned char initialRights[BOARD_FILES];
 520 int   nrCastlingRights; // For TwoKings, or to implement castling-unknown status
 521 int   initialRulePlies, FENrulePlies;
 522 FILE  *serverMoves = NULL; // next two for broadcasting (/serverMoves option)
 523 int loadFlag = 0;
 524 Boolean shuffleOpenings;
 525 int mute; // mute all sounds
 526
 527 // [HGM] vari: next 12 to save and restore variations
 528 #define MAX_VARIATIONS 10
 529 int framePtr = MAX_MOVES-1; // points to free stack entry
 530 int storedGames = 0;
 531 int savedFirst[MAX_VARIATIONS];
 532 int savedLast[MAX_VARIATIONS];
 533 int savedFramePtr[MAX_VARIATIONS];
 534 char *savedDetails[MAX_VARIATIONS];
 535 ChessMove savedResult[MAX_VARIATIONS];
 536
 537 void PushTail P((int firstMove, int lastMove));
 538 Boolean PopTail P((Boolean annotate));
 539 void PushInner P((int firstMove, int lastMove));
 540 void PopInner P((Boolean annotate));
 541 void CleanupTail P((void));
 542
 543 ChessSquare  FIDEArray[2][BOARD_FILES] = {
 544     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 545         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 546     { BlackRook, BlackKnight, BlackBishop, BlackQueen,
 547         BlackKing, BlackBishop, BlackKnight, BlackRook }
 548 };
 549
 550 ChessSquare twoKingsArray[2][BOARD_FILES] = {
 551     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 552         WhiteKing, WhiteKing, WhiteKnight, WhiteRook },
 553     { BlackRook, BlackKnight, BlackBishop, BlackQueen,
 554         BlackKing, BlackKing, BlackKnight, BlackRook }
 555 };
 556
 557 ChessSquare  KnightmateArray[2][BOARD_FILES] = {
 558     { WhiteRook, WhiteMan, WhiteBishop, WhiteQueen,
 559         WhiteUnicorn, WhiteBishop, WhiteMan, WhiteRook },
 560     { BlackRook, BlackMan, BlackBishop, BlackQueen,
 561         BlackUnicorn, BlackBishop, BlackMan, BlackRook }
 562 };
 563
 564 ChessSquare SpartanArray[2][BOARD_FILES] = {
 565     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 566         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 567     { BlackAlfil, BlackMarshall, BlackKing, BlackDragon,
 568         BlackDragon, BlackKing, BlackAngel, BlackAlfil }
 569 };
 570
 571 ChessSquare fairyArray[2][BOARD_FILES] = { /* [HGM] Queen side differs from King side */
 572     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 573         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 574     { BlackCardinal, BlackAlfil, BlackMarshall, BlackAngel,
 575         BlackKing, BlackMarshall, BlackAlfil, BlackCardinal }
 576 };
 577
 578 ChessSquare ShatranjArray[2][BOARD_FILES] = { /* [HGM] (movGen knows about Shatranj Q and P) */
 579     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteKing,
 580         WhiteFerz, WhiteAlfil, WhiteKnight, WhiteRook },
 581     { BlackRook, BlackKnight, BlackAlfil, BlackKing,
 582         BlackFerz, BlackAlfil, BlackKnight, BlackRook }
 583 };
 584
 585 ChessSquare makrukArray[2][BOARD_FILES] = { /* [HGM] (movGen knows about Shatranj Q and P) */
 586     { WhiteRook, WhiteKnight, WhiteMan, WhiteKing,
 587         WhiteFerz, WhiteMan, WhiteKnight, WhiteRook },
 588     { BlackRook, BlackKnight, BlackMan, BlackFerz,
 589         BlackKing, BlackMan, BlackKnight, BlackRook }
 590 };
 591
 592 ChessSquare aseanArray[2][BOARD_FILES] = { /* [HGM] (movGen knows about Shatranj Q and P) */
 593     { WhiteRook, WhiteKnight, WhiteMan, WhiteFerz,
 594         WhiteKing, WhiteMan, WhiteKnight, WhiteRook },
 595     { BlackRook, BlackKnight, BlackMan, BlackFerz,
 596         BlackKing, BlackMan, BlackKnight, BlackRook }
 597 };
 598
 599 ChessSquare  lionArray[2][BOARD_FILES] = {
 600     { WhiteRook, WhiteLion, WhiteBishop, WhiteQueen,
 601         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 602     { BlackRook, BlackLion, BlackBishop, BlackQueen,
 603         BlackKing, BlackBishop, BlackKnight, BlackRook }
 604 };
 605
 606
 607 #if (BOARD_FILES>=10)
 608 ChessSquare ShogiArray[2][BOARD_FILES] = {
 609     { WhiteQueen, WhiteKnight, WhiteFerz, WhiteWazir,
 610         WhiteKing, WhiteWazir, WhiteFerz, WhiteKnight, WhiteQueen },
 611     { BlackQueen, BlackKnight, BlackFerz, BlackWazir,
 612         BlackKing, BlackWazir, BlackFerz, BlackKnight, BlackQueen }
 613 };
 614
 615 ChessSquare XiangqiArray[2][BOARD_FILES] = {
 616     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteFerz,
 617         WhiteWazir, WhiteFerz, WhiteAlfil, WhiteKnight, WhiteRook },
 618     { BlackRook, BlackKnight, BlackAlfil, BlackFerz,
 619         BlackWazir, BlackFerz, BlackAlfil, BlackKnight, BlackRook }
 620 };
 621
 622 ChessSquare CapablancaArray[2][BOARD_FILES] = {
 623     { WhiteRook, WhiteKnight, WhiteAngel, WhiteBishop, WhiteQueen,
 624         WhiteKing, WhiteBishop, WhiteMarshall, WhiteKnight, WhiteRook },
 625     { BlackRook, BlackKnight, BlackAngel, BlackBishop, BlackQueen,
 626         BlackKing, BlackBishop, BlackMarshall, BlackKnight, BlackRook }
 627 };
 628
 629 ChessSquare GreatArray[2][BOARD_FILES] = {
 630     { WhiteDragon, WhiteKnight, WhiteAlfil, WhiteGrasshopper, WhiteKing,
 631         WhiteSilver, WhiteCardinal, WhiteAlfil, WhiteKnight, WhiteDragon },
 632     { BlackDragon, BlackKnight, BlackAlfil, BlackGrasshopper, BlackKing,
 633         BlackSilver, BlackCardinal, BlackAlfil, BlackKnight, BlackDragon },
 634 };
 635
 636 ChessSquare JanusArray[2][BOARD_FILES] = {
 637     { WhiteRook, WhiteAngel, WhiteKnight, WhiteBishop, WhiteKing,
 638         WhiteQueen, WhiteBishop, WhiteKnight, WhiteAngel, WhiteRook },
 639     { BlackRook, BlackAngel, BlackKnight, BlackBishop, BlackKing,
 640         BlackQueen, BlackBishop, BlackKnight, BlackAngel, BlackRook }
 641 };
 642
 643 ChessSquare GrandArray[2][BOARD_FILES] = {
 644     { EmptySquare, WhiteKnight, WhiteBishop, WhiteQueen, WhiteKing,
 645         WhiteMarshall, WhiteAngel, WhiteBishop, WhiteKnight, EmptySquare },
 646     { EmptySquare, BlackKnight, BlackBishop, BlackQueen, BlackKing,
 647         BlackMarshall, BlackAngel, BlackBishop, BlackKnight, EmptySquare }
 648 };
 649
 650 ChessSquare ChuChessArray[2][BOARD_FILES] = {
 651     { WhiteMan, WhiteKnight, WhiteBishop, WhiteCardinal, WhiteLion,
 652         WhiteQueen, WhiteDragon, WhiteBishop, WhiteKnight, WhiteMan },
 653     { BlackMan, BlackKnight, BlackBishop, BlackDragon, BlackQueen,
 654         BlackLion, BlackCardinal, BlackBishop, BlackKnight, BlackMan }
 655 };
 656
 657 #ifdef GOTHIC
 658 ChessSquare GothicArray[2][BOARD_FILES] = {
 659     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen, WhiteMarshall,
 660         WhiteKing, WhiteAngel, WhiteBishop, WhiteKnight, WhiteRook },
 661     { BlackRook, BlackKnight, BlackBishop, BlackQueen, BlackMarshall,
 662         BlackKing, BlackAngel, BlackBishop, BlackKnight, BlackRook }
 663 };
 664 #else // !GOTHIC
 665 #define GothicArray CapablancaArray
 666 #endif // !GOTHIC
 667
 668 #ifdef FALCON
 669 ChessSquare FalconArray[2][BOARD_FILES] = {
 670     { WhiteRook, WhiteKnight, WhiteBishop, WhiteFalcon, WhiteQueen,
 671         WhiteKing, WhiteFalcon, WhiteBishop, WhiteKnight, WhiteRook },
 672     { BlackRook, BlackKnight, BlackBishop, BlackFalcon, BlackQueen,
 673         BlackKing, BlackFalcon, BlackBishop, BlackKnight, BlackRook }
 674 };
 675 #else // !FALCON
 676 #define FalconArray CapablancaArray
 677 #endif // !FALCON
 678
 679 #else // !(BOARD_FILES>=10)
 680 #define XiangqiPosition FIDEArray
 681 #define CapablancaArray FIDEArray
 682 #define GothicArray FIDEArray
 683 #define GreatArray FIDEArray
 684 #endif // !(BOARD_FILES>=10)
 685
 686 #if (BOARD_FILES>=12)
 687 ChessSquare CourierArray[2][BOARD_FILES] = {
 688     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteBishop, WhiteMan, WhiteKing,
 689         WhiteFerz, WhiteWazir, WhiteBishop, WhiteAlfil, WhiteKnight, WhiteRook },
 690     { BlackRook, BlackKnight, BlackAlfil, BlackBishop, BlackMan, BlackKing,
 691         BlackFerz, BlackWazir, BlackBishop, BlackAlfil, BlackKnight, BlackRook }
 692 };
 693 ChessSquare ChuArray[6][BOARD_FILES] = {
 694     { WhiteLance, WhiteUnicorn, WhiteMan, WhiteFerz, WhiteWazir, WhiteKing,
 695       WhiteAlfil, WhiteWazir, WhiteFerz, WhiteMan, WhiteUnicorn, WhiteLance },
 696     { BlackLance, BlackUnicorn, BlackMan, BlackFerz, BlackWazir, BlackAlfil,
 697       BlackKing, BlackWazir, BlackFerz, BlackMan, BlackUnicorn, BlackLance },
 698     { WhiteCannon, EmptySquare, WhiteBishop, EmptySquare, WhiteNightrider, WhiteMarshall,
 699       WhiteAngel, WhiteNightrider, EmptySquare, WhiteBishop, EmptySquare, WhiteCannon },
 700     { BlackCannon, EmptySquare, BlackBishop, EmptySquare, BlackNightrider, BlackAngel,
 701       BlackMarshall, BlackNightrider, EmptySquare, BlackBishop, EmptySquare, BlackCannon },
 702     { WhiteFalcon, WhiteSilver, WhiteRook, WhiteCardinal, WhiteDragon, WhiteLion,
 703       WhiteQueen, WhiteDragon, WhiteCardinal, WhiteRook, WhiteSilver, WhiteFalcon },
 704     { BlackFalcon, BlackSilver, BlackRook, BlackCardinal, BlackDragon, BlackQueen,
 705       BlackLion, BlackDragon, BlackCardinal, BlackRook, BlackSilver, BlackFalcon }
 706 };
 707 #else // !(BOARD_FILES>=12)
 708 #define CourierArray CapablancaArray
 709 #define ChuArray CapablancaArray
 710 #endif // !(BOARD_FILES>=12)
 711
 712
 713 Board initialPosition;
 714
 715
 716 /* Convert str to a rating. Checks for special cases of "----",
 717
 718    "++++", etc. Also strips ()'s */
 719 int
 720 string_to_rating (char *str)
 721 {
 722   while(*str && !isdigit(*str)) ++str;
 723   if (!*str)
 724     return 0;   /* One of the special "no rating" cases */
 725   else
 726     return atoi(str);
 727 }
 728
 729 void
 730 ClearProgramStats ()
 731 {
 732     /* Init programStats */
 733     programStats.movelist[0] = 0;
 734     programStats.depth = 0;
 735     programStats.nr_moves = 0;
 736     programStats.moves_left = 0;
 737     programStats.nodes = 0;
 738     programStats.time = -1;        // [HGM] PGNtime: make invalid to recognize engine output
 739     programStats.score = 0;
 740     programStats.got_only_move = 0;
 741     programStats.got_fail = 0;
 742     programStats.line_is_book = 0;
 743 }
 744
 745 void
 746 CommonEngineInit ()
 747 {   // [HGM] moved some code here from InitBackend1 that has to be done after both engines have contributed their settings
 748     if (appData.firstPlaysBlack) {
 749         first.twoMachinesColor = "black\n";
 750         second.twoMachinesColor = "white\n";
 751     } else {
 752         first.twoMachinesColor = "white\n";
 753         second.twoMachinesColor = "black\n";
 754     }
 755
 756     first.other = &second;
 757     second.other = &first;
 758
 759     { float norm = 1;
 760         if(appData.timeOddsMode) {
 761             norm = appData.timeOdds[0];
 762             if(norm > appData.timeOdds[1]) norm = appData.timeOdds[1];
 763         }
 764         first.timeOdds  = appData.timeOdds[0]/norm;
 765         second.timeOdds = appData.timeOdds[1]/norm;
 766     }
 767
 768     if(programVersion) free(programVersion);
 769     if (appData.noChessProgram) {
 770         programVersion = (char*) malloc(5 + strlen(PACKAGE_STRING));
 771         sprintf(programVersion, "%s", PACKAGE_STRING);
 772     } else {
 773       /* [HGM] tidy: use tidy name, in stead of full pathname (which was probably a bug due to / vs \ ) */
 774       programVersion = (char*) malloc(8 + strlen(PACKAGE_STRING) + strlen(first.tidy));
 775       sprintf(programVersion, "%s + %s", PACKAGE_STRING, first.tidy);
 776     }
 777 }
 778
 779 void
 780 UnloadEngine (ChessProgramState *cps)
 781 {
 782         /* Kill off first chess program */
 783         if (cps->isr != NULL)
 784           RemoveInputSource(cps->isr);
 785         cps->isr = NULL;
 786
 787         if (cps->pr != NoProc) {
 788             ExitAnalyzeMode();
 789             DoSleep( appData.delayBeforeQuit );
 790             SendToProgram("quit\n", cps);
 791             DestroyChildProcess(cps->pr, 4 + cps->useSigterm);
 792         }
 793         cps->pr = NoProc;
 794         if(appData.debugMode) fprintf(debugFP, "Unload %s\n", cps->which);
 795 }
 796
 797 void
 798 ClearOptions (ChessProgramState *cps)
 799 {
 800     int i;
 801     cps->nrOptions = cps->comboCnt = 0;
 802     for(i=0; i<MAX_OPTIONS; i++) {
 803         cps->option[i].min = cps->option[i].max = cps->option[i].value = 0;
 804         cps->option[i].textValue = 0;
 805     }
 806 }
 807
 808 char *engineNames[] = {
 809   /* TRANSLATORS: "first" is the first of possible two chess engines. It is inserted into strings
 810      such as "%s engine" / "%s chess program" / "%s machine" - all meaning the same thing */
 811 N_("first"),
 812   /* TRANSLATORS: "second" is the second of possible two chess engines. It is inserted into strings
 813      such as "%s engine" / "%s chess program" / "%s machine" - all meaning the same thing */
 814 N_("second")
 815 };
 816
 817 void
 818 InitEngine (ChessProgramState *cps, int n)
 819 {   // [HGM] all engine initialiation put in a function that does one engine
 820
 821     ClearOptions(cps);
 822
 823     cps->which = engineNames[n];
 824     cps->maybeThinking = FALSE;
 825     cps->pr = NoProc;
 826     cps->isr = NULL;
 827     cps->sendTime = 2;
 828     cps->sendDrawOffers = 1;
 829
 830     cps->program = appData.chessProgram[n];
 831     cps->host = appData.host[n];
 832     cps->dir = appData.directory[n];
 833     cps->initString = appData.engInitString[n];
 834     cps->computerString = appData.computerString[n];
 835     cps->useSigint  = TRUE;
 836     cps->useSigterm = TRUE;
 837     cps->reuse = appData.reuse[n];
 838     cps->nps = appData.NPS[n];   // [HGM] nps: copy nodes per second
 839     cps->useSetboard = FALSE;
 840     cps->useSAN = FALSE;
 841     cps->usePing = FALSE;
 842     cps->lastPing = 0;
 843     cps->lastPong = 0;
 844     cps->usePlayother = FALSE;
 845     cps->useColors = TRUE;
 846     cps->useUsermove = FALSE;
 847     cps->sendICS = FALSE;
 848     cps->sendName = appData.icsActive;
 849     cps->sdKludge = FALSE;
 850     cps->stKludge = FALSE;
 851     if(cps->tidy == NULL) cps->tidy = (char*) malloc(MSG_SIZ);
 852     TidyProgramName(cps->program, cps->host, cps->tidy);
 853     cps->matchWins = 0;
 854     ASSIGN(cps->variants, appData.noChessProgram ? "" : appData.variant);
 855     cps->analysisSupport = 2; /* detect */
 856     cps->analyzing = FALSE;
 857     cps->initDone = FALSE;
 858     cps->reload = FALSE;
 859     cps->pseudo = appData.pseudo[n];
 860
 861     /* New features added by Tord: */
 862     cps->useFEN960 = FALSE;
 863     cps->useOOCastle = TRUE;
 864     /* End of new features added by Tord. */
 865     cps->fenOverride  = appData.fenOverride[n];
 866
 867     /* [HGM] time odds: set factor for each machine */
 868     cps->timeOdds  = appData.timeOdds[n];
 869
 870     /* [HGM] secondary TC: how to handle sessions that do not fit in 'level'*/
 871     cps->accumulateTC = appData.accumulateTC[n];
 872     cps->maxNrOfSessions = 1;
 873
 874     /* [HGM] debug */
 875     cps->debug = FALSE;
 876
 877     cps->drawDepth = appData.drawDepth[n];
 878     cps->supportsNPS = UNKNOWN;
 879     cps->memSize = FALSE;
 880     cps->maxCores = FALSE;
 881     ASSIGN(cps->egtFormats, "");
 882
 883     /* [HGM] options */
 884     cps->optionSettings  = appData.engOptions[n];
 885
 886     cps->scoreIsAbsolute = appData.scoreIsAbsolute[n]; /* [AS] */
 887     cps->isUCI = appData.isUCI[n]; /* [AS] */
 888     cps->hasOwnBookUCI = appData.hasOwnBookUCI[n]; /* [AS] */
 889     cps->highlight = 0;
 890
 891     if (appData.protocolVersion[n] > PROTOVER
 892         || appData.protocolVersion[n] < 1)
 893       {
 894         char buf[MSG_SIZ];
 895         int len;
 896
 897         len = snprintf(buf, MSG_SIZ, _("protocol version %d not supported"),
 898                        appData.protocolVersion[n]);
 899         if( (len >= MSG_SIZ) && appData.debugMode )
 900           fprintf(debugFP, "InitBackEnd1: buffer truncated.\n");
 901
 902         DisplayFatalError(buf, 0, 2);
 903       }
 904     else
 905       {
 906         cps->protocolVersion = appData.protocolVersion[n];
 907       }
 908
 909     InitEngineUCI( installDir, cps );  // [HGM] moved here from winboard.c, to make available in xboard
 910     ParseFeatures(appData.featureDefaults, cps);
 911 }
 912
 913 ChessProgramState *savCps;
 914
 915 GameMode oldMode;
 916
 917 void
 918 LoadEngine ()
 919 {
 920     int i;
 921     if(WaitForEngine(savCps, LoadEngine)) return;
 922     CommonEngineInit(); // recalculate time odds
 923     if(gameInfo.variant != StringToVariant(appData.variant)) {
 924         // we changed variant when loading the engine; this forces us to reset
 925         Reset(TRUE, savCps != &first);
 926         oldMode = BeginningOfGame; // to prevent restoring old mode
 927     }
 928     InitChessProgram(savCps, FALSE);
 929     if(gameMode == EditGame) SendToProgram("force\n", savCps); // in EditGame mode engine must be in force mode
 930     DisplayMessage("", "");
 931     if (startedFromSetupPosition) SendBoard(savCps, backwardMostMove);
 932     for (i = backwardMostMove; i < currentMove; i++) SendMoveToProgram(i, savCps);
 933     ThawUI();
 934     SetGNUMode();
 935     if(oldMode == AnalyzeMode) AnalyzeModeEvent();
 936 }
 937
 938 void
 939 ReplaceEngine (ChessProgramState *cps, int n)
 940 {
 941     oldMode = gameMode; // remember mode, so it can be restored after loading sequence is complete
 942     keepInfo = 1;
 943     if(oldMode != BeginningOfGame) EditGameEvent();
 944     keepInfo = 0;
 945     UnloadEngine(cps);
 946     appData.noChessProgram = FALSE;
 947     appData.clockMode = TRUE;
 948     InitEngine(cps, n);
 949     UpdateLogos(TRUE);
 950     if(n) return; // only startup first engine immediately; second can wait
 951     savCps = cps; // parameter to LoadEngine passed as globals, to allow scheduled calling :-(
 952     LoadEngine();
 953 }
 954
 955 extern char *engineName, *engineDir, *engineChoice, *engineLine, *nickName, *params;
 956 extern Boolean isUCI, hasBook, storeVariant, v1, addToList, useNick;
 957
 958 static char resetOptions[] =
 959         "-reuse -firstIsUCI false -firstHasOwnBookUCI true -firstTimeOdds 1 "
 960         "-firstInitString \"" INIT_STRING "\" -firstComputerString \"" COMPUTER_STRING "\" "
 961         "-firstFeatures \"\" -firstLogo \"\" -firstAccumulateTC 1 -fd \".\" "
 962         "-firstOptions \"\" -firstNPS -1 -fn \"\" -firstScoreAbs false";
 963
 964 void
 965 FloatToFront(char **list, char *engineLine)
 966 {
 967     char buf[MSG_SIZ], tidy[MSG_SIZ], *p = buf, *q, *r = buf;
 968     int i=0;
 969     if(appData.recentEngines <= 0) return;
 970     TidyProgramName(engineLine, "localhost", tidy+1);
 971     tidy[0] = buf[0] = '\n'; strcat(tidy, "\n");
 972     strncpy(buf+1, *list, MSG_SIZ-50);
 973     if(p = strstr(buf, tidy)) { // tidy name appears in list
 974         q = strchr(++p, '\n'); if(q == NULL) return; // malformed, don't touch
 975         while(*p++ = *++q); // squeeze out
 976     }
 977     strcat(tidy, buf+1); // put list behind tidy name
 978     p = tidy + 1; while(q = strchr(p, '\n')) i++, r = p, p = q + 1; // count entries in new list
 979     if(i > appData.recentEngines) *r = NULLCHAR; // if maximum rached, strip off last
 980     ASSIGN(*list, tidy+1);
 981 }
 982
 983 char *insert, *wbOptions; // point in ChessProgramNames were we should insert new engine
 984
 985 void
 986 Load (ChessProgramState *cps, int i)
 987 {
 988     char *p, *q, buf[MSG_SIZ], command[MSG_SIZ], buf2[MSG_SIZ], buf3[MSG_SIZ], jar;
 989     if(engineLine && engineLine[0]) { // an engine was selected from the combo box
 990         snprintf(buf, MSG_SIZ, "-fcp %s", engineLine);
 991         SwapEngines(i); // kludge to parse -f* / -first* like it is -s* / -second*
 992         ParseArgsFromString(resetOptions); appData.pvSAN[0] = FALSE;
 993         FREE(appData.fenOverride[0]); appData.fenOverride[0] = NULL;
 994         appData.firstProtocolVersion = PROTOVER;
 995         ParseArgsFromString(buf);
 996         SwapEngines(i);
 997         ReplaceEngine(cps, i);
 998         FloatToFront(&appData.recentEngineList, engineLine);
 999         if(gameMode == BeginningOfGame) Reset(TRUE, TRUE);
1000         return;
1001     }
1002     p = engineName;
1003     while(q = strchr(p, SLASH)) p = q+1;
1004     if(*p== NULLCHAR) { DisplayError(_("You did not specify the engine executable"), 0); return; }
1005     if(engineDir[0] != NULLCHAR) {
1006         ASSIGN(appData.directory[i], engineDir); p = engineName;
1007     } else if(p != engineName) { // derive directory from engine path, when not given
1008         p[-1] = 0;
1009         ASSIGN(appData.directory[i], engineName);
1010         p[-1] = SLASH;
1011         if(SLASH == '/' && p - engineName > 1) *(p -= 2) = '.'; // for XBoard use ./exeName as command after split!
1012     } else { ASSIGN(appData.directory[i], "."); }
1013     jar = (strstr(p, ".jar") == p + strlen(p) - 4);
1014     if(params[0]) {
1015         if(strchr(p, ' ') && !strchr(p, '"')) snprintf(buf2, MSG_SIZ, "\"%s\"", p), p = buf2; // quote if it contains spaces
1016         snprintf(command, MSG_SIZ, "%s %s", p, params);
1017         p = command;
1018     }
1019     if(jar) { snprintf(buf3, MSG_SIZ, "java -jar %s", p); p = buf3; }
1020     ASSIGN(appData.chessProgram[i], p);
1021     appData.isUCI[i] = isUCI;
1022     appData.protocolVersion[i] = v1 ? 1 : PROTOVER;
1023     appData.hasOwnBookUCI[i] = hasBook;
1024     if(!nickName[0]) useNick = FALSE;
1025     if(useNick) ASSIGN(appData.pgnName[i], nickName);
1026     if(addToList) {
1027         int len;
1028         char quote;
1029         q = firstChessProgramNames;
1030         if(nickName[0]) snprintf(buf, MSG_SIZ, "\"%s\" -fcp ", nickName); else buf[0] = NULLCHAR;
1031         quote = strchr(p, '"') ? '\'' : '"'; // use single quotes around engine command if it contains double quotes
1032         snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), "%c%s%c -fd \"%s\"%s%s%s%s%s%s%s%s\n",
1033                         quote, p, quote, appData.directory[i],
1034                         useNick ? " -fn \"" : "",
1035                         useNick ? nickName : "",
1036                         useNick ? "\"" : "",
1037                         v1 ? " -firstProtocolVersion 1" : "",
1038                         hasBook ? "" : " -fNoOwnBookUCI",
1039                         isUCI ? (isUCI == TRUE ? " -fUCI" : gameInfo.variant == VariantShogi ? " -fUSI" : " -fUCCI") : "",
1040                         storeVariant ? " -variant " : "",
1041                         storeVariant ? VariantName(gameInfo.variant) : "");
1042         if(wbOptions && wbOptions[0]) snprintf(buf+strlen(buf)-1, MSG_SIZ-strlen(buf), " %s\n", wbOptions);
1043         firstChessProgramNames = malloc(len = strlen(q) + strlen(buf) + 1);
1044         if(insert != q) insert[-1] = NULLCHAR;
1045         snprintf(firstChessProgramNames, len, "%s\n%s%s", q, buf, insert);
1046         if(q)   free(q);
1047         FloatToFront(&appData.recentEngineList, buf);
1048     }
1049     ReplaceEngine(cps, i);
1050 }
1051
1052 void
1053 InitTimeControls ()
1054 {
1055     int matched, min, sec;
1056     /*
1057      * Parse timeControl resource
1058      */
1059     if (!ParseTimeControl(appData.timeControl, appData.timeIncrement,
1060                           appData.movesPerSession)) {
1061         char buf[MSG_SIZ];
1062         snprintf(buf, sizeof(buf), _("bad timeControl option %s"), appData.timeControl);
1063         DisplayFatalError(buf, 0, 2);
1064     }
1065
1066     /*
1067      * Parse searchTime resource
1068      */
1069     if (*appData.searchTime != NULLCHAR) {
1070         matched = sscanf(appData.searchTime, "%d:%d", &min, &sec);
1071         if (matched == 1) {
1072             searchTime = min * 60;
1073         } else if (matched == 2) {
1074             searchTime = min * 60 + sec;
1075         } else {
1076             char buf[MSG_SIZ];
1077             snprintf(buf, sizeof(buf), _("bad searchTime option %s"), appData.searchTime);
1078             DisplayFatalError(buf, 0, 2);
1079         }
1080     }
1081 }
1082
1083 void
1084 InitBackEnd1 ()
1085 {
1086
1087     ShowThinkingEvent(); // [HGM] thinking: make sure post/nopost state is set according to options
1088     startVariant = StringToVariant(appData.variant); // [HGM] nicks: remember original variant
1089
1090     GetTimeMark(&programStartTime);
1091     srandom((programStartTime.ms + 1000*programStartTime.sec)*0x1001001); // [HGM] book: makes sure random is unpredictabe to msec level
1092     appData.seedBase = random() + (random()<<15);
1093     pauseStart = programStartTime; pauseStart.sec -= 100; // [HGM] matchpause: fake a pause that has long since ended
1094
1095     ClearProgramStats();
1096     programStats.ok_to_send = 1;
1097     programStats.seen_stat = 0;
1098
1099     /*
1100      * Initialize game list
1101      */
1102     ListNew(&gameList);
1103
1104
1105     /*
1106      * Internet chess server status
1107      */
1108     if (appData.icsActive) {
1109         appData.matchMode = FALSE;
1110         appData.matchGames = 0;
1111 #if ZIPPY
1112         appData.noChessProgram = !appData.zippyPlay;
1113 #else
1114         appData.zippyPlay = FALSE;
1115         appData.zippyTalk = FALSE;
1116         appData.noChessProgram = TRUE;
1117 #endif
1118         if (*appData.icsHelper != NULLCHAR) {
1119             appData.useTelnet = TRUE;
1120             appData.telnetProgram = appData.icsHelper;
1121         }
1122     } else {
1123         appData.zippyTalk = appData.zippyPlay = FALSE;
1124     }
1125
1126     /* [AS] Initialize pv info list [HGM] and game state */
1127     {
1128         int i, j;
1129
1130         for( i=0; i<=framePtr; i++ ) {
1131             pvInfoList[i].depth = -1;
1132             boards[i][EP_STATUS] = EP_NONE;
1133             for( j=0; j<BOARD_FILES-2; j++ ) boards[i][CASTLING][j] = NoRights;
1134         }
1135     }
1136
1137     InitTimeControls();
1138
1139     /* [AS] Adjudication threshold */
1140     adjudicateLossThreshold = appData.adjudicateLossThreshold;
1141
1142     InitEngine(&first, 0);
1143     InitEngine(&second, 1);
1144     CommonEngineInit();
1145
1146     pairing.which = "pairing"; // pairing engine
1147     pairing.pr = NoProc;
1148     pairing.isr = NULL;
1149     pairing.program = appData.pairingEngine;
1150     pairing.host = "localhost";
1151     pairing.dir = ".";
1152
1153     if (appData.icsActive) {
1154         appData.clockMode = TRUE;  /* changes dynamically in ICS mode */
1155     } else if (appData.noChessProgram) { // [HGM] st: searchTime mode now also is clockMode
1156         appData.clockMode = FALSE;
1157         first.sendTime = second.sendTime = 0;
1158     }
1159
1160 #if ZIPPY
1161     /* Override some settings from environment variables, for backward
1162        compatibility.  Unfortunately it's not feasible to have the env
1163        vars just set defaults, at least in xboard.  Ugh.
1164     */
1165     if (appData.icsActive && (appData.zippyPlay || appData.zippyTalk)) {
1166       ZippyInit();
1167     }
1168 #endif
1169
1170     if (!appData.icsActive) {
1171       char buf[MSG_SIZ];
1172       int len;
1173
1174       /* Check for variants that are supported only in ICS mode,
1175          or not at all.  Some that are accepted here nevertheless
1176          have bugs; see comments below.
1177       */
1178       VariantClass variant = StringToVariant(appData.variant);
1179       switch (variant) {
1180       case VariantBughouse:     /* need four players and two boards */
1181       case VariantKriegspiel:   /* need to hide pieces and move details */
1182         /* case VariantFischeRandom: (Fabien: moved below) */
1183         len = snprintf(buf,MSG_SIZ, _("Variant %s supported only in ICS mode"), appData.variant);
1184         if( (len >= MSG_SIZ) && appData.debugMode )
1185           fprintf(debugFP, "InitBackEnd1: buffer truncated.\n");
1186
1187         DisplayFatalError(buf, 0, 2);
1188         return;
1189
1190       case VariantUnknown:
1191       case VariantLoadable:
1192       case Variant29:
1193       case Variant30:
1194       case Variant31:
1195       case Variant32:
1196       case Variant33:
1197       case Variant34:
1198       case Variant35:
1199       case Variant36:
1200       default:
1201         len = snprintf(buf, MSG_SIZ, _("Unknown variant name %s"), appData.variant);
1202         if( (len >= MSG_SIZ) && appData.debugMode )
1203           fprintf(debugFP, "InitBackEnd1: buffer truncated.\n");
1204
1205         DisplayFatalError(buf, 0, 2);
1206         return;
1207
1208       case VariantNormal:     /* definitely works! */
1209         if(strcmp(appData.variant, "normal") && !appData.noChessProgram) { // [HGM] hope this is an engine-defined variant
1210           safeStrCpy(engineVariant, appData.variant, MSG_SIZ);
1211           return;
1212         }
1213       case VariantXiangqi:    /* [HGM] repetition rules not implemented */
1214       case VariantFairy:      /* [HGM] TestLegality definitely off! */
1215       case VariantGothic:     /* [HGM] should work */
1216       case VariantCapablanca: /* [HGM] should work */
1217       case VariantCourier:    /* [HGM] initial forced moves not implemented */
1218       case VariantShogi:      /* [HGM] could still mate with pawn drop */
1219       case VariantChu:        /* [HGM] experimental */
1220       case VariantKnightmate: /* [HGM] should work */
1221       case VariantCylinder:   /* [HGM] untested */
1222       case VariantFalcon:     /* [HGM] untested */
1223       case VariantCrazyhouse: /* holdings not shown, ([HGM] fixed that!)
1224                                  offboard interposition not understood */
1225       case VariantWildCastle: /* pieces not automatically shuffled */
1226       case VariantNoCastle:   /* pieces not automatically shuffled */
1227       case VariantFischeRandom: /* [HGM] works and shuffles pieces */
1228       case VariantLosers:     /* should work except for win condition,
1229                                  and doesn't know captures are mandatory */
1230       case VariantSuicide:    /* should work except for win condition,
1231                                  and doesn't know captures are mandatory */
1232       case VariantGiveaway:   /* should work except for win condition,
1233                                  and doesn't know captures are mandatory */
1234       case VariantTwoKings:   /* should work */
1235       case VariantAtomic:     /* should work except for win condition */
1236       case Variant3Check:     /* should work except for win condition */
1237       case VariantShatranj:   /* should work except for all win conditions */
1238       case VariantMakruk:     /* should work except for draw countdown */
1239       case VariantASEAN :     /* should work except for draw countdown */
1240       case VariantBerolina:   /* might work if TestLegality is off */
1241       case VariantCapaRandom: /* should work */
1242       case VariantJanus:      /* should work */
1243       case VariantSuper:      /* experimental */
1244       case VariantGreat:      /* experimental, requires legality testing to be off */
1245       case VariantSChess:     /* S-Chess, should work */
1246       case VariantGrand:      /* should work */
1247       case VariantSpartan:    /* should work */
1248       case VariantLion:       /* should work */
1249       case VariantChuChess:   /* should work */
1250         break;
1251       }
1252     }
1253
1254 }
1255
1256 int
1257 NextIntegerFromString (char ** str, long * value)
1258 {
1259     int result = -1;
1260     char * s = *str;
1261
1262     while( *s == ' ' || *s == '\t' ) {
1263         s++;
1264     }
1265
1266     *value = 0;
1267
1268     if( *s >= '0' && *s <= '9' ) {
1269         while( *s >= '0' && *s <= '9' ) {
1270             *value = *value * 10 + (*s - '0');
1271             s++;
1272         }
1273
1274         result = 0;
1275     }
1276
1277     *str = s;
1278
1279     return result;
1280 }
1281
1282 int
1283 NextTimeControlFromString (char ** str, long * value)
1284 {
1285     long temp;
1286     int result = NextIntegerFromString( str, &temp );
1287
1288     if( result == 0 ) {
1289         *value = temp * 60; /* Minutes */
1290         if( **str == ':' ) {
1291             (*str)++;
1292             result = NextIntegerFromString( str, &temp );
1293             *value += temp; /* Seconds */
1294         }
1295     }
1296
1297     return result;
1298 }
1299
1300 int
1301 NextSessionFromString (char ** str, int *moves, long * tc, long *inc, int *incType)
1302 {   /* [HGM] routine added to read '+moves/time' for secondary time control. */
1303     int result = -1, type = 0; long temp, temp2;
1304
1305     if(**str != ':') return -1; // old params remain in force!
1306     (*str)++;
1307     if(**str == '*') type = *(*str)++, temp = 0; // sandclock TC
1308     if( NextIntegerFromString( str, &temp ) ) return -1;
1309     if(type) { *moves = 0; *tc = temp * 500; *inc = temp * 1000; *incType = '*'; return 0; }
1310
1311     if(**str != '/') {
1312         /* time only: incremental or sudden-death time control */
1313         if(**str == '+') { /* increment follows; read it */
1314             (*str)++;
1315             if(**str == '!') type = *(*str)++; // Bronstein TC
1316             if(result = NextIntegerFromString( str, &temp2)) return -1;
1317             *inc = temp2 * 1000;
1318             if(**str == '.') { // read fraction of increment
1319                 char *start = ++(*str);
1320                 if(result = NextIntegerFromString( str, &temp2)) return -1;
1321                 temp2 *= 1000;
1322                 while(start++ < *str) temp2 /= 10;
1323                 *inc += temp2;
1324             }
1325         } else *inc = 0;
1326         *moves = 0; *tc = temp * 1000; *incType = type;
1327         return 0;
1328     }
1329
1330     (*str)++; /* classical time control */
1331     result = NextIntegerFromString( str, &temp2); // NOTE: already converted to seconds by ParseTimeControl()
1332
1333     if(result == 0) {
1334         *moves = temp;
1335         *tc    = temp2 * 1000;
1336         *inc   = 0;
1337         *incType = type;
1338     }
1339     return result;
1340 }
1341
1342 int
1343 GetTimeQuota (int movenr, int lastUsed, char *tcString)
1344 {   /* [HGM] get time to add from the multi-session time-control string */
1345     int incType, moves=1; /* kludge to force reading of first session */
1346     long time, increment;
1347     char *s = tcString;
1348
1349     if(!s || !*s) return 0; // empty TC string means we ran out of the last sudden-death version
1350     do {
1351         if(moves) NextSessionFromString(&s, &moves, &time, &increment, &incType);
1352         nextSession = s; suddenDeath = moves == 0 && increment == 0;
1353         if(movenr == -1) return time;    /* last move before new session     */
1354         if(incType == '*') increment = 0; else // for sandclock, time is added while not thinking
1355         if(incType == '!' && lastUsed < increment) increment = lastUsed;
1356         if(!moves) return increment;     /* current session is incremental   */
1357         if(movenr >= 0) movenr -= moves; /* we already finished this session */
1358     } while(movenr >= -1);               /* try again for next session       */
1359
1360     return 0; // no new time quota on this move
1361 }
1362
1363 int
1364 ParseTimeControl (char *tc, float ti, int mps)
1365 {
1366   long tc1;
1367   long tc2;
1368   char buf[MSG_SIZ], buf2[MSG_SIZ], *mytc = tc;
1369   int min, sec=0;
1370
1371   if(ti >= 0 && !strchr(tc, '+') && !strchr(tc, '/') ) mps = 0;
1372   if(!strchr(tc, '+') && !strchr(tc, '/') && sscanf(tc, "%d:%d", &min, &sec) >= 1)
1373       sprintf(mytc=buf2, "%d", 60*min+sec); // convert 'classical' min:sec tc string to seconds
1374   if(ti > 0) {
1375
1376     if(mps)
1377       snprintf(buf, MSG_SIZ, ":%d/%s+%g", mps, mytc, ti);
1378     else
1379       snprintf(buf, MSG_SIZ, ":%s+%g", mytc, ti);
1380   } else {
1381     if(mps)
1382       snprintf(buf, MSG_SIZ, ":%d/%s", mps, mytc);
1383     else
1384       snprintf(buf, MSG_SIZ, ":%s", mytc);
1385   }
1386   fullTimeControlString = StrSave(buf); // this should now be in PGN format
1387
1388   if( NextTimeControlFromString( &tc, &tc1 ) != 0 ) {
1389     return FALSE;
1390   }
1391
1392   if( *tc == '/' ) {
1393     /* Parse second time control */
1394     tc++;
1395
1396     if( NextTimeControlFromString( &tc, &tc2 ) != 0 ) {
1397       return FALSE;
1398     }
1399
1400     if( tc2 == 0 ) {
1401       return FALSE;
1402     }
1403
1404     timeControl_2 = tc2 * 1000;
1405   }
1406   else {
1407     timeControl_2 = 0;
1408   }
1409
1410   if( tc1 == 0 ) {
1411     return FALSE;
1412   }
1413
1414   timeControl = tc1 * 1000;
1415
1416   if (ti >= 0) {
1417     timeIncrement = ti * 1000;  /* convert to ms */
1418     movesPerSession = 0;
1419   } else {
1420     timeIncrement = 0;
1421     movesPerSession = mps;
1422   }
1423   return TRUE;
1424 }
1425
1426 void
1427 InitBackEnd2 ()
1428 {
1429     if (appData.debugMode) {
1430 #    ifdef __GIT_VERSION
1431       fprintf(debugFP, "Version: %s (%s)\n", programVersion, __GIT_VERSION);
1432 #    else
1433       fprintf(debugFP, "Version: %s\n", programVersion);
1434 #    endif
1435     }
1436     ASSIGN(currentDebugFile, appData.nameOfDebugFile); // [HGM] debug split: remember initial name in use
1437
1438     set_cont_sequence(appData.wrapContSeq);
1439     if (appData.matchGames > 0) {
1440         appData.matchMode = TRUE;
1441     } else if (appData.matchMode) {
1442         appData.matchGames = 1;
1443     }
1444     if(appData.matchMode && appData.sameColorGames > 0) /* [HGM] alternate: overrule matchGames */
1445         appData.matchGames = appData.sameColorGames;
1446     if(appData.rewindIndex > 1) { /* [HGM] autoinc: rewind implies auto-increment and overrules given index */
1447         if(appData.loadPositionIndex >= 0) appData.loadPositionIndex = -1;
1448         if(appData.loadGameIndex >= 0) appData.loadGameIndex = -1;
1449     }
1450     Reset(TRUE, FALSE);
1451     if (appData.noChessProgram || first.protocolVersion == 1) {
1452       InitBackEnd3();
1453     } else {
1454       /* kludge: allow timeout for initial "feature" commands */
1455       FreezeUI();
1456       DisplayMessage("", _("Starting chess program"));
1457       ScheduleDelayedEvent(InitBackEnd3, FEATURE_TIMEOUT);
1458     }
1459 }
1460
1461 int
1462 CalculateIndex (int index, int gameNr)
1463 {   // [HGM] autoinc: absolute way to determine load index from game number (taking auto-inc and rewind into account)
1464     int res;
1465     if(index > 0) return index; // fixed nmber
1466     if(index == 0) return 1;
1467     res = (index == -1 ? gameNr : (gameNr-1)/2 + 1); // autoinc
1468     if(appData.rewindIndex > 0) res = (res-1) % appData.rewindIndex + 1; // rewind
1469     return res;
1470 }
1471
1472 int
1473 LoadGameOrPosition (int gameNr)
1474 {   // [HGM] taken out of MatchEvent and NextMatchGame (to combine it)
1475     if (*appData.loadGameFile != NULLCHAR) {
1476         if (!LoadGameFromFile(appData.loadGameFile,
1477                 CalculateIndex(appData.loadGameIndex, gameNr),
1478                               appData.loadGameFile, FALSE)) {
1479             DisplayFatalError(_("Bad game file"), 0, 1);
1480             return 0;
1481         }
1482     } else if (*appData.loadPositionFile != NULLCHAR) {
1483         if (!LoadPositionFromFile(appData.loadPositionFile,
1484                 CalculateIndex(appData.loadPositionIndex, gameNr),
1485                                   appData.loadPositionFile)) {
1486             DisplayFatalError(_("Bad position file"), 0, 1);
1487             return 0;
1488         }
1489     }
1490     return 1;
1491 }
1492
1493 void
1494 ReserveGame (int gameNr, char resChar)
1495 {
1496     FILE *tf = fopen(appData.tourneyFile, "r+");
1497     char *p, *q, c, buf[MSG_SIZ];
1498     if(tf == NULL) { nextGame = appData.matchGames + 1; return; } // kludge to terminate match
1499     safeStrCpy(buf, lastMsg, MSG_SIZ);
1500     DisplayMessage(_("Pick new game"), "");
1501     flock(fileno(tf), LOCK_EX); // lock the tourney file while we are messing with it
1502     ParseArgsFromFile(tf);
1503     p = q = appData.results;
1504     if(appData.debugMode) {
1505       char *r = appData.participants;
1506       fprintf(debugFP, "results = '%s'\n", p);
1507       while(*r) fprintf(debugFP, *r >= ' ' ? "%c" : "\\%03o", *r), r++;
1508       fprintf(debugFP, "\n");
1509     }
1510     while(*q && *q != ' ') q++; // get first un-played game (could be beyond end!)
1511     nextGame = q - p;
1512     q = malloc(strlen(p) + 2); // could be arbitrary long, but allow to extend by one!
1513     safeStrCpy(q, p, strlen(p) + 2);
1514     if(gameNr >= 0) q[gameNr] = resChar; // replace '*' with result
1515     if(appData.debugMode) fprintf(debugFP, "pick next game from '%s': %d\n", q, nextGame);
1516     if(nextGame <= appData.matchGames && resChar != ' ' && !abortMatch) { // reserve next game if tourney not yet done
1517         if(q[nextGame] == NULLCHAR) q[nextGame+1] = NULLCHAR; // append one char
1518         q[nextGame] = '*';
1519     }
1520     fseek(tf, -(strlen(p)+4), SEEK_END);
1521     c = fgetc(tf);
1522     if(c != '"') // depending on DOS or Unix line endings we can be one off
1523          fseek(tf, -(strlen(p)+2), SEEK_END);
1524     else fseek(tf, -(strlen(p)+3), SEEK_END);
1525     fprintf(tf, "%s\"\n", q); fclose(tf); // update, and flush by closing
1526     DisplayMessage(buf, "");
1527     free(p); appData.results = q;
1528     if(nextGame <= appData.matchGames && resChar != ' ' && !abortMatch &&
1529        (gameNr < 0 || nextGame / appData.defaultMatchGames != gameNr / appData.defaultMatchGames)) {
1530       int round = appData.defaultMatchGames * appData.tourneyType;
1531       if(gameNr < 0 || appData.tourneyType < 1 ||  // gauntlet engine can always stay loaded as first engine
1532          appData.tourneyType > 1 && nextGame/round != gameNr/round) // in multi-gauntlet change only after round
1533         UnloadEngine(&first);  // next game belongs to other pairing;
1534         UnloadEngine(&second); // already unload the engines, so TwoMachinesEvent will load new ones.
1535     }
1536     if(appData.debugMode) fprintf(debugFP, "Reserved, next=%d, nr=%d\n", nextGame, gameNr);
1537 }
1538
1539 void
1540 MatchEvent (int mode)
1541 {       // [HGM] moved out of InitBackend3, to make it callable when match starts through menu
1542         int dummy;
1543         if(matchMode) { // already in match mode: switch it off
1544             abortMatch = TRUE;
1545             if(!appData.tourneyFile[0]) appData.matchGames = matchGame; // kludge to let match terminate after next game.
1546             return;
1547         }
1548 //      if(gameMode != BeginningOfGame) {
1549 //          DisplayError(_("You can only start a match from the initial position."), 0);
1550 //          return;
1551 //      }
1552         abortMatch = FALSE;
1553         if(mode == 2) appData.matchGames = appData.defaultMatchGames;
1554         /* Set up machine vs. machine match */
1555         nextGame = 0;
1556         NextTourneyGame(-1, &dummy); // sets appData.matchGames if this is tourney, to make sure ReserveGame knows it
1557         if(appData.tourneyFile[0]) {
1558             ReserveGame(-1, 0);
1559             if(nextGame > appData.matchGames) {
1560                 char buf[MSG_SIZ];
1561                 if(strchr(appData.results, '*') == NULL) {
1562                     FILE *f;
1563                     appData.tourneyCycles++;
1564                     if(f = WriteTourneyFile(appData.results, NULL)) { // make a tourney file with increased number of cycles
1565                         fclose(f);
1566                         NextTourneyGame(-1, &dummy);
1567                         ReserveGame(-1, 0);
1568                         if(nextGame <= appData.matchGames) {
1569                             DisplayNote(_("You restarted an already completed tourney.\nOne more cycle will now be added to it.\nGames commence in 10 sec."));
1570                             matchMode = mode;
1571                             ScheduleDelayedEvent(NextMatchGame, 10000);
1572                             return;
1573                         }
1574                     }
1575                 }
1576                 snprintf(buf, MSG_SIZ, _("All games in tourney '%s' are already played or playing"), appData.tourneyFile);
1577                 DisplayError(buf, 0);
1578                 appData.tourneyFile[0] = 0;
1579                 return;
1580             }
1581         } else
1582         if (appData.noChessProgram) {  // [HGM] in tourney engines are loaded automatically
1583             DisplayFatalError(_("Can't have a match with no chess programs"),
1584                               0, 2);
1585             return;
1586         }
1587         matchMode = mode;
1588         matchGame = roundNr = 1;
1589         first.matchWins = second.matchWins = 0; // [HGM] match: needed in later matches
1590         NextMatchGame();
1591 }
1592
1593 char *comboLine = NULL; // [HGM] recent: WinBoard's first-engine combobox line
1594
1595 void
1596 InitBackEnd3 P((void))
1597 {
1598     GameMode initialMode;
1599     char buf[MSG_SIZ];
1600     int err, len;
1601
1602     if(!appData.icsActive && !appData.noChessProgram && !appData.matchMode &&                         // mode involves only first engine
1603        !strcmp(appData.variant, "normal") &&                                                          // no explicit variant request
1604         appData.NrRanks == -1 && appData.NrFiles == -1 && appData.holdingsSize == -1 &&               // no size overrides requested
1605        !SupportedVariant(first.variants, VariantNormal, 8, 8, 0, first.protocolVersion, "") &&        // but 'normal' won't work with engine
1606        !SupportedVariant(first.variants, VariantFischeRandom, 8, 8, 0, first.protocolVersion, "") ) { // nor will Chess960
1607         char c, *q = first.variants, *p = strchr(q, ',');
1608         if(p) *p = NULLCHAR;
1609         if(StringToVariant(q) != VariantUnknown) { // the engine can play a recognized variant, however
1610             int w, h, s;
1611             if(sscanf(q, "%dx%d+%d_%c", &w, &h, &s, &c) == 4) // get size overrides the engine needs with it (if any)
1612                 appData.NrFiles = w, appData.NrRanks = h, appData.holdingsSize = s, q = strchr(q, '_') + 1;
1613             ASSIGN(appData.variant, q); // fake user requested the first variant played by the engine
1614             Reset(TRUE, FALSE);         // and re-initialize
1615         }
1616         if(p) *p = ',';
1617     }
1618
1619     InitChessProgram(&first, startedFromSetupPosition);
1620
1621     if(!appData.noChessProgram) {  /* [HGM] tidy: redo program version to use name from myname feature */
1622         free(programVersion);
1623         programVersion = (char*) malloc(8 + strlen(PACKAGE_STRING) + strlen(first.tidy));
1624         sprintf(programVersion, "%s + %s", PACKAGE_STRING, first.tidy);
1625         FloatToFront(&appData.recentEngineList, comboLine ? comboLine : appData.firstChessProgram);
1626     }
1627
1628     if (appData.icsActive) {
1629 #ifdef WIN32
1630         /* [DM] Make a console window if needed [HGM] merged ifs */
1631         ConsoleCreate();
1632 #endif
1633         err = establish();
1634         if (err != 0)
1635           {
1636             if (*appData.icsCommPort != NULLCHAR)
1637               len = snprintf(buf, MSG_SIZ, _("Could not open comm port %s"),
1638                              appData.icsCommPort);
1639             else
1640               len = snprintf(buf, MSG_SIZ, _("Could not connect to host %s, port %s"),
1641                         appData.icsHost, appData.icsPort);
1642
1643             if( (len >= MSG_SIZ) && appData.debugMode )
1644               fprintf(debugFP, "InitBackEnd3: buffer truncated.\n");
1645
1646             DisplayFatalError(buf, err, 1);
1647             return;
1648         }
1649         SetICSMode();
1650         telnetISR =
1651           AddInputSource(icsPR, FALSE, read_from_ics, &telnetISR);
1652         fromUserISR =
1653           AddInputSource(NoProc, FALSE, read_from_player, &fromUserISR);
1654         if(appData.keepAlive) // [HGM] alive: schedule sending of dummy 'date' command
1655             ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
1656     } else if (appData.noChessProgram) {
1657         SetNCPMode();
1658     } else {
1659         SetGNUMode();
1660     }
1661
1662     if (*appData.cmailGameName != NULLCHAR) {
1663         SetCmailMode();
1664         OpenLoopback(&cmailPR);
1665         cmailISR =
1666           AddInputSource(cmailPR, FALSE, CmailSigHandlerCallBack, &cmailISR);
1667     }
1668
1669     ThawUI();
1670     DisplayMessage("", "");
1671     if (StrCaseCmp(appData.initialMode, "") == 0) {
1672       initialMode = BeginningOfGame;
1673       if(!appData.icsActive && appData.noChessProgram) { // [HGM] could be fall-back
1674         gameMode = MachinePlaysBlack; // "Machine Black" might have been implicitly highlighted
1675         ModeHighlight(); // make sure XBoard knows it is highlighted, so it will un-highlight it
1676         gameMode = BeginningOfGame; // in case BeginningOfGame now means "Edit Position"
1677         ModeHighlight();
1678       }
1679     } else if (StrCaseCmp(appData.initialMode, "TwoMachines") == 0) {
1680       initialMode = TwoMachinesPlay;
1681     } else if (StrCaseCmp(appData.initialMode, "AnalyzeFile") == 0) {
1682       initialMode = AnalyzeFile;
1683     } else if (StrCaseCmp(appData.initialMode, "Analysis") == 0) {
1684       initialMode = AnalyzeMode;
1685     } else if (StrCaseCmp(appData.initialMode, "MachineWhite") == 0) {
1686       initialMode = MachinePlaysWhite;
1687     } else if (StrCaseCmp(appData.initialMode, "MachineBlack") == 0) {
1688       initialMode = MachinePlaysBlack;
1689     } else if (StrCaseCmp(appData.initialMode, "EditGame") == 0) {
1690       initialMode = EditGame;
1691     } else if (StrCaseCmp(appData.initialMode, "EditPosition") == 0) {
1692       initialMode = EditPosition;
1693     } else if (StrCaseCmp(appData.initialMode, "Training") == 0) {
1694       initialMode = Training;
1695     } else {
1696       len = snprintf(buf, MSG_SIZ, _("Unknown initialMode %s"), appData.initialMode);
1697       if( (len >= MSG_SIZ) && appData.debugMode )
1698         fprintf(debugFP, "InitBackEnd3: buffer truncated.\n");
1699
1700       DisplayFatalError(buf, 0, 2);
1701       return;
1702     }
1703
1704     if (appData.matchMode) {
1705         if(appData.tourneyFile[0]) { // start tourney from command line
1706             FILE *f;
1707             if(f = fopen(appData.tourneyFile, "r")) {
1708                 ParseArgsFromFile(f); // make sure tourney parmeters re known
1709                 fclose(f);
1710                 appData.clockMode = TRUE;
1711                 SetGNUMode();
1712             } else appData.tourneyFile[0] = NULLCHAR; // for now ignore bad tourney file
1713         }
1714         MatchEvent(TRUE);
1715     } else if (*appData.cmailGameName != NULLCHAR) {
1716         /* Set up cmail mode */
1717         ReloadCmailMsgEvent(TRUE);
1718     } else {
1719         /* Set up other modes */
1720         if (initialMode == AnalyzeFile) {
1721           if (*appData.loadGameFile == NULLCHAR) {
1722             DisplayFatalError(_("AnalyzeFile mode requires a game file"), 0, 1);
1723             return;
1724           }
1725         }
1726         if (*appData.loadGameFile != NULLCHAR) {
1727             (void) LoadGameFromFile(appData.loadGameFile,
1728                                     appData.loadGameIndex,
1729                                     appData.loadGameFile, TRUE);
1730         } else if (*appData.loadPositionFile != NULLCHAR) {
1731             (void) LoadPositionFromFile(appData.loadPositionFile,
1732                                         appData.loadPositionIndex,
1733                                         appData.loadPositionFile);
1734             /* [HGM] try to make self-starting even after FEN load */
1735             /* to allow automatic setup of fairy variants with wtm */
1736             if(initialMode == BeginningOfGame && !blackPlaysFirst) {
1737                 gameMode = BeginningOfGame;
1738                 setboardSpoiledMachineBlack = 1;
1739             }
1740             /* [HGM] loadPos: make that every new game uses the setup */
1741             /* from file as long as we do not switch variant          */
1742             if(!blackPlaysFirst) {
1743                 startedFromPositionFile = TRUE;
1744                 CopyBoard(filePosition, boards[0]);
1745                 CopyBoard(initialPosition, boards[0]);
1746             }
1747         } else if(*appData.fen != NULLCHAR) {
1748             if(ParseFEN(filePosition, &blackPlaysFirst, appData.fen, TRUE) && !blackPlaysFirst) {
1749                 startedFromPositionFile = TRUE;
1750                 Reset(TRUE, TRUE);
1751             }
1752         }
1753         if (initialMode == AnalyzeMode) {
1754           if (appData.noChessProgram) {
1755             DisplayFatalError(_("Analysis mode requires a chess engine"), 0, 2);
1756             return;
1757           }
1758           if (appData.icsActive) {
1759             DisplayFatalError(_("Analysis mode does not work with ICS mode"),0,2);
1760             return;
1761           }
1762           AnalyzeModeEvent();
1763         } else if (initialMode == AnalyzeFile) {
1764           appData.showThinking = TRUE; // [HGM] thinking: moved out of ShowThinkingEvent
1765           ShowThinkingEvent();
1766           AnalyzeFileEvent();
1767           AnalysisPeriodicEvent(1);
1768         } else if (initialMode == MachinePlaysWhite) {
1769           if (appData.noChessProgram) {
1770             DisplayFatalError(_("MachineWhite mode requires a chess engine"),
1771                               0, 2);
1772             return;
1773           }
1774           if (appData.icsActive) {
1775             DisplayFatalError(_("MachineWhite mode does not work with ICS mode"),
1776                               0, 2);
1777             return;
1778           }
1779           MachineWhiteEvent();
1780         } else if (initialMode == MachinePlaysBlack) {
1781           if (appData.noChessProgram) {
1782             DisplayFatalError(_("MachineBlack mode requires a chess engine"),
1783                               0, 2);
1784             return;
1785           }
1786           if (appData.icsActive) {
1787             DisplayFatalError(_("MachineBlack mode does not work with ICS mode"),
1788                               0, 2);
1789             return;
1790           }
1791           MachineBlackEvent();
1792         } else if (initialMode == TwoMachinesPlay) {
1793           if (appData.noChessProgram) {
1794             DisplayFatalError(_("TwoMachines mode requires a chess engine"),
1795                               0, 2);
1796             return;
1797           }
1798           if (appData.icsActive) {
1799             DisplayFatalError(_("TwoMachines mode does not work with ICS mode"),
1800                               0, 2);
1801             return;
1802           }
1803           TwoMachinesEvent();
1804         } else if (initialMode == EditGame) {
1805           EditGameEvent();
1806         } else if (initialMode == EditPosition) {
1807           EditPositionEvent();
1808         } else if (initialMode == Training) {
1809           if (*appData.loadGameFile == NULLCHAR) {
1810             DisplayFatalError(_("Training mode requires a game file"), 0, 2);
1811             return;
1812           }
1813           TrainingEvent();
1814         }
1815     }
1816 }
1817
1818 void
1819 HistorySet (char movelist[][2*MOVE_LEN], int first, int last, int current)
1820 {
1821     DisplayBook(current+1);
1822
1823     MoveHistorySet( movelist, first, last, current, pvInfoList );
1824
1825     EvalGraphSet( first, last, current, pvInfoList );
1826
1827     MakeEngineOutputTitle();
1828 }
1829
1830 /*
1831  * Establish will establish a contact to a remote host.port.
1832  * Sets icsPR to a ProcRef for a process (or pseudo-process)
1833  *  used to talk to the host.
1834  * Returns 0 if okay, error code if not.
1835  */
1836 int
1837 establish ()
1838 {
1839     char buf[MSG_SIZ];
1840
1841     if (*appData.icsCommPort != NULLCHAR) {
1842         /* Talk to the host through a serial comm port */
1843         return OpenCommPort(appData.icsCommPort, &icsPR);
1844
1845     } else if (*appData.gateway != NULLCHAR) {
1846         if (*appData.remoteShell == NULLCHAR) {
1847             /* Use the rcmd protocol to run telnet program on a gateway host */
1848             snprintf(buf, sizeof(buf), "%s %s %s",
1849                     appData.telnetProgram, appData.icsHost, appData.icsPort);
1850             return OpenRcmd(appData.gateway, appData.remoteUser, buf, &icsPR);
1851
1852         } else {
1853             /* Use the rsh program to run telnet program on a gateway host */
1854             if (*appData.remoteUser == NULLCHAR) {
1855                 snprintf(buf, sizeof(buf), "%s %s %s %s %s", appData.remoteShell,
1856                         appData.gateway, appData.telnetProgram,
1857                         appData.icsHost, appData.icsPort);
1858             } else {
1859                 snprintf(buf, sizeof(buf), "%s %s -l %s %s %s %s",
1860                         appData.remoteShell, appData.gateway,
1861                         appData.remoteUser, appData.telnetProgram,
1862                         appData.icsHost, appData.icsPort);
1863             }
1864             return StartChildProcess(buf, "", &icsPR);
1865
1866         }
1867     } else if (appData.useTelnet) {
1868         return OpenTelnet(appData.icsHost, appData.icsPort, &icsPR);
1869
1870     } else {
1871         /* TCP socket interface differs somewhat between
1872            Unix and NT; handle details in the front end.
1873            */
1874         return OpenTCP(appData.icsHost, appData.icsPort, &icsPR);
1875     }
1876 }
1877
1878 void
1879 EscapeExpand (char *p, char *q)
1880 {       // [HGM] initstring: routine to shape up string arguments
1881         while(*p++ = *q++) if(p[-1] == '\\')
1882             switch(*q++) {
1883                 case 'n': p[-1] = '\n'; break;
1884                 case 'r': p[-1] = '\r'; break;
1885                 case 't': p[-1] = '\t'; break;
1886                 case '\\': p[-1] = '\\'; break;
1887                 case 0: *p = 0; return;
1888                 default: p[-1] = q[-1]; break;
1889             }
1890 }
1891
1892 void
1893 show_bytes (FILE *fp, char *buf, int count)
1894 {
1895     while (count--) {
1896         if (*buf < 040 || *(unsigned char *) buf > 0177) {
1897             fprintf(fp, "\\%03o", *buf & 0xff);
1898         } else {
1899             putc(*buf, fp);
1900         }
1901         buf++;
1902     }
1903     fflush(fp);
1904 }
1905
1906 /* Returns an errno value */
1907 int
1908 OutputMaybeTelnet (ProcRef pr, char *message, int count, int *outError)
1909 {
1910     char buf[8192], *p, *q, *buflim;
1911     int left, newcount, outcount;
1912
1913     if (*appData.icsCommPort != NULLCHAR || appData.useTelnet ||
1914         *appData.gateway != NULLCHAR) {
1915         if (appData.debugMode) {
1916             fprintf(debugFP, ">ICS: ");
1917             show_bytes(debugFP, message, count);
1918             fprintf(debugFP, "\n");
1919         }
1920         return OutputToProcess(pr, message, count, outError);
1921     }
1922
1923     buflim = &buf[sizeof(buf)-1]; /* allow 1 byte for expanding last char */
1924     p = message;
1925     q = buf;
1926     left = count;
1927     newcount = 0;
1928     while (left) {
1929         if (q >= buflim) {
1930             if (appData.debugMode) {
1931                 fprintf(debugFP, ">ICS: ");
1932                 show_bytes(debugFP, buf, newcount);
1933                 fprintf(debugFP, "\n");
1934             }
1935             outcount = OutputToProcess(pr, buf, newcount, outError);
1936             if (outcount < newcount) return -1; /* to be sure */
1937             q = buf;
1938             newcount = 0;
1939         }
1940         if (*p == '\n') {
1941             *q++ = '\r';
1942             newcount++;
1943         } else if (((unsigned char) *p) == TN_IAC) {
1944             *q++ = (char) TN_IAC;
1945             newcount ++;
1946         }
1947         *q++ = *p++;
1948         newcount++;
1949         left--;
1950     }
1951     if (appData.debugMode) {
1952         fprintf(debugFP, ">ICS: ");
1953         show_bytes(debugFP, buf, newcount);
1954         fprintf(debugFP, "\n");
1955     }
1956     outcount = OutputToProcess(pr, buf, newcount, outError);
1957     if (outcount < newcount) return -1; /* to be sure */
1958     return count;
1959 }
1960
1961 void
1962 read_from_player (InputSourceRef isr, VOIDSTAR closure, char *message, int count, int error)
1963 {
1964     int outError, outCount;
1965     static int gotEof = 0;
1966     static FILE *ini;
1967
1968     /* Pass data read from player on to ICS */
1969     if (count > 0) {
1970         gotEof = 0;
1971         outCount = OutputMaybeTelnet(icsPR, message, count, &outError);
1972         if (outCount < count) {
1973             DisplayFatalError(_("Error writing to ICS"), outError, 1);
1974         }
1975         if(have_sent_ICS_logon == 2) {
1976           if(ini = fopen(appData.icsLogon, "w")) { // save first two lines (presumably username & password) on init script file
1977             fprintf(ini, "%s", message);
1978             have_sent_ICS_logon = 3;
1979           } else
1980             have_sent_ICS_logon = 1;
1981         } else if(have_sent_ICS_logon == 3) {
1982             fprintf(ini, "%s", message);
1983             fclose(ini);
1984           have_sent_ICS_logon = 1;
1985         }
1986     } else if (count < 0) {
1987         RemoveInputSource(isr);
1988         DisplayFatalError(_("Error reading from keyboard"), error, 1);
1989     } else if (gotEof++ > 0) {
1990         RemoveInputSource(isr);
1991         DisplayFatalError(_("Got end of file from keyboard"), 0, 666); // [HGM] 666 is kludge to alert front end
1992     }
1993 }
1994
1995 void
1996 KeepAlive ()
1997 {   // [HGM] alive: periodically send dummy (date) command to ICS to prevent time-out
1998     if(!connectionAlive) DisplayFatalError("No response from ICS", 0, 1);
1999     connectionAlive = FALSE; // only sticks if no response to 'date' command.
2000     SendToICS("date\n");
2001     if(appData.keepAlive) ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
2002 }
2003
2004 /* added routine for printf style output to ics */
2005 void
2006 ics_printf (char *format, ...)
2007 {
2008     char buffer[MSG_SIZ];
2009     va_list args;
2010
2011     va_start(args, format);
2012     vsnprintf(buffer, sizeof(buffer), format, args);
2013     buffer[sizeof(buffer)-1] = '\0';
2014     SendToICS(buffer);
2015     va_end(args);
2016 }
2017
2018 void
2019 SendToICS (char *s)
2020 {
2021     int count, outCount, outError;
2022
2023     if (icsPR == NoProc) return;
2024
2025     count = strlen(s);
2026     outCount = OutputMaybeTelnet(icsPR, s, count, &outError);
2027     if (outCount < count) {
2028         DisplayFatalError(_("Error writing to ICS"), outError, 1);
2029     }
2030 }
2031
2032 /* This is used for sending logon scripts to the ICS. Sending
2033    without a delay causes problems when using timestamp on ICC
2034    (at least on my machine). */
2035 void
2036 SendToICSDelayed (char *s, long msdelay)
2037 {
2038     int count, outCount, outError;
2039
2040     if (icsPR == NoProc) return;
2041
2042     count = strlen(s);
2043     if (appData.debugMode) {
2044         fprintf(debugFP, ">ICS: ");
2045         show_bytes(debugFP, s, count);
2046         fprintf(debugFP, "\n");
2047     }
2048     outCount = OutputToProcessDelayed(icsPR, s, count, &outError,
2049                                       msdelay);
2050     if (outCount < count) {
2051         DisplayFatalError(_("Error writing to ICS"), outError, 1);
2052     }
2053 }
2054
2055
2056 /* Remove all highlighting escape sequences in s
2057    Also deletes any suffix starting with '('
2058    */
2059 char *
2060 StripHighlightAndTitle (char *s)
2061 {
2062     static char retbuf[MSG_SIZ];
2063     char *p = retbuf;
2064
2065     while (*s != NULLCHAR) {
2066         while (*s == '\033') {
2067             while (*s != NULLCHAR && !isalpha(*s)) s++;
2068             if (*s != NULLCHAR) s++;
2069         }
2070         while (*s != NULLCHAR && *s != '\033') {
2071             if (*s == '(' || *s == '[') {
2072                 *p = NULLCHAR;
2073                 return retbuf;
2074             }
2075             *p++ = *s++;
2076         }
2077     }
2078     *p = NULLCHAR;
2079     return retbuf;
2080 }
2081
2082 /* Remove all highlighting escape sequences in s */
2083 char *
2084 StripHighlight (char *s)
2085 {
2086     static char retbuf[MSG_SIZ];
2087     char *p = retbuf;
2088
2089     while (*s != NULLCHAR) {
2090         while (*s == '\033') {
2091             while (*s != NULLCHAR && !isalpha(*s)) s++;
2092             if (*s != NULLCHAR) s++;
2093         }
2094         while (*s != NULLCHAR && *s != '\033') {
2095             *p++ = *s++;
2096         }
2097     }
2098     *p = NULLCHAR;
2099     return retbuf;
2100 }
2101
2102 char engineVariant[MSG_SIZ];
2103 char *variantNames[] = VARIANT_NAMES;
2104 char *
2105 VariantName (VariantClass v)
2106 {
2107     if(v == VariantUnknown || *engineVariant) return engineVariant;
2108     return variantNames[v];
2109 }
2110
2111
2112 /* Identify a variant from the strings the chess servers use or the
2113    PGN Variant tag names we use. */
2114 VariantClass
2115 StringToVariant (char *e)
2116 {
2117     char *p;
2118     int wnum = -1;
2119     VariantClass v = VariantNormal;
2120     int i, found = FALSE;
2121     char buf[MSG_SIZ], c;
2122     int len;
2123
2124     if (!e) return v;
2125
2126     /* [HGM] skip over optional board-size prefixes */
2127     if( sscanf(e, "%dx%d_%c", &i, &i, &c) == 3 ||
2128         sscanf(e, "%dx%d+%d_%c", &i, &i, &i, &c) == 4 ) {
2129         while( *e++ != '_');
2130     }
2131
2132     if(StrCaseStr(e, "misc/")) { // [HGM] on FICS, misc/shogi is not shogi
2133         v = VariantNormal;
2134         found = TRUE;
2135     } else
2136     for (i=0; i<sizeof(variantNames)/sizeof(char*); i++) {
2137       if (p = StrCaseStr(e, variantNames[i])) {
2138         if(p && i >= VariantShogi && (p != e && !appData.icsActive || isalpha(p[strlen(variantNames[i])]))) continue;
2139         v = (VariantClass) i;
2140         found = TRUE;
2141         break;
2142       }
2143     }
2144
2145     if (!found) {
2146       if ((StrCaseStr(e, "fischer") && StrCaseStr(e, "random"))
2147           || StrCaseStr(e, "wild/fr")
2148           || StrCaseStr(e, "frc") || StrCaseStr(e, "960")) {
2149         v = VariantFischeRandom;
2150       } else if ((i = 4, p = StrCaseStr(e, "wild")) ||
2151                  (i = 1, p = StrCaseStr(e, "w"))) {
2152         p += i;
2153         while (*p && (isspace(*p) || *p == '(' || *p == '/')) p++;
2154         if (isdigit(*p)) {
2155           wnum = atoi(p);
2156         } else {
2157           wnum = -1;
2158         }
2159         switch (wnum) {
2160         case 0: /* FICS only, actually */
2161         case 1:
2162           /* Castling legal even if K starts on d-file */
2163           v = VariantWildCastle;
2164           break;
2165         case 2:
2166         case 3:
2167         case 4:
2168           /* Castling illegal even if K & R happen to start in
2169              normal positions. */
2170           v = VariantNoCastle;
2171           break;
2172         case 5:
2173         case 7:
2174         case 8:
2175         case 10:
2176         case 11:
2177         case 12:
2178         case 13:
2179         case 14:
2180         case 15:
2181         case 18:
2182         case 19:
2183           /* Castling legal iff K & R start in normal positions */
2184           v = VariantNormal;
2185           break;
2186         case 6:
2187         case 20:
2188         case 21:
2189           /* Special wilds for position setup; unclear what to do here */
2190           v = VariantLoadable;
2191           break;
2192         case 9:
2193           /* Bizarre ICC game */
2194           v = VariantTwoKings;
2195           break;
2196         case 16:
2197           v = VariantKriegspiel;
2198           break;
2199         case 17:
2200           v = VariantLosers;
2201           break;
2202         case 22:
2203           v = VariantFischeRandom;
2204           break;
2205         case 23:
2206           v = VariantCrazyhouse;
2207           break;
2208         case 24:
2209           v = VariantBughouse;
2210           break;
2211         case 25:
2212           v = Variant3Check;
2213           break;
2214         case 26:
2215           /* Not quite the same as FICS suicide! */
2216           v = VariantGiveaway;
2217           break;
2218         case 27:
2219           v = VariantAtomic;
2220           break;
2221         case 28:
2222           v = VariantShatranj;
2223           break;
2224
2225         /* Temporary names for future ICC types.  The name *will* change in
2226            the next xboard/WinBoard release after ICC defines it. */
2227         case 29:
2228           v = Variant29;
2229           break;
2230         case 30:
2231           v = Variant30;
2232           break;
2233         case 31:
2234           v = Variant31;
2235           break;
2236         case 32:
2237           v = Variant32;
2238           break;
2239         case 33:
2240           v = Variant33;
2241           break;
2242         case 34:
2243           v = Variant34;
2244           break;
2245         case 35:
2246           v = Variant35;
2247           break;
2248         case 36:
2249           v = Variant36;
2250           break;
2251         case 37:
2252           v = VariantShogi;
2253           break;
2254         case 38:
2255           v = VariantXiangqi;
2256           break;
2257         case 39:
2258           v = VariantCourier;
2259           break;
2260         case 40:
2261           v = VariantGothic;
2262           break;
2263         case 41:
2264           v = VariantCapablanca;
2265           break;
2266         case 42:
2267           v = VariantKnightmate;
2268           break;
2269         case 43:
2270           v = VariantFairy;
2271           break;
2272         case 44:
2273           v = VariantCylinder;
2274           break;
2275         case 45:
2276           v = VariantFalcon;
2277           break;
2278         case 46:
2279           v = VariantCapaRandom;
2280           break;
2281         case 47:
2282           v = VariantBerolina;
2283           break;
2284         case 48:
2285           v = VariantJanus;
2286           break;
2287         case 49:
2288           v = VariantSuper;
2289           break;
2290         case 50:
2291           v = VariantGreat;
2292           break;
2293         case -1:
2294           /* Found "wild" or "w" in the string but no number;
2295              must assume it's normal chess. */
2296           v = VariantNormal;
2297           break;
2298         default:
2299           len = snprintf(buf, MSG_SIZ, _("Unknown wild type %d"), wnum);
2300           if( (len >= MSG_SIZ) && appData.debugMode )
2301             fprintf(debugFP, "StringToVariant: buffer truncated.\n");
2302
2303           DisplayError(buf, 0);
2304           v = VariantUnknown;
2305           break;
2306         }
2307       }
2308     }
2309     if (appData.debugMode) {
2310       fprintf(debugFP, "recognized '%s' (%d) as variant %s\n",
2311               e, wnum, VariantName(v));
2312     }
2313     return v;
2314 }
2315
2316 static int leftover_start = 0, leftover_len = 0;
2317 char star_match[STAR_MATCH_N][MSG_SIZ];
2318
2319 /* Test whether pattern is present at &buf[*index]; if so, return TRUE,
2320    advance *index beyond it, and set leftover_start to the new value of
2321    *index; else return FALSE.  If pattern contains the character '*', it
2322    matches any sequence of characters not containing '\r', '\n', or the
2323    character following the '*' (if any), and the matched sequence(s) are
2324    copied into star_match.
2325    */
2326 int
2327 looking_at ( char *buf, int *index, char *pattern)
2328 {
2329     char *bufp = &buf[*index], *patternp = pattern;
2330     int star_count = 0;
2331     char *matchp = star_match[0];
2332
2333     for (;;) {
2334         if (*patternp == NULLCHAR) {
2335             *index = leftover_start = bufp - buf;
2336             *matchp = NULLCHAR;
2337             return TRUE;
2338         }
2339         if (*bufp == NULLCHAR) return FALSE;
2340         if (*patternp == '*') {
2341             if (*bufp == *(patternp + 1)) {
2342                 *matchp = NULLCHAR;
2343                 matchp = star_match[++star_count];
2344                 patternp += 2;
2345                 bufp++;
2346                 continue;
2347             } else if (*bufp == '\n' || *bufp == '\r') {
2348                 patternp++;
2349                 if (*patternp == NULLCHAR)
2350                   continue;
2351                 else
2352                   return FALSE;
2353             } else {
2354                 *matchp++ = *bufp++;
2355                 continue;
2356             }
2357         }
2358         if (*patternp != *bufp) return FALSE;
2359         patternp++;
2360         bufp++;
2361     }
2362 }
2363
2364 void
2365 SendToPlayer (char *data, int length)
2366 {
2367     int error, outCount;
2368     outCount = OutputToProcess(NoProc, data, length, &error);
2369     if (outCount < length) {
2370         DisplayFatalError(_("Error writing to display"), error, 1);
2371     }
2372 }
2373
2374 void
2375 PackHolding (char packed[], char *holding)
2376 {
2377     char *p = holding;
2378     char *q = packed;
2379     int runlength = 0;
2380     int curr = 9999;
2381     do {
2382         if (*p == curr) {
2383             runlength++;
2384         } else {
2385             switch (runlength) {
2386               case 0:
2387                 break;
2388               case 1:
2389                 *q++ = curr;
2390                 break;
2391               case 2:
2392                 *q++ = curr;
2393                 *q++ = curr;
2394                 break;
2395               default:
2396                 sprintf(q, "%d", runlength);
2397                 while (*q) q++;
2398                 *q++ = curr;
2399                 break;
2400             }
2401             runlength = 1;
2402             curr = *p;
2403         }
2404     } while (*p++);
2405     *q = NULLCHAR;
2406 }
2407
2408 /* Telnet protocol requests from the front end */
2409 void
2410 TelnetRequest (unsigned char ddww, unsigned char option)
2411 {
2412     unsigned char msg[3];
2413     int outCount, outError;
2414
2415     if (*appData.icsCommPort != NULLCHAR || appData.useTelnet) return;
2416
2417     if (appData.debugMode) {
2418         char buf1[8], buf2[8], *ddwwStr, *optionStr;
2419         switch (ddww) {
2420           case TN_DO:
2421             ddwwStr = "DO";
2422             break;
2423           case TN_DONT:
2424             ddwwStr = "DONT";
2425             break;
2426           case TN_WILL:
2427             ddwwStr = "WILL";
2428             break;
2429           case TN_WONT:
2430             ddwwStr = "WONT";
2431             break;
2432           default:
2433             ddwwStr = buf1;
2434             snprintf(buf1,sizeof(buf1)/sizeof(buf1[0]), "%d", ddww);
2435             break;
2436         }
2437         switch (option) {
2438           case TN_ECHO:
2439             optionStr = "ECHO";
2440             break;
2441           default:
2442             optionStr = buf2;
2443             snprintf(buf2,sizeof(buf2)/sizeof(buf2[0]), "%d", option);
2444             break;
2445         }
2446         fprintf(debugFP, ">%s %s ", ddwwStr, optionStr);
2447     }
2448     msg[0] = TN_IAC;
2449     msg[1] = ddww;
2450     msg[2] = option;
2451     outCount = OutputToProcess(icsPR, (char *)msg, 3, &outError);
2452     if (outCount < 3) {
2453         DisplayFatalError(_("Error writing to ICS"), outError, 1);
2454     }
2455 }
2456
2457 void
2458 DoEcho ()
2459 {
2460     if (!appData.icsActive) return;
2461     TelnetRequest(TN_DO, TN_ECHO);
2462 }
2463
2464 void
2465 DontEcho ()
2466 {
2467     if (!appData.icsActive) return;
2468     TelnetRequest(TN_DONT, TN_ECHO);
2469 }
2470
2471 void
2472 CopyHoldings (Board board, char *holdings, ChessSquare lowestPiece)
2473 {
2474     /* put the holdings sent to us by the server on the board holdings area */
2475     int i, j, holdingsColumn, holdingsStartRow, direction, countsColumn;
2476     char p;
2477     ChessSquare piece;
2478
2479     if(gameInfo.holdingsWidth < 2)  return;
2480     if(gameInfo.variant != VariantBughouse && board[HOLDINGS_SET])
2481         return; // prevent overwriting by pre-board holdings
2482
2483     if( (int)lowestPiece >= BlackPawn ) {
2484         holdingsColumn = 0;
2485         countsColumn = 1;
2486         holdingsStartRow = BOARD_HEIGHT-1;
2487         direction = -1;
2488     } else {
2489         holdingsColumn = BOARD_WIDTH-1;
2490         countsColumn = BOARD_WIDTH-2;
2491         holdingsStartRow = 0;
2492         direction = 1;
2493     }
2494
2495     for(i=0; i<BOARD_HEIGHT; i++) { /* clear holdings */
2496         board[i][holdingsColumn] = EmptySquare;
2497         board[i][countsColumn]   = (ChessSquare) 0;
2498     }
2499     while( (p=*holdings++) != NULLCHAR ) {
2500         piece = CharToPiece( ToUpper(p) );
2501         if(piece == EmptySquare) continue;
2502         /*j = (int) piece - (int) WhitePawn;*/
2503         j = PieceToNumber(piece);
2504         if(j >= gameInfo.holdingsSize) continue; /* ignore pieces that do not fit */
2505         if(j < 0) continue;               /* should not happen */
2506         piece = (ChessSquare) ( (int)piece + (int)lowestPiece );
2507         board[holdingsStartRow+j*direction][holdingsColumn] = piece;
2508         board[holdingsStartRow+j*direction][countsColumn]++;
2509     }
2510 }
2511
2512
2513 void
2514 VariantSwitch (Board board, VariantClass newVariant)
2515 {
2516    int newHoldingsWidth, newWidth = 8, newHeight = 8, i, j;
2517    static Board oldBoard;
2518
2519    startedFromPositionFile = FALSE;
2520    if(gameInfo.variant == newVariant) return;
2521
2522    /* [HGM] This routine is called each time an assignment is made to
2523     * gameInfo.variant during a game, to make sure the board sizes
2524     * are set to match the new variant. If that means adding or deleting
2525     * holdings, we shift the playing board accordingly
2526     * This kludge is needed because in ICS observe mode, we get boards
2527     * of an ongoing game without knowing the variant, and learn about the
2528     * latter only later. This can be because of the move list we requested,
2529     * in which case the game history is refilled from the beginning anyway,
2530     * but also when receiving holdings of a crazyhouse game. In the latter
2531     * case we want to add those holdings to the already received position.
2532     */
2533
2534
2535    if (appData.debugMode) {
2536      fprintf(debugFP, "Switch board from %s to %s\n",
2537              VariantName(gameInfo.variant), VariantName(newVariant));
2538      setbuf(debugFP, NULL);
2539    }
2540    shuffleOpenings = 0;       /* [HGM] shuffle */
2541    gameInfo.holdingsSize = 5; /* [HGM] prepare holdings */
2542    switch(newVariant)
2543      {
2544      case VariantShogi:
2545        newWidth = 9;  newHeight = 9;
2546        gameInfo.holdingsSize = 7;
2547      case VariantBughouse:
2548      case VariantCrazyhouse:
2549        newHoldingsWidth = 2; break;
2550      case VariantGreat:
2551        newWidth = 10;
2552      case VariantSuper:
2553        newHoldingsWidth = 2;
2554        gameInfo.holdingsSize = 8;
2555        break;
2556      case VariantGothic:
2557      case VariantCapablanca:
2558      case VariantCapaRandom:
2559        newWidth = 10;
2560      default:
2561        newHoldingsWidth = gameInfo.holdingsSize = 0;
2562      };
2563
2564    if(newWidth  != gameInfo.boardWidth  ||
2565       newHeight != gameInfo.boardHeight ||
2566       newHoldingsWidth != gameInfo.holdingsWidth ) {
2567
2568      /* shift position to new playing area, if needed */
2569      if(newHoldingsWidth > gameInfo.holdingsWidth) {
2570        for(i=0; i<BOARD_HEIGHT; i++)
2571          for(j=BOARD_RGHT-1; j>=BOARD_LEFT; j--)
2572            board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
2573              board[i][j];
2574        for(i=0; i<newHeight; i++) {
2575          board[i][0] = board[i][newWidth+2*newHoldingsWidth-1] = EmptySquare;
2576          board[i][1] = board[i][newWidth+2*newHoldingsWidth-2] = (ChessSquare) 0;
2577        }
2578      } else if(newHoldingsWidth < gameInfo.holdingsWidth) {
2579        for(i=0; i<BOARD_HEIGHT; i++)
2580          for(j=BOARD_LEFT; j<BOARD_RGHT; j++)
2581            board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
2582              board[i][j];
2583      }
2584      board[HOLDINGS_SET] = 0;
2585      gameInfo.boardWidth  = newWidth;
2586      gameInfo.boardHeight = newHeight;
2587      gameInfo.holdingsWidth = newHoldingsWidth;
2588      gameInfo.variant = newVariant;
2589      InitDrawingSizes(-2, 0);
2590    } else gameInfo.variant = newVariant;
2591    CopyBoard(oldBoard, board);   // remember correctly formatted board
2592      InitPosition(FALSE);          /* this sets up board[0], but also other stuff        */
2593    DrawPosition(TRUE, currentMove ? boards[currentMove] : oldBoard);
2594 }
2595
2596 static int loggedOn = FALSE;
2597
2598 /*-- Game start info cache: --*/
2599 int gs_gamenum;
2600 char gs_kind[MSG_SIZ];
2601 static char player1Name[128] = "";
2602 static char player2Name[128] = "";
2603 static char cont_seq[] = "\n\\   ";
2604 static int player1Rating = -1;
2605 static int player2Rating = -1;
2606 /*----------------------------*/
2607
2608 ColorClass curColor = ColorNormal;
2609 int suppressKibitz = 0;
2610
2611 // [HGM] seekgraph
2612 Boolean soughtPending = FALSE;
2613 Boolean seekGraphUp;
2614 #define MAX_SEEK_ADS 200
2615 #define SQUARE 0x80
2616 char *seekAdList[MAX_SEEK_ADS];
2617 int ratingList[MAX_SEEK_ADS], xList[MAX_SEEK_ADS], yList[MAX_SEEK_ADS], seekNrList[MAX_SEEK_ADS], zList[MAX_SEEK_ADS];
2618 float tcList[MAX_SEEK_ADS];
2619 char colorList[MAX_SEEK_ADS];
2620 int nrOfSeekAds = 0;
2621 int minRating = 1010, maxRating = 2800;
2622 int hMargin = 10, vMargin = 20, h, w;
2623 extern int squareSize, lineGap;
2624
2625 void
2626 PlotSeekAd (int i)
2627 {
2628         int x, y, color = 0, r = ratingList[i]; float tc = tcList[i];
2629         xList[i] = yList[i] = -100; // outside graph, so cannot be clicked
2630         if(r < minRating+100 && r >=0 ) r = minRating+100;
2631         if(r > maxRating) r = maxRating;
2632         if(tc < 1.f) tc = 1.f;
2633         if(tc > 95.f) tc = 95.f;
2634         x = (w-hMargin-squareSize/8-7)* log(tc)/log(95.) + hMargin;
2635         y = ((double)r - minRating)/(maxRating - minRating)
2636             * (h-vMargin-squareSize/8-1) + vMargin;
2637         if(ratingList[i] < 0) y = vMargin + squareSize/4;
2638         if(strstr(seekAdList[i], " u ")) color = 1;
2639         if(!strstr(seekAdList[i], "lightning") && // for now all wilds same color
2640            !strstr(seekAdList[i], "bullet") &&
2641            !strstr(seekAdList[i], "blitz") &&
2642            !strstr(seekAdList[i], "standard") ) color = 2;
2643         if(strstr(seekAdList[i], "(C) ")) color |= SQUARE; // plot computer seeks as squares
2644         DrawSeekDot(xList[i]=x+3*(color&~SQUARE), yList[i]=h-1-y, colorList[i]=color);
2645 }
2646
2647 void
2648 PlotSingleSeekAd (int i)
2649 {
2650         PlotSeekAd(i);
2651 }
2652
2653 void
2654 AddAd (char *handle, char *rating, int base, int inc,  char rated, char *type, int nr, Boolean plot)
2655 {
2656         char buf[MSG_SIZ], *ext = "";
2657         VariantClass v = StringToVariant(type);
2658         if(strstr(type, "wild")) {
2659             ext = type + 4; // append wild number
2660             if(v == VariantFischeRandom) type = "chess960"; else
2661             if(v == VariantLoadable) type = "setup"; else
2662             type = VariantName(v);
2663         }
2664         snprintf(buf, MSG_SIZ, "%s (%s) %d %d %c %s%s", handle, rating, base, inc, rated, type, ext);
2665         if(nrOfSeekAds < MAX_SEEK_ADS-1) {
2666             if(seekAdList[nrOfSeekAds]) free(seekAdList[nrOfSeekAds]);
2667             ratingList[nrOfSeekAds] = -1; // for if seeker has no rating
2668             sscanf(rating, "%d", &ratingList[nrOfSeekAds]);
2669             tcList[nrOfSeekAds] = base + (2./3.)*inc;
2670             seekNrList[nrOfSeekAds] = nr;
2671             zList[nrOfSeekAds] = 0;
2672             seekAdList[nrOfSeekAds++] = StrSave(buf);
2673             if(plot) PlotSingleSeekAd(nrOfSeekAds-1);
2674         }
2675 }
2676
2677 void
2678 EraseSeekDot (int i)
2679 {
2680     int x = xList[i], y = yList[i], d=squareSize/4, k;
2681     DrawSeekBackground(x-squareSize/8, y-squareSize/8, x+squareSize/8+1, y+squareSize/8+1);
2682     if(x < hMargin+d) DrawSeekAxis(hMargin, y-squareSize/8, hMargin, y+squareSize/8+1);
2683     // now replot every dot that overlapped
2684     for(k=0; k<nrOfSeekAds; k++) if(k != i) {
2685         int xx = xList[k], yy = yList[k];
2686         if(xx <= x+d && xx > x-d && yy <= y+d && yy > y-d)
2687             DrawSeekDot(xx, yy, colorList[k]);
2688     }
2689 }
2690
2691 void
2692 RemoveSeekAd (int nr)
2693 {
2694         int i;
2695         for(i=0; i<nrOfSeekAds; i++) if(seekNrList[i] == nr) {
2696             EraseSeekDot(i);
2697             if(seekAdList[i]) free(seekAdList[i]);
2698             seekAdList[i] = seekAdList[--nrOfSeekAds];
2699             seekNrList[i] = seekNrList[nrOfSeekAds];
2700             ratingList[i] = ratingList[nrOfSeekAds];
2701             colorList[i]  = colorList[nrOfSeekAds];
2702             tcList[i] = tcList[nrOfSeekAds];
2703             xList[i]  = xList[nrOfSeekAds];
2704             yList[i]  = yList[nrOfSeekAds];
2705             zList[i]  = zList[nrOfSeekAds];
2706             seekAdList[nrOfSeekAds] = NULL;
2707             break;
2708         }
2709 }
2710
2711 Boolean
2712 MatchSoughtLine (char *line)
2713 {
2714     char handle[MSG_SIZ], rating[MSG_SIZ], type[MSG_SIZ];
2715     int nr, base, inc, u=0; char dummy;
2716
2717     if(sscanf(line, "%d %s %s %d %d rated %s", &nr, rating, handle, &base, &inc, type) == 6 ||
2718        sscanf(line, "%d %s %s %s %d %d rated %c", &nr, rating, handle, type, &base, &inc, &dummy) == 7 ||
2719        (u=1) &&
2720        (sscanf(line, "%d %s %s %d %d unrated %s", &nr, rating, handle, &base, &inc, type) == 6 ||
2721         sscanf(line, "%d %s %s %s %d %d unrated %c", &nr, rating, handle, type, &base, &inc, &dummy) == 7)  ) {
2722         // match: compact and save the line
2723         AddAd(handle, rating, base, inc, u ? 'u' : 'r', type, nr, FALSE);
2724         return TRUE;
2725     }
2726     return FALSE;
2727 }
2728
2729 int
2730 DrawSeekGraph ()
2731 {
2732     int i;
2733     if(!seekGraphUp) return FALSE;
2734     h = BOARD_HEIGHT * (squareSize + lineGap) + lineGap + 2*border;
2735     w = BOARD_WIDTH  * (squareSize + lineGap) + lineGap + 2*border;
2736
2737     DrawSeekBackground(0, 0, w, h);
2738     DrawSeekAxis(hMargin, h-1-vMargin, w-5, h-1-vMargin);
2739     DrawSeekAxis(hMargin, h-1-vMargin, hMargin, 5);
2740     for(i=0; i<4000; i+= 100) if(i>=minRating && i<maxRating) {
2741         int yy =((double)i - minRating)/(maxRating - minRating)*(h-vMargin-squareSize/8-1) + vMargin;
2742         yy = h-1-yy;
2743         DrawSeekAxis(hMargin-5, yy, hMargin+5*(i%500==0), yy); // rating ticks
2744         if(i%500 == 0) {
2745             char buf[MSG_SIZ];
2746             snprintf(buf, MSG_SIZ, "%d", i);
2747             DrawSeekText(buf, hMargin+squareSize/8+7, yy);
2748         }
2749     }
2750     DrawSeekText("unrated", hMargin+squareSize/8+7, h-1-vMargin-squareSize/4);
2751     for(i=1; i<100; i+=(i<10?1:5)) {
2752         int xx = (w-hMargin-squareSize/8-7)* log((double)i)/log(95.) + hMargin;
2753         DrawSeekAxis(xx, h-1-vMargin, xx, h-6-vMargin-3*(i%10==0)); // TC ticks
2754         if(i<=5 || (i>40 ? i%20 : i%10) == 0) {
2755             char buf[MSG_SIZ];
2756             snprintf(buf, MSG_SIZ, "%d", i);
2757             DrawSeekText(buf, xx-2-3*(i>9), h-1-vMargin/2);
2758         }
2759     }
2760     for(i=0; i<nrOfSeekAds; i++) PlotSeekAd(i);
2761     return TRUE;
2762 }
2763
2764 int
2765 SeekGraphClick (ClickType click, int x, int y, int moving)
2766 {
2767     static int lastDown = 0, displayed = 0, lastSecond;
2768     if(y < 0) return FALSE;
2769     if(!(appData.seekGraph && appData.icsActive && loggedOn &&
2770         (gameMode == BeginningOfGame || gameMode == IcsIdle))) {
2771         if(!seekGraphUp) return FALSE;
2772         seekGraphUp = FALSE; // seek graph is up when it shouldn't be: take it down
2773         DrawPosition(TRUE, NULL);
2774         return TRUE;
2775     }
2776     if(!seekGraphUp) { // initiate cration of seek graph by requesting seek-ad list
2777         if(click == Release || moving) return FALSE;
2778         nrOfSeekAds = 0;
2779         soughtPending = TRUE;
2780         SendToICS(ics_prefix);
2781         SendToICS("sought\n"); // should this be "sought all"?
2782     } else { // issue challenge based on clicked ad
2783         int dist = 10000; int i, closest = 0, second = 0;
2784         for(i=0; i<nrOfSeekAds; i++) {
2785             int d = (x-xList[i])*(x-xList[i]) +  (y-yList[i])*(y-yList[i]) + zList[i];
2786             if(d < dist) { dist = d; closest = i; }
2787             second += (d - zList[i] < 120); // count in-range ads
2788             if(click == Press && moving != 1 && zList[i]>0) zList[i] *= 0.8; // age priority
2789         }
2790         if(dist < 120) {
2791             char buf[MSG_SIZ];
2792             second = (second > 1);
2793             if(displayed != closest || second != lastSecond) {
2794                 DisplayMessage(second ? "!" : "", seekAdList[closest]);
2795                 lastSecond = second; displayed = closest;
2796             }
2797             if(click == Press) {
2798                 if(moving == 2) zList[closest] = 100; // right-click; push to back on press
2799                 lastDown = closest;
2800                 return TRUE;
2801             } // on press 'hit', only show info
2802             if(moving == 2) return TRUE; // ignore right up-clicks on dot
2803             snprintf(buf, MSG_SIZ, "play %d\n", seekNrList[closest]);
2804             SendToICS(ics_prefix);
2805             SendToICS(buf);
2806             return TRUE; // let incoming board of started game pop down the graph
2807         } else if(click == Release) { // release 'miss' is ignored
2808             zList[lastDown] = 100; // make future selection of the rejected ad more difficult
2809             if(moving == 2) { // right up-click
2810                 nrOfSeekAds = 0; // refresh graph
2811                 soughtPending = TRUE;
2812                 SendToICS(ics_prefix);
2813                 SendToICS("sought\n"); // should this be "sought all"?
2814             }
2815             return TRUE;
2816         } else if(moving) { if(displayed >= 0) DisplayMessage("", ""); displayed = -1; return TRUE; }
2817         // press miss or release hit 'pop down' seek graph
2818         seekGraphUp = FALSE;
2819         DrawPosition(TRUE, NULL);
2820     }
2821     return TRUE;
2822 }
2823
2824 void
2825 read_from_ics (InputSourceRef isr, VOIDSTAR closure, char *data, int count, int error)
2826 {
2827 #define BUF_SIZE (16*1024) /* overflowed at 8K with "inchannel 1" on FICS? */
2828 #define STARTED_NONE 0
2829 #define STARTED_MOVES 1
2830 #define STARTED_BOARD 2
2831 #define STARTED_OBSERVE 3
2832 #define STARTED_HOLDINGS 4
2833 #define STARTED_CHATTER 5
2834 #define STARTED_COMMENT 6
2835 #define STARTED_MOVES_NOHIDE 7
2836
2837     static int started = STARTED_NONE;
2838     static char parse[20000];
2839     static int parse_pos = 0;
2840     static char buf[BUF_SIZE + 1];
2841     static int firstTime = TRUE, intfSet = FALSE;
2842     static ColorClass prevColor = ColorNormal;
2843     static int savingComment = FALSE;
2844     static int cmatch = 0; // continuation sequence match
2845     char *bp;
2846     char str[MSG_SIZ];
2847     int i, oldi;
2848     int buf_len;
2849     int next_out;
2850     int tkind;
2851     int backup;    /* [DM] For zippy color lines */
2852     char *p;
2853     char talker[MSG_SIZ]; // [HGM] chat
2854     int channel, collective=0;
2855
2856     connectionAlive = TRUE; // [HGM] alive: I think, therefore I am...
2857
2858     if (appData.debugMode) {
2859       if (!error) {
2860         fprintf(debugFP, "<ICS: ");
2861         show_bytes(debugFP, data, count);
2862         fprintf(debugFP, "\n");
2863       }
2864     }
2865
2866     if (appData.debugMode) { int f = forwardMostMove;
2867         fprintf(debugFP, "ics input %d, castling = %d %d %d %d %d %d\n", f,
2868                 boards[f][CASTLING][0],boards[f][CASTLING][1],boards[f][CASTLING][2],
2869                 boards[f][CASTLING][3],boards[f][CASTLING][4],boards[f][CASTLING][5]);
2870     }
2871     if (count > 0) {
2872         /* If last read ended with a partial line that we couldn't parse,
2873            prepend it to the new read and try again. */
2874         if (leftover_len > 0) {
2875             for (i=0; i<leftover_len; i++)
2876               buf[i] = buf[leftover_start + i];
2877         }
2878
2879     /* copy new characters into the buffer */
2880     bp = buf + leftover_len;
2881     buf_len=leftover_len;
2882     for (i=0; i<count; i++)
2883     {
2884         // ignore these
2885         if (data[i] == '\r')
2886             continue;
2887
2888         // join lines split by ICS?
2889         if (!appData.noJoin)
2890         {
2891             /*
2892                 Joining just consists of finding matches against the
2893                 continuation sequence, and discarding that sequence
2894                 if found instead of copying it.  So, until a match
2895                 fails, there's nothing to do since it might be the
2896                 complete sequence, and thus, something we don't want
2897                 copied.
2898             */
2899             if (data[i] == cont_seq[cmatch])
2900             {
2901                 cmatch++;
2902                 if (cmatch == strlen(cont_seq))
2903                 {
2904                     cmatch = 0; // complete match.  just reset the counter
2905
2906                     /*
2907                         it's possible for the ICS to not include the space
2908                         at the end of the last word, making our [correct]
2909                         join operation fuse two separate words.  the server
2910                         does this when the space occurs at the width setting.
2911                     */
2912                     if (!buf_len || buf[buf_len-1] != ' ')
2913                     {
2914                         *bp++ = ' ';
2915                         buf_len++;
2916                     }
2917                 }
2918                 continue;
2919             }
2920             else if (cmatch)
2921             {
2922                 /*
2923                     match failed, so we have to copy what matched before
2924                     falling through and copying this character.  In reality,
2925                     this will only ever be just the newline character, but
2926                     it doesn't hurt to be precise.
2927                 */
2928                 strncpy(bp, cont_seq, cmatch);
2929                 bp += cmatch;
2930                 buf_len += cmatch;
2931                 cmatch = 0;
2932             }
2933         }
2934
2935         // copy this char
2936         *bp++ = data[i];
2937         buf_len++;
2938     }
2939
2940         buf[buf_len] = NULLCHAR;
2941 //      next_out = leftover_len; // [HGM] should we set this to 0, and not print it in advance?
2942         next_out = 0;
2943         leftover_start = 0;
2944
2945         i = 0;
2946         while (i < buf_len) {
2947             /* Deal with part of the TELNET option negotiation
2948                protocol.  We refuse to do anything beyond the
2949                defaults, except that we allow the WILL ECHO option,
2950                which ICS uses to turn off password echoing when we are
2951                directly connected to it.  We reject this option
2952                if localLineEditing mode is on (always on in xboard)
2953                and we are talking to port 23, which might be a real
2954                telnet server that will try to keep WILL ECHO on permanently.
2955              */
2956             if (buf_len - i >= 3 && (unsigned char) buf[i] == TN_IAC) {
2957                 static int remoteEchoOption = FALSE; /* telnet ECHO option */
2958                 unsigned char option;
2959                 oldi = i;
2960                 switch ((unsigned char) buf[++i]) {
2961                   case TN_WILL:
2962                     if (appData.debugMode)
2963                       fprintf(debugFP, "\n<WILL ");
2964                     switch (option = (unsigned char) buf[++i]) {
2965                       case TN_ECHO:
2966                         if (appData.debugMode)
2967                           fprintf(debugFP, "ECHO ");
2968                         /* Reply only if this is a change, according
2969                            to the protocol rules. */
2970                         if (remoteEchoOption) break;
2971                         if (appData.localLineEditing &&
2972                             atoi(appData.icsPort) == TN_PORT) {
2973                             TelnetRequest(TN_DONT, TN_ECHO);
2974                         } else {
2975                             EchoOff();
2976                             TelnetRequest(TN_DO, TN_ECHO);
2977                             remoteEchoOption = TRUE;
2978                         }
2979                         break;
2980                       default:
2981                         if (appData.debugMode)
2982                           fprintf(debugFP, "%d ", option);
2983                         /* Whatever this is, we don't want it. */
2984                         TelnetRequest(TN_DONT, option);
2985                         break;
2986                     }
2987                     break;
2988                   case TN_WONT:
2989                     if (appData.debugMode)
2990                       fprintf(debugFP, "\n<WONT ");
2991                     switch (option = (unsigned char) buf[++i]) {
2992                       case TN_ECHO:
2993                         if (appData.debugMode)
2994                           fprintf(debugFP, "ECHO ");
2995                         /* Reply only if this is a change, according
2996                            to the protocol rules. */
2997                         if (!remoteEchoOption) break;
2998                         EchoOn();
2999                         TelnetRequest(TN_DONT, TN_ECHO);
3000                         remoteEchoOption = FALSE;
3001                         break;
3002                       default:
3003                         if (appData.debugMode)
3004                           fprintf(debugFP, "%d ", (unsigned char) option);
3005                         /* Whatever this is, it must already be turned
3006                            off, because we never agree to turn on
3007                            anything non-default, so according to the
3008                            protocol rules, we don't reply. */
3009                         break;
3010                     }
3011                     break;
3012                   case TN_DO:
3013                     if (appData.debugMode)
3014                       fprintf(debugFP, "\n<DO ");
3015                     switch (option = (unsigned char) buf[++i]) {
3016                       default:
3017                         /* Whatever this is, we refuse to do it. */
3018                         if (appData.debugMode)
3019                           fprintf(debugFP, "%d ", option);
3020                         TelnetRequest(TN_WONT, option);
3021                         break;
3022                     }
3023                     break;
3024                   case TN_DONT:
3025                     if (appData.debugMode)
3026                       fprintf(debugFP, "\n<DONT ");
3027                     switch (option = (unsigned char) buf[++i]) {
3028                       default:
3029                         if (appData.debugMode)
3030                           fprintf(debugFP, "%d ", option);
3031                         /* Whatever this is, we are already not doing
3032                            it, because we never agree to do anything
3033                            non-default, so according to the protocol
3034                            rules, we don't reply. */
3035                         break;
3036                     }
3037                     break;
3038                   case TN_IAC:
3039                     if (appData.debugMode)
3040                       fprintf(debugFP, "\n<IAC ");
3041                     /* Doubled IAC; pass it through */
3042                     i--;
3043                     break;
3044                   default:
3045                     if (appData.debugMode)
3046                       fprintf(debugFP, "\n<%d ", (unsigned char) buf[i]);
3047                     /* Drop all other telnet commands on the floor */
3048                     break;
3049                 }
3050                 if (oldi > next_out)
3051                   SendToPlayer(&buf[next_out], oldi - next_out);
3052                 if (++i > next_out)
3053                   next_out = i;
3054                 continue;
3055             }
3056
3057             /* OK, this at least will *usually* work */
3058             if (!loggedOn && looking_at(buf, &i, "ics%")) {
3059                 loggedOn = TRUE;
3060             }
3061
3062             if (loggedOn && !intfSet) {
3063                 if (ics_type == ICS_ICC) {
3064                   snprintf(str, MSG_SIZ,
3065                           "/set-quietly interface %s\n/set-quietly style 12\n",
3066                           programVersion);
3067                   if(appData.seekGraph && appData.autoRefresh) // [HGM] seekgraph
3068                       strcat(str, "/set-2 51 1\n/set seek 1\n");
3069                 } else if (ics_type == ICS_CHESSNET) {
3070                   snprintf(str, MSG_SIZ, "/style 12\n");
3071                 } else {
3072                   safeStrCpy(str, "alias $ @\n$set interface ", sizeof(str)/sizeof(str[0]));
3073                   strcat(str, programVersion);
3074                   strcat(str, "\n$iset startpos 1\n$iset ms 1\n");
3075                   if(appData.seekGraph && appData.autoRefresh) // [HGM] seekgraph
3076                       strcat(str, "$iset seekremove 1\n$set seek 1\n");
3077 #ifdef WIN32
3078                   strcat(str, "$iset nohighlight 1\n");
3079 #endif
3080                   strcat(str, "$iset lock 1\n$style 12\n");
3081                 }
3082                 SendToICS(str);
3083                 NotifyFrontendLogin();
3084                 intfSet = TRUE;
3085             }
3086
3087             if (started == STARTED_COMMENT) {
3088                 /* Accumulate characters in comment */
3089                 parse[parse_pos++] = buf[i];
3090                 if (buf[i] == '\n') {
3091                     parse[parse_pos] = NULLCHAR;
3092                     if(chattingPartner>=0) {
3093                         char mess[MSG_SIZ];
3094                         snprintf(mess, MSG_SIZ, "%s%s", talker, parse);
3095                         OutputChatMessage(chattingPartner, mess);
3096                         if(collective == 1) { // broadcasted talk also goes to private chatbox of talker
3097                             int p;
3098                             talker[strlen(talker+1)-1] = NULLCHAR; // strip closing delimiter
3099                             for(p=0; p<MAX_CHAT; p++) if(!StrCaseCmp(talker+1, chatPartner[p])) {
3100                                 snprintf(mess, MSG_SIZ, "%s: %s", chatPartner[chattingPartner], parse);
3101                                 OutputChatMessage(p, mess);
3102                                 break;
3103                             }
3104                         }
3105                         chattingPartner = -1;
3106                         if(collective != 3) next_out = i+1; // [HGM] suppress printing in ICS window
3107                         collective = 0;
3108                     } else
3109                     if(!suppressKibitz) // [HGM] kibitz
3110                         AppendComment(forwardMostMove, StripHighlight(parse), TRUE);
3111                     else { // [HGM kibitz: divert memorized engine kibitz to engine-output window
3112                         int nrDigit = 0, nrAlph = 0, j;
3113                         if(parse_pos > MSG_SIZ - 30) // defuse unreasonably long input
3114                         { parse_pos = MSG_SIZ-30; parse[parse_pos - 1] = '\n'; }
3115                         parse[parse_pos] = NULLCHAR;
3116                         // try to be smart: if it does not look like search info, it should go to
3117                         // ICS interaction window after all, not to engine-output window.
3118                         for(j=0; j<parse_pos; j++) { // count letters and digits
3119                             nrDigit += (parse[j] >= '0' && parse[j] <= '9');
3120                             nrAlph  += (parse[j] >= 'a' && parse[j] <= 'z');
3121                             nrAlph  += (parse[j] >= 'A' && parse[j] <= 'Z');
3122                         }
3123                         if(nrAlph < 9*nrDigit) { // if more than 10% digit we assume search info
3124                             int depth=0; float score;
3125                             if(sscanf(parse, "!!! %f/%d", &score, &depth) == 2 && depth>0) {
3126                                 // [HGM] kibitz: save kibitzed opponent info for PGN and eval graph
3127                                 pvInfoList[forwardMostMove-1].depth = depth;
3128                                 pvInfoList[forwardMostMove-1].score = 100*score;
3129                             }
3130                             OutputKibitz(suppressKibitz, parse);
3131                         } else {
3132                             char tmp[MSG_SIZ];
3133                             if(gameMode == IcsObserving) // restore original ICS messages
3134                               /* TRANSLATORS: to 'kibitz' is to send a message to all players and the game observers */
3135                               snprintf(tmp, MSG_SIZ, "%s kibitzes: %s", star_match[0], parse);
3136                             else
3137                             /* TRANSLATORS: to 'kibitz' is to send a message to all players and the game observers */
3138                             snprintf(tmp, MSG_SIZ, _("your opponent kibitzes: %s"), parse);
3139                             SendToPlayer(tmp, strlen(tmp));
3140                         }
3141                         next_out = i+1; // [HGM] suppress printing in ICS window
3142                     }
3143                     started = STARTED_NONE;
3144                 } else {
3145                     /* Don't match patterns against characters in comment */
3146                     i++;
3147                     continue;
3148                 }
3149             }
3150             if (started == STARTED_CHATTER) {
3151                 if (buf[i] != '\n') {
3152                     /* Don't match patterns against characters in chatter */
3153                     i++;
3154                     continue;
3155                 }
3156                 started = STARTED_NONE;
3157                 if(suppressKibitz) next_out = i+1;
3158             }
3159
3160             /* Kludge to deal with rcmd protocol */
3161             if (firstTime && looking_at(buf, &i, "\001*")) {
3162                 DisplayFatalError(&buf[1], 0, 1);
3163                 continue;
3164             } else {
3165                 firstTime = FALSE;
3166             }
3167
3168             if (!loggedOn && looking_at(buf, &i, "chessclub.com")) {
3169                 ics_type = ICS_ICC;
3170                 ics_prefix = "/";
3171                 if (appData.debugMode)
3172                   fprintf(debugFP, "ics_type %d\n", ics_type);
3173                 continue;
3174             }
3175             if (!loggedOn && looking_at(buf, &i, "freechess.org")) {
3176                 ics_type = ICS_FICS;
3177                 ics_prefix = "$";
3178                 if (appData.debugMode)
3179                   fprintf(debugFP, "ics_type %d\n", ics_type);
3180                 continue;
3181             }
3182             if (!loggedOn && looking_at(buf, &i, "chess.net")) {
3183                 ics_type = ICS_CHESSNET;
3184                 ics_prefix = "/";
3185                 if (appData.debugMode)
3186                   fprintf(debugFP, "ics_type %d\n", ics_type);
3187                 continue;
3188             }
3189
3190             if (!loggedOn &&
3191                 (looking_at(buf, &i, "\"*\" is *a registered name") ||
3192                  looking_at(buf, &i, "Logging you in as \"*\"") ||
3193                  looking_at(buf, &i, "will be \"*\""))) {
3194               safeStrCpy(ics_handle, star_match[0], sizeof(ics_handle)/sizeof(ics_handle[0]));
3195               continue;
3196             }
3197
3198             if (loggedOn && !have_set_title && ics_handle[0] != NULLCHAR) {
3199               char buf[MSG_SIZ];
3200               snprintf(buf, sizeof(buf), "%s@%s", ics_handle, appData.icsHost);
3201               DisplayIcsInteractionTitle(buf);
3202               have_set_title = TRUE;
3203             }
3204
3205             /* skip finger notes */
3206             if (started == STARTED_NONE &&
3207                 ((buf[i] == ' ' && isdigit(buf[i+1])) ||
3208                  (buf[i] == '1' && buf[i+1] == '0')) &&
3209                 buf[i+2] == ':' && buf[i+3] == ' ') {
3210               started = STARTED_CHATTER;
3211               i += 3;
3212               continue;
3213             }
3214
3215             oldi = i;
3216             // [HGM] seekgraph: recognize sought lines and end-of-sought message
3217             if(appData.seekGraph) {
3218                 if(soughtPending && MatchSoughtLine(buf+i)) {
3219                     i = strstr(buf+i, "rated") - buf;
3220                     if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
3221                     next_out = leftover_start = i;
3222                     started = STARTED_CHATTER;
3223                     suppressKibitz = TRUE;
3224                     continue;
3225                 }
3226                 if((gameMode == IcsIdle || gameMode == BeginningOfGame)
3227                         && looking_at(buf, &i, "* ads displayed")) {
3228                     soughtPending = FALSE;
3229                     seekGraphUp = TRUE;
3230                     DrawSeekGraph();
3231                     continue;
3232                 }
3233                 if(appData.autoRefresh) {
3234                     if(looking_at(buf, &i, "* (*) seeking * * * * *\"play *\" to respond)\n")) {
3235                         int s = (ics_type == ICS_ICC); // ICC format differs
3236                         if(seekGraphUp)
3237                         AddAd(star_match[0], star_match[1], atoi(star_match[2+s]), atoi(star_match[3+s]),
3238                               star_match[4+s][0], star_match[5-3*s], atoi(star_match[7]), TRUE);
3239                         looking_at(buf, &i, "*% "); // eat prompt
3240                         if(oldi > 0 && buf[oldi-1] == '\n') oldi--; // suppress preceding LF, if any
3241                         if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
3242                         next_out = i; // suppress
3243                         continue;
3244                     }
3245                     if(looking_at(buf, &i, "\nAds removed: *\n") || looking_at(buf, &i, "\031(51 * *\031)")) {
3246                         char *p = star_match[0];
3247                         while(*p) {
3248                             if(seekGraphUp) RemoveSeekAd(atoi(p));
3249                             while(*p && *p++ != ' '); // next
3250                         }
3251                         looking_at(buf, &i, "*% "); // eat prompt
3252                         if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
3253                         next_out = i;
3254                         continue;
3255                     }
3256                 }
3257             }
3258
3259             /* skip formula vars */
3260             if (started == STARTED_NONE &&
3261                 buf[i] == 'f' && isdigit(buf[i+1]) && buf[i+2] == ':') {
3262               started = STARTED_CHATTER;
3263               i += 3;
3264               continue;
3265             }
3266
3267             // [HGM] kibitz: try to recognize opponent engine-score kibitzes, to divert them to engine-output window
3268             if (appData.autoKibitz && started == STARTED_NONE &&
3269                 !appData.icsEngineAnalyze &&                     // [HGM] [DM] ICS analyze
3270                 (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack || gameMode == IcsObserving)) {
3271                 if((looking_at(buf, &i, "\n* kibitzes: ") || looking_at(buf, &i, "\n* whispers: ") ||
3272                     looking_at(buf, &i, "* kibitzes: ") || looking_at(buf, &i, "* whispers: ")) &&
3273                    (StrStr(star_match[0], gameInfo.white) == star_match[0] ||
3274                     StrStr(star_match[0], gameInfo.black) == star_match[0]   )) { // kibitz of self or opponent
3275                         suppressKibitz = TRUE;
3276                         if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
3277                         next_out = i;
3278                         if((StrStr(star_match[0], gameInfo.white) == star_match[0]
3279                                 && (gameMode == IcsPlayingWhite)) ||
3280                            (StrStr(star_match[0], gameInfo.black) == star_match[0]
3281                                 && (gameMode == IcsPlayingBlack))   ) // opponent kibitz
3282                             started = STARTED_CHATTER; // own kibitz we simply discard
3283                         else {
3284                             started = STARTED_COMMENT; // make sure it will be collected in parse[]
3285                             parse_pos = 0; parse[0] = NULLCHAR;
3286                             savingComment = TRUE;
3287                             suppressKibitz = gameMode != IcsObserving ? 2 :
3288                                 (StrStr(star_match[0], gameInfo.white) == NULL) + 1;
3289                         }
3290                         continue;
3291                 } else
3292                 if((looking_at(buf, &i, "\nkibitzed to *\n") || looking_at(buf, &i, "kibitzed to *\n") ||
3293                     looking_at(buf, &i, "\n(kibitzed to *\n") || looking_at(buf, &i, "(kibitzed to *\n"))
3294                          && atoi(star_match[0])) {
3295                     // suppress the acknowledgements of our own autoKibitz
3296                     char *p;
3297                     if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
3298                     if(p = strchr(star_match[0], ' ')) p[1] = NULLCHAR; // clip off "players)" on FICS
3299                     SendToPlayer(star_match[0], strlen(star_match[0]));
3300                     if(looking_at(buf, &i, "*% ")) // eat prompt
3301                         suppressKibitz = FALSE;
3302                     next_out = i;
3303                     continue;
3304                 }
3305             } // [HGM] kibitz: end of patch
3306
3307             if(looking_at(buf, &i, "* rating adjustment: * --> *\n")) continue;
3308
3309             // [HGM] chat: intercept tells by users for which we have an open chat window
3310             channel = -1;
3311             if(started == STARTED_NONE && (looking_at(buf, &i, "* tells you:") || looking_at(buf, &i, "* says:") ||
3312                                            looking_at(buf, &i, "* whispers:") ||
3313                                            looking_at(buf, &i, "* kibitzes:") ||
3314                                            looking_at(buf, &i, "* shouts:") ||
3315                                            looking_at(buf, &i, "* c-shouts:") ||
3316                                            looking_at(buf, &i, "--> * ") ||
3317                                            looking_at(buf, &i, "*(*):") && (sscanf(star_match[1], "%d", &channel),1) ||
3318                                            looking_at(buf, &i, "*(*)(*):") && (sscanf(star_match[2], "%d", &channel),1) ||
3319                                            looking_at(buf, &i, "*(*)(*)(*):") && (sscanf(star_match[3], "%d", &channel),1) ||
3320                                            looking_at(buf, &i, "*(*)(*)(*)(*):") && sscanf(star_match[4], "%d", &channel) == 1 )) {
3321                 int p;
3322                 sscanf(star_match[0], "%[^(]", talker+1); // strip (C) or (U) off ICS handle
3323                 chattingPartner = -1; collective = 0;
3324
3325                 if(channel >= 0) // channel broadcast; look if there is a chatbox for this channel
3326                 for(p=0; p<MAX_CHAT; p++) {
3327                     collective = 1;
3328                     if(chatPartner[p][0] >= '0' && chatPartner[p][0] <= '9' && channel == atoi(chatPartner[p])) {
3329                     talker[0] = '['; strcat(talker, "] ");
3330                     Colorize((channel == 1 ? ColorChannel1 : ColorChannel), FALSE);
3331                     chattingPartner = p; break;
3332                     }
3333                 } else
3334                 if(buf[i-3] == 'e') // kibitz; look if there is a KIBITZ chatbox
3335                 for(p=0; p<MAX_CHAT; p++) {
3336                     collective = 1;
3337                     if(!strcmp("kibitzes", chatPartner[p])) {
3338                         talker[0] = '['; strcat(talker, "] ");
3339                         chattingPartner = p; break;
3340                     }
3341                 } else
3342                 if(buf[i-3] == 'r') // whisper; look if there is a WHISPER chatbox
3343                 for(p=0; p<MAX_CHAT; p++) {
3344                     collective = 1;
3345                     if(!strcmp("whispers", chatPartner[p])) {
3346                         talker[0] = '['; strcat(talker, "] ");
3347                         chattingPartner = p; break;
3348                     }
3349                 } else
3350                 if(buf[i-3] == 't' || buf[oldi+2] == '>') {// shout, c-shout or it; look if there is a 'shouts' chatbox
3351                   if(buf[i-8] == '-' && buf[i-3] == 't')
3352                   for(p=0; p<MAX_CHAT; p++) { // c-shout; check if dedicatesd c-shout box exists
3353                     collective = 1;
3354                     if(!strcmp("c-shouts", chatPartner[p])) {
3355                         talker[0] = '('; strcat(talker, ") "); Colorize(ColorSShout, FALSE);
3356                         chattingPartner = p; break;
3357                     }
3358                   }
3359                   if(chattingPartner < 0)
3360                   for(p=0; p<MAX_CHAT; p++) {
3361                     collective = 1;
3362                     if(!strcmp("shouts", chatPartner[p])) {
3363                         if(buf[oldi+2] == '>') { talker[0] = '<'; strcat(talker, "> "); Colorize(ColorShout, FALSE); }
3364                         else if(buf[i-8] == '-') { talker[0] = '('; strcat(talker, ") "); Colorize(ColorSShout, FALSE); }
3365                         else { talker[0] = '['; strcat(talker, "] "); Colorize(ColorShout, FALSE); }
3366                         chattingPartner = p; break;
3367                     }
3368                   }
3369                 }
3370                 if(chattingPartner<0) // if not, look if there is a chatbox for this indivdual
3371                 for(p=0; p<MAX_CHAT; p++) if(!StrCaseCmp(talker+1, chatPartner[p])) {
3372                     talker[0] = 0;
3373                     Colorize(ColorTell, FALSE);
3374                     if(collective) safeStrCpy(talker, "broadcasts: ", MSG_SIZ);
3375                     collective |= 2;
3376                     chattingPartner = p; break;
3377                 }
3378                 if(chattingPartner<0) i = oldi, safeStrCpy(lastTalker, talker+1, MSG_SIZ); else {
3379                     Colorize(curColor, TRUE); // undo the bogus colorations we just made to trigger the souds
3380                     started = STARTED_COMMENT;
3381                     parse_pos = 0; parse[0] = NULLCHAR;
3382                     savingComment = 3 + chattingPartner; // counts as TRUE
3383                     if(collective == 3) i = oldi; else {
3384                         suppressKibitz = TRUE;
3385                         if(oldi > 0 && buf[oldi-1] == '\n') oldi--;
3386                         if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
3387                         continue;
3388                     }
3389                 }
3390             } // [HGM] chat: end of patch
3391
3392           backup = i;
3393             if (appData.zippyTalk || appData.zippyPlay) {
3394                 /* [DM] Backup address for color zippy lines */
3395 #if ZIPPY
3396                if (loggedOn == TRUE)
3397                        if (ZippyControl(buf, &backup) || ZippyConverse(buf, &backup) ||
3398                           (appData.zippyPlay && ZippyMatch(buf, &backup)));
3399 #endif
3400             } // [DM] 'else { ' deleted
3401                 if (
3402                     /* Regular tells and says */
3403                     (tkind = 1, looking_at(buf, &i, "* tells you: ")) ||
3404                     looking_at(buf, &i, "* (your partner) tells you: ") ||
3405                     looking_at(buf, &i, "* says: ") ||
3406                     /* Don't color "message" or "messages" output */
3407                     (tkind = 5, looking_at(buf, &i, "*. * (*:*): ")) ||
3408                     looking_at(buf, &i, "*. * at *:*: ") ||
3409                     looking_at(buf, &i, "--* (*:*): ") ||
3410                     /* Message notifications (same color as tells) */
3411                     looking_at(buf, &i, "* has left a message ") ||
3412                     looking_at(buf, &i, "* just sent you a message:\n") ||
3413                     /* Whispers and kibitzes */
3414                     (tkind = 2, looking_at(buf, &i, "* whispers: ")) ||
3415                     looking_at(buf, &i, "* kibitzes: ") ||
3416                     /* Channel tells */
3417                     (tkind = 3, looking_at(buf, &i, "*(*: "))) {
3418
3419                   if (tkind == 1 && strchr(star_match[0], ':')) {
3420                       /* Avoid "tells you:" spoofs in channels */
3421                      tkind = 3;
3422                   }
3423                   if (star_match[0][0] == NULLCHAR ||
3424                       strchr(star_match[0], ' ') ||
3425                       (tkind == 3 && strchr(star_match[1], ' '))) {
3426                     /* Reject bogus matches */
3427                     i = oldi;
3428                   } else {
3429                     if (appData.colorize) {
3430                       if (oldi > next_out) {
3431                         SendToPlayer(&buf[next_out], oldi - next_out);
3432                         next_out = oldi;
3433                       }
3434                       switch (tkind) {
3435                       case 1:
3436                         Colorize(ColorTell, FALSE);
3437                         curColor = ColorTell;
3438                         break;
3439                       case 2:
3440                         Colorize(ColorKibitz, FALSE);
3441                         curColor = ColorKibitz;
3442                         break;
3443                       case 3:
3444                         p = strrchr(star_match[1], '(');
3445                         if (p == NULL) {
3446                           p = star_match[1];
3447                         } else {
3448                           p++;
3449                         }
3450                         if (atoi(p) == 1) {
3451                           Colorize(ColorChannel1, FALSE);
3452                           curColor = ColorChannel1;
3453                         } else {
3454                           Colorize(ColorChannel, FALSE);
3455                           curColor = ColorChannel;
3456                         }
3457                         break;
3458                       case 5:
3459                         curColor = ColorNormal;
3460                         break;
3461                       }
3462                     }
3463                     if (started == STARTED_NONE && appData.autoComment &&
3464                         (gameMode == IcsObserving ||
3465                          gameMode == IcsPlayingWhite ||
3466                          gameMode == IcsPlayingBlack)) {
3467                       parse_pos = i - oldi;
3468                       memcpy(parse, &buf[oldi], parse_pos);
3469                       parse[parse_pos] = NULLCHAR;
3470                       started = STARTED_COMMENT;
3471                       savingComment = TRUE;
3472                     } else if(collective != 3) {
3473                       started = STARTED_CHATTER;
3474                       savingComment = FALSE;
3475                     }
3476                     loggedOn = TRUE;
3477                     continue;
3478                   }
3479                 }
3480
3481                 if (looking_at(buf, &i, "* s-shouts: ") ||
3482                     looking_at(buf, &i, "* c-shouts: ")) {
3483                     if (appData.colorize) {
3484                         if (oldi > next_out) {
3485                             SendToPlayer(&buf[next_out], oldi - next_out);
3486                             next_out = oldi;
3487                         }
3488                         Colorize(ColorSShout, FALSE);
3489                         curColor = ColorSShout;
3490                     }
3491                     loggedOn = TRUE;
3492                     started = STARTED_CHATTER;
3493                     continue;
3494                 }
3495
3496                 if (looking_at(buf, &i, "--->")) {
3497                     loggedOn = TRUE;
3498                     continue;
3499                 }
3500
3501                 if (looking_at(buf, &i, "* shouts: ") ||
3502                     looking_at(buf, &i, "--> ")) {
3503                     if (appData.colorize) {
3504                         if (oldi > next_out) {
3505                             SendToPlayer(&buf[next_out], oldi - next_out);
3506                             next_out = oldi;
3507                         }
3508                         Colorize(ColorShout, FALSE);
3509                         curColor = ColorShout;
3510                     }
3511                     loggedOn = TRUE;
3512                     started = STARTED_CHATTER;
3513                     continue;
3514                 }
3515
3516                 if (looking_at( buf, &i, "Challenge:")) {
3517                     if (appData.colorize) {
3518                         if (oldi > next_out) {
3519                             SendToPlayer(&buf[next_out], oldi - next_out);
3520                             next_out = oldi;
3521                         }
3522                         Colorize(ColorChallenge, FALSE);
3523                         curColor = ColorChallenge;
3524                     }
3525                     loggedOn = TRUE;
3526                     continue;
3527                 }
3528
3529                 if (looking_at(buf, &i, "* offers you") ||
3530                     looking_at(buf, &i, "* offers to be") ||
3531                     looking_at(buf, &i, "* would like to") ||
3532                     looking_at(buf, &i, "* requests to") ||
3533                     looking_at(buf, &i, "Your opponent offers") ||
3534                     looking_at(buf, &i, "Your opponent requests")) {
3535
3536                     if (appData.colorize) {
3537                         if (oldi > next_out) {
3538                             SendToPlayer(&buf[next_out], oldi - next_out);
3539                             next_out = oldi;
3540                         }
3541                         Colorize(ColorRequest, FALSE);
3542                         curColor = ColorRequest;
3543                     }
3544                     continue;
3545                 }
3546
3547                 if (looking_at(buf, &i, "* (*) seeking")) {
3548                     if (appData.colorize) {
3549                         if (oldi > next_out) {
3550                             SendToPlayer(&buf[next_out], oldi - next_out);
3551                             next_out = oldi;
3552                         }
3553                         Colorize(ColorSeek, FALSE);
3554                         curColor = ColorSeek;
3555                     }
3556                     continue;
3557             }
3558
3559           if(i < backup) { i = backup; continue; } // [HGM] for if ZippyControl matches, but the colorie code doesn't
3560
3561             if (looking_at(buf, &i, "\\   ")) {
3562                 if (prevColor != ColorNormal) {
3563                     if (oldi > next_out) {
3564                         SendToPlayer(&buf[next_out], oldi - next_out);
3565                         next_out = oldi;
3566                     }
3567                     Colorize(prevColor, TRUE);
3568                     curColor = prevColor;
3569                 }
3570                 if (savingComment) {
3571                     parse_pos = i - oldi;
3572                     memcpy(parse, &buf[oldi], parse_pos);
3573                     parse[parse_pos] = NULLCHAR;
3574                     started = STARTED_COMMENT;
3575                     if(savingComment >= 3) // [HGM] chat: continuation of line for chat box
3576                         chattingPartner = savingComment - 3; // kludge to remember the box
3577                 } else {
3578                     started = STARTED_CHATTER;
3579                 }
3580                 continue;
3581             }
3582
3583             if (looking_at(buf, &i, "Black Strength :") ||
3584                 looking_at(buf, &i, "<<< style 10 board >>>") ||
3585                 looking_at(buf, &i, "<10>") ||
3586                 looking_at(buf, &i, "#@#")) {
3587                 /* Wrong board style */
3588                 loggedOn = TRUE;
3589                 SendToICS(ics_prefix);
3590                 SendToICS("set style 12\n");
3591                 SendToICS(ics_prefix);
3592                 SendToICS("refresh\n");
3593                 continue;
3594             }
3595
3596             if (looking_at(buf, &i, "login:")) {
3597               if (!have_sent_ICS_logon) {
3598                 if(ICSInitScript())
3599                   have_sent_ICS_logon = 1;
3600                 else // no init script was found
3601                   have_sent_ICS_logon = (appData.autoCreateLogon ? 2 : 1); // flag that we should capture username + password
3602               } else { // we have sent (or created) the InitScript, but apparently the ICS rejected it
3603                   have_sent_ICS_logon = (appData.autoCreateLogon ? 2 : 1); // request creation of a new script
3604               }
3605                 continue;
3606             }
3607
3608             if (ics_getting_history != H_GETTING_MOVES /*smpos kludge*/ &&
3609                 (looking_at(buf, &i, "\n<12> ") ||
3610                  looking_at(buf, &i, "<12> "))) {
3611                 loggedOn = TRUE;
3612                 if (oldi > next_out) {
3613                     SendToPlayer(&buf[next_out], oldi - next_out);
3614                 }
3615                 next_out = i;
3616                 started = STARTED_BOARD;
3617                 parse_pos = 0;
3618                 continue;
3619             }
3620
3621             if ((started == STARTED_NONE && looking_at(buf, &i, "\n<b1> ")) ||
3622                 looking_at(buf, &i, "<b1> ")) {
3623                 if (oldi > next_out) {
3624                     SendToPlayer(&buf[next_out], oldi - next_out);
3625                 }
3626                 next_out = i;
3627                 started = STARTED_HOLDINGS;
3628                 parse_pos = 0;
3629                 continue;
3630             }
3631
3632             if (looking_at(buf, &i, "* *vs. * *--- *")) {
3633                 loggedOn = TRUE;
3634                 /* Header for a move list -- first line */
3635
3636                 switch (ics_getting_history) {
3637                   case H_FALSE:
3638                     switch (gameMode) {
3639                       case IcsIdle:
3640                       case BeginningOfGame:
3641                         /* User typed "moves" or "oldmoves" while we
3642                            were idle.  Pretend we asked for these
3643                            moves and soak them up so user can step
3644                            through them and/or save them.
3645                            */
3646                         Reset(FALSE, TRUE);
3647                         gameMode = IcsObserving;
3648                         ModeHighlight();
3649                         ics_gamenum = -1;
3650                         ics_getting_history = H_GOT_UNREQ_HEADER;
3651                         break;
3652                       case EditGame: /*?*/
3653                       case EditPosition: /*?*/
3654                         /* Should above feature work in these modes too? */
3655                         /* For now it doesn't */
3656                         ics_getting_history = H_GOT_UNWANTED_HEADER;
3657                         break;
3658                       default:
3659                         ics_getting_history = H_GOT_UNWANTED_HEADER;
3660                         break;
3661                     }
3662                     break;
3663                   case H_REQUESTED:
3664                     /* Is this the right one? */
3665                     if (gameInfo.white && gameInfo.black &&
3666                         strcmp(gameInfo.white, star_match[0]) == 0 &&
3667                         strcmp(gameInfo.black, star_match[2]) == 0) {
3668                         /* All is well */
3669                         ics_getting_history = H_GOT_REQ_HEADER;
3670                     }
3671                     break;
3672                   case H_GOT_REQ_HEADER:
3673                   case H_GOT_UNREQ_HEADER:
3674                   case H_GOT_UNWANTED_HEADER:
3675                   case H_GETTING_MOVES:
3676                     /* Should not happen */
3677                     DisplayError(_("Error gathering move list: two headers"), 0);
3678                     ics_getting_history = H_FALSE;
3679                     break;
3680                 }
3681
3682                 /* Save player ratings into gameInfo if needed */
3683                 if ((ics_getting_history == H_GOT_REQ_HEADER ||
3684                      ics_getting_history == H_GOT_UNREQ_HEADER) &&
3685                     (gameInfo.whiteRating == -1 ||
3686                      gameInfo.blackRating == -1)) {
3687
3688                     gameInfo.whiteRating = string_to_rating(star_match[1]);
3689                     gameInfo.blackRating = string_to_rating(star_match[3]);
3690                     if (appData.debugMode)
3691                       fprintf(debugFP, "Ratings from header: W %d, B %d\n",
3692                               gameInfo.whiteRating, gameInfo.blackRating);
3693                 }
3694                 continue;
3695             }
3696
3697             if (looking_at(buf, &i,
3698               "* * match, initial time: * minute*, increment: * second")) {
3699                 /* Header for a move list -- second line */
3700                 /* Initial board will follow if this is a wild game */
3701                 if (gameInfo.event != NULL) free(gameInfo.event);
3702                 snprintf(str, MSG_SIZ, "ICS %s %s match", star_match[0], star_match[1]);
3703                 gameInfo.event = StrSave(str);
3704                 /* [HGM] we switched variant. Translate boards if needed. */
3705                 VariantSwitch(boards[currentMove], StringToVariant(gameInfo.event));
3706                 continue;
3707             }
3708
3709             if (looking_at(buf, &i, "Move  ")) {
3710                 /* Beginning of a move list */
3711                 switch (ics_getting_history) {
3712                   case H_FALSE:
3713                     /* Normally should not happen */
3714                     /* Maybe user hit reset while we were parsing */
3715                     break;
3716                   case H_REQUESTED:
3717                     /* Happens if we are ignoring a move list that is not
3718                      * the one we just requested.  Common if the user
3719                      * tries to observe two games without turning off
3720                      * getMoveList */
3721                     break;
3722                   case H_GETTING_MOVES:
3723                     /* Should not happen */
3724                     DisplayError(_("Error gathering move list: nested"), 0);
3725                     ics_getting_history = H_FALSE;
3726                     break;
3727                   case H_GOT_REQ_HEADER:
3728                     ics_getting_history = H_GETTING_MOVES;
3729                     started = STARTED_MOVES;
3730                     parse_pos = 0;
3731                     if (oldi > next_out) {
3732                         SendToPlayer(&buf[next_out], oldi - next_out);
3733                     }
3734                     break;
3735                   case H_GOT_UNREQ_HEADER:
3736                     ics_getting_history = H_GETTING_MOVES;
3737                     started = STARTED_MOVES_NOHIDE;
3738                     parse_pos = 0;
3739                     break;
3740                   case H_GOT_UNWANTED_HEADER:
3741                     ics_getting_history = H_FALSE;
3742                     break;
3743                 }
3744                 continue;
3745             }
3746
3747             if (looking_at(buf, &i, "% ") ||
3748                 ((started == STARTED_MOVES || started == STARTED_MOVES_NOHIDE)
3749                  && looking_at(buf, &i, "}*"))) { char *bookHit = NULL; // [HGM] book
3750                 if(soughtPending && nrOfSeekAds) { // [HGM] seekgraph: on ICC sought-list has no termination line
3751                     soughtPending = FALSE;
3752                     seekGraphUp = TRUE;
3753                     DrawSeekGraph();
3754                 }
3755                 if(suppressKibitz) next_out = i;
3756                 savingComment = FALSE;
3757                 suppressKibitz = 0;
3758                 switch (started) {
3759                   case STARTED_MOVES:
3760                   case STARTED_MOVES_NOHIDE:
3761                     memcpy(&parse[parse_pos], &buf[oldi], i - oldi);
3762                     parse[parse_pos + i - oldi] = NULLCHAR;
3763                     ParseGameHistory(parse);
3764 #if ZIPPY
3765                     if (appData.zippyPlay && first.initDone) {
3766                         FeedMovesToProgram(&first, forwardMostMove);
3767                         if (gameMode == IcsPlayingWhite) {
3768                             if (WhiteOnMove(forwardMostMove)) {
3769                                 if (first.sendTime) {
3770                                   if (first.useColors) {
3771                                     SendToProgram("black\n", &first);
3772                                   }
3773                                   SendTimeRemaining(&first, TRUE);
3774                                 }
3775                                 if (first.useColors) {
3776                                   SendToProgram("white\n", &first); // [HGM] book: made sending of "go\n" book dependent
3777                                 }
3778                                 bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: probe book for initial pos
3779                                 first.maybeThinking = TRUE;
3780                             } else {
3781                                 if (first.usePlayother) {
3782                                   if (first.sendTime) {
3783                                     SendTimeRemaining(&first, TRUE);
3784                                   }
3785                                   SendToProgram("playother\n", &first);
3786                                   firstMove = FALSE;
3787                                 } else {
3788                                   firstMove = TRUE;
3789                                 }
3790                             }
3791                         } else if (gameMode == IcsPlayingBlack) {
3792                             if (!WhiteOnMove(forwardMostMove)) {
3793                                 if (first.sendTime) {
3794                                   if (first.useColors) {
3795                                     SendToProgram("white\n", &first);
3796                                   }
3797                                   SendTimeRemaining(&first, FALSE);
3798                                 }
3799                                 if (first.useColors) {
3800                                   SendToProgram("black\n", &first);
3801                                 }
3802                                 bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE);
3803                                 first.maybeThinking = TRUE;
3804                             } else {
3805                                 if (first.usePlayother) {
3806                                   if (first.sendTime) {
3807                                     SendTimeRemaining(&first, FALSE);
3808                                   }
3809                                   SendToProgram("playother\n", &first);
3810                                   firstMove = FALSE;
3811                                 } else {
3812                                   firstMove = TRUE;
3813                                 }
3814                             }
3815                         }
3816                     }
3817 #endif
3818                     if (gameMode == IcsObserving && ics_gamenum == -1) {
3819                         /* Moves came from oldmoves or moves command
3820                            while we weren't doing anything else.
3821                            */
3822                         currentMove = forwardMostMove;
3823                         ClearHighlights();/*!!could figure this out*/
3824                         flipView = appData.flipView;
3825                         DrawPosition(TRUE, boards[currentMove]);
3826                         DisplayBothClocks();
3827                         snprintf(str, MSG_SIZ, "%s %s %s",
3828                                 gameInfo.white, _("vs."),  gameInfo.black);
3829                         DisplayTitle(str);
3830                         gameMode = IcsIdle;
3831                     } else {
3832                         /* Moves were history of an active game */
3833                         if (gameInfo.resultDetails != NULL) {
3834                             free(gameInfo.resultDetails);
3835                             gameInfo.resultDetails = NULL;
3836                         }
3837                     }
3838                     HistorySet(parseList, backwardMostMove,
3839                                forwardMostMove, currentMove-1);
3840                     DisplayMove(currentMove - 1);
3841                     if (started == STARTED_MOVES) next_out = i;
3842                     started = STARTED_NONE;
3843                     ics_getting_history = H_FALSE;
3844                     break;
3845
3846                   case STARTED_OBSERVE:
3847                     started = STARTED_NONE;
3848                     SendToICS(ics_prefix);
3849                     SendToICS("refresh\n");
3850                     break;
3851
3852                   default:
3853                     break;
3854                 }
3855                 if(bookHit) { // [HGM] book: simulate book reply
3856                     static char bookMove[MSG_SIZ]; // a bit generous?
3857
3858                     programStats.nodes = programStats.depth = programStats.time =
3859                     programStats.score = programStats.got_only_move = 0;
3860                     sprintf(programStats.movelist, "%s (xbook)", bookHit);
3861
3862                     safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
3863                     strcat(bookMove, bookHit);
3864                     HandleMachineMove(bookMove, &first);
3865                 }
3866                 continue;
3867             }
3868
3869             if ((started == STARTED_MOVES || started == STARTED_BOARD ||
3870                  started == STARTED_HOLDINGS ||
3871                  started == STARTED_MOVES_NOHIDE) && i >= leftover_len) {
3872                 /* Accumulate characters in move list or board */
3873                 parse[parse_pos++] = buf[i];
3874             }
3875
3876             /* Start of game messages.  Mostly we detect start of game
3877                when the first board image arrives.  On some versions
3878                of the ICS, though, we need to do a "refresh" after starting
3879                to observe in order to get the current board right away. */
3880             if (looking_at(buf, &i, "Adding game * to observation list")) {
3881                 started = STARTED_OBSERVE;
3882                 continue;
3883             }
3884
3885             /* Handle auto-observe */
3886             if (appData.autoObserve &&
3887                 (gameMode == IcsIdle || gameMode == BeginningOfGame) &&
3888                 looking_at(buf, &i, "Game notification: * (*) vs. * (*)")) {
3889                 char *player;
3890                 /* Choose the player that was highlighted, if any. */
3891                 if (star_match[0][0] == '\033' ||
3892                     star_match[1][0] != '\033') {
3893                     player = star_match[0];
3894                 } else {
3895                     player = star_match[2];
3896                 }
3897                 snprintf(str, MSG_SIZ, "%sobserve %s\n",
3898                         ics_prefix, StripHighlightAndTitle(player));
3899                 SendToICS(str);
3900
3901                 /* Save ratings from notify string */
3902                 safeStrCpy(player1Name, star_match[0], sizeof(player1Name)/sizeof(player1Name[0]));
3903                 player1Rating = string_to_rating(star_match[1]);
3904                 safeStrCpy(player2Name, star_match[2], sizeof(player2Name)/sizeof(player2Name[0]));
3905                 player2Rating = string_to_rating(star_match[3]);
3906
3907                 if (appData.debugMode)
3908                   fprintf(debugFP,
3909                           "Ratings from 'Game notification:' %s %d, %s %d\n",
3910                           player1Name, player1Rating,
3911                           player2Name, player2Rating);
3912
3913                 continue;
3914             }
3915
3916             /* Deal with automatic examine mode after a game,
3917                and with IcsObserving -> IcsExamining transition */
3918             if (looking_at(buf, &i, "Entering examine mode for game *") ||
3919                 looking_at(buf, &i, "has made you an examiner of game *")) {
3920
3921                 int gamenum = atoi(star_match[0]);
3922                 if ((gameMode == IcsIdle || gameMode == IcsObserving) &&
3923                     gamenum == ics_gamenum) {
3924                     /* We were already playing or observing this game;
3925                        no need to refetch history */
3926                     gameMode = IcsExamining;
3927                     if (pausing) {
3928                         pauseExamForwardMostMove = forwardMostMove;
3929                     } else if (currentMove < forwardMostMove) {
3930                         ForwardInner(forwardMostMove);
3931                     }
3932                 } else {
3933                     /* I don't think this case really can happen */
3934                     SendToICS(ics_prefix);
3935                     SendToICS("refresh\n");
3936                 }
3937                 continue;
3938             }
3939
3940             /* Error messages */
3941 //          if (ics_user_moved) {
3942             if (1) { // [HGM] old way ignored error after move type in; ics_user_moved is not set then!
3943                 if (looking_at(buf, &i, "Illegal move") ||
3944                     looking_at(buf, &i, "Not a legal move") ||
3945                     looking_at(buf, &i, "Your king is in check") ||
3946                     looking_at(buf, &i, "It isn't your turn") ||
3947                     looking_at(buf, &i, "It is not your move")) {
3948                     /* Illegal move */
3949                     if (ics_user_moved && forwardMostMove > backwardMostMove) { // only backup if we already moved
3950                         currentMove = forwardMostMove-1;
3951                         DisplayMove(currentMove - 1); /* before DMError */
3952                         DrawPosition(FALSE, boards[currentMove]);
3953                         SwitchClocks(forwardMostMove-1); // [HGM] race
3954                         DisplayBothClocks();
3955                     }
3956                     DisplayMoveError(_("Illegal move (rejected by ICS)")); // [HGM] but always relay error msg
3957                     ics_user_moved = 0;
3958                     continue;
3959                 }
3960             }
3961
3962             if (looking_at(buf, &i, "still have time") ||
3963                 looking_at(buf, &i, "not out of time") ||
3964                 looking_at(buf, &i, "either player is out of time") ||
3965                 looking_at(buf, &i, "has timeseal; checking")) {
3966                 /* We must have called his flag a little too soon */
3967                 whiteFlag = blackFlag = FALSE;
3968                 continue;
3969             }
3970
3971             if (looking_at(buf, &i, "added * seconds to") ||
3972                 looking_at(buf, &i, "seconds were added to")) {
3973                 /* Update the clocks */
3974                 SendToICS(ics_prefix);
3975                 SendToICS("refresh\n");
3976                 continue;
3977             }
3978
3979             if (!ics_clock_paused && looking_at(buf, &i, "clock paused")) {
3980                 ics_clock_paused = TRUE;
3981                 StopClocks();
3982                 continue;
3983             }
3984
3985             if (ics_clock_paused && looking_at(buf, &i, "clock resumed")) {
3986                 ics_clock_paused = FALSE;
3987                 StartClocks();
3988                 continue;
3989             }
3990
3991             /* Grab player ratings from the Creating: message.
3992                Note we have to check for the special case when
3993                the ICS inserts things like [white] or [black]. */
3994             if (looking_at(buf, &i, "Creating: * (*)* * (*)") ||
3995                 looking_at(buf, &i, "Creating: * (*) [*] * (*)")) {
3996                 /* star_matches:
3997                    0    player 1 name (not necessarily white)
3998                    1    player 1 rating
3999                    2    empty, white, or black (IGNORED)
4000                    3    player 2 name (not necessarily black)
4001                    4    player 2 rating
4002
4003                    The names/ratings are sorted out when the game
4004                    actually starts (below).
4005                 */
4006                 safeStrCpy(player1Name, StripHighlightAndTitle(star_match[0]), sizeof(player1Name)/sizeof(player1Name[0]));
4007                 player1Rating = string_to_rating(star_match[1]);
4008                 safeStrCpy(player2Name, StripHighlightAndTitle(star_match[3]), sizeof(player2Name)/sizeof(player2Name[0]));
4009                 player2Rating = string_to_rating(star_match[4]);
4010
4011                 if (appData.debugMode)
4012                   fprintf(debugFP,
4013                           "Ratings from 'Creating:' %s %d, %s %d\n",
4014                           player1Name, player1Rating,
4015                           player2Name, player2Rating);
4016
4017                 continue;
4018             }
4019
4020             /* Improved generic start/end-of-game messages */
4021             if ((tkind=0, looking_at(buf, &i, "{Game * (* vs. *) *}*")) ||
4022                 (tkind=1, looking_at(buf, &i, "{Game * (*(*) vs. *(*)) *}*"))){
4023                 /* If tkind == 0: */
4024                 /* star_match[0] is the game number */
4025                 /*           [1] is the white player's name */
4026                 /*           [2] is the black player's name */
4027                 /* For end-of-game: */
4028                 /*           [3] is the reason for the game end */
4029                 /*           [4] is a PGN end game-token, preceded by " " */
4030                 /* For start-of-game: */
4031                 /*           [3] begins with "Creating" or "Continuing" */
4032                 /*           [4] is " *" or empty (don't care). */
4033                 int gamenum = atoi(star_match[0]);
4034                 char *whitename, *blackname, *why, *endtoken;
4035                 ChessMove endtype = EndOfFile;
4036
4037                 if (tkind == 0) {
4038                   whitename = star_match[1];
4039                   blackname = star_match[2];
4040                   why = star_match[3];
4041                   endtoken = star_match[4];
4042                 } else {
4043                   whitename = star_match[1];
4044                   blackname = star_match[3];
4045                   why = star_match[5];
4046                   endtoken = star_match[6];
4047                 }
4048
4049                 /* Game start messages */
4050                 if (strncmp(why, "Creating ", 9) == 0 ||
4051                     strncmp(why, "Continuing ", 11) == 0) {
4052                     gs_gamenum = gamenum;
4053                     safeStrCpy(gs_kind, strchr(why, ' ') + 1,sizeof(gs_kind)/sizeof(gs_kind[0]));
4054                     if(ics_gamenum == -1) // [HGM] only if we are not already involved in a game (because gin=1 sends us such messages)
4055                     VariantSwitch(boards[currentMove], StringToVariant(gs_kind)); // [HGM] variantswitch: even before we get first board
4056 #if ZIPPY
4057                     if (appData.zippyPlay) {
4058                         ZippyGameStart(whitename, blackname);
4059                     }
4060 #endif /*ZIPPY*/
4061                     partnerBoardValid = FALSE; // [HGM] bughouse
4062                     continue;
4063                 }
4064
4065                 /* Game end messages */
4066                 if (gameMode == IcsIdle || gameMode == BeginningOfGame ||
4067                     ics_gamenum != gamenum) {
4068                     continue;
4069                 }
4070                 while (endtoken[0] == ' ') endtoken++;
4071                 switch (endtoken[0]) {
4072                   case '*':
4073                   default:
4074                     endtype = GameUnfinished;
4075                     break;
4076                   case '0':
4077                     endtype = BlackWins;
4078                     break;
4079                   case '1':
4080                     if (endtoken[1] == '/')
4081                       endtype = GameIsDrawn;
4082                     else
4083                       endtype = WhiteWins;
4084                     break;
4085                 }
4086                 GameEnds(endtype, why, GE_ICS);
4087 #if ZIPPY
4088                 if (appData.zippyPlay && first.initDone) {
4089                     ZippyGameEnd(endtype, why);
4090                     if (first.pr == NoProc) {
4091                       /* Start the next process early so that we'll
4092                          be ready for the next challenge */
4093                       StartChessProgram(&first);
4094                     }
4095                     /* Send "new" early, in case this command takes
4096                        a long time to finish, so that we'll be ready
4097                        for the next challenge. */
4098                     gameInfo.variant = VariantNormal; // [HGM] variantswitch: suppress sending of 'variant'
4099                     Reset(TRUE, TRUE);
4100                 }
4101 #endif /*ZIPPY*/
4102                 if(appData.bgObserve && partnerBoardValid) DrawPosition(TRUE, partnerBoard);
4103                 continue;
4104             }
4105
4106             if (looking_at(buf, &i, "Removing game * from observation") ||
4107                 looking_at(buf, &i, "no longer observing game *") ||
4108                 looking_at(buf, &i, "Game * (*) has no examiners")) {
4109                 if (gameMode == IcsObserving &&
4110                     atoi(star_match[0]) == ics_gamenum)
4111                   {
4112                       /* icsEngineAnalyze */
4113                       if (appData.icsEngineAnalyze) {
4114                             ExitAnalyzeMode();
4115                             ModeHighlight();
4116                       }
4117                       StopClocks();
4118                       gameMode = IcsIdle;
4119                       ics_gamenum = -1;
4120                       ics_user_moved = FALSE;
4121                   }
4122                 continue;
4123             }
4124
4125             if (looking_at(buf, &i, "no longer examining game *")) {
4126                 if (gameMode == IcsExamining &&
4127                     atoi(star_match[0]) == ics_gamenum)
4128                   {
4129                       gameMode = IcsIdle;
4130                       ics_gamenum = -1;
4131                       ics_user_moved = FALSE;
4132                   }
4133                 continue;
4134             }
4135
4136             /* Advance leftover_start past any newlines we find,
4137                so only partial lines can get reparsed */
4138             if (looking_at(buf, &i, "\n")) {
4139                 prevColor = curColor;
4140                 if (curColor != ColorNormal) {
4141                     if (oldi > next_out) {
4142                         SendToPlayer(&buf[next_out], oldi - next_out);
4143                         next_out = oldi;
4144                     }
4145                     Colorize(ColorNormal, FALSE);
4146                     curColor = ColorNormal;
4147                 }
4148                 if (started == STARTED_BOARD) {
4149                     started = STARTED_NONE;
4150                     parse[parse_pos] = NULLCHAR;
4151                     ParseBoard12(parse);
4152                     ics_user_moved = 0;
4153
4154                     /* Send premove here */
4155                     if (appData.premove) {
4156                       char str[MSG_SIZ];
4157                       if (currentMove == 0 &&
4158                           gameMode == IcsPlayingWhite &&
4159                           appData.premoveWhite) {
4160                         snprintf(str, MSG_SIZ, "%s\n", appData.premoveWhiteText);
4161                         if (appData.debugMode)
4162                           fprintf(debugFP, "Sending premove:\n");
4163                         SendToICS(str);
4164                       } else if (currentMove == 1 &&
4165                                  gameMode == IcsPlayingBlack &&
4166                                  appData.premoveBlack) {
4167                         snprintf(str, MSG_SIZ, "%s\n", appData.premoveBlackText);
4168                         if (appData.debugMode)
4169                           fprintf(debugFP, "Sending premove:\n");
4170                         SendToICS(str);
4171                       } else if (gotPremove) {
4172                         int oldFMM = forwardMostMove;
4173                         gotPremove = 0;
4174                         ClearPremoveHighlights();
4175                         if (appData.debugMode)
4176                           fprintf(debugFP, "Sending premove:\n");
4177                           UserMoveEvent(premoveFromX, premoveFromY,
4178                                         premoveToX, premoveToY,
4179                                         premovePromoChar);
4180                         if(forwardMostMove == oldFMM) { // premove was rejected, highlight last opponent move
4181                           if(moveList[oldFMM-1][1] != '@')
4182                             SetHighlights(moveList[oldFMM-1][0]-AAA, moveList[oldFMM-1][1]-ONE,
4183                                           moveList[oldFMM-1][2]-AAA, moveList[oldFMM-1][3]-ONE);
4184                           else // (drop)
4185                             SetHighlights(-1, -1, moveList[oldFMM-1][2]-AAA, moveList[oldFMM-1][3]-ONE);
4186                         }
4187                       }
4188                     }
4189
4190                     /* Usually suppress following prompt */
4191                     if (!(forwardMostMove == 0 && gameMode == IcsExamining)) {
4192                         while(looking_at(buf, &i, "\n")); // [HGM] skip empty lines
4193                         if (looking_at(buf, &i, "*% ")) {
4194                             savingComment = FALSE;
4195                             suppressKibitz = 0;
4196                         }
4197                     }
4198                     next_out = i;
4199                 } else if (started == STARTED_HOLDINGS) {
4200                     int gamenum;
4201                     char new_piece[MSG_SIZ];
4202                     started = STARTED_NONE;
4203                     parse[parse_pos] = NULLCHAR;
4204                     if (appData.debugMode)
4205                       fprintf(debugFP, "Parsing holdings: %s, currentMove = %d\n",
4206                                                         parse, currentMove);
4207                     if (sscanf(parse, " game %d", &gamenum) == 1) {
4208                       if(gamenum == ics_gamenum) { // [HGM] bughouse: old code if part of foreground game
4209                         if (gameInfo.variant == VariantNormal) {
4210                           /* [HGM] We seem to switch variant during a game!
4211                            * Presumably no holdings were displayed, so we have
4212                            * to move the position two files to the right to
4213                            * create room for them!
4214                            */
4215                           VariantClass newVariant;
4216                           switch(gameInfo.boardWidth) { // base guess on board width
4217                                 case 9:  newVariant = VariantShogi; break;
4218                                 case 10: newVariant = VariantGreat; break;
4219                                 default: newVariant = VariantCrazyhouse; break;
4220                           }
4221                           VariantSwitch(boards[currentMove], newVariant); /* temp guess */
4222                           /* Get a move list just to see the header, which
4223                              will tell us whether this is really bug or zh */
4224                           if (ics_getting_history == H_FALSE) {
4225                             ics_getting_history = H_REQUESTED;
4226                             snprintf(str, MSG_SIZ, "%smoves %d\n", ics_prefix, gamenum);
4227                             SendToICS(str);
4228                           }
4229                         }
4230                         new_piece[0] = NULLCHAR;
4231                         sscanf(parse, "game %d white [%s black [%s <- %s",
4232                                &gamenum, white_holding, black_holding,
4233                                new_piece);
4234                         white_holding[strlen(white_holding)-1] = NULLCHAR;
4235                         black_holding[strlen(black_holding)-1] = NULLCHAR;
4236                         /* [HGM] copy holdings to board holdings area */
4237                         CopyHoldings(boards[forwardMostMove], white_holding, WhitePawn);
4238                         CopyHoldings(boards[forwardMostMove], black_holding, BlackPawn);
4239                         boards[forwardMostMove][HOLDINGS_SET] = 1; // flag holdings as set
4240 #if ZIPPY
4241                         if (appData.zippyPlay && first.initDone) {
4242                             ZippyHoldings(white_holding, black_holding,
4243                                           new_piece);
4244                         }
4245 #endif /*ZIPPY*/
4246                         if (tinyLayout || smallLayout) {
4247                             char wh[16], bh[16];
4248                             PackHolding(wh, white_holding);
4249                             PackHolding(bh, black_holding);
4250                             snprintf(str, MSG_SIZ, "[%s-%s] %s-%s", wh, bh,
4251                                     gameInfo.white, gameInfo.black);
4252                         } else {
4253                           snprintf(str, MSG_SIZ, "%s [%s] %s %s [%s]",
4254                                     gameInfo.white, white_holding, _("vs."),
4255                                     gameInfo.black, black_holding);
4256                         }
4257                         if(!partnerUp) // [HGM] bughouse: when peeking at partner game we already know what he captured...
4258                         DrawPosition(FALSE, boards[currentMove]);
4259                         DisplayTitle(str);
4260                       } else if(appData.bgObserve) { // [HGM] bughouse: holdings of other game => background
4261                         sscanf(parse, "game %d white [%s black [%s <- %s",
4262                                &gamenum, white_holding, black_holding,
4263                                new_piece);
4264                         white_holding[strlen(white_holding)-1] = NULLCHAR;
4265                         black_holding[strlen(black_holding)-1] = NULLCHAR;
4266                         /* [HGM] copy holdings to partner-board holdings area */
4267                         CopyHoldings(partnerBoard, white_holding, WhitePawn);
4268                         CopyHoldings(partnerBoard, black_holding, BlackPawn);
4269                         if(twoBoards) { partnerUp = 1; flipView = !flipView; } // [HGM] dual: always draw
4270                         if(partnerUp) DrawPosition(FALSE, partnerBoard);
4271                         if(twoBoards) { partnerUp = 0; flipView = !flipView; }
4272                       }
4273                     }
4274                     /* Suppress following prompt */
4275                     if (looking_at(buf, &i, "*% ")) {
4276                         if(strchr(star_match[0], 7)) SendToPlayer("\007", 1); // Bell(); // FICS fuses bell for next board with prompt in zh captures
4277                         savingComment = FALSE;
4278                         suppressKibitz = 0;
4279                     }
4280                     next_out = i;
4281                 }
4282                 continue;
4283             }
4284
4285             i++;                /* skip unparsed character and loop back */
4286         }
4287
4288         if (started != STARTED_MOVES && started != STARTED_BOARD && !suppressKibitz && // [HGM] kibitz
4289 //          started != STARTED_HOLDINGS && i > next_out) { // [HGM] should we compare to leftover_start in stead of i?
4290 //          SendToPlayer(&buf[next_out], i - next_out);
4291             started != STARTED_HOLDINGS && leftover_start > next_out) {
4292             SendToPlayer(&buf[next_out], leftover_start - next_out);
4293             next_out = i;
4294         }
4295
4296         leftover_len = buf_len - leftover_start;
4297         /* if buffer ends with something we couldn't parse,
4298            reparse it after appending the next read */
4299
4300     } else if (count == 0) {
4301         RemoveInputSource(isr);
4302         DisplayFatalError(_("Connection closed by ICS"), 0, 0);
4303     } else {
4304         DisplayFatalError(_("Error reading from ICS"), error, 1);
4305     }
4306 }
4307
4308
4309 /* Board style 12 looks like this:
4310
4311    <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
4312
4313  * The "<12> " is stripped before it gets to this routine.  The two
4314  * trailing 0's (flip state and clock ticking) are later addition, and
4315  * some chess servers may not have them, or may have only the first.
4316  * Additional trailing fields may be added in the future.
4317  */
4318
4319 #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"
4320
4321 #define RELATION_OBSERVING_PLAYED    0
4322 #define RELATION_OBSERVING_STATIC   -2   /* examined, oldmoves, or smoves */
4323 #define RELATION_PLAYING_MYMOVE      1
4324 #define RELATION_PLAYING_NOTMYMOVE  -1
4325 #define RELATION_EXAMINING           2
4326 #define RELATION_ISOLATED_BOARD     -3
4327 #define RELATION_STARTING_POSITION  -4   /* FICS only */
4328
4329 void
4330 ParseBoard12 (char *string)
4331 {
4332 #if ZIPPY
4333     int i, takeback;
4334     char *bookHit = NULL; // [HGM] book
4335 #endif
4336     GameMode newGameMode;
4337     int gamenum, newGame, newMove, relation, basetime, increment, ics_flip = 0;
4338     int j, k, n, moveNum, white_stren, black_stren, white_time, black_time;
4339     int double_push, castle_ws, castle_wl, castle_bs, castle_bl, irrev_count;
4340     char to_play, board_chars[200];
4341     char move_str[MSG_SIZ], str[MSG_SIZ], elapsed_time[MSG_SIZ];
4342     char black[32], white[32];
4343     Board board;
4344     int prevMove = currentMove;
4345     int ticking = 2;
4346     ChessMove moveType;
4347     int fromX, fromY, toX, toY;
4348     char promoChar;
4349     int ranks=1, files=0; /* [HGM] ICS80: allow variable board size */
4350     Boolean weird = FALSE, reqFlag = FALSE;
4351
4352     fromX = fromY = toX = toY = -1;
4353
4354     newGame = FALSE;
4355
4356     if (appData.debugMode)
4357       fprintf(debugFP, "Parsing board: %s\n", string);
4358
4359     move_str[0] = NULLCHAR;
4360     elapsed_time[0] = NULLCHAR;
4361     {   /* [HGM] figure out how many ranks and files the board has, for ICS extension used by Capablanca server */
4362         int  i = 0, j;
4363         while(i < 199 && (string[i] != ' ' || string[i+2] != ' ')) {
4364             if(string[i] == ' ') { ranks++; files = 0; }
4365             else files++;
4366             if(!strchr(" -pnbrqkPNBRQK" , string[i])) weird = TRUE; // test for fairies
4367             i++;
4368         }
4369         for(j = 0; j <i; j++) board_chars[j] = string[j];
4370         board_chars[i] = '\0';
4371         string += i + 1;
4372     }
4373     n = sscanf(string, PATTERN, &to_play, &double_push,
4374                &castle_ws, &castle_wl, &castle_bs, &castle_bl, &irrev_count,
4375                &gamenum, white, black, &relation, &basetime, &increment,
4376                &white_stren, &black_stren, &white_time, &black_time,
4377                &moveNum, str, elapsed_time, move_str, &ics_flip,
4378                &ticking);
4379
4380     if (n < 21) {
4381         snprintf(str, MSG_SIZ, _("Failed to parse board string:\n\"%s\""), string);
4382         DisplayError(str, 0);
4383         return;
4384     }
4385
4386     /* Convert the move number to internal form */
4387     moveNum = (moveNum - 1) * 2;
4388     if (to_play == 'B') moveNum++;
4389     if (moveNum > framePtr) { // [HGM] vari: do not run into saved variations
4390       DisplayFatalError(_("Game too long; increase MAX_MOVES and recompile"),
4391                         0, 1);
4392       return;
4393     }
4394
4395     switch (relation) {
4396       case RELATION_OBSERVING_PLAYED:
4397       case RELATION_OBSERVING_STATIC:
4398         if (gamenum == -1) {
4399             /* Old ICC buglet */
4400             relation = RELATION_OBSERVING_STATIC;
4401         }
4402         newGameMode = IcsObserving;
4403         break;
4404       case RELATION_PLAYING_MYMOVE:
4405       case RELATION_PLAYING_NOTMYMOVE:
4406         newGameMode =
4407           ((relation == RELATION_PLAYING_MYMOVE) == (to_play == 'W')) ?
4408             IcsPlayingWhite : IcsPlayingBlack;
4409         soughtPending =FALSE; // [HGM] seekgraph: solve race condition
4410         break;
4411       case RELATION_EXAMINING:
4412         newGameMode = IcsExamining;
4413         break;
4414       case RELATION_ISOLATED_BOARD:
4415       default:
4416         /* Just display this board.  If user was doing something else,
4417            we will forget about it until the next board comes. */
4418         newGameMode = IcsIdle;
4419         break;
4420       case RELATION_STARTING_POSITION:
4421         newGameMode = gameMode;
4422         break;
4423     }
4424
4425     if((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack ||
4426         gameMode == IcsObserving && appData.dualBoard) // also allow use of second board for observing two games
4427          && newGameMode == IcsObserving && gamenum != ics_gamenum && appData.bgObserve) {
4428       // [HGM] bughouse: don't act on alien boards while we play. Just parse the board and save it */
4429       int fac = strchr(elapsed_time, '.') ? 1 : 1000;
4430       static int lastBgGame = -1;
4431       char *toSqr;
4432       for (k = 0; k < ranks; k++) {
4433         for (j = 0; j < files; j++)
4434           board[k][j+gameInfo.holdingsWidth] = CharToPiece(board_chars[(ranks-1-k)*(files+1) + j]);
4435         if(gameInfo.holdingsWidth > 1) {
4436              board[k][0] = board[k][BOARD_WIDTH-1] = EmptySquare;
4437              board[k][1] = board[k][BOARD_WIDTH-2] = (ChessSquare) 0;;
4438         }
4439       }
4440       CopyBoard(partnerBoard, board);
4441       if(toSqr = strchr(str, '/')) { // extract highlights from long move
4442         partnerBoard[EP_STATUS-3] = toSqr[1] - AAA; // kludge: hide highlighting info in board
4443         partnerBoard[EP_STATUS-4] = toSqr[2] - ONE;
4444       } else partnerBoard[EP_STATUS-4] = partnerBoard[EP_STATUS-3] = -1;
4445       if(toSqr = strchr(str, '-')) {
4446         partnerBoard[EP_STATUS-1] = toSqr[1] - AAA;
4447         partnerBoard[EP_STATUS-2] = toSqr[2] - ONE;
4448       } else partnerBoard[EP_STATUS-1] = partnerBoard[EP_STATUS-2] = -1;
4449       if(appData.dualBoard && !twoBoards) { twoBoards = 1; InitDrawingSizes(-2,0); }
4450       if(twoBoards) { partnerUp = 1; flipView = !flipView; } // [HGM] dual
4451       if(partnerUp) DrawPosition(FALSE, partnerBoard);
4452       if(twoBoards) {
4453           DisplayWhiteClock(white_time*fac, to_play == 'W');
4454           DisplayBlackClock(black_time*fac, to_play != 'W');
4455           activePartner = to_play;
4456           if(gamenum != lastBgGame) {
4457               char buf[MSG_SIZ];
4458               snprintf(buf, MSG_SIZ, "%s %s %s", white, _("vs."), black);
4459               DisplayTitle(buf);
4460           }
4461           lastBgGame = gamenum;
4462           activePartnerTime = to_play == 'W' ? white_time*fac : black_time*fac;
4463                       partnerUp = 0; flipView = !flipView; } // [HGM] dual
4464       snprintf(partnerStatus, MSG_SIZ,"W: %d:%02d B: %d:%02d (%d-%d) %c", white_time*fac/60000, (white_time*fac%60000)/1000,
4465                  (black_time*fac/60000), (black_time*fac%60000)/1000, white_stren, black_stren, to_play);
4466       if(!twoBoards) DisplayMessage(partnerStatus, "");
4467         partnerBoardValid = TRUE;
4468       return;
4469     }
4470
4471     if(appData.dualBoard && appData.bgObserve) {
4472         if((newGameMode == IcsPlayingWhite || newGameMode == IcsPlayingBlack) && moveNum == 1)
4473             SendToICS(ics_prefix), SendToICS("pobserve\n");
4474         else if(newGameMode == IcsObserving && (gameMode == BeginningOfGame || gameMode == IcsIdle)) {
4475             char buf[MSG_SIZ];
4476             snprintf(buf, MSG_SIZ, "%spobserve %s\n", ics_prefix, white);
4477             SendToICS(buf);
4478         }
4479     }
4480
4481     /* Modify behavior for initial board display on move listing
4482        of wild games.
4483        */
4484     switch (ics_getting_history) {
4485       case H_FALSE:
4486       case H_REQUESTED:
4487         break;
4488       case H_GOT_REQ_HEADER:
4489       case H_GOT_UNREQ_HEADER:
4490         /* This is the initial position of the current game */
4491         gamenum = ics_gamenum;
4492         moveNum = 0;            /* old ICS bug workaround */
4493         if (to_play == 'B') {
4494           startedFromSetupPosition = TRUE;
4495           blackPlaysFirst = TRUE;
4496           moveNum = 1;
4497           if (forwardMostMove == 0) forwardMostMove = 1;
4498           if (backwardMostMove == 0) backwardMostMove = 1;
4499           if (currentMove == 0) currentMove = 1;
4500         }
4501         newGameMode = gameMode;
4502         relation = RELATION_STARTING_POSITION; /* ICC needs this */
4503         break;
4504       case H_GOT_UNWANTED_HEADER:
4505         /* This is an initial board that we don't want */
4506         return;
4507       case H_GETTING_MOVES:
4508         /* Should not happen */
4509         DisplayError(_("Error gathering move list: extra board"), 0);
4510         ics_getting_history = H_FALSE;
4511         return;
4512     }
4513
4514    if (gameInfo.boardHeight != ranks || gameInfo.boardWidth != files ||
4515                                         move_str[1] == '@' && !gameInfo.holdingsWidth ||
4516                                         weird && (int)gameInfo.variant < (int)VariantShogi) {
4517      /* [HGM] We seem to have switched variant unexpectedly
4518       * Try to guess new variant from board size
4519       */
4520           VariantClass newVariant = VariantFairy; // if 8x8, but fairies present
4521           if(ranks == 8 && files == 10) newVariant = VariantCapablanca; else
4522           if(ranks == 10 && files == 9) newVariant = VariantXiangqi; else
4523           if(ranks == 8 && files == 12) newVariant = VariantCourier; else
4524           if(ranks == 9 && files == 9)  newVariant = VariantShogi; else
4525           if(ranks == 10 && files == 10) newVariant = VariantGrand; else
4526           if(!weird) newVariant = move_str[1] == '@' ? VariantCrazyhouse : VariantNormal;
4527           VariantSwitch(boards[currentMove], newVariant); /* temp guess */
4528           /* Get a move list just to see the header, which
4529              will tell us whether this is really bug or zh */
4530           if (ics_getting_history == H_FALSE) {
4531             ics_getting_history = H_REQUESTED; reqFlag = TRUE;
4532             snprintf(str, MSG_SIZ, "%smoves %d\n", ics_prefix, gamenum);
4533             SendToICS(str);
4534           }
4535     }
4536
4537     /* Take action if this is the first board of a new game, or of a
4538        different game than is currently being displayed.  */
4539     if (gamenum != ics_gamenum || newGameMode != gameMode ||
4540         relation == RELATION_ISOLATED_BOARD) {
4541
4542         /* Forget the old game and get the history (if any) of the new one */
4543         if (gameMode != BeginningOfGame) {
4544           Reset(TRUE, TRUE);
4545         }
4546         newGame = TRUE;
4547         if (appData.autoRaiseBoard) BoardToTop();
4548         prevMove = -3;
4549         if (gamenum == -1) {
4550             newGameMode = IcsIdle;
4551         } else if ((moveNum > 0 || newGameMode == IcsObserving) && newGameMode != IcsIdle &&
4552                    appData.getMoveList && !reqFlag) {
4553             /* Need to get game history */
4554             ics_getting_history = H_REQUESTED;
4555             snprintf(str, MSG_SIZ, "%smoves %d\n", ics_prefix, gamenum);
4556             SendToICS(str);
4557         }
4558
4559         /* Initially flip the board to have black on the bottom if playing
4560            black or if the ICS flip flag is set, but let the user change
4561            it with the Flip View button. */
4562         flipView = appData.autoFlipView ?
4563           (newGameMode == IcsPlayingBlack) || ics_flip :
4564           appData.flipView;
4565
4566         /* Done with values from previous mode; copy in new ones */
4567         gameMode = newGameMode;
4568         ModeHighlight();
4569         ics_gamenum = gamenum;
4570         if (gamenum == gs_gamenum) {
4571             int klen = strlen(gs_kind);
4572             if (gs_kind[klen - 1] == '.') gs_kind[klen - 1] = NULLCHAR;
4573             snprintf(str, MSG_SIZ, "ICS %s", gs_kind);
4574             gameInfo.event = StrSave(str);
4575         } else {
4576             gameInfo.event = StrSave("ICS game");
4577         }
4578         gameInfo.site = StrSave(appData.icsHost);
4579         gameInfo.date = PGNDate();
4580         gameInfo.round = StrSave("-");
4581         gameInfo.white = StrSave(white);
4582         gameInfo.black = StrSave(black);
4583         timeControl = basetime * 60 * 1000;
4584         timeControl_2 = 0;
4585         timeIncrement = increment * 1000;
4586         movesPerSession = 0;
4587         gameInfo.timeControl = TimeControlTagValue();
4588         VariantSwitch(boards[currentMove], StringToVariant(gameInfo.event) );
4589   if (appData.debugMode) {
4590     fprintf(debugFP, "ParseBoard says variant = '%s'\n", gameInfo.event);
4591     fprintf(debugFP, "recognized as %s\n", VariantName(gameInfo.variant));
4592     setbuf(debugFP, NULL);
4593   }
4594
4595         gameInfo.outOfBook = NULL;
4596
4597         /* Do we have the ratings? */
4598         if (strcmp(player1Name, white) == 0 &&
4599             strcmp(player2Name, black) == 0) {
4600             if (appData.debugMode)
4601               fprintf(debugFP, "Remembered ratings: W %d, B %d\n",
4602                       player1Rating, player2Rating);
4603             gameInfo.whiteRating = player1Rating;
4604             gameInfo.blackRating = player2Rating;
4605         } else if (strcmp(player2Name, white) == 0 &&
4606                    strcmp(player1Name, black) == 0) {
4607             if (appData.debugMode)
4608               fprintf(debugFP, "Remembered ratings: W %d, B %d\n",
4609                       player2Rating, player1Rating);
4610             gameInfo.whiteRating = player2Rating;
4611             gameInfo.blackRating = player1Rating;
4612         }
4613         player1Name[0] = player2Name[0] = NULLCHAR;
4614
4615         /* Silence shouts if requested */
4616         if (appData.quietPlay &&
4617             (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack)) {
4618             SendToICS(ics_prefix);
4619             SendToICS("set shout 0\n");
4620         }
4621     }
4622
4623     /* Deal with midgame name changes */
4624     if (!newGame) {
4625         if (!gameInfo.white || strcmp(gameInfo.white, white) != 0) {
4626             if (gameInfo.white) free(gameInfo.white);
4627             gameInfo.white = StrSave(white);
4628         }
4629         if (!gameInfo.black || strcmp(gameInfo.black, black) != 0) {
4630             if (gameInfo.black) free(gameInfo.black);
4631             gameInfo.black = StrSave(black);
4632         }
4633     }
4634
4635     /* Throw away game result if anything actually changes in examine mode */
4636     if (gameMode == IcsExamining && !newGame) {
4637         gameInfo.result = GameUnfinished;
4638         if (gameInfo.resultDetails != NULL) {
4639             free(gameInfo.resultDetails);
4640             gameInfo.resultDetails = NULL;
4641         }
4642     }
4643
4644     /* In pausing && IcsExamining mode, we ignore boards coming
4645        in if they are in a different variation than we are. */
4646     if (pauseExamInvalid) return;
4647     if (pausing && gameMode == IcsExamining) {
4648         if (moveNum <= pauseExamForwardMostMove) {
4649             pauseExamInvalid = TRUE;
4650             forwardMostMove = pauseExamForwardMostMove;
4651             return;
4652         }
4653     }
4654
4655   if (appData.debugMode) {
4656     fprintf(debugFP, "load %dx%d board\n", files, ranks);
4657   }
4658     /* Parse the board */
4659     for (k = 0; k < ranks; k++) {
4660       for (j = 0; j < files; j++)
4661         board[k][j+gameInfo.holdingsWidth] = CharToPiece(board_chars[(ranks-1-k)*(files+1) + j]);
4662       if(gameInfo.holdingsWidth > 1) {
4663            board[k][0] = board[k][BOARD_WIDTH-1] = EmptySquare;
4664            board[k][1] = board[k][BOARD_WIDTH-2] = (ChessSquare) 0;;
4665       }
4666     }
4667     if(moveNum==0 && gameInfo.variant == VariantSChess) {
4668       board[5][BOARD_RGHT+1] = WhiteAngel;
4669       board[6][BOARD_RGHT+1] = WhiteMarshall;
4670       board[1][0] = BlackMarshall;
4671       board[2][0] = BlackAngel;
4672       board[1][1] = board[2][1] = board[5][BOARD_RGHT] = board[6][BOARD_RGHT] = 1;
4673     }
4674     CopyBoard(boards[moveNum], board);
4675     boards[moveNum][HOLDINGS_SET] = 0; // [HGM] indicate holdings not set
4676     if (moveNum == 0) {
4677         startedFromSetupPosition =
4678           !CompareBoards(board, initialPosition);
4679         if(startedFromSetupPosition)
4680             initialRulePlies = irrev_count; /* [HGM] 50-move counter offset */
4681     }
4682
4683     /* [HGM] Set castling rights. Take the outermost Rooks,
4684        to make it also work for FRC opening positions. Note that board12
4685        is really defective for later FRC positions, as it has no way to
4686        indicate which Rook can castle if they are on the same side of King.
4687        For the initial position we grant rights to the outermost Rooks,
4688        and remember thos rights, and we then copy them on positions
4689        later in an FRC game. This means WB might not recognize castlings with
4690        Rooks that have moved back to their original position as illegal,
4691        but in ICS mode that is not its job anyway.
4692     */
4693     if(moveNum == 0 || gameInfo.variant != VariantFischeRandom)
4694     { int i, j; ChessSquare wKing = WhiteKing, bKing = BlackKing;
4695
4696         for(i=BOARD_LEFT, j=NoRights; i<BOARD_RGHT; i++)
4697             if(board[0][i] == WhiteRook) j = i;
4698         initialRights[0] = boards[moveNum][CASTLING][0] = (castle_ws == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
4699         for(i=BOARD_RGHT-1, j=NoRights; i>=BOARD_LEFT; i--)
4700             if(board[0][i] == WhiteRook) j = i;
4701         initialRights[1] = boards[moveNum][CASTLING][1] = (castle_wl == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
4702         for(i=BOARD_LEFT, j=NoRights; i<BOARD_RGHT; i++)
4703             if(board[BOARD_HEIGHT-1][i] == BlackRook) j = i;
4704         initialRights[3] = boards[moveNum][CASTLING][3] = (castle_bs == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
4705         for(i=BOARD_RGHT-1, j=NoRights; i>=BOARD_LEFT; i--)
4706             if(board[BOARD_HEIGHT-1][i] == BlackRook) j = i;
4707         initialRights[4] = boards[moveNum][CASTLING][4] = (castle_bl == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
4708
4709         boards[moveNum][CASTLING][2] = boards[moveNum][CASTLING][5] = NoRights;
4710         if(gameInfo.variant == VariantKnightmate) { wKing = WhiteUnicorn; bKing = BlackUnicorn; }
4711         for(k=BOARD_LEFT; k<BOARD_RGHT; k++)
4712             if(board[0][k] == wKing) initialRights[2] = boards[moveNum][CASTLING][2] = k;
4713         for(k=BOARD_LEFT; k<BOARD_RGHT; k++)
4714             if(board[BOARD_HEIGHT-1][k] == bKing)
4715                 initialRights[5] = boards[moveNum][CASTLING][5] = k;
4716         if(gameInfo.variant == VariantTwoKings) {
4717             // In TwoKings looking for a King does not work, so always give castling rights to a King on e1/e8
4718             if(board[0][4] == wKing) initialRights[2] = boards[moveNum][CASTLING][2] = 4;
4719             if(board[BOARD_HEIGHT-1][4] == bKing) initialRights[5] = boards[moveNum][CASTLING][5] = 4;
4720         }
4721     } else { int r;
4722         r = boards[moveNum][CASTLING][0] = initialRights[0];
4723         if(board[0][r] != WhiteRook) boards[moveNum][CASTLING][0] = NoRights;
4724         r = boards[moveNum][CASTLING][1] = initialRights[1];
4725         if(board[0][r] != WhiteRook) boards[moveNum][CASTLING][1] = NoRights;
4726         r = boards[moveNum][CASTLING][3] = initialRights[3];
4727         if(board[BOARD_HEIGHT-1][r] != BlackRook) boards[moveNum][CASTLING][3] = NoRights;
4728         r = boards[moveNum][CASTLING][4] = initialRights[4];
4729         if(board[BOARD_HEIGHT-1][r] != BlackRook) boards[moveNum][CASTLING][4] = NoRights;
4730         /* wildcastle kludge: always assume King has rights */
4731         r = boards[moveNum][CASTLING][2] = initialRights[2];
4732         r = boards[moveNum][CASTLING][5] = initialRights[5];
4733     }
4734     /* [HGM] e.p. rights. Assume that ICS sends file number here? */
4735     boards[moveNum][EP_STATUS] = EP_NONE;
4736     if(str[0] == 'P') boards[moveNum][EP_STATUS] = EP_PAWN_MOVE;
4737     if(strchr(move_str, 'x')) boards[moveNum][EP_STATUS] = EP_CAPTURE;
4738     if(double_push !=  -1) boards[moveNum][EP_STATUS] = double_push + BOARD_LEFT;
4739
4740
4741     if (ics_getting_history == H_GOT_REQ_HEADER ||
4742         ics_getting_history == H_GOT_UNREQ_HEADER) {
4743         /* This was an initial position from a move list, not
4744            the current position */
4745         return;
4746     }
4747
4748     /* Update currentMove and known move number limits */
4749     newMove = newGame || moveNum > forwardMostMove;
4750
4751     if (newGame) {
4752         forwardMostMove = backwardMostMove = currentMove = moveNum;
4753         if (gameMode == IcsExamining && moveNum == 0) {
4754           /* Workaround for ICS limitation: we are not told the wild
4755              type when starting to examine a game.  But if we ask for
4756              the move list, the move list header will tell us */
4757             ics_getting_history = H_REQUESTED;
4758             snprintf(str, MSG_SIZ, "%smoves %d\n", ics_prefix, gamenum);
4759             SendToICS(str);
4760         }
4761     } else if (moveNum == forwardMostMove + 1 || moveNum == forwardMostMove
4762                || (moveNum < forwardMostMove && moveNum >= backwardMostMove)) {
4763 #if ZIPPY
4764         /* [DM] If we found takebacks during icsEngineAnalyze try send to engine */
4765         /* [HGM] applied this also to an engine that is silently watching        */
4766         if (appData.zippyPlay && moveNum < forwardMostMove && first.initDone &&
4767             (gameMode == IcsObserving || gameMode == IcsExamining) &&
4768             gameInfo.variant == currentlyInitializedVariant) {
4769           takeback = forwardMostMove - moveNum;
4770           for (i = 0; i < takeback; i++) {
4771             if (appData.debugMode) fprintf(debugFP, "take back move\n");
4772             SendToProgram("undo\n", &first);
4773           }
4774         }
4775 #endif
4776
4777         forwardMostMove = moveNum;
4778         if (!pausing || currentMove > forwardMostMove)
4779           currentMove = forwardMostMove;
4780     } else {
4781         /* New part of history that is not contiguous with old part */
4782         if (pausing && gameMode == IcsExamining) {
4783             pauseExamInvalid = TRUE;
4784             forwardMostMove = pauseExamForwardMostMove;
4785             return;
4786         }
4787         if (gameMode == IcsExamining && moveNum > 0 && appData.getMoveList) {
4788 #if ZIPPY
4789             if(appData.zippyPlay && forwardMostMove > 0 && first.initDone) {
4790                 // [HGM] when we will receive the move list we now request, it will be
4791                 // fed to the engine from the first move on. So if the engine is not
4792                 // in the initial position now, bring it there.
4793                 InitChessProgram(&first, 0);
4794             }
4795 #endif
4796             ics_getting_history = H_REQUESTED;
4797             snprintf(str, MSG_SIZ, "%smoves %d\n", ics_prefix, gamenum);
4798             SendToICS(str);
4799         }
4800         forwardMostMove = backwardMostMove = currentMove = moveNum;
4801     }
4802
4803     /* Update the clocks */
4804     if (strchr(elapsed_time, '.')) {
4805       /* Time is in ms */
4806       timeRemaining[0][moveNum] = whiteTimeRemaining = white_time;
4807       timeRemaining[1][moveNum] = blackTimeRemaining = black_time;
4808     } else {
4809       /* Time is in seconds */
4810       timeRemaining[0][moveNum] = whiteTimeRemaining = white_time * 1000;
4811       timeRemaining[1][moveNum] = blackTimeRemaining = black_time * 1000;
4812     }
4813
4814
4815 #if ZIPPY
4816     if (appData.zippyPlay && newGame &&
4817         gameMode != IcsObserving && gameMode != IcsIdle &&
4818         gameMode != IcsExamining)
4819       ZippyFirstBoard(moveNum, basetime, increment);
4820 #endif
4821
4822     /* Put the move on the move list, first converting
4823        to canonical algebraic form. */
4824     if (moveNum > 0) {
4825   if (appData.debugMode) {
4826     int f = forwardMostMove;
4827     fprintf(debugFP, "parseboard %d, castling = %d %d %d %d %d %d\n", f,
4828             boards[f][CASTLING][0],boards[f][CASTLING][1],boards[f][CASTLING][2],
4829             boards[f][CASTLING][3],boards[f][CASTLING][4],boards[f][CASTLING][5]);
4830     fprintf(debugFP, "accepted move %s from ICS, parse it.\n", move_str);
4831     fprintf(debugFP, "moveNum = %d\n", moveNum);
4832     fprintf(debugFP, "board = %d-%d x %d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT);
4833     setbuf(debugFP, NULL);
4834   }
4835         if (moveNum <= backwardMostMove) {
4836             /* We don't know what the board looked like before
4837                this move.  Punt. */
4838           safeStrCpy(parseList[moveNum - 1], move_str, sizeof(parseList[moveNum - 1])/sizeof(parseList[moveNum - 1][0]));
4839             strcat(parseList[moveNum - 1], " ");
4840             strcat(parseList[moveNum - 1], elapsed_time);
4841             moveList[moveNum - 1][0] = NULLCHAR;
4842         } else if (strcmp(move_str, "none") == 0) {
4843             // [HGM] long SAN: swapped order; test for 'none' before parsing move
4844             /* Again, we don't know what the board looked like;
4845                this is really the start of the game. */
4846             parseList[moveNum - 1][0] = NULLCHAR;
4847             moveList[moveNum - 1][0] = NULLCHAR;
4848             backwardMostMove = moveNum;
4849             startedFromSetupPosition = TRUE;
4850             fromX = fromY = toX = toY = -1;
4851         } else {
4852           // [HGM] long SAN: if legality-testing is off, disambiguation might not work or give wrong move.
4853           //                 So we parse the long-algebraic move string in stead of the SAN move
4854           int valid; char buf[MSG_SIZ], *prom;
4855
4856           if(gameInfo.variant == VariantShogi && !strchr(move_str, '=') && !strchr(move_str, '@'))
4857                 strcat(move_str, "="); // if ICS does not say 'promote' on non-drop, we defer.
4858           // str looks something like "Q/a1-a2"; kill the slash
4859           if(str[1] == '/')
4860             snprintf(buf, MSG_SIZ,"%c%s", str[0], str+2);
4861           else  safeStrCpy(buf, str, sizeof(buf)/sizeof(buf[0])); // might be castling
4862           if((prom = strstr(move_str, "=")) && !strstr(buf, "="))
4863                 strcat(buf, prom); // long move lacks promo specification!
4864           if(!appData.testLegality && move_str[1] != '@') { // drops never ambiguous (parser chokes on long form!)
4865                 if(appData.debugMode)
4866                         fprintf(debugFP, "replaced ICS move '%s' by '%s'\n", move_str, buf);
4867                 safeStrCpy(move_str, buf, MSG_SIZ);
4868           }
4869           valid = ParseOneMove(move_str, moveNum - 1, &moveType,
4870                                 &fromX, &fromY, &toX, &toY, &promoChar)
4871                || ParseOneMove(buf, moveNum - 1, &moveType,
4872                                 &fromX, &fromY, &toX, &toY, &promoChar);
4873           // end of long SAN patch
4874           if (valid) {
4875             (void) CoordsToAlgebraic(boards[moveNum - 1],
4876                                      PosFlags(moveNum - 1),
4877                                      fromY, fromX, toY, toX, promoChar,
4878                                      parseList[moveNum-1]);
4879             switch (MateTest(boards[moveNum], PosFlags(moveNum)) ) {
4880               case MT_NONE:
4881               case MT_STALEMATE:
4882               default:
4883                 break;
4884               case MT_CHECK:
4885                 if(!IS_SHOGI(gameInfo.variant))
4886                     strcat(parseList[moveNum - 1], "+");
4887                 break;
4888               case MT_CHECKMATE:
4889               case MT_STAINMATE: // [HGM] xq: for notation stalemate that wins counts as checkmate
4890                 strcat(parseList[moveNum - 1], "#");
4891                 break;
4892             }
4893             strcat(parseList[moveNum - 1], " ");
4894             strcat(parseList[moveNum - 1], elapsed_time);
4895             /* currentMoveString is set as a side-effect of ParseOneMove */
4896             if(gameInfo.variant == VariantShogi && currentMoveString[4]) currentMoveString[4] = '^';
4897             safeStrCpy(moveList[moveNum - 1], currentMoveString, sizeof(moveList[moveNum - 1])/sizeof(moveList[moveNum - 1][0]));
4898             strcat(moveList[moveNum - 1], "\n");
4899
4900             if(gameInfo.holdingsWidth && !appData.disguise && gameInfo.variant != VariantSuper && gameInfo.variant != VariantGreat
4901                && gameInfo.variant != VariantGrand&& gameInfo.variant != VariantSChess) // inherit info that ICS does not give from previous board
4902               for(k=0; k<ranks; k++) for(j=BOARD_LEFT; j<BOARD_RGHT; j++) {
4903                 ChessSquare old, new = boards[moveNum][k][j];
4904                   if(fromY == DROP_RANK && k==toY && j==toX) continue; // dropped pieces always stand for themselves
4905                   old = (k==toY && j==toX) ? boards[moveNum-1][fromY][fromX] : boards[moveNum-1][k][j]; // trace back mover
4906                   if(old == new) continue;
4907                   if(old == PROMOTED(new)) boards[moveNum][k][j] = old;// prevent promoted pieces to revert to primordial ones
4908                   else if(new == WhiteWazir || new == BlackWazir) {
4909                       if(old < WhiteCannon || old >= BlackPawn && old < BlackCannon)
4910                            boards[moveNum][k][j] = PROMOTED(old); // choose correct type of Gold in promotion
4911                       else boards[moveNum][k][j] = old; // preserve type of Gold
4912                   } else if((old == WhitePawn || old == BlackPawn) && new != EmptySquare) // Pawn promotions (but not e.p.capture!)
4913                       boards[moveNum][k][j] = PROMOTED(new); // use non-primordial representation of chosen piece
4914               }
4915           } else {
4916             /* Move from ICS was illegal!?  Punt. */
4917             if (appData.debugMode) {
4918               fprintf(debugFP, "Illegal move from ICS '%s'\n", move_str);
4919               fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
4920             }
4921             safeStrCpy(parseList[moveNum - 1], move_str, sizeof(parseList[moveNum - 1])/sizeof(parseList[moveNum - 1][0]));
4922             strcat(parseList[moveNum - 1], " ");
4923             strcat(parseList[moveNum - 1], elapsed_time);
4924             moveList[moveNum - 1][0] = NULLCHAR;
4925             fromX = fromY = toX = toY = -1;
4926           }
4927         }
4928   if (appData.debugMode) {
4929     fprintf(debugFP, "Move parsed to '%s'\n", parseList[moveNum - 1]);
4930     setbuf(debugFP, NULL);
4931   }
4932
4933 #if ZIPPY
4934         /* Send move to chess program (BEFORE animating it). */
4935         if (appData.zippyPlay && !newGame && newMove &&
4936            (!appData.getMoveList || backwardMostMove == 0) && first.initDone) {
4937
4938             if ((gameMode == IcsPlayingWhite && WhiteOnMove(moveNum)) ||
4939                 (gameMode == IcsPlayingBlack && !WhiteOnMove(moveNum))) {
4940                 if (moveList[moveNum - 1][0] == NULLCHAR) {
4941                   snprintf(str, MSG_SIZ, _("Couldn't parse move \"%s\" from ICS"),
4942                             move_str);
4943                     DisplayError(str, 0);
4944                 } else {
4945                     if (first.sendTime) {
4946                         SendTimeRemaining(&first, gameMode == IcsPlayingWhite);
4947                     }
4948                     bookHit = SendMoveToBookUser(moveNum - 1, &first, FALSE); // [HGM] book
4949                     if (firstMove && !bookHit) {
4950                         firstMove = FALSE;
4951                         if (first.useColors) {
4952                           SendToProgram(gameMode == IcsPlayingWhite ?
4953                                         "white\ngo\n" :
4954                                         "black\ngo\n", &first);
4955                         } else {
4956                           SendToProgram("go\n", &first);
4957                         }
4958                         first.maybeThinking = TRUE;
4959                     }
4960                 }
4961             } else if (gameMode == IcsObserving || gameMode == IcsExamining) {
4962               if (moveList[moveNum - 1][0] == NULLCHAR) {
4963                 snprintf(str, MSG_SIZ, _("Couldn't parse move \"%s\" from ICS"), move_str);
4964                 DisplayError(str, 0);
4965               } else {
4966                 if(gameInfo.variant == currentlyInitializedVariant) // [HGM] refrain sending moves engine can't understand!
4967                 SendMoveToProgram(moveNum - 1, &first);
4968               }
4969             }
4970         }
4971 #endif
4972     }
4973
4974     if (moveNum > 0 && !gotPremove && !appData.noGUI) {
4975         /* If move comes from a remote source, animate it.  If it
4976            isn't remote, it will have already been animated. */
4977         if (!pausing && !ics_user_moved && prevMove == moveNum - 1) {
4978             AnimateMove(boards[moveNum - 1], fromX, fromY, toX, toY);
4979         }
4980         if (!pausing && appData.highlightLastMove) {
4981             SetHighlights(fromX, fromY, toX, toY);
4982         }
4983     }
4984
4985     /* Start the clocks */
4986     whiteFlag = blackFlag = FALSE;
4987     appData.clockMode = !(basetime == 0 && increment == 0);
4988     if (ticking == 0) {
4989       ics_clock_paused = TRUE;
4990       StopClocks();
4991     } else if (ticking == 1) {
4992       ics_clock_paused = FALSE;
4993     }
4994     if (gameMode == IcsIdle ||
4995         relation == RELATION_OBSERVING_STATIC ||
4996         relation == RELATION_EXAMINING ||
4997         ics_clock_paused)
4998       DisplayBothClocks();
4999     else
5000       StartClocks();
5001
5002     /* Display opponents and material strengths */
5003     if (gameInfo.variant != VariantBughouse &&
5004         gameInfo.variant != VariantCrazyhouse && !appData.noGUI) {
5005         if (tinyLayout || smallLayout) {
5006             if(gameInfo.variant == VariantNormal)
5007               snprintf(str, MSG_SIZ, "%s(%d) %s(%d) {%d %d}",
5008                     gameInfo.white, white_stren, gameInfo.black, black_stren,
5009                     basetime, increment);
5010             else
5011               snprintf(str, MSG_SIZ, "%s(%d) %s(%d) {%d %d w%d}",
5012                     gameInfo.white, white_stren, gameInfo.black, black_stren,
5013                     basetime, increment, (int) gameInfo.variant);
5014         } else {
5015             if(gameInfo.variant == VariantNormal)
5016               snprintf(str, MSG_SIZ, "%s (%d) %s %s (%d) {%d %d}",
5017                     gameInfo.white, white_stren, _("vs."), gameInfo.black, black_stren,
5018                     basetime, increment);
5019             else
5020               snprintf(str, MSG_SIZ, "%s (%d) %s %s (%d) {%d %d %s}",
5021                     gameInfo.white, white_stren, _("vs."), gameInfo.black, black_stren,
5022                     basetime, increment, VariantName(gameInfo.variant));
5023         }
5024         DisplayTitle(str);
5025   if (appData.debugMode) {
5026     fprintf(debugFP, "Display title '%s, gameInfo.variant = %d'\n", str, gameInfo.variant);
5027   }
5028     }
5029
5030
5031     /* Display the board */
5032     if (!pausing && !appData.noGUI) {
5033
5034       if (appData.premove)
5035           if (!gotPremove ||
5036              ((gameMode == IcsPlayingWhite) && (WhiteOnMove(currentMove))) ||
5037              ((gameMode == IcsPlayingBlack) && (!WhiteOnMove(currentMove))))
5038               ClearPremoveHighlights();
5039
5040       j = seekGraphUp; seekGraphUp = FALSE; // [HGM] seekgraph: when we draw a board, it overwrites the seek graph
5041         if(partnerUp) { flipView = originalFlip; partnerUp = FALSE; j = TRUE; } // [HGM] bughouse: restore view
5042       DrawPosition(j, boards[currentMove]);
5043
5044       DisplayMove(moveNum - 1);
5045       if (appData.ringBellAfterMoves && /*!ics_user_moved*/ // [HGM] use absolute method to recognize own move
5046             !((gameMode == IcsPlayingWhite) && (!WhiteOnMove(moveNum)) ||
5047               (gameMode == IcsPlayingBlack) &&  (WhiteOnMove(moveNum))   ) ) {
5048         if(newMove) RingBell(); else PlayIcsUnfinishedSound();
5049       }
5050     }
5051
5052     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
5053 #if ZIPPY
5054     if(bookHit) { // [HGM] book: simulate book reply
5055         static char bookMove[MSG_SIZ]; // a bit generous?
5056
5057         programStats.nodes = programStats.depth = programStats.time =
5058         programStats.score = programStats.got_only_move = 0;
5059         sprintf(programStats.movelist, "%s (xbook)", bookHit);
5060
5061         safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
5062         strcat(bookMove, bookHit);
5063         HandleMachineMove(bookMove, &first);
5064     }
5065 #endif
5066 }
5067
5068 void
5069 GetMoveListEvent ()
5070 {
5071     char buf[MSG_SIZ];
5072     if (appData.icsActive && gameMode != IcsIdle && ics_gamenum > 0) {
5073         ics_getting_history = H_REQUESTED;
5074         snprintf(buf, MSG_SIZ, "%smoves %d\n", ics_prefix, ics_gamenum);
5075         SendToICS(buf);
5076     }
5077 }
5078
5079 void
5080 SendToBoth (char *msg)
5081 {   // to make it easy to keep two engines in step in dual analysis
5082     SendToProgram(msg, &first);
5083     if(second.analyzing) SendToProgram(msg, &second);
5084 }
5085
5086 void
5087 AnalysisPeriodicEvent (int force)
5088 {
5089     if (((programStats.ok_to_send == 0 || programStats.line_is_book)
5090          && !force) || !appData.periodicUpdates)
5091       return;
5092
5093     /* Send . command to Crafty to collect stats */
5094     SendToBoth(".\n");
5095
5096     /* Don't send another until we get a response (this makes
5097        us stop sending to old Crafty's which don't understand
5098        the "." command (sending illegal cmds resets node count & time,
5099        which looks bad)) */
5100     programStats.ok_to_send = 0;
5101 }
5102
5103 void
5104 ics_update_width (int new_width)
5105 {
5106         ics_printf("set width %d\n", new_width);
5107 }
5108
5109 void
5110 SendMoveToProgram (int moveNum, ChessProgramState *cps)
5111 {
5112     char buf[MSG_SIZ];
5113
5114     if(moveList[moveNum][1] == '@' && moveList[moveNum][0] == '@') {
5115         if(gameInfo.variant == VariantLion || gameInfo.variant == VariantChuChess || gameInfo.variant == VariantChu) {
5116             sprintf(buf, "%s@@@@\n", cps->useUsermove ? "usermove " : "");
5117             SendToProgram(buf, cps);
5118             return;
5119         }
5120         // null move in variant where engine does not understand it (for analysis purposes)
5121         SendBoard(cps, moveNum + 1); // send position after move in stead.
5122         return;
5123     }
5124     if (cps->useUsermove) {
5125       SendToProgram("usermove ", cps);
5126     }
5127     if (cps->useSAN) {
5128       char *space;
5129       if ((space = strchr(parseList[moveNum], ' ')) != NULL) {
5130         int len = space - parseList[moveNum];
5131         memcpy(buf, parseList[moveNum], len);
5132         buf[len++] = '\n';
5133         buf[len] = NULLCHAR;
5134       } else {
5135         snprintf(buf, MSG_SIZ,"%s\n", parseList[moveNum]);
5136       }
5137       SendToProgram(buf, cps);
5138     } else {
5139       if(cps->alphaRank) { /* [HGM] shogi: temporarily convert to shogi coordinates before sending */
5140         AlphaRank(moveList[moveNum], 4);
5141         SendToProgram(moveList[moveNum], cps);
5142         AlphaRank(moveList[moveNum], 4); // and back
5143       } else
5144       /* Added by Tord: Send castle moves in "O-O" in FRC games if required by
5145        * the engine. It would be nice to have a better way to identify castle
5146        * moves here. */
5147       if(appData.fischerCastling && cps->useOOCastle) {
5148         int fromX = moveList[moveNum][0] - AAA;
5149         int fromY = moveList[moveNum][1] - ONE;
5150         int toX = moveList[moveNum][2] - AAA;
5151         int toY = moveList[moveNum][3] - ONE;
5152         if((boards[moveNum][fromY][fromX] == WhiteKing
5153             && boards[moveNum][toY][toX] == WhiteRook)
5154            || (boards[moveNum][fromY][fromX] == BlackKing
5155                && boards[moveNum][toY][toX] == BlackRook)) {
5156           if(toX > fromX) SendToProgram("O-O\n", cps);
5157           else SendToProgram("O-O-O\n", cps);
5158         }
5159         else SendToProgram(moveList[moveNum], cps);
5160       } else
5161       if(moveList[moveNum][4] == ';') { // [HGM] lion: move is double-step over intermediate square
5162         char *m = moveList[moveNum];
5163         static char c[2];
5164         *c = m[7]; // promoChar
5165         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
5166           snprintf(buf, MSG_SIZ, "%c%d%c%d,%c%d%c%d\n", m[0], m[1] - '0', // convert to two moves
5167                                                m[2], m[3] - '0',
5168                                                m[5], m[6] - '0',
5169                                                m[2] + (m[0] > m[5] ? 1 : -1), m[3] - '0');
5170         else if(*c && m[8]) { // kill square followed by 2 characters: 2nd kill square rather than promo suffix
5171           *c = m[9];
5172           snprintf(buf, MSG_SIZ, "%c%d%c%d,%c%d%c%d,%c%d%c%d%s\n", m[0], m[1] - '0', // convert to three moves
5173                                                m[7], m[8] - '0',
5174                                                m[7], m[8] - '0',
5175                                                m[5], m[6] - '0',
5176                                                m[5], m[6] - '0',
5177                                                m[2], m[3] - '0', c);
5178         } else
5179           snprintf(buf, MSG_SIZ, "%c%d%c%d,%c%d%c%d%s\n", m[0], m[1] - '0', // convert to two moves
5180                                                m[5], m[6] - '0',
5181                                                m[5], m[6] - '0',
5182                                                m[2], m[3] - '0', c);
5183           SendToProgram(buf, cps);
5184       } else
5185       if(BOARD_HEIGHT > 10) { // [HGM] big: convert ranks to double-digit where needed
5186         if(moveList[moveNum][1] == '@' && (BOARD_HEIGHT < 16 || moveList[moveNum][0] <= 'Z')) { // drop move
5187           if(moveList[moveNum][0]== '@') snprintf(buf, MSG_SIZ, "@@@@\n"); else
5188           snprintf(buf, MSG_SIZ, "%c@%c%d%s", moveList[moveNum][0],
5189                                               moveList[moveNum][2], moveList[moveNum][3] - '0', moveList[moveNum]+4);
5190         } else
5191           snprintf(buf, MSG_SIZ, "%c%d%c%d%s", moveList[moveNum][0], moveList[moveNum][1] - '0',
5192                                                moveList[moveNum][2], moveList[moveNum][3] - '0', moveList[moveNum]+4);
5193         SendToProgram(buf, cps);
5194       }
5195       else SendToProgram(moveList[moveNum], cps);
5196       /* End of additions by Tord */
5197     }
5198
5199     /* [HGM] setting up the opening has brought engine in force mode! */
5200     /*       Send 'go' if we are in a mode where machine should play. */
5201     if( (moveNum == 0 && setboardSpoiledMachineBlack && cps == &first) &&
5202         (gameMode == TwoMachinesPlay   ||
5203 #if ZIPPY
5204          gameMode == IcsPlayingBlack     || gameMode == IcsPlayingWhite ||
5205 #endif
5206          gameMode == MachinePlaysBlack || gameMode == MachinePlaysWhite) ) {
5207         SendToProgram("go\n", cps);
5208   if (appData.debugMode) {
5209     fprintf(debugFP, "(extra)\n");
5210   }
5211     }
5212     setboardSpoiledMachineBlack = 0;
5213 }
5214
5215 void
5216 SendMoveToICS (ChessMove moveType, int fromX, int fromY, int toX, int toY, char promoChar)
5217 {
5218     char user_move[MSG_SIZ];
5219     char suffix[4];
5220
5221     if(gameInfo.variant == VariantSChess && promoChar) {
5222         snprintf(suffix, 4, "=%c", toX == BOARD_WIDTH<<1 ? ToUpper(promoChar) : ToLower(promoChar));
5223         if(moveType == NormalMove) moveType = WhitePromotion; // kludge to do gating
5224     } else suffix[0] = NULLCHAR;
5225
5226     switch (moveType) {
5227       default:
5228         snprintf(user_move, MSG_SIZ, _("say Internal error; bad moveType %d (%d,%d-%d,%d)"),
5229                 (int)moveType, fromX, fromY, toX, toY);
5230         DisplayError(user_move + strlen("say "), 0);
5231         break;
5232       case WhiteKingSideCastle:
5233       case BlackKingSideCastle:
5234       case WhiteQueenSideCastleWild:
5235       case BlackQueenSideCastleWild:
5236       /* PUSH Fabien */
5237       case WhiteHSideCastleFR:
5238       case BlackHSideCastleFR:
5239       /* POP Fabien */
5240         snprintf(user_move, MSG_SIZ, "o-o%s\n", suffix);
5241         break;
5242       case WhiteQueenSideCastle:
5243       case BlackQueenSideCastle:
5244       case WhiteKingSideCastleWild:
5245       case BlackKingSideCastleWild:
5246       /* PUSH Fabien */
5247       case WhiteASideCastleFR:
5248       case BlackASideCastleFR:
5249       /* POP Fabien */
5250         snprintf(user_move, MSG_SIZ, "o-o-o%s\n",suffix);
5251         break;
5252       case WhiteNonPromotion:
5253       case BlackNonPromotion:
5254         sprintf(user_move, "%c%c%c%c==\n", AAA + fromX, ONE + fromY, AAA + toX, ONE + toY);
5255         break;
5256       case WhitePromotion:
5257       case BlackPromotion:
5258         if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier ||
5259            gameInfo.variant == VariantMakruk)
5260           snprintf(user_move, MSG_SIZ, "%c%c%c%c=%c\n",
5261                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
5262                 PieceToChar(WhiteFerz));
5263         else if(gameInfo.variant == VariantGreat)
5264           snprintf(user_move, MSG_SIZ,"%c%c%c%c=%c\n",
5265                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
5266                 PieceToChar(WhiteMan));
5267         else
5268           snprintf(user_move, MSG_SIZ, "%c%c%c%c=%c\n",
5269                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
5270                 promoChar);
5271         break;
5272       case WhiteDrop:
5273       case BlackDrop:
5274       drop:
5275         snprintf(user_move, MSG_SIZ, "%c@%c%c\n",
5276                  ToUpper(PieceToChar((ChessSquare) fromX)),
5277                  AAA + toX, ONE + toY);
5278         break;
5279       case IllegalMove:  /* could be a variant we don't quite understand */
5280         if(fromY == DROP_RANK) goto drop; // We need 'IllegalDrop' move type?
5281       case NormalMove:
5282       case WhiteCapturesEnPassant:
5283       case BlackCapturesEnPassant:
5284         snprintf(user_move, MSG_SIZ,"%c%c%c%c\n",
5285                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY);
5286         break;
5287     }
5288     SendToICS(user_move);
5289     if(appData.keepAlive) // [HGM] alive: schedule sending of dummy 'date' command
5290         ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
5291 }
5292
5293 void
5294 UploadGameEvent ()
5295 {   // [HGM] upload: send entire stored game to ICS as long-algebraic moves.
5296     int i, last = forwardMostMove; // make sure ICS reply cannot pre-empt us by clearing fmm
5297     static char *castlingStrings[4] = { "none", "kside", "qside", "both" };
5298     if(gameMode == IcsObserving || gameMode == IcsPlayingBlack || gameMode == IcsPlayingWhite) {
5299       DisplayError(_("You cannot do this while you are playing or observing"), 0);
5300       return;
5301     }
5302     if(gameMode != IcsExamining) { // is this ever not the case?
5303         char buf[MSG_SIZ], *p, *fen, command[MSG_SIZ], bsetup = 0;
5304
5305         if(ics_type == ICS_ICC) { // on ICC match ourselves in applicable variant
5306           snprintf(command,MSG_SIZ, "match %s", ics_handle);
5307         } else { // on FICS we must first go to general examine mode
5308           safeStrCpy(command, "examine\nbsetup", sizeof(command)/sizeof(command[0])); // and specify variant within it with bsetups
5309         }
5310         if(gameInfo.variant != VariantNormal) {
5311             // try figure out wild number, as xboard names are not always valid on ICS
5312             for(i=1; i<=36; i++) {
5313               snprintf(buf, MSG_SIZ, "wild/%d", i);
5314                 if(StringToVariant(buf) == gameInfo.variant) break;
5315             }
5316             if(i<=36 && ics_type == ICS_ICC) snprintf(buf, MSG_SIZ,"%s w%d\n", command, i);
5317             else if(i == 22) snprintf(buf,MSG_SIZ, "%s fr\n", command);
5318             else snprintf(buf, MSG_SIZ,"%s %s\n", command, VariantName(gameInfo.variant));
5319         } else snprintf(buf, MSG_SIZ,"%s\n", ics_type == ICS_ICC ? command : "examine\n"); // match yourself or examine
5320         SendToICS(ics_prefix);
5321         SendToICS(buf);
5322         if(startedFromSetupPosition || backwardMostMove != 0) {
5323           fen = PositionToFEN(backwardMostMove, NULL, 1);
5324           if(ics_type == ICS_ICC) { // on ICC we can simply send a complete FEN to set everything
5325             snprintf(buf, MSG_SIZ,"loadfen %s\n", fen);
5326             SendToICS(buf);
5327           } else { // FICS: everything has to set by separate bsetup commands
5328             p = strchr(fen, ' '); p[0] = NULLCHAR; // cut after board
5329             snprintf(buf, MSG_SIZ,"bsetup fen %s\n", fen);
5330             SendToICS(buf);
5331             if(!WhiteOnMove(backwardMostMove)) {
5332                 SendToICS("bsetup tomove black\n");
5333             }
5334             i = (strchr(p+3, 'K') != NULL) + 2*(strchr(p+3, 'Q') != NULL);
5335             snprintf(buf, MSG_SIZ,"bsetup wcastle %s\n", castlingStrings[i]);
5336             SendToICS(buf);
5337             i = (strchr(p+3, 'k') != NULL) + 2*(strchr(p+3, 'q') != NULL);
5338             snprintf(buf, MSG_SIZ, "bsetup bcastle %s\n", castlingStrings[i]);
5339             SendToICS(buf);
5340             i = boards[backwardMostMove][EP_STATUS];
5341             if(i >= 0) { // set e.p.
5342               snprintf(buf, MSG_SIZ,"bsetup eppos %c\n", i+AAA);
5343                 SendToICS(buf);
5344             }
5345             bsetup++;
5346           }
5347         }
5348       if(bsetup || ics_type != ICS_ICC && gameInfo.variant != VariantNormal)
5349             SendToICS("bsetup done\n"); // switch to normal examining.
5350     }
5351     for(i = backwardMostMove; i<last; i++) {
5352         char buf[20];
5353         snprintf(buf, sizeof(buf)/sizeof(buf[0]),"%s\n", parseList[i]);
5354         if((*buf == 'b' || *buf == 'B') && buf[1] == 'x') { // work-around for stupid FICS bug, which thinks bxc3 can be a Bishop move
5355             int len = strlen(moveList[i]);
5356             snprintf(buf, sizeof(buf)/sizeof(buf[0]),"%s", moveList[i]); // use long algebraic
5357             if(!isdigit(buf[len-2])) snprintf(buf+len-2, 20-len, "=%c\n", ToUpper(buf[len-2])); // promotion must have '=' in ICS format
5358         }
5359         SendToICS(buf);
5360     }
5361     SendToICS(ics_prefix);
5362     SendToICS(ics_type == ICS_ICC ? "tag result Game in progress\n" : "commit\n");
5363 }
5364
5365 int killX = -1, killY = -1, kill2X = -1, kill2Y = -1; // [HGM] lion: used for passing e.p. capture square to MakeMove
5366 int legNr = 1;
5367
5368 void
5369 CoordsToComputerAlgebraic (int rf, int ff, int rt, int ft, char promoChar, char move[9])
5370 {
5371     if (rf == DROP_RANK) {
5372       if(ff == EmptySquare) sprintf(move, "@@@@\n"); else // [HGM] pass
5373       sprintf(move, "%c@%c%c\n",
5374                 ToUpper(PieceToChar((ChessSquare) ff)), AAA + ft, ONE + rt);
5375     } else {
5376         if (promoChar == 'x' || promoChar == NULLCHAR) {
5377           sprintf(move, "%c%c%c%c\n",
5378                     AAA + ff, ONE + rf, AAA + ft, ONE + rt);
5379           if(killX >= 0 && killY >= 0) {
5380             sprintf(move+4, ";%c%c\n", AAA + killX, ONE + killY);
5381             if(kill2X >= 0 && kill2Y >= 0) sprintf(move+7, "%c%c\n", AAA + kill2X, ONE + kill2Y);
5382           }
5383         } else {
5384             sprintf(move, "%c%c%c%c%c\n",
5385                     AAA + ff, ONE + rf, AAA + ft, ONE + rt, promoChar);
5386           if(killX >= 0 && killY >= 0) {
5387             sprintf(move+4, ";%c%c\n", AAA + killX, ONE + killY);
5388             if(kill2X >= 0 && kill2Y >= 0) sprintf(move+7, "%c%c%c\n", AAA + kill2X, ONE + kill2Y, promoChar);
5389           }
5390         }
5391     }
5392 }
5393
5394 void
5395 ProcessICSInitScript (FILE *f)
5396 {
5397     char buf[MSG_SIZ];
5398
5399     while (fgets(buf, MSG_SIZ, f)) {
5400         SendToICSDelayed(buf,(long)appData.msLoginDelay);
5401     }
5402
5403     fclose(f);
5404 }
5405
5406
5407 static int lastX, lastY, lastLeftX, lastLeftY, selectFlag;
5408 int dragging;
5409 static ClickType lastClickType;
5410
5411 int
5412 PieceInString (char *s, ChessSquare piece)
5413 {
5414   char *p, ID = ToUpper(PieceToChar(piece)), suffix = PieceSuffix(piece);
5415   while((p = strchr(s, ID))) {
5416     if(!suffix || p[1] == suffix) return TRUE;
5417     s = p;
5418   }
5419   return FALSE;
5420 }
5421
5422 int
5423 Partner (ChessSquare *p)
5424 { // change piece into promotion partner if one shogi-promotes to the other
5425   ChessSquare partner = promoPartner[*p];
5426   if(PieceToChar(*p) != '+' && PieceToChar(partner) != '+') return 0;
5427   if(PieceToChar(*p) == '+') partner = boards[currentMove][fromY][fromX];
5428   *p = partner;
5429   return 1;
5430 }
5431
5432 void
5433 Sweep (int step)
5434 {
5435     ChessSquare king = WhiteKing, pawn = WhitePawn, last = promoSweep;
5436     static int toggleFlag;
5437     if(gameInfo.variant == VariantKnightmate) king = WhiteUnicorn;
5438     if(gameInfo.variant == VariantSuicide || gameInfo.variant == VariantGiveaway) king = EmptySquare;
5439     if(promoSweep >= BlackPawn) king = WHITE_TO_BLACK king, pawn = WHITE_TO_BLACK pawn;
5440     if(gameInfo.variant == VariantSpartan && pawn == BlackPawn) pawn = BlackLance, king = EmptySquare;
5441     if(fromY != BOARD_HEIGHT-2 && fromY != 1 && gameInfo.variant != VariantChuChess) pawn = EmptySquare;
5442     if(!step) toggleFlag = Partner(&last); // piece has shogi-promotion
5443     do {
5444         if(step && !(toggleFlag && Partner(&promoSweep))) promoSweep -= step;
5445         if(promoSweep == EmptySquare) promoSweep = BlackPawn; // wrap
5446         else if((int)promoSweep == -1) promoSweep = WhiteKing;
5447         else if(promoSweep == BlackPawn && step < 0 && !toggleFlag) promoSweep = WhitePawn;
5448         else if(promoSweep == WhiteKing && step > 0 && !toggleFlag) promoSweep = BlackKing;
5449         if(!step) step = -1;
5450     } while(PieceToChar(promoSweep) == '.' || PieceToChar(promoSweep) == '~' ||
5451             !toggleFlag && PieceToChar(promoSweep) == '+' || // skip promoted versions of other
5452             promoRestrict[0] ? !PieceInString(promoRestrict, promoSweep) : // if choice set available, use it
5453             promoSweep == pawn ||
5454             appData.testLegality && (promoSweep == king || gameInfo.variant != VariantChuChess &&
5455             (promoSweep == WhiteLion || promoSweep == BlackLion)));
5456     if(toX >= 0) {
5457         int victim = boards[currentMove][toY][toX];
5458         boards[currentMove][toY][toX] = promoSweep;
5459         DrawPosition(FALSE, boards[currentMove]);
5460         boards[currentMove][toY][toX] = victim;
5461     } else
5462     ChangeDragPiece(promoSweep);
5463 }
5464
5465 int
5466 PromoScroll (int x, int y)
5467 {
5468   int step = 0;
5469
5470   if(promoSweep == EmptySquare || !appData.sweepSelect) return FALSE;
5471   if(abs(x - lastX) < 25 && abs(y - lastY) < 25) return FALSE;
5472   if( y > lastY + 2 ) step = -1; else if(y < lastY - 2) step = 1;
5473   if(!step) return FALSE;
5474   lastX = x; lastY = y;
5475   if((promoSweep < BlackPawn) == flipView) step = -step;
5476   if(step > 0) selectFlag = 1;
5477   if(!selectFlag) Sweep(step);
5478   return FALSE;
5479 }
5480
5481 void
5482 NextPiece (int step)
5483 {
5484     ChessSquare piece = boards[currentMove][toY][toX];
5485     do {
5486         pieceSweep -= step;
5487         if(pieceSweep == EmptySquare) pieceSweep = WhitePawn; // wrap
5488         if((int)pieceSweep == -1) pieceSweep = BlackKing;
5489         if(!step) step = -1;
5490     } while(PieceToChar(pieceSweep) == '.');
5491     boards[currentMove][toY][toX] = pieceSweep;
5492     DrawPosition(FALSE, boards[currentMove]);
5493     boards[currentMove][toY][toX] = piece;
5494 }
5495 /* [HGM] Shogi move preprocessor: swap digits for letters, vice versa */
5496 void
5497 AlphaRank (char *move, int n)
5498 {
5499 //    char *p = move, c; int x, y;
5500
5501     if (appData.debugMode) {
5502         fprintf(debugFP, "alphaRank(%s,%d)\n", move, n);
5503     }
5504
5505     if(move[1]=='*' &&
5506        move[2]>='0' && move[2]<='9' &&
5507        move[3]>='a' && move[3]<='x'    ) {
5508         move[1] = '@';
5509         move[2] = BOARD_RGHT  -1 - (move[2]-'1') + AAA;
5510         move[3] = BOARD_HEIGHT-1 - (move[3]-'a') + ONE;
5511     } else
5512     if(move[0]>='0' && move[0]<='9' &&
5513        move[1]>='a' && move[1]<='x' &&
5514        move[2]>='0' && move[2]<='9' &&
5515        move[3]>='a' && move[3]<='x'    ) {
5516         /* input move, Shogi -> normal */
5517         move[0] = BOARD_RGHT  -1 - (move[0]-'1') + AAA;
5518         move[1] = BOARD_HEIGHT-1 - (move[1]-'a') + ONE;
5519         move[2] = BOARD_RGHT  -1 - (move[2]-'1') + AAA;
5520         move[3] = BOARD_HEIGHT-1 - (move[3]-'a') + ONE;
5521     } else
5522     if(move[1]=='@' &&
5523        move[3]>='0' && move[3]<='9' &&
5524        move[2]>='a' && move[2]<='x'    ) {
5525         move[1] = '*';
5526         move[2] = BOARD_RGHT - 1 - (move[2]-AAA) + '1';
5527         move[3] = BOARD_HEIGHT-1 - (move[3]-ONE) + 'a';
5528     } else
5529     if(
5530        move[0]>='a' && move[0]<='x' &&
5531        move[3]>='0' && move[3]<='9' &&
5532        move[2]>='a' && move[2]<='x'    ) {
5533          /* output move, normal -> Shogi */
5534         move[0] = BOARD_RGHT - 1 - (move[0]-AAA) + '1';
5535         move[1] = BOARD_HEIGHT-1 - (move[1]-ONE) + 'a';
5536         move[2] = BOARD_RGHT - 1 - (move[2]-AAA) + '1';
5537         move[3] = BOARD_HEIGHT-1 - (move[3]-ONE) + 'a';
5538         if(move[4] == PieceToChar(BlackQueen)) move[4] = '+';
5539     }
5540     if (appData.debugMode) {
5541         fprintf(debugFP, "   out = '%s'\n", move);
5542     }
5543 }
5544
5545 char yy_textstr[8000];
5546
5547 /* Parser for moves from gnuchess, ICS, or user typein box */
5548 Boolean
5549 ParseOneMove (char *move, int moveNum, ChessMove *moveType, int *fromX, int *fromY, int *toX, int *toY, char *promoChar)
5550 {
5551     *moveType = yylexstr(moveNum, move, yy_textstr, sizeof yy_textstr);
5552
5553     switch (*moveType) {
5554       case WhitePromotion:
5555       case BlackPromotion:
5556       case WhiteNonPromotion:
5557       case BlackNonPromotion:
5558       case NormalMove:
5559       case FirstLeg:
5560       case WhiteCapturesEnPassant:
5561       case BlackCapturesEnPassant:
5562       case WhiteKingSideCastle:
5563       case WhiteQueenSideCastle:
5564       case BlackKingSideCastle:
5565       case BlackQueenSideCastle:
5566       case WhiteKingSideCastleWild:
5567       case WhiteQueenSideCastleWild:
5568       case BlackKingSideCastleWild:
5569       case BlackQueenSideCastleWild:
5570       /* Code added by Tord: */
5571       case WhiteHSideCastleFR:
5572       case WhiteASideCastleFR:
5573       case BlackHSideCastleFR:
5574       case BlackASideCastleFR:
5575       /* End of code added by Tord */
5576       case IllegalMove:         /* bug or odd chess variant */
5577         if(currentMoveString[1] == '@') { // illegal drop
5578           *fromX = WhiteOnMove(moveNum) ?
5579             (int) CharToPiece(ToUpper(currentMoveString[0])) :
5580             (int) CharToPiece(ToLower(currentMoveString[0]));
5581           goto drop;
5582         }
5583         *fromX = currentMoveString[0] - AAA;
5584         *fromY = currentMoveString[1] - ONE;
5585         *toX = currentMoveString[2] - AAA;
5586         *toY = currentMoveString[3] - ONE;
5587         *promoChar = currentMoveString[4];
5588         if(*promoChar == ';') *promoChar = currentMoveString[7 + 2*(currentMoveString[8] != 0)];
5589         if (*fromX < BOARD_LEFT || *fromX >= BOARD_RGHT || *fromY < 0 || *fromY >= BOARD_HEIGHT ||
5590             *toX < BOARD_LEFT || *toX >= BOARD_RGHT || *toY < 0 || *toY >= BOARD_HEIGHT) {
5591     if (appData.debugMode) {
5592         fprintf(debugFP, "Off-board move (%d,%d)-(%d,%d)%c, type = %d\n", *fromX, *fromY, *toX, *toY, *promoChar, *moveType);
5593     }
5594             *fromX = *fromY = *toX = *toY = 0;
5595             return FALSE;
5596         }
5597         if (appData.testLegality) {
5598           return (*moveType != IllegalMove);
5599         } else {
5600           return !(*fromX == *toX && *fromY == *toY && killX < 0) && boards[moveNum][*fromY][*fromX] != EmptySquare &&
5601                          // [HGM] lion: if this is a double move we are less critical
5602                         WhiteOnMove(moveNum) == (boards[moveNum][*fromY][*fromX] < BlackPawn);
5603         }
5604
5605       case WhiteDrop:
5606       case BlackDrop:
5607         *fromX = *moveType == WhiteDrop ?
5608           (int) CharToPiece(ToUpper(currentMoveString[0])) :
5609           (int) CharToPiece(ToLower(currentMoveString[0]));
5610       drop:
5611         *fromY = DROP_RANK;
5612         *toX = currentMoveString[2] - AAA;
5613         *toY = currentMoveString[3] - ONE;
5614         *promoChar = NULLCHAR;
5615         return TRUE;
5616
5617       case AmbiguousMove:
5618       case ImpossibleMove:
5619       case EndOfFile:
5620       case ElapsedTime:
5621       case Comment:
5622       case PGNTag:
5623       case NAG:
5624       case WhiteWins:
5625       case BlackWins:
5626       case GameIsDrawn:
5627       default:
5628     if (appData.debugMode) {
5629         fprintf(debugFP, "Impossible move %s, type = %d\n", currentMoveString, *moveType);
5630     }
5631         /* bug? */
5632         *fromX = *fromY = *toX = *toY = 0;
5633         *promoChar = NULLCHAR;
5634         return FALSE;
5635     }
5636 }
5637
5638 Boolean pushed = FALSE;
5639 char *lastParseAttempt;
5640
5641 void
5642 ParsePV (char *pv, Boolean storeComments, Boolean atEnd)
5643 { // Parse a string of PV moves, and append to current game, behind forwardMostMove
5644   int fromX, fromY, toX, toY; char promoChar;
5645   ChessMove moveType;
5646   Boolean valid;
5647   int nr = 0;
5648
5649   lastParseAttempt = pv; if(!*pv) return;    // turns out we crash when we parse an empty PV
5650   if ((gameMode == AnalyzeMode || gameMode == AnalyzeFile) && currentMove < forwardMostMove) {
5651     PushInner(currentMove, forwardMostMove); // [HGM] engine might not be thinking on forwardMost position!
5652     pushed = TRUE;
5653   }
5654   endPV = forwardMostMove;
5655   do {
5656     while(*pv == ' ' || *pv == '\n' || *pv == '\t') pv++; // must still read away whitespace
5657     if(nr == 0 && !storeComments && *pv == '(') pv++; // first (ponder) move can be in parentheses
5658     lastParseAttempt = pv;
5659     valid = ParseOneMove(pv, endPV, &moveType, &fromX, &fromY, &toX, &toY, &promoChar);
5660     if(!valid && nr == 0 &&
5661        ParseOneMove(pv, endPV-1, &moveType, &fromX, &fromY, &toX, &toY, &promoChar)){
5662         nr++; moveType = Comment; // First move has been played; kludge to make sure we continue
5663         // Hande case where played move is different from leading PV move
5664         CopyBoard(boards[endPV+1], boards[endPV-1]); // tentatively unplay last game move
5665         CopyBoard(boards[endPV+2], boards[endPV-1]); // and play first move of PV
5666         ApplyMove(fromX, fromY, toX, toY, promoChar, boards[endPV+2]);
5667         if(!CompareBoards(boards[endPV], boards[endPV+2])) {
5668           endPV += 2; // if position different, keep this
5669           moveList[endPV-1][0] = fromX + AAA;
5670           moveList[endPV-1][1] = fromY + ONE;
5671           moveList[endPV-1][2] = toX + AAA;
5672           moveList[endPV-1][3] = toY + ONE;
5673           parseList[endPV-1][0] = NULLCHAR;
5674           safeStrCpy(moveList[endPV-2], "_0_0", sizeof(moveList[endPV-2])/sizeof(moveList[endPV-2][0])); // suppress premove highlight on takeback move
5675         }
5676       }
5677     pv = strstr(pv, yy_textstr) + strlen(yy_textstr); // skip what we parsed
5678     if(nr == 0 && !storeComments && *pv == ')') pv++; // closing parenthesis of ponder move;
5679     if(moveType == Comment && storeComments) AppendComment(endPV, yy_textstr, FALSE);
5680     if(moveType == Comment || moveType == NAG || moveType == ElapsedTime) {
5681         valid++; // allow comments in PV
5682         continue;
5683     }
5684     nr++;
5685     if(endPV+1 > framePtr) break; // no space, truncate
5686     if(!valid) break;
5687     endPV++;
5688     CopyBoard(boards[endPV], boards[endPV-1]);
5689     ApplyMove(fromX, fromY, toX, toY, promoChar, boards[endPV]);
5690     CoordsToComputerAlgebraic(fromY, fromX, toY, toX, promoChar, moveList[endPV - 1]);
5691     strncat(moveList[endPV-1], "\n", MOVE_LEN);
5692     CoordsToAlgebraic(boards[endPV - 1],
5693                              PosFlags(endPV - 1),
5694                              fromY, fromX, toY, toX, promoChar,
5695                              parseList[endPV - 1]);
5696   } while(valid);
5697   if(atEnd == 2) return; // used hidden, for PV conversion
5698   currentMove = (atEnd || endPV == forwardMostMove) ? endPV : forwardMostMove + 1;
5699   if(currentMove == forwardMostMove) ClearPremoveHighlights(); else
5700   SetPremoveHighlights(moveList[currentMove-1][0]-AAA, moveList[currentMove-1][1]-ONE,
5701                        moveList[currentMove-1][2]-AAA, moveList[currentMove-1][3]-ONE);
5702   DrawPosition(TRUE, boards[currentMove]);
5703 }
5704
5705 int
5706 MultiPV (ChessProgramState *cps, int kind)
5707 {       // check if engine supports MultiPV, and if so, return the number of the option that sets it
5708         int i;
5709         for(i=0; i<cps->nrOptions; i++) {
5710             char *s = cps->option[i].name;
5711             if((kind & 1) && !StrCaseCmp(s, "MultiPV") && cps->option[i].type == Spin) return i;
5712             if((kind & 2) && StrCaseStr(s, "multi") && StrCaseStr(s, "PV")
5713                           && StrCaseStr(s, "margin") && cps->option[i].type == Spin) return -i-2;
5714         }
5715         return -1;
5716 }
5717
5718 Boolean extendGame; // signals to UnLoadPV() if walked part of PV has to be appended to game
5719 static int multi, pv_margin;
5720 static ChessProgramState *activeCps;
5721
5722 Boolean
5723 LoadMultiPV (int x, int y, char *buf, int index, int *start, int *end, int pane)
5724 {
5725         int startPV, lineStart, origIndex = index;
5726         char *p, buf2[MSG_SIZ];
5727         ChessProgramState *cps = (pane ? &second : &first);
5728
5729         if(index < 0 || index >= strlen(buf)) return FALSE; // sanity
5730         lastX = x; lastY = y;
5731         while(index > 0 && buf[index-1] != '\n') index--; // beginning of line
5732         lineStart = startPV = index;
5733         while(buf[index] != '\n') if(buf[index++] == '\t') startPV = index;
5734         if(index == startPV && (p = StrCaseStr(buf+index, "PV="))) startPV = p - buf + 3;
5735         index = startPV;
5736         do{ while(buf[index] && buf[index] != '\n') index++;
5737         } while(buf[index] == '\n' && buf[index+1] == '\\' && buf[index+2] == ' ' && index++); // join kibitzed PV continuation line
5738         buf[index] = 0;
5739         if(lineStart == 0 && gameMode == AnalyzeMode) {
5740             int n = 0;
5741             if(origIndex > 17 && origIndex < 24) n--; else if(origIndex > index - 6) n++;
5742             if(n == 0) { // click not on "fewer" or "more"
5743                 if((multi = -2 - MultiPV(cps, 2)) >= 0) {
5744                     pv_margin = cps->option[multi].value;
5745                     activeCps = cps; // non-null signals margin adjustment
5746                 }
5747             } else if((multi = MultiPV(cps, 1)) >= 0) {
5748                 n += cps->option[multi].value; if(n < 1) n = 1;
5749                 snprintf(buf2, MSG_SIZ, "option MultiPV=%d\n", n);
5750                 if(cps->option[multi].value != n) SendToProgram(buf2, cps);
5751                 cps->option[multi].value = n;
5752                 *start = *end = 0;
5753                 return FALSE;
5754             }
5755         } else if(strstr(buf+lineStart, "exclude:") == buf+lineStart) { // exclude moves clicked
5756                 ExcludeClick(origIndex - lineStart);
5757                 return FALSE;
5758         } else if(!strncmp(buf+lineStart, "dep\t", 4)) {                // column headers clicked
5759                 Collapse(origIndex - lineStart);
5760                 return FALSE;
5761         }
5762         ParsePV(buf+startPV, FALSE, gameMode != AnalyzeMode);
5763         *start = startPV; *end = index-1;
5764         extendGame = (gameMode == AnalyzeMode && appData.autoExtend && origIndex - startPV < 5);
5765         return TRUE;
5766 }
5767
5768 char *
5769 PvToSAN (char *pv)
5770 {
5771         static char buf[10*MSG_SIZ];
5772         int i, k=0, savedEnd=endPV, saveFMM = forwardMostMove;
5773         *buf = NULLCHAR;
5774         if(forwardMostMove < endPV) PushInner(forwardMostMove, endPV); // shelve PV of PV-walk
5775         ParsePV(pv, FALSE, 2); // this appends PV to game, suppressing any display of it
5776         for(i = forwardMostMove; i<endPV; i++){
5777             if(i&1) snprintf(buf+k, 10*MSG_SIZ-k, "%s ", parseList[i]);
5778             else    snprintf(buf+k, 10*MSG_SIZ-k, "%d. %s ", i/2 + 1, parseList[i]);
5779             k += strlen(buf+k);
5780         }
5781         snprintf(buf+k, 10*MSG_SIZ-k, "%s", lastParseAttempt); // if we ran into stuff that could not be parsed, print it verbatim
5782         if(pushed) { PopInner(0); pushed = FALSE; } // restore game continuation shelved by ParsePV
5783         if(forwardMostMove < savedEnd) { PopInner(0); forwardMostMove = saveFMM; } // PopInner would set fmm to endPV!
5784         endPV = savedEnd;
5785         return buf;
5786 }
5787
5788 Boolean
5789 LoadPV (int x, int y)
5790 { // called on right mouse click to load PV
5791   int which = gameMode == TwoMachinesPlay && (WhiteOnMove(forwardMostMove) == (second.twoMachinesColor[0] == 'w'));
5792   lastX = x; lastY = y;
5793   ParsePV(lastPV[which], FALSE, TRUE); // load the PV of the thinking engine in the boards array.
5794   extendGame = FALSE;
5795   return TRUE;
5796 }
5797
5798 void
5799 UnLoadPV ()
5800 {
5801   int oldFMM = forwardMostMove; // N.B.: this was currentMove before PV was loaded!
5802   if(activeCps) {
5803     if(pv_margin != activeCps->option[multi].value) {
5804       char buf[MSG_SIZ];
5805       snprintf(buf, MSG_SIZ, "option %s=%d\n", "Multi-PV Margin", pv_margin);
5806       SendToProgram(buf, activeCps);
5807       activeCps->option[multi].value = pv_margin;
5808     }
5809     activeCps = NULL;
5810     return;
5811   }
5812   if(endPV < 0) return;
5813   if(appData.autoCopyPV) CopyFENToClipboard();
5814   endPV = -1;
5815   if(extendGame && currentMove > forwardMostMove) {
5816         Boolean saveAnimate = appData.animate;
5817         if(pushed) {
5818             if(shiftKey && storedGames < MAX_VARIATIONS-2) { // wants to start variation, and there is space
5819                 if(storedGames == 1) GreyRevert(FALSE);      // we already pushed the tail, so just make it official
5820             } else storedGames--; // abandon shelved tail of original game
5821         }
5822         pushed = FALSE;
5823         forwardMostMove = currentMove;
5824         currentMove = oldFMM;
5825         appData.animate = FALSE;
5826         ToNrEvent(forwardMostMove);
5827         appData.animate = saveAnimate;
5828   }
5829   currentMove = forwardMostMove;
5830   if(pushed) { PopInner(0); pushed = FALSE; } // restore shelved game continuation
5831   ClearPremoveHighlights();
5832   DrawPosition(TRUE, boards[currentMove]);
5833 }
5834
5835 void
5836 MovePV (int x, int y, int h)
5837 { // step through PV based on mouse coordinates (called on mouse move)
5838   int margin = h>>3, step = 0, threshold = (pieceSweep == EmptySquare ? 10 : 15);
5839
5840   if(activeCps) { // adjusting engine's multi-pv margin
5841     if(x > lastX) pv_margin++; else
5842     if(x < lastX) pv_margin -= (pv_margin > 0);
5843     if(x != lastX) {
5844       char buf[MSG_SIZ];
5845       snprintf(buf, MSG_SIZ, "margin = %d", pv_margin);
5846       DisplayMessage(buf, "");
5847     }
5848     lastX = x;
5849     return;
5850   }
5851   // we must somehow check if right button is still down (might be released off board!)
5852   if(endPV < 0 && pieceSweep == EmptySquare) return; // needed in XBoard because lastX/Y is shared :-(
5853   if(abs(x - lastX) < threshold && abs(y - lastY) < threshold) return;
5854   if( y > lastY + 2 ) step = -1; else if(y < lastY - 2) step = 1;
5855   if(!step) return;
5856   lastX = x; lastY = y;
5857
5858   if(pieceSweep != EmptySquare) { NextPiece(step); return; }
5859   if(endPV < 0) return;
5860   if(y < margin) step = 1; else
5861   if(y > h - margin) step = -1;
5862   if(currentMove + step > endPV || currentMove + step < forwardMostMove) step = 0;
5863   currentMove += step;
5864   if(currentMove == forwardMostMove) ClearPremoveHighlights(); else
5865   SetPremoveHighlights(moveList[currentMove-1][0]-AAA, moveList[currentMove-1][1]-ONE,
5866                        moveList[currentMove-1][2]-AAA, moveList[currentMove-1][3]-ONE);
5867   DrawPosition(FALSE, boards[currentMove]);
5868 }
5869
5870
5871 // [HGM] shuffle: a general way to suffle opening setups, applicable to arbitrary variants.
5872 // All positions will have equal probability, but the current method will not provide a unique
5873 // numbering scheme for arrays that contain 3 or more pieces of the same kind.
5874 #define DARK 1
5875 #define LITE 2
5876 #define ANY 3
5877
5878 int squaresLeft[4];
5879 int piecesLeft[(int)BlackPawn];
5880 int seed, nrOfShuffles;
5881
5882 void
5883 GetPositionNumber ()
5884 {       // sets global variable seed
5885         int i;
5886
5887         seed = appData.defaultFrcPosition;
5888         if(seed < 0) { // randomize based on time for negative FRC position numbers
5889                 for(i=0; i<50; i++) seed += random();
5890                 seed = random() ^ random() >> 8 ^ random() << 8;
5891                 if(seed<0) seed = -seed;
5892         }
5893 }
5894
5895 int
5896 put (Board board, int pieceType, int rank, int n, int shade)
5897 // put the piece on the (n-1)-th empty squares of the given shade
5898 {
5899         int i;
5900
5901         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) {
5902                 if( (((i-BOARD_LEFT)&1)+1) & shade && board[rank][i] == EmptySquare && n-- == 0) {
5903                         board[rank][i] = (ChessSquare) pieceType;
5904                         squaresLeft[((i-BOARD_LEFT)&1) + 1]--;
5905                         squaresLeft[ANY]--;
5906                         piecesLeft[pieceType]--;
5907                         return i;
5908                 }
5909         }
5910         return -1;
5911 }
5912
5913
5914 void
5915 AddOnePiece (Board board, int pieceType, int rank, int shade)
5916 // calculate where the next piece goes, (any empty square), and put it there
5917 {
5918         int i;
5919
5920         i = seed % squaresLeft[shade];
5921         nrOfShuffles *= squaresLeft[shade];
5922         seed /= squaresLeft[shade];
5923         put(board, pieceType, rank, i, shade);
5924 }
5925
5926 void
5927 AddTwoPieces (Board board, int pieceType, int rank)
5928 // calculate where the next 2 identical pieces go, (any empty square), and put it there
5929 {
5930         int i, n=squaresLeft[ANY], j=n-1, k;
5931
5932         k = n*(n-1)/2; // nr of possibilities, not counting permutations
5933         i = seed % k;  // pick one
5934         nrOfShuffles *= k;
5935         seed /= k;
5936         while(i >= j) i -= j--;
5937         j = n - 1 - j; i += j;
5938         put(board, pieceType, rank, j, ANY);
5939         put(board, pieceType, rank, i, ANY);
5940 }
5941
5942 void
5943 SetUpShuffle (Board board, int number)
5944 {
5945         int i, p, first=1;
5946
5947         GetPositionNumber(); nrOfShuffles = 1;
5948
5949         squaresLeft[DARK] = (BOARD_RGHT - BOARD_LEFT + 1)/2;
5950         squaresLeft[ANY]  = BOARD_RGHT - BOARD_LEFT;
5951         squaresLeft[LITE] = squaresLeft[ANY] - squaresLeft[DARK];
5952
5953         for(p = 0; p<=(int)WhiteKing; p++) piecesLeft[p] = 0;
5954
5955         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) { // count pieces and clear board
5956             p = (int) board[0][i];
5957             if(p < (int) BlackPawn) piecesLeft[p] ++;
5958             board[0][i] = EmptySquare;
5959         }
5960
5961         if(PosFlags(0) & F_ALL_CASTLE_OK) {
5962             // shuffles restricted to allow normal castling put KRR first
5963             if(piecesLeft[(int)WhiteKing]) // King goes rightish of middle
5964                 put(board, WhiteKing, 0, (gameInfo.boardWidth+1)/2, ANY);
5965             else if(piecesLeft[(int)WhiteUnicorn]) // in Knightmate Unicorn castles
5966                 put(board, WhiteUnicorn, 0, (gameInfo.boardWidth+1)/2, ANY);
5967             if(piecesLeft[(int)WhiteRook]) // First supply a Rook for K-side castling
5968                 put(board, WhiteRook, 0, gameInfo.boardWidth-2, ANY);
5969             if(piecesLeft[(int)WhiteRook]) // Then supply a Rook for Q-side castling
5970                 put(board, WhiteRook, 0, 0, ANY);
5971             // in variants with super-numerary Kings and Rooks, we leave these for the shuffle
5972         }
5973
5974         if(((BOARD_RGHT-BOARD_LEFT) & 1) == 0)
5975             // only for even boards make effort to put pairs of colorbound pieces on opposite colors
5976             for(p = (int) WhiteKing; p > (int) WhitePawn; p--) {
5977                 if(p != (int) WhiteBishop && p != (int) WhiteFerz && p != (int) WhiteAlfil) continue;
5978                 while(piecesLeft[p] >= 2) {
5979                     AddOnePiece(board, p, 0, LITE);
5980                     AddOnePiece(board, p, 0, DARK);
5981                 }
5982                 // Odd color-bound pieces are shuffled with the rest (to not run out of paired squares)
5983             }
5984
5985         for(p = (int) WhiteKing - 2; p > (int) WhitePawn; p--) {
5986             // Remaining pieces (non-colorbound, or odd color bound) can be put anywhere
5987             // but we leave King and Rooks for last, to possibly obey FRC restriction
5988             if(p == (int)WhiteRook) continue;
5989             while(piecesLeft[p] >= 2) AddTwoPieces(board, p, 0); // add in pairs, for not counting permutations
5990             if(piecesLeft[p]) AddOnePiece(board, p, 0, ANY);     // add the odd piece
5991         }
5992
5993         // now everything is placed, except perhaps King (Unicorn) and Rooks
5994
5995         if(PosFlags(0) & F_FRC_TYPE_CASTLING) {
5996             // Last King gets castling rights
5997             while(piecesLeft[(int)WhiteUnicorn]) {
5998                 i = put(board, WhiteUnicorn, 0, piecesLeft[(int)WhiteRook]/2, ANY);
5999                 initialRights[2]  = initialRights[5]  = board[CASTLING][2] = board[CASTLING][5] = i;
6000             }
6001
6002             while(piecesLeft[(int)WhiteKing]) {
6003                 i = put(board, WhiteKing, 0, piecesLeft[(int)WhiteRook]/2, ANY);
6004                 initialRights[2]  = initialRights[5]  = board[CASTLING][2] = board[CASTLING][5] = i;
6005             }
6006
6007
6008         } else {
6009             while(piecesLeft[(int)WhiteKing])    AddOnePiece(board, WhiteKing, 0, ANY);
6010             while(piecesLeft[(int)WhiteUnicorn]) AddOnePiece(board, WhiteUnicorn, 0, ANY);
6011         }
6012
6013         // Only Rooks can be left; simply place them all
6014         while(piecesLeft[(int)WhiteRook]) {
6015                 i = put(board, WhiteRook, 0, 0, ANY);
6016                 if(PosFlags(0) & F_FRC_TYPE_CASTLING) { // first and last Rook get FRC castling rights
6017                         if(first) {
6018                                 first=0;
6019                                 initialRights[1]  = initialRights[4]  = board[CASTLING][1] = board[CASTLING][4] = i;
6020                         }
6021                         initialRights[0]  = initialRights[3]  = board[CASTLING][0] = board[CASTLING][3] = i;
6022                 }
6023         }
6024         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) { // copy black from white
6025             board[BOARD_HEIGHT-1][i] =  (int) board[0][i] < BlackPawn ? WHITE_TO_BLACK board[0][i] : EmptySquare;
6026         }
6027
6028         if(number >= 0) appData.defaultFrcPosition %= nrOfShuffles; // normalize
6029 }
6030
6031 int
6032 ptclen (const char *s, char *escapes)
6033 {
6034     int n = 0;
6035     if(!*escapes) return strlen(s);
6036     while(*s) n += (*s != '/' && *s != '-' && *s != '^' && *s != '*' && !strchr(escapes, *s)) - 2*(*s == '='), s++;
6037     return n;
6038 }
6039
6040 int
6041 SetCharTableEsc (unsigned char *table, const char * map, char * escapes)
6042 /* [HGM] moved here from winboard.c because of its general usefulness */
6043 /*       Basically a safe strcpy that uses the last character as King */
6044 {
6045     int result = FALSE; int NrPieces;
6046     unsigned char partner[EmptySquare];
6047
6048     if( map != NULL && (NrPieces=ptclen(map, escapes)) <= (int) EmptySquare
6049                     && NrPieces >= 12 && !(NrPieces&1)) {
6050         int i, ii, offs, j = 0; /* [HGM] Accept even length from 12 to 88 */
6051
6052         for( i=0; i<(int) EmptySquare; i++ ) table[i] = '.';
6053         for( i=offs=0; i<NrPieces/2-1; i++ ) {
6054             char *p, c=0;
6055             if(map[j] == '/') offs = WhitePBishop - i, j++;
6056             if(*escapes && (map[j] == '*' || map[j] == '-' || map[j] == '^')) c = map[j++];
6057             table[i+offs] = map[j++];
6058             if(p = strchr(escapes, map[j])) j++, table[i+offs] += 64*(p - escapes + 1);
6059             if(c) partner[i+offs] = table[i+offs], table[i+offs] = c;
6060             if(*escapes && map[j] == '=') pieceNickName[i+offs] = map[++j], j++;
6061         }
6062         table[(int) WhiteKing]  = map[j++];
6063         for( ii=offs=0; ii<NrPieces/2-1; ii++ ) {
6064             char *p, c=0;
6065             if(map[j] == '/') offs = WhitePBishop - ii, j++;
6066             i = WHITE_TO_BLACK ii;
6067             if(*escapes && (map[j] == '*' || map[j] == '-' || map[j] == '^')) c = map[j++];
6068             table[i+offs] = map[j++];
6069             if(p = strchr(escapes, map[j])) j++, table[i+offs] += 64*(p - escapes + 1);
6070             if(c) partner[i+offs] = table[i+offs], table[i+offs] = c;
6071             if(*escapes && map[j] == '=') pieceNickName[i+offs] = map[++j], j++;
6072         }
6073         table[(int) BlackKing]  = map[j++];
6074
6075
6076         if(*escapes) { // set up promotion pairing
6077             for( i=0; i<(int) EmptySquare; i++ ) promoPartner[i] = (i%BlackPawn < 11 ? i + 11 : i%BlackPawn < 22 ? i - 11 : i); // default
6078             // pieceToChar entirely filled, so we can look up specified partners
6079             for(i=0; i<EmptySquare; i++) { // adjust promotion pairing
6080                 int c = table[i];
6081                 if(c == '^' || c == '-') { // has specified partner
6082                     int p;
6083                     for(p=0; p<EmptySquare; p++) if(table[p] == partner[i]) break;
6084                     if(c == '^') table[i] = '+';
6085                     if(p < EmptySquare) {
6086                         if(promoPartner[promoPartner[p]] == p) promoPartner[promoPartner[p]] = promoPartner[p]; // divorce old partners
6087                         if(promoPartner[promoPartner[i]] == i) promoPartner[promoPartner[i]] = promoPartner[i];
6088                         promoPartner[p] = i, promoPartner[i] = p; // and marry this couple
6089                     }
6090                 } else if(c == '*') {
6091                     table[i] = partner[i];
6092                     promoPartner[i] = (i < BlackPawn ? WhiteTokin : BlackTokin); // promotes to Tokin
6093                 }
6094             }
6095         }
6096
6097         result = TRUE;
6098     }
6099
6100     return result;
6101 }
6102
6103 int
6104 SetCharTable (unsigned char *table, const char * map)
6105 {
6106     return SetCharTableEsc(table, map, "");
6107 }
6108
6109 void
6110 Prelude (Board board)
6111 {       // [HGM] superchess: random selection of exo-pieces
6112         int i, j, k; ChessSquare p;
6113         static ChessSquare exoPieces[4] = { WhiteAngel, WhiteMarshall, WhiteSilver, WhiteLance };
6114
6115         GetPositionNumber(); // use FRC position number
6116
6117         if(appData.pieceToCharTable != NULL) { // select pieces to participate from given char table
6118             SetCharTable(pieceToChar, appData.pieceToCharTable);
6119             for(i=(int)WhiteQueen+1, j=0; i<(int)WhiteKing && j<4; i++)
6120                 if(PieceToChar((ChessSquare)i) != '.') exoPieces[j++] = (ChessSquare) i;
6121         }
6122
6123         j = seed%4;                 seed /= 4;
6124         p = board[0][BOARD_LEFT+j];   board[0][BOARD_LEFT+j] = EmptySquare; k = PieceToNumber(p);
6125         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
6126         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
6127         j = seed%3 + (seed%3 >= j); seed /= 3;
6128         p = board[0][BOARD_LEFT+j];   board[0][BOARD_LEFT+j] = EmptySquare; k = PieceToNumber(p);
6129         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
6130         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
6131         j = seed%3;                 seed /= 3;
6132         p = board[0][BOARD_LEFT+j+5]; board[0][BOARD_LEFT+j+5] = EmptySquare; k = PieceToNumber(p);
6133         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
6134         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
6135         j = seed%2 + (seed%2 >= j); seed /= 2;
6136         p = board[0][BOARD_LEFT+j+5]; board[0][BOARD_LEFT+j+5] = EmptySquare; k = PieceToNumber(p);
6137         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
6138         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
6139         j = seed%4; seed /= 4; put(board, exoPieces[3],    0, j, ANY);
6140         j = seed%3; seed /= 3; put(board, exoPieces[2],   0, j, ANY);
6141         j = seed%2; seed /= 2; put(board, exoPieces[1], 0, j, ANY);
6142         put(board, exoPieces[0],    0, 0, ANY);
6143         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) board[BOARD_HEIGHT-1][i] = WHITE_TO_BLACK board[0][i];
6144 }
6145
6146 void
6147 InitPosition (int redraw)
6148 {
6149     ChessSquare (* pieces)[BOARD_FILES];
6150     int i, j, pawnRow=1, pieceRows=1, overrule,
6151     oldx = gameInfo.boardWidth,
6152     oldy = gameInfo.boardHeight,
6153     oldh = gameInfo.holdingsWidth;
6154     static int oldv;
6155
6156     if(appData.icsActive) shuffleOpenings = appData.fischerCastling = FALSE; // [HGM] shuffle: in ICS mode, only shuffle on ICS request
6157
6158     /* [AS] Initialize pv info list [HGM] and game status */
6159     {
6160         for( i=0; i<=framePtr; i++ ) { // [HGM] vari: spare saved variations
6161             pvInfoList[i].depth = 0;
6162             boards[i][EP_STATUS] = EP_NONE;
6163             for( j=0; j<BOARD_FILES-2; j++ ) boards[i][CASTLING][j] = NoRights;
6164         }
6165
6166         initialRulePlies = 0; /* 50-move counter start */
6167
6168         castlingRank[0] = castlingRank[1] = castlingRank[2] = 0;
6169         castlingRank[3] = castlingRank[4] = castlingRank[5] = BOARD_HEIGHT-1;
6170     }
6171
6172
6173     /* [HGM] logic here is completely changed. In stead of full positions */
6174     /* the initialized data only consist of the two backranks. The switch */
6175     /* selects which one we will use, which is than copied to the Board   */
6176     /* initialPosition, which for the rest is initialized by Pawns and    */
6177     /* empty squares. This initial position is then copied to boards[0],  */
6178     /* possibly after shuffling, so that it remains available.            */
6179
6180     gameInfo.holdingsWidth = 0; /* default board sizes */
6181     gameInfo.boardWidth    = 8;
6182     gameInfo.boardHeight   = 8;
6183     gameInfo.holdingsSize  = 0;
6184     nrCastlingRights = -1; /* [HGM] Kludge to indicate default should be used */
6185     for(i=0; i<BOARD_FILES-6; i++)
6186       initialPosition[CASTLING][i] = initialRights[i] = NoRights; /* but no rights yet */
6187     initialPosition[EP_STATUS] = EP_NONE;
6188     initialPosition[TOUCHED_W] = initialPosition[TOUCHED_B] = 0;
6189     SetCharTableEsc(pieceToChar, "PNBRQ...........Kpnbrq...........k", SUFFIXES);
6190     if(startVariant == gameInfo.variant) // [HGM] nicks: enable nicknames in original variant
6191          SetCharTable(pieceNickName, appData.pieceNickNames);
6192     else SetCharTable(pieceNickName, "............");
6193     pieces = FIDEArray;
6194
6195     switch (gameInfo.variant) {
6196     case VariantFischeRandom:
6197       shuffleOpenings = TRUE;
6198       appData.fischerCastling = TRUE;
6199     default:
6200       break;
6201     case VariantShatranj:
6202       pieces = ShatranjArray;
6203       nrCastlingRights = 0;
6204       SetCharTable(pieceToChar, "PN.R.QB...Kpn.r.qb...k");
6205       break;
6206     case VariantMakruk:
6207       pieces = makrukArray;
6208       nrCastlingRights = 0;
6209       SetCharTable(pieceToChar, "PN.R.M....SKpn.r.m....sk");
6210       break;
6211     case VariantASEAN:
6212       pieces = aseanArray;
6213       nrCastlingRights = 0;
6214       SetCharTable(pieceToChar, "PN.R.Q....BKpn.r.q....bk");
6215       break;
6216     case VariantTwoKings:
6217       pieces = twoKingsArray;
6218       break;
6219     case VariantGrand:
6220       pieces = GrandArray;
6221       nrCastlingRights = 0;
6222       SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
6223       gameInfo.boardWidth = 10;
6224       gameInfo.boardHeight = 10;
6225       gameInfo.holdingsSize = 7;
6226       break;
6227     case VariantCapaRandom:
6228       shuffleOpenings = TRUE;
6229       appData.fischerCastling = TRUE;
6230     case VariantCapablanca:
6231       pieces = CapablancaArray;
6232       gameInfo.boardWidth = 10;
6233       SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
6234       break;
6235     case VariantGothic:
6236       pieces = GothicArray;
6237       gameInfo.boardWidth = 10;
6238       SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
6239       break;
6240     case VariantSChess:
6241       SetCharTable(pieceToChar, "PNBRQ..HEKpnbrq..hek");
6242       gameInfo.holdingsSize = 7;
6243       for(i=0; i<BOARD_FILES; i++) initialPosition[VIRGIN][i] = VIRGIN_W | VIRGIN_B;
6244       break;
6245     case VariantJanus:
6246       pieces = JanusArray;
6247       gameInfo.boardWidth = 10;
6248       SetCharTable(pieceToChar, "PNBRQ..JKpnbrq..jk");
6249       nrCastlingRights = 6;
6250         initialPosition[CASTLING][0] = initialRights[0] = BOARD_RGHT-1;
6251         initialPosition[CASTLING][1] = initialRights[1] = BOARD_LEFT;
6252         initialPosition[CASTLING][2] = initialRights[2] =(BOARD_WIDTH-1)>>1;
6253         initialPosition[CASTLING][3] = initialRights[3] = BOARD_RGHT-1;
6254         initialPosition[CASTLING][4] = initialRights[4] = BOARD_LEFT;
6255         initialPosition[CASTLING][5] = initialRights[5] =(BOARD_WIDTH-1)>>1;
6256       break;
6257     case VariantFalcon:
6258       pieces = FalconArray;
6259       gameInfo.boardWidth = 10;
6260       SetCharTable(pieceToChar, "PNBRQ............FKpnbrq............fk");
6261       break;
6262     case VariantXiangqi:
6263       pieces = XiangqiArray;
6264       gameInfo.boardWidth  = 9;
6265       gameInfo.boardHeight = 10;
6266       nrCastlingRights = 0;
6267       SetCharTable(pieceToChar, "PH.R.AE..K.C.ph.r.ae..k.c.");
6268       break;
6269     case VariantShogi:
6270       pieces = ShogiArray;
6271       gameInfo.boardWidth  = 9;
6272       gameInfo.boardHeight = 9;
6273       gameInfo.holdingsSize = 7;
6274       nrCastlingRights = 0;
6275       SetCharTable(pieceToChar, "PNBRLS...G.++++++Kpnbrls...g.++++++k");
6276       break;
6277     case VariantChu:
6278       pieces = ChuArray; pieceRows = 3;
6279       gameInfo.boardWidth  = 12;
6280       gameInfo.boardHeight = 12;
6281       nrCastlingRights = 0;
6282       SetCharTableEsc(pieceToChar, "P.BRQSEXOGCATHD.VMLIFN.........^T..^L......^A^H/^F^G^M.^E^X^O^I.^P.^B^R..^D^S^C^VK"
6283                                    "p.brqsexogcathd.vmlifn.........^t..^l......^a^h/^f^g^m.^e^x^o^i.^p.^b^r..^d^s^c^vk", SUFFIXES);
6284       break;
6285     case VariantCourier:
6286       pieces = CourierArray;
6287       gameInfo.boardWidth  = 12;
6288       nrCastlingRights = 0;
6289       SetCharTable(pieceToChar, "PNBR.FE..WMKpnbr.fe..wmk");
6290       break;
6291     case VariantKnightmate:
6292       pieces = KnightmateArray;
6293       SetCharTable(pieceToChar, "P.BRQ.....M.........K.p.brq.....m.........k.");
6294       break;
6295     case VariantSpartan:
6296       pieces = SpartanArray;
6297       SetCharTable(pieceToChar, "PNBRQ................K......lwg.....c...h..k");
6298       break;
6299     case VariantLion:
6300       pieces = lionArray;
6301       SetCharTable(pieceToChar, "PNBRQ................LKpnbrq................lk");
6302       break;
6303     case VariantChuChess:
6304       pieces = ChuChessArray;
6305       gameInfo.boardWidth = 10;
6306       gameInfo.boardHeight = 10;
6307       SetCharTable(pieceToChar, "PNBRQ.....M.+++......LKpnbrq.....m.+++......lk");
6308       break;
6309     case VariantFairy:
6310       pieces = fairyArray;
6311       SetCharTable(pieceToChar, "PNBRQFEACWMOHIJGDVLSUKpnbrqfeacwmohijgdvlsuk");
6312       break;
6313     case VariantGreat:
6314       pieces = GreatArray;
6315       gameInfo.boardWidth = 10;
6316       SetCharTable(pieceToChar, "PN....E...S..HWGMKpn....e...s..hwgmk");
6317       gameInfo.holdingsSize = 8;
6318       break;
6319     case VariantSuper:
6320       pieces = FIDEArray;
6321       SetCharTable(pieceToChar, "PNBRQ..SE.......V.AKpnbrq..se.......v.ak");
6322       gameInfo.holdingsSize = 8;
6323       startedFromSetupPosition = TRUE;
6324       break;
6325     case VariantCrazyhouse:
6326     case VariantBughouse:
6327       pieces = FIDEArray;
6328       SetCharTable(pieceToChar, "PNBRQ.......~~~~Kpnbrq.......~~~~k");
6329       gameInfo.holdingsSize = 5;
6330       break;
6331     case VariantWildCastle:
6332       pieces = FIDEArray;
6333       /* !!?shuffle with kings guaranteed to be on d or e file */
6334       shuffleOpenings = 1;
6335       break;
6336     case VariantNoCastle:
6337       pieces = FIDEArray;
6338       nrCastlingRights = 0;
6339       /* !!?unconstrained back-rank shuffle */
6340       shuffleOpenings = 1;
6341       break;
6342     }
6343
6344     overrule = 0;
6345     if(appData.NrFiles >= 0) {
6346         if(gameInfo.boardWidth != appData.NrFiles) overrule++;
6347         gameInfo.boardWidth = appData.NrFiles;
6348     }
6349     if(appData.NrRanks >= 0) {
6350         gameInfo.boardHeight = appData.NrRanks;
6351     }
6352     if(appData.holdingsSize >= 0) {
6353         i = appData.holdingsSize;
6354         if(i > gameInfo.boardHeight) i = gameInfo.boardHeight;
6355         gameInfo.holdingsSize = i;
6356     }
6357     if(gameInfo.holdingsSize) gameInfo.holdingsWidth = 2;
6358     if(BOARD_HEIGHT > BOARD_RANKS || BOARD_WIDTH > BOARD_FILES)
6359         DisplayFatalError(_("Recompile to support this BOARD_RANKS or BOARD_FILES!"), 0, 2);
6360
6361     pawnRow = gameInfo.boardHeight - 7; /* seems to work in all common variants */
6362     if(pawnRow < 1) pawnRow = 1;
6363     if(gameInfo.variant == VariantMakruk || gameInfo.variant == VariantASEAN ||
6364        gameInfo.variant == VariantGrand || gameInfo.variant == VariantChuChess) pawnRow = 2;
6365     if(gameInfo.variant == VariantChu) pawnRow = 3;
6366
6367     /* User pieceToChar list overrules defaults */
6368     if(appData.pieceToCharTable != NULL)
6369         SetCharTableEsc(pieceToChar, appData.pieceToCharTable, SUFFIXES);
6370
6371     for( j=0; j<BOARD_WIDTH; j++ ) { ChessSquare s = EmptySquare;
6372
6373         if(j==BOARD_LEFT-1 || j==BOARD_RGHT)
6374             s = (ChessSquare) 0; /* account holding counts in guard band */
6375         for( i=0; i<BOARD_HEIGHT; i++ )
6376             initialPosition[i][j] = s;
6377
6378         if(j < BOARD_LEFT || j >= BOARD_RGHT || overrule) continue;
6379         initialPosition[gameInfo.variant == VariantGrand || gameInfo.variant == VariantChuChess][j] = pieces[0][j-gameInfo.holdingsWidth];
6380         initialPosition[pawnRow][j] = WhitePawn;
6381         initialPosition[BOARD_HEIGHT-pawnRow-1][j] = gameInfo.variant == VariantSpartan ? BlackLance : BlackPawn;
6382         if(gameInfo.variant == VariantXiangqi) {
6383             if(j&1) {
6384                 initialPosition[pawnRow][j] =
6385                 initialPosition[BOARD_HEIGHT-pawnRow-1][j] = EmptySquare;
6386                 if(j==BOARD_LEFT+1 || j>=BOARD_RGHT-2) {
6387                    initialPosition[2][j] = WhiteCannon;
6388                    initialPosition[BOARD_HEIGHT-3][j] = BlackCannon;
6389                 }
6390             }
6391         }
6392         if(gameInfo.variant == VariantChu) {
6393              if(j == (BOARD_WIDTH-2)/3 || j == BOARD_WIDTH - (BOARD_WIDTH+1)/3)
6394                initialPosition[pawnRow+1][j] = WhiteCobra,
6395                initialPosition[BOARD_HEIGHT-pawnRow-2][j] = BlackCobra;
6396              for(i=1; i<pieceRows; i++) {
6397                initialPosition[i][j] = pieces[2*i][j-gameInfo.holdingsWidth];
6398                initialPosition[BOARD_HEIGHT-1-i][j] =  pieces[2*i+1][j-gameInfo.holdingsWidth];
6399              }
6400         }
6401         if(gameInfo.variant == VariantGrand || gameInfo.variant == VariantChuChess) {
6402             if(j==BOARD_LEFT || j>=BOARD_RGHT-1) {
6403                initialPosition[0][j] = WhiteRook;
6404                initialPosition[BOARD_HEIGHT-1][j] = BlackRook;
6405             }
6406         }
6407         initialPosition[BOARD_HEIGHT-1-(gameInfo.variant == VariantGrand || gameInfo.variant == VariantChuChess)][j] =  pieces[1][j-gameInfo.holdingsWidth];
6408     }
6409     if(gameInfo.variant == VariantChuChess) initialPosition[0][BOARD_WIDTH/2] = WhiteKing, initialPosition[BOARD_HEIGHT-1][BOARD_WIDTH/2-1] = BlackKing;
6410     if( (gameInfo.variant == VariantShogi) && !overrule ) {
6411
6412             j=BOARD_LEFT+1;
6413             initialPosition[1][j] = WhiteBishop;
6414             initialPosition[BOARD_HEIGHT-2][j] = BlackRook;
6415             j=BOARD_RGHT-2;
6416             initialPosition[1][j] = WhiteRook;
6417             initialPosition[BOARD_HEIGHT-2][j] = BlackBishop;
6418     }
6419
6420     if( nrCastlingRights == -1) {
6421         /* [HGM] Build normal castling rights (must be done after board sizing!) */
6422         /*       This sets default castling rights from none to normal corners   */
6423         /* Variants with other castling rights must set them themselves above    */
6424         nrCastlingRights = 6;
6425
6426         initialPosition[CASTLING][0] = initialRights[0] = BOARD_RGHT-1;
6427         initialPosition[CASTLING][1] = initialRights[1] = BOARD_LEFT;
6428         initialPosition[CASTLING][2] = initialRights[2] = BOARD_WIDTH>>1;
6429         initialPosition[CASTLING][3] = initialRights[3] = BOARD_RGHT-1;
6430         initialPosition[CASTLING][4] = initialRights[4] = BOARD_LEFT;
6431         initialPosition[CASTLING][5] = initialRights[5] = BOARD_WIDTH>>1;
6432      }
6433
6434      if(gameInfo.variant == VariantSuper) Prelude(initialPosition);
6435      if(gameInfo.variant == VariantGreat) { // promotion commoners
6436         initialPosition[PieceToNumber(WhiteMan)][BOARD_WIDTH-1] = WhiteMan;
6437         initialPosition[PieceToNumber(WhiteMan)][BOARD_WIDTH-2] = 9;
6438         initialPosition[BOARD_HEIGHT-1-PieceToNumber(WhiteMan)][0] = BlackMan;
6439         initialPosition[BOARD_HEIGHT-1-PieceToNumber(WhiteMan)][1] = 9;
6440      }
6441      if( gameInfo.variant == VariantSChess ) {
6442       initialPosition[1][0] = BlackMarshall;
6443       initialPosition[2][0] = BlackAngel;
6444       initialPosition[6][BOARD_WIDTH-1] = WhiteMarshall;
6445       initialPosition[5][BOARD_WIDTH-1] = WhiteAngel;
6446       initialPosition[1][1] = initialPosition[2][1] =
6447       initialPosition[6][BOARD_WIDTH-2] = initialPosition[5][BOARD_WIDTH-2] = 1;
6448      }
6449   if (appData.debugMode) {
6450     fprintf(debugFP, "shuffleOpenings = %d\n", shuffleOpenings);
6451   }
6452     if(shuffleOpenings) {
6453         SetUpShuffle(initialPosition, appData.defaultFrcPosition);
6454         startedFromSetupPosition = TRUE;
6455     }
6456     if(startedFromPositionFile) {
6457       /* [HGM] loadPos: use PositionFile for every new game */
6458       CopyBoard(initialPosition, filePosition);
6459       for(i=0; i<nrCastlingRights; i++)
6460           initialRights[i] = filePosition[CASTLING][i];
6461       startedFromSetupPosition = TRUE;
6462     }
6463     if(*appData.men) LoadPieceDesc(appData.men);
6464
6465     CopyBoard(boards[0], initialPosition);
6466
6467     if(oldx != gameInfo.boardWidth ||
6468        oldy != gameInfo.boardHeight ||
6469        oldv != gameInfo.variant ||
6470        oldh != gameInfo.holdingsWidth
6471                                          )
6472             InitDrawingSizes(-2 ,0);
6473
6474     oldv = gameInfo.variant;
6475     if (redraw)
6476       DrawPosition(TRUE, boards[currentMove]);
6477 }
6478
6479 void
6480 SendBoard (ChessProgramState *cps, int moveNum)
6481 {
6482     char message[MSG_SIZ];
6483
6484     if (cps->useSetboard) {
6485       char* fen = PositionToFEN(moveNum, cps->fenOverride, 1);
6486       snprintf(message, MSG_SIZ,"setboard %s\n", fen);
6487       SendToProgram(message, cps);
6488       free(fen);
6489
6490     } else {
6491       ChessSquare *bp;
6492       int i, j, left=0, right=BOARD_WIDTH;
6493       /* Kludge to set black to move, avoiding the troublesome and now
6494        * deprecated "black" command.
6495        */
6496       if (!WhiteOnMove(moveNum)) // [HGM] but better a deprecated command than an illegal move...
6497         SendToProgram(boards[0][1][BOARD_LEFT] == WhitePawn ? "a2a3\n" : "black\n", cps);
6498
6499       if(!cps->extendedEdit) left = BOARD_LEFT, right = BOARD_RGHT; // only board proper
6500
6501       SendToProgram("edit\n", cps);
6502       SendToProgram("#\n", cps);
6503       for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
6504         bp = &boards[moveNum][i][left];
6505         for (j = left; j < right; j++, bp++) {
6506           if(j == BOARD_LEFT-1 || j == BOARD_RGHT) continue;
6507           if ((int) *bp < (int) BlackPawn) {
6508             if(j == BOARD_RGHT+1)
6509                  snprintf(message, MSG_SIZ, "%c@%d\n", PieceToChar(*bp), bp[-1]);
6510             else snprintf(message, MSG_SIZ, "%c%c%d\n", PieceToChar(*bp), AAA + j, ONE + i - '0');
6511             if(message[0] == '+' || message[0] == '~') {
6512               snprintf(message, MSG_SIZ,"%c%c%d+\n",
6513                         PieceToChar((ChessSquare)(DEMOTED(*bp))),
6514                         AAA + j, ONE + i - '0');
6515             }
6516             if(cps->alphaRank) { /* [HGM] shogi: translate coords */
6517                 message[1] = BOARD_RGHT   - 1 - j + '1';
6518                 message[2] = BOARD_HEIGHT - 1 - i + 'a';
6519             }
6520             SendToProgram(message, cps);
6521           }
6522         }
6523       }
6524
6525       SendToProgram("c\n", cps);
6526       for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
6527         bp = &boards[moveNum][i][left];
6528         for (j = left; j < right; j++, bp++) {
6529           if(j == BOARD_LEFT-1 || j == BOARD_RGHT) continue;
6530           if (((int) *bp != (int) EmptySquare)
6531               && ((int) *bp >= (int) BlackPawn)) {
6532             if(j == BOARD_LEFT-2)
6533                  snprintf(message, MSG_SIZ, "%c@%d\n", ToUpper(PieceToChar(*bp)), bp[1]);
6534             else snprintf(message,MSG_SIZ, "%c%c%d\n", ToUpper(PieceToChar(*bp)),
6535                     AAA + j, ONE + i - '0');
6536             if(message[0] == '+' || message[0] == '~') {
6537               snprintf(message, MSG_SIZ,"%c%c%d+\n",
6538                         PieceToChar((ChessSquare)(DEMOTED(*bp))),
6539                         AAA + j, ONE + i - '0');
6540             }
6541             if(cps->alphaRank) { /* [HGM] shogi: translate coords */
6542                 message[1] = BOARD_RGHT   - 1 - j + '1';
6543                 message[2] = BOARD_HEIGHT - 1 - i + 'a';
6544             }
6545             SendToProgram(message, cps);
6546           }
6547         }
6548       }
6549
6550       SendToProgram(".\n", cps);
6551     }
6552     setboardSpoiledMachineBlack = 0; /* [HGM] assume WB 4.2.7 already solves this after sending setboard */
6553 }
6554
6555 char exclusionHeader[MSG_SIZ];
6556 int exCnt, excludePtr;
6557 typedef struct { int ff, fr, tf, tr, pc, mark; } Exclusion;
6558 static Exclusion excluTab[200];
6559 static char excludeMap[(BOARD_RANKS*BOARD_FILES*BOARD_RANKS*BOARD_FILES+7)/8]; // [HGM] exclude: bitmap for excluced moves
6560
6561 static void
6562 WriteMap (int s)
6563 {
6564     int j;
6565     for(j=0; j<(BOARD_RANKS*BOARD_FILES*BOARD_RANKS*BOARD_FILES+7)/8; j++) excludeMap[j] = s;
6566     exclusionHeader[19] = s ? '-' : '+'; // update tail state
6567 }
6568
6569 static void
6570 ClearMap ()
6571 {
6572     safeStrCpy(exclusionHeader, "exclude: none best +tail                                          \n", MSG_SIZ);
6573     excludePtr = 24; exCnt = 0;
6574     WriteMap(0);
6575 }
6576
6577 static void
6578 UpdateExcludeHeader (int fromY, int fromX, int toY, int toX, char promoChar, char state)
6579 {   // search given move in table of header moves, to know where it is listed (and add if not there), and update state
6580     char buf[2*MOVE_LEN], *p;
6581     Exclusion *e = excluTab;
6582     int i;
6583     for(i=0; i<exCnt; i++)
6584         if(e[i].ff == fromX && e[i].fr == fromY &&
6585            e[i].tf == toX   && e[i].tr == toY && e[i].pc == promoChar) break;
6586     if(i == exCnt) { // was not in exclude list; add it
6587         CoordsToAlgebraic(boards[currentMove], PosFlags(currentMove), fromY, fromX, toY, toX, promoChar, buf);
6588         if(strlen(exclusionHeader + excludePtr) < strlen(buf)) { // no space to write move
6589             if(state != exclusionHeader[19]) exclusionHeader[19] = '*'; // tail is now in mixed state
6590             return; // abort
6591         }
6592         e[i].ff = fromX; e[i].fr = fromY; e[i].tf = toX; e[i].tr = toY; e[i].pc = promoChar;
6593         excludePtr++; e[i].mark = excludePtr++;
6594         for(p=buf; *p; p++) exclusionHeader[excludePtr++] = *p; // copy move
6595         exCnt++;
6596     }
6597     exclusionHeader[e[i].mark] = state;
6598 }
6599
6600 static int
6601 ExcludeOneMove (int fromY, int fromX, int toY, int toX, char promoChar, char state)
6602 {   // include or exclude the given move, as specified by state ('+' or '-'), or toggle
6603     char buf[MSG_SIZ];
6604     int j, k;
6605     ChessMove moveType;
6606     if((signed char)promoChar == -1) { // kludge to indicate best move
6607         if(!ParseOneMove(lastPV[0], currentMove, &moveType, &fromX, &fromY, &toX, &toY, &promoChar)) // get current best move from last PV
6608             return 1; // if unparsable, abort
6609     }
6610     // update exclusion map (resolving toggle by consulting existing state)
6611     k=(BOARD_FILES*fromY+fromX)*BOARD_RANKS*BOARD_FILES + (BOARD_FILES*toY+toX);
6612     j = k%8; k >>= 3;
6613     if(state == '*') state = (excludeMap[k] & 1<<j ? '+' : '-'); // toggle
6614     if(state == '-' && !promoChar) // only non-promotions get marked as excluded, to allow exclusion of under-promotions
6615          excludeMap[k] |=   1<<j;
6616     else excludeMap[k] &= ~(1<<j);
6617     // update header
6618     UpdateExcludeHeader(fromY, fromX, toY, toX, promoChar, state);
6619     // inform engine
6620     snprintf(buf, MSG_SIZ, "%sclude ", state == '+' ? "in" : "ex");
6621     CoordsToComputerAlgebraic(fromY, fromX, toY, toX, promoChar, buf+8);
6622     SendToBoth(buf);
6623     return (state == '+');
6624 }
6625
6626 static void
6627 ExcludeClick (int index)
6628 {
6629     int i, j;
6630     Exclusion *e = excluTab;
6631     if(index < 25) { // none, best or tail clicked
6632         if(index < 13) { // none: include all
6633             WriteMap(0); // clear map
6634             for(i=0; i<exCnt; i++) exclusionHeader[excluTab[i].mark] = '+'; // and moves
6635             SendToBoth("include all\n"); // and inform engine
6636         } else if(index > 18) { // tail
6637             if(exclusionHeader[19] == '-') { // tail was excluded
6638                 SendToBoth("include all\n");
6639                 WriteMap(0); // clear map completely
6640                 // now re-exclude selected moves
6641                 for(i=0; i<exCnt; i++) if(exclusionHeader[e[i].mark] == '-')
6642                     ExcludeOneMove(e[i].fr, e[i].ff, e[i].tr, e[i].tf, e[i].pc, '-');
6643             } else { // tail was included or in mixed state
6644                 SendToBoth("exclude all\n");
6645                 WriteMap(0xFF); // fill map completely
6646                 // now re-include selected moves
6647                 j = 0; // count them
6648                 for(i=0; i<exCnt; i++) if(exclusionHeader[e[i].mark] == '+')
6649                     ExcludeOneMove(e[i].fr, e[i].ff, e[i].tr, e[i].tf, e[i].pc, '+'), j++;
6650                 if(!j) ExcludeOneMove(0, 0, 0, 0, -1, '+'); // if no moves were selected, keep best
6651             }
6652         } else { // best
6653             ExcludeOneMove(0, 0, 0, 0, -1, '-'); // exclude it
6654         }
6655     } else {
6656         for(i=0; i<exCnt; i++) if(i == exCnt-1 || excluTab[i+1].mark > index) {
6657             char *p=exclusionHeader + excluTab[i].mark; // do trust header more than map (promotions!)
6658             ExcludeOneMove(e[i].fr, e[i].ff, e[i].tr, e[i].tf, e[i].pc, *p == '+' ? '-' : '+');
6659             break;
6660         }
6661     }
6662 }
6663
6664 ChessSquare
6665 DefaultPromoChoice (int white)
6666 {
6667     ChessSquare result;
6668     if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier ||
6669        gameInfo.variant == VariantMakruk)
6670         result = WhiteFerz; // no choice
6671     else if(gameInfo.variant == VariantASEAN)
6672         result = WhiteRook; // no choice
6673     else if(gameInfo.variant == VariantSuicide || gameInfo.variant == VariantGiveaway)
6674         result= WhiteKing; // in Suicide Q is the last thing we want
6675     else if(gameInfo.variant == VariantSpartan)
6676         result = white ? WhiteQueen : WhiteAngel;
6677     else result = WhiteQueen;
6678     if(!white) result = WHITE_TO_BLACK result;
6679     return result;
6680 }
6681
6682 static int autoQueen; // [HGM] oneclick
6683
6684 int
6685 HasPromotionChoice (int fromX, int fromY, int toX, int toY, char *promoChoice, int sweepSelect)
6686 {
6687     /* [HGM] rewritten IsPromotion to only flag promotions that offer a choice */
6688     /* [HGM] add Shogi promotions */
6689     int promotionZoneSize=1, highestPromotingPiece = (int)WhitePawn;
6690     ChessSquare piece, partner;
6691     ChessMove moveType;
6692     Boolean premove;
6693
6694     if(fromX < BOARD_LEFT || fromX >= BOARD_RGHT) return FALSE; // drop
6695     if(toX   < BOARD_LEFT || toX   >= BOARD_RGHT) return FALSE; // move into holdings
6696
6697     if(gameMode == EditPosition || gameInfo.variant == VariantXiangqi || // no promotions
6698       !(fromX >=0 && fromY >= 0 && toX >= 0 && toY >= 0) ) // invalid move
6699         return FALSE;
6700
6701     piece = boards[currentMove][fromY][fromX];
6702     if(gameInfo.variant == VariantChu) {
6703         promotionZoneSize = BOARD_HEIGHT/3;
6704         highestPromotingPiece = (PieceToChar(piece) == '+' || PieceToChar(CHUPROMOTED(piece)) != '+') ? WhitePawn : WhiteKing;
6705     } else if(gameInfo.variant == VariantShogi) {
6706         promotionZoneSize = BOARD_HEIGHT/3 +(BOARD_HEIGHT == 8);
6707         highestPromotingPiece = (int)WhiteAlfil;
6708     } else if(gameInfo.variant == VariantMakruk || gameInfo.variant == VariantGrand || gameInfo.variant == VariantChuChess) {
6709         promotionZoneSize = 3;
6710     }
6711
6712     // Treat Lance as Pawn when it is not representing Amazon or Lance
6713     if(gameInfo.variant != VariantSuper && gameInfo.variant != VariantChu) {
6714         if(piece == WhiteLance) piece = WhitePawn; else
6715         if(piece == BlackLance) piece = BlackPawn;
6716     }
6717
6718     // next weed out all moves that do not touch the promotion zone at all
6719     if((int)piece >= BlackPawn) {
6720         if(toY >= promotionZoneSize && fromY >= promotionZoneSize)
6721              return FALSE;
6722         if(fromY < promotionZoneSize && gameInfo.variant == VariantChuChess) return FALSE;
6723         highestPromotingPiece = WHITE_TO_BLACK highestPromotingPiece;
6724     } else {
6725         if(  toY < BOARD_HEIGHT - promotionZoneSize &&
6726            fromY < BOARD_HEIGHT - promotionZoneSize) return FALSE;
6727         if(fromY >= BOARD_HEIGHT - promotionZoneSize && gameInfo.variant == VariantChuChess)
6728              return FALSE;
6729     }
6730
6731     if( (int)piece > highestPromotingPiece ) return FALSE; // non-promoting piece
6732
6733     // weed out mandatory Shogi promotions
6734     if(gameInfo.variant == VariantShogi) {
6735         if(piece >= BlackPawn) {
6736             if(toY == 0 && piece == BlackPawn ||
6737                toY == 0 && piece == BlackQueen ||
6738                toY <= 1 && piece == BlackKnight) {
6739                 *promoChoice = '+';
6740                 return FALSE;
6741             }
6742         } else {
6743             if(toY == BOARD_HEIGHT-1 && piece == WhitePawn ||
6744                toY == BOARD_HEIGHT-1 && piece == WhiteQueen ||
6745                toY >= BOARD_HEIGHT-2 && piece == WhiteKnight) {
6746                 *promoChoice = '+';
6747                 return FALSE;
6748             }
6749         }
6750     }
6751
6752     // weed out obviously illegal Pawn moves
6753     if(appData.testLegality  && (piece == WhitePawn || piece == BlackPawn) ) {
6754         if(toX > fromX+1 || toX < fromX-1) return FALSE; // wide
6755         if(piece == WhitePawn && toY != fromY+1) return FALSE; // deep
6756         if(piece == BlackPawn && toY != fromY-1) return FALSE; // deep
6757         if(fromX != toX && gameInfo.variant == VariantShogi) return FALSE;
6758         // note we are not allowed to test for valid (non-)capture, due to premove
6759     }
6760
6761     // we either have a choice what to promote to, or (in Shogi) whether to promote
6762     if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier ||
6763        gameInfo.variant == VariantMakruk) {
6764         ChessSquare p=BlackFerz;  // no choice
6765         while(p < EmptySquare) {  //but make sure we use piece that exists
6766             *promoChoice = PieceToChar(p++);
6767             if(*promoChoice != '.') break;
6768         }
6769         if(!*engineVariant) return FALSE; // if used as parent variant there might be promotion choice
6770     }
6771     // no sense asking what we must promote to if it is going to explode...
6772     if(gameInfo.variant == VariantAtomic && boards[currentMove][toY][toX] != EmptySquare) {
6773         *promoChoice = PieceToChar(BlackQueen); // Queen as good as any
6774         return FALSE;
6775     }
6776     // give caller the default choice even if we will not make it
6777     *promoChoice = ToLower(PieceToChar(defaultPromoChoice));
6778     partner = piece; // pieces can promote if the pieceToCharTable says so
6779     if(IS_SHOGI(gameInfo.variant)) *promoChoice = (defaultPromoChoice == piece && sweepSelect ? '=' : '+'); // obsolete?
6780     else if(Partner(&partner))     *promoChoice = (defaultPromoChoice == piece && sweepSelect ? NULLCHAR : '+');
6781     if(        sweepSelect && gameInfo.variant != VariantGreat
6782                            && gameInfo.variant != VariantGrand
6783                            && gameInfo.variant != VariantSuper) return FALSE;
6784     if(autoQueen) return FALSE; // predetermined
6785
6786     // suppress promotion popup on illegal moves that are not premoves
6787     premove = gameMode == IcsPlayingWhite && !WhiteOnMove(currentMove) ||
6788               gameMode == IcsPlayingBlack &&  WhiteOnMove(currentMove);
6789     if(appData.testLegality && !premove) {
6790         moveType = LegalityTest(boards[currentMove], PosFlags(currentMove),
6791                         fromY, fromX, toY, toX, IS_SHOGI(gameInfo.variant) || gameInfo.variant == VariantChuChess ? '+' : NULLCHAR);
6792         if(moveType == IllegalMove) *promoChoice = NULLCHAR; // could be the fact we promoted was illegal
6793         if(moveType != WhitePromotion && moveType  != BlackPromotion)
6794             return FALSE;
6795     }
6796
6797     return TRUE;
6798 }
6799
6800 int
6801 InPalace (int row, int column)
6802 {   /* [HGM] for Xiangqi */
6803     if( (row < 3 || row > BOARD_HEIGHT-4) &&
6804          column < (BOARD_WIDTH + 4)/2 &&
6805          column > (BOARD_WIDTH - 5)/2 ) return TRUE;
6806     return FALSE;
6807 }
6808
6809 int
6810 PieceForSquare (int x, int y)
6811 {
6812   if (x < 0 || x >= BOARD_WIDTH || y < 0 || y >= BOARD_HEIGHT)
6813      return -1;
6814   else
6815      return boards[currentMove][y][x];
6816 }
6817
6818 int
6819 OKToStartUserMove (int x, int y)
6820 {
6821     ChessSquare from_piece;
6822     int white_piece;
6823
6824     if (matchMode) return FALSE;
6825     if (gameMode == EditPosition) return TRUE;
6826
6827     if (x >= 0 && y >= 0)
6828       from_piece = boards[currentMove][y][x];
6829     else
6830       from_piece = EmptySquare;
6831
6832     if (from_piece == EmptySquare) return FALSE;
6833
6834     white_piece = (int)from_piece >= (int)WhitePawn &&
6835       (int)from_piece < (int)BlackPawn; /* [HGM] can be > King! */
6836
6837     switch (gameMode) {
6838       case AnalyzeFile:
6839       case TwoMachinesPlay:
6840       case EndOfGame:
6841         return FALSE;
6842
6843       case IcsObserving:
6844       case IcsIdle:
6845         return FALSE;
6846
6847       case MachinePlaysWhite:
6848       case IcsPlayingBlack:
6849         if (appData.zippyPlay) return FALSE;
6850         if (white_piece) {
6851             DisplayMoveError(_("You are playing Black"));
6852             return FALSE;
6853         }
6854         break;
6855
6856       case MachinePlaysBlack:
6857       case IcsPlayingWhite:
6858         if (appData.zippyPlay) return FALSE;
6859         if (!white_piece) {
6860             DisplayMoveError(_("You are playing White"));
6861             return FALSE;
6862         }
6863         break;
6864
6865       case PlayFromGameFile:
6866             if(!shiftKey || !appData.variations) return FALSE; // [HGM] allow starting variation in this mode
6867       case EditGame:
6868       case AnalyzeMode:
6869         if (!white_piece && WhiteOnMove(currentMove)) {
6870             DisplayMoveError(_("It is White's turn"));
6871             return FALSE;
6872         }
6873         if (white_piece && !WhiteOnMove(currentMove)) {
6874             DisplayMoveError(_("It is Black's turn"));
6875             return FALSE;
6876         }
6877         if (cmailMsgLoaded && (currentMove < cmailOldMove)) {
6878             /* Editing correspondence game history */
6879             /* Could disallow this or prompt for confirmation */
6880             cmailOldMove = -1;
6881         }
6882         break;
6883
6884       case BeginningOfGame:
6885         if (appData.icsActive) return FALSE;
6886         if (!appData.noChessProgram) {
6887             if (!white_piece) {
6888                 DisplayMoveError(_("You are playing White"));
6889                 return FALSE;
6890             }
6891         }
6892         break;
6893
6894       case Training:
6895         if (!white_piece && WhiteOnMove(currentMove)) {
6896             DisplayMoveError(_("It is White's turn"));
6897             return FALSE;
6898         }
6899         if (white_piece && !WhiteOnMove(currentMove)) {
6900             DisplayMoveError(_("It is Black's turn"));
6901             return FALSE;
6902         }
6903         break;
6904
6905       default:
6906       case IcsExamining:
6907         break;
6908     }
6909     if (currentMove != forwardMostMove && gameMode != AnalyzeMode
6910         && gameMode != EditGame // [HGM] vari: treat as AnalyzeMode
6911         && gameMode != PlayFromGameFile // [HGM] as EditGame, with protected main line
6912         && gameMode != AnalyzeFile && gameMode != Training) {
6913         DisplayMoveError(_("Displayed position is not current"));
6914         return FALSE;
6915     }
6916     return TRUE;
6917 }
6918
6919 Boolean
6920 OnlyMove (int *x, int *y, Boolean captures)
6921 {
6922     DisambiguateClosure cl;
6923     if (appData.zippyPlay || !appData.testLegality) return FALSE;
6924     switch(gameMode) {
6925       case MachinePlaysBlack:
6926       case IcsPlayingWhite:
6927       case BeginningOfGame:
6928         if(!WhiteOnMove(currentMove)) return FALSE;
6929         break;
6930       case MachinePlaysWhite:
6931       case IcsPlayingBlack:
6932         if(WhiteOnMove(currentMove)) return FALSE;
6933         break;
6934       case EditGame:
6935         break;
6936       default:
6937         return FALSE;
6938     }
6939     cl.pieceIn = EmptySquare;
6940     cl.rfIn = *y;
6941     cl.ffIn = *x;
6942     cl.rtIn = -1;
6943     cl.ftIn = -1;
6944     cl.promoCharIn = NULLCHAR;
6945     Disambiguate(boards[currentMove], PosFlags(currentMove), &cl);
6946     if( cl.kind == NormalMove ||
6947         cl.kind == AmbiguousMove && captures && cl.captures == 1 ||
6948         cl.kind == WhitePromotion || cl.kind == BlackPromotion ||
6949         cl.kind == WhiteCapturesEnPassant || cl.kind == BlackCapturesEnPassant) {
6950       fromX = cl.ff;
6951       fromY = cl.rf;
6952       *x = cl.ft;
6953       *y = cl.rt;
6954       return TRUE;
6955     }
6956     if(cl.kind != ImpossibleMove) return FALSE;
6957     cl.pieceIn = EmptySquare;
6958     cl.rfIn = -1;
6959     cl.ffIn = -1;
6960     cl.rtIn = *y;
6961     cl.ftIn = *x;
6962     cl.promoCharIn = NULLCHAR;
6963     Disambiguate(boards[currentMove], PosFlags(currentMove), &cl);
6964     if( cl.kind == NormalMove ||
6965         cl.kind == AmbiguousMove && captures && cl.captures == 1 ||
6966         cl.kind == WhitePromotion || cl.kind == BlackPromotion ||
6967         cl.kind == WhiteCapturesEnPassant || cl.kind == BlackCapturesEnPassant) {
6968       fromX = cl.ff;
6969       fromY = cl.rf;
6970       *x = cl.ft;
6971       *y = cl.rt;
6972       autoQueen = TRUE; // act as if autoQueen on when we click to-square
6973       return TRUE;
6974     }
6975     return FALSE;
6976 }
6977
6978 FILE *lastLoadGameFP = NULL, *lastLoadPositionFP = NULL;
6979 int lastLoadGameNumber = 0, lastLoadPositionNumber = 0;
6980 int lastLoadGameUseList = FALSE;
6981 char lastLoadGameTitle[MSG_SIZ], lastLoadPositionTitle[MSG_SIZ];
6982 ChessMove lastLoadGameStart = EndOfFile;
6983 int doubleClick;
6984 Boolean addToBookFlag;
6985
6986 void
6987 UserMoveEvent (int fromX, int fromY, int toX, int toY, int promoChar)
6988 {
6989     ChessMove moveType;
6990     ChessSquare pup;
6991     int ff=fromX, rf=fromY, ft=toX, rt=toY;
6992
6993     /* Check if the user is playing in turn.  This is complicated because we
6994        let the user "pick up" a piece before it is his turn.  So the piece he
6995        tried to pick up may have been captured by the time he puts it down!
6996        Therefore we use the color the user is supposed to be playing in this
6997        test, not the color of the piece that is currently on the starting
6998        square---except in EditGame mode, where the user is playing both
6999        sides; fortunately there the capture race can't happen.  (It can
7000        now happen in IcsExamining mode, but that's just too bad.  The user
7001        will get a somewhat confusing message in that case.)
7002        */
7003
7004     switch (gameMode) {
7005       case AnalyzeFile:
7006       case TwoMachinesPlay:
7007       case EndOfGame:
7008       case IcsObserving:
7009       case IcsIdle:
7010         /* We switched into a game mode where moves are not accepted,
7011            perhaps while the mouse button was down. */
7012         return;
7013
7014       case MachinePlaysWhite:
7015         /* User is moving for Black */
7016         if (WhiteOnMove(currentMove)) {
7017             DisplayMoveError(_("It is White's turn"));
7018             return;
7019         }
7020         break;
7021
7022       case MachinePlaysBlack:
7023         /* User is moving for White */
7024         if (!WhiteOnMove(currentMove)) {
7025             DisplayMoveError(_("It is Black's turn"));
7026             return;
7027         }
7028         break;
7029
7030       case PlayFromGameFile:
7031             if(!shiftKey ||!appData.variations) return; // [HGM] only variations
7032       case EditGame:
7033       case IcsExamining:
7034       case BeginningOfGame:
7035       case AnalyzeMode:
7036       case Training:
7037         if(fromY == DROP_RANK) break; // [HGM] drop moves (entered through move type-in) are automatically assigned to side-to-move
7038         if ((int) boards[currentMove][fromY][fromX] >= (int) BlackPawn &&
7039             (int) boards[currentMove][fromY][fromX] < (int) EmptySquare) {
7040             /* User is moving for Black */
7041             if (WhiteOnMove(currentMove)) {
7042                 DisplayMoveError(_("It is White's turn"));
7043                 return;
7044             }
7045         } else {
7046             /* User is moving for White */
7047             if (!WhiteOnMove(currentMove)) {
7048                 DisplayMoveError(_("It is Black's turn"));
7049                 return;
7050             }
7051         }
7052         break;
7053
7054       case IcsPlayingBlack:
7055         /* User is moving for Black */
7056         if (WhiteOnMove(currentMove)) {
7057             if (!appData.premove) {
7058                 DisplayMoveError(_("It is White's turn"));
7059             } else if (toX >= 0 && toY >= 0) {
7060                 premoveToX = toX;
7061                 premoveToY = toY;
7062                 premoveFromX = fromX;
7063                 premoveFromY = fromY;
7064                 premovePromoChar = promoChar;
7065                 gotPremove = 1;
7066                 if (appData.debugMode)
7067                     fprintf(debugFP, "Got premove: fromX %d,"
7068                             "fromY %d, toX %d, toY %d\n",
7069                             fromX, fromY, toX, toY);
7070             }
7071             DrawPosition(TRUE, boards[currentMove]); // [HGM] repair animation damage done by premove (in particular emptying from-square)
7072             return;
7073         }
7074         break;
7075
7076       case IcsPlayingWhite:
7077         /* User is moving for White */
7078         if (!WhiteOnMove(currentMove)) {
7079             if (!appData.premove) {
7080                 DisplayMoveError(_("It is Black's turn"));
7081             } else if (toX >= 0 && toY >= 0) {
7082                 premoveToX = toX;
7083                 premoveToY = toY;
7084                 premoveFromX = fromX;
7085                 premoveFromY = fromY;
7086                 premovePromoChar = promoChar;
7087                 gotPremove = 1;
7088                 if (appData.debugMode)
7089                     fprintf(debugFP, "Got premove: fromX %d,"
7090                             "fromY %d, toX %d, toY %d\n",
7091                             fromX, fromY, toX, toY);
7092             }
7093             DrawPosition(TRUE, boards[currentMove]);
7094             return;
7095         }
7096         break;
7097
7098       default:
7099         break;
7100
7101       case EditPosition:
7102         /* EditPosition, empty square, or different color piece;
7103            click-click move is possible */
7104         if (toX == -2 || toY == -2) {
7105             boards[0][fromY][fromX] = (boards[0][fromY][fromX] == EmptySquare ? DarkSquare : EmptySquare);
7106             DrawPosition(FALSE, boards[currentMove]);
7107             return;
7108         } else if (toX >= 0 && toY >= 0) {
7109             if(!appData.pieceMenu && toX == fromX && toY == fromY && boards[0][rf][ff] != EmptySquare) {
7110                 ChessSquare p = boards[0][rf][ff];
7111                 if(PieceToChar(p) == '+') gatingPiece = CHUDEMOTED(p); else
7112                 if(PieceToChar(CHUPROMOTED(p)) =='+') gatingPiece = CHUPROMOTED(p);
7113             }
7114             boards[0][toY][toX] = boards[0][fromY][fromX];
7115             if(fromX == BOARD_LEFT-2) { // handle 'moves' out of holdings
7116                 if(boards[0][fromY][0] != EmptySquare) {
7117                     if(boards[0][fromY][1]) boards[0][fromY][1]--;
7118                     if(boards[0][fromY][1] == 0)  boards[0][fromY][0] = EmptySquare;
7119                 }
7120             } else
7121             if(fromX == BOARD_RGHT+1) {
7122                 if(boards[0][fromY][BOARD_WIDTH-1] != EmptySquare) {
7123                     if(boards[0][fromY][BOARD_WIDTH-2]) boards[0][fromY][BOARD_WIDTH-2]--;
7124                     if(boards[0][fromY][BOARD_WIDTH-2] == 0)  boards[0][fromY][BOARD_WIDTH-1] = EmptySquare;
7125                 }
7126             } else
7127             boards[0][fromY][fromX] = gatingPiece;
7128             ClearHighlights();
7129             DrawPosition(FALSE, boards[currentMove]);
7130             return;
7131         }
7132         return;
7133     }
7134
7135     if((toX < 0 || toY < 0) && (fromY != DROP_RANK || fromX != EmptySquare)) return;
7136     pup = boards[currentMove][toY][toX];
7137
7138     /* [HGM] If move started in holdings, it means a drop. Convert to standard form */
7139     if( (fromX == BOARD_LEFT-2 || fromX == BOARD_RGHT+1) && fromY != DROP_RANK ) {
7140          if( pup != EmptySquare ) return;
7141          moveType = WhiteOnMove(currentMove) ? WhiteDrop : BlackDrop;
7142            if(appData.debugMode) fprintf(debugFP, "Drop move %d, curr=%d, x=%d,y=%d, p=%d\n",
7143                 moveType, currentMove, fromX, fromY, boards[currentMove][fromY][fromX]);
7144            // holdings might not be sent yet in ICS play; we have to figure out which piece belongs here
7145            if(fromX == 0) fromY = BOARD_HEIGHT-1 - fromY; // black holdings upside-down
7146            fromX = fromX ? WhitePawn : BlackPawn; // first piece type in selected holdings
7147            while(PieceToChar(fromX) == '.' || PieceToChar(fromX) == '+' || PieceToNumber(fromX) != fromY && fromX != (int) EmptySquare) fromX++;
7148          fromY = DROP_RANK;
7149     }
7150
7151     /* [HGM] always test for legality, to get promotion info */
7152     moveType = LegalityTest(boards[currentMove], PosFlags(currentMove),
7153                                          fromY, fromX, toY, toX, promoChar);
7154
7155     if(fromY == DROP_RANK && fromX == EmptySquare && (gameMode == AnalyzeMode || gameMode == EditGame || PosFlags(0) & F_NULL_MOVE)) moveType = NormalMove;
7156
7157     if(moveType == IllegalMove && legal[toY][toX] > 1) moveType = NormalMove; // someone explicitly told us this move is legal
7158
7159     /* [HGM] but possibly ignore an IllegalMove result */
7160     if (appData.testLegality) {
7161         if (moveType == IllegalMove || moveType == ImpossibleMove) {
7162             DisplayMoveError(_("Illegal move"));
7163             return;
7164         }
7165     }
7166
7167     if(doubleClick && gameMode == AnalyzeMode) { // [HGM] exclude: move entered with double-click on from square is for exclusion, not playing
7168         if(ExcludeOneMove(fromY, fromX, toY, toX, promoChar, '*')) // toggle
7169              ClearPremoveHighlights(); // was included
7170         else ClearHighlights(), SetPremoveHighlights(ff, rf, ft, rt); // exclusion indicated  by premove highlights
7171         return;
7172     }
7173
7174     if(addToBookFlag) { // adding moves to book
7175         char buf[MSG_SIZ], move[MSG_SIZ];
7176         CoordsToAlgebraic(boards[currentMove], PosFlags(currentMove), fromY, fromX, toY, toX, promoChar, move);
7177         if(killX >= 0) snprintf(move, MSG_SIZ, "%c%dx%c%d-%c%d%c", fromX + AAA, fromY + ONE - '0',
7178                                                                    killX + AAA, killY + ONE - '0', toX + AAA, toY + ONE - '0', promoChar);
7179         snprintf(buf, MSG_SIZ, "  0.0%%     1  %s\n", move);
7180         AddBookMove(buf);
7181         addToBookFlag = FALSE;
7182         ClearHighlights();
7183         return;
7184     }
7185
7186     FinishMove(moveType, fromX, fromY, toX, toY, promoChar);
7187 }
7188
7189 /* Common tail of UserMoveEvent and DropMenuEvent */
7190 int
7191 FinishMove (ChessMove moveType, int fromX, int fromY, int toX, int toY, int promoChar)
7192 {
7193     char *bookHit = 0;
7194
7195     if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat || gameInfo.variant == VariantGrand) && promoChar != NULLCHAR) {
7196         // [HGM] superchess: suppress promotions to non-available piece (but P always allowed)
7197         int k = PieceToNumber(CharToPiece(ToUpper(promoChar)));
7198         if(WhiteOnMove(currentMove)) {
7199             if(!boards[currentMove][k][BOARD_WIDTH-2]) return 0;
7200         } else {
7201             if(!boards[currentMove][BOARD_HEIGHT-1-k][1]) return 0;
7202         }
7203     }
7204
7205     /* [HGM] <popupFix> kludge to avoid having to know the exact promotion
7206        move type in caller when we know the move is a legal promotion */
7207     if(moveType == NormalMove && promoChar)
7208         moveType = WhiteOnMove(currentMove) ? WhitePromotion : BlackPromotion;
7209
7210     /* [HGM] <popupFix> The following if has been moved here from
7211        UserMoveEvent(). Because it seemed to belong here (why not allow
7212        piece drops in training games?), and because it can only be
7213        performed after it is known to what we promote. */
7214     if (gameMode == Training) {
7215       /* compare the move played on the board to the next move in the
7216        * game. If they match, display the move and the opponent's response.
7217        * If they don't match, display an error message.
7218        */
7219       int saveAnimate;
7220       Board testBoard;
7221       CopyBoard(testBoard, boards[currentMove]);
7222       ApplyMove(fromX, fromY, toX, toY, promoChar, testBoard);
7223
7224       if (CompareBoards(testBoard, boards[currentMove+1])) {
7225         ForwardInner(currentMove+1);
7226
7227         /* Autoplay the opponent's response.
7228          * if appData.animate was TRUE when Training mode was entered,
7229          * the response will be animated.
7230          */
7231         saveAnimate = appData.animate;
7232         appData.animate = animateTraining;
7233         ForwardInner(currentMove+1);
7234         appData.animate = saveAnimate;
7235
7236         /* check for the end of the game */
7237         if (currentMove >= forwardMostMove) {
7238           gameMode = PlayFromGameFile;
7239           ModeHighlight();
7240           SetTrainingModeOff();
7241           DisplayInformation(_("End of game"));
7242         }
7243       } else {
7244         DisplayError(_("Incorrect move"), 0);
7245       }
7246       return 1;
7247     }
7248
7249   /* Ok, now we know that the move is good, so we can kill
7250      the previous line in Analysis Mode */
7251   if ((gameMode == AnalyzeMode || gameMode == EditGame || gameMode == PlayFromGameFile && appData.variations && shiftKey)
7252                                 && currentMove < forwardMostMove) {
7253     if(appData.variations && shiftKey) PushTail(currentMove, forwardMostMove); // [HGM] vari: save tail of game
7254     else forwardMostMove = currentMove;
7255   }
7256
7257   ClearMap();
7258
7259   /* If we need the chess program but it's dead, restart it */
7260   ResurrectChessProgram();
7261
7262   /* A user move restarts a paused game*/
7263   if (pausing)
7264     PauseEvent();
7265
7266   thinkOutput[0] = NULLCHAR;
7267
7268   MakeMove(fromX, fromY, toX, toY, promoChar); /*updates forwardMostMove*/
7269
7270   if(Adjudicate(NULL)) { // [HGM] adjudicate: take care of automatic game end
7271     ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
7272     return 1;
7273   }
7274
7275   if (gameMode == BeginningOfGame) {
7276     if (appData.noChessProgram) {
7277       gameMode = EditGame;
7278       SetGameInfo();
7279     } else {
7280       char buf[MSG_SIZ];
7281       gameMode = MachinePlaysBlack;
7282       StartClocks();
7283       SetGameInfo();
7284       snprintf(buf, MSG_SIZ, "%s %s %s", gameInfo.white, _("vs."), gameInfo.black);
7285       DisplayTitle(buf);
7286       if (first.sendName) {
7287         snprintf(buf, MSG_SIZ,"name %s\n", gameInfo.white);
7288         SendToProgram(buf, &first);
7289       }
7290       StartClocks();
7291     }
7292     ModeHighlight();
7293   }
7294
7295   /* Relay move to ICS or chess engine */
7296   if (appData.icsActive) {
7297     if (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack ||
7298         gameMode == IcsExamining) {
7299       if(userOfferedDraw && (signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
7300         SendToICS(ics_prefix); // [HGM] drawclaim: send caim and move on one line for FICS
7301         SendToICS("draw ");
7302         SendMoveToICS(moveType, fromX, fromY, toX, toY, promoChar);
7303       }
7304       // also send plain move, in case ICS does not understand atomic claims
7305       SendMoveToICS(moveType, fromX, fromY, toX, toY, promoChar);
7306       ics_user_moved = 1;
7307     }
7308   } else {
7309     if (first.sendTime && (gameMode == BeginningOfGame ||
7310                            gameMode == MachinePlaysWhite ||
7311                            gameMode == MachinePlaysBlack)) {
7312       SendTimeRemaining(&first, gameMode != MachinePlaysBlack);
7313     }
7314     if (gameMode != EditGame && gameMode != PlayFromGameFile && gameMode != AnalyzeMode) {
7315          // [HGM] book: if program might be playing, let it use book
7316         bookHit = SendMoveToBookUser(forwardMostMove-1, &first, FALSE);
7317         first.maybeThinking = TRUE;
7318     } else if(fromY == DROP_RANK && fromX == EmptySquare) {
7319         if(!first.useSetboard) SendToProgram("undo\n", &first); // kludge to change stm in engines that do not support setboard
7320         SendBoard(&first, currentMove+1);
7321         if(second.analyzing) {
7322             if(!second.useSetboard) SendToProgram("undo\n", &second);
7323             SendBoard(&second, currentMove+1);
7324         }
7325     } else {
7326         SendMoveToProgram(forwardMostMove-1, &first);
7327         if(second.analyzing) SendMoveToProgram(forwardMostMove-1, &second);
7328     }
7329     if (currentMove == cmailOldMove + 1) {
7330       cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
7331     }
7332   }
7333
7334   ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
7335
7336   switch (gameMode) {
7337   case EditGame:
7338     if(appData.testLegality)
7339     switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
7340     case MT_NONE:
7341     case MT_CHECK:
7342       break;
7343     case MT_CHECKMATE:
7344     case MT_STAINMATE:
7345       if (WhiteOnMove(currentMove)) {
7346         GameEnds(BlackWins, "Black mates", GE_PLAYER);
7347       } else {
7348         GameEnds(WhiteWins, "White mates", GE_PLAYER);
7349       }
7350       break;
7351     case MT_STALEMATE:
7352       GameEnds(GameIsDrawn, "Stalemate", GE_PLAYER);
7353       break;
7354     }
7355     break;
7356
7357   case MachinePlaysBlack:
7358   case MachinePlaysWhite:
7359     /* disable certain menu options while machine is thinking */
7360     SetMachineThinkingEnables();
7361     break;
7362
7363   default:
7364     break;
7365   }
7366
7367   userOfferedDraw = FALSE; // [HGM] drawclaim: after move made, and tested for claimable draw
7368   promoDefaultAltered = FALSE; // [HGM] fall back on default choice
7369
7370   if(bookHit) { // [HGM] book: simulate book reply
7371         static char bookMove[MSG_SIZ]; // a bit generous?
7372
7373         programStats.nodes = programStats.depth = programStats.time =
7374         programStats.score = programStats.got_only_move = 0;
7375         sprintf(programStats.movelist, "%s (xbook)", bookHit);
7376
7377         safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
7378         strcat(bookMove, bookHit);
7379         HandleMachineMove(bookMove, &first);
7380   }
7381   return 1;
7382 }
7383
7384 void
7385 MarkByFEN(char *fen)
7386 {
7387         int r, f;
7388         if(!appData.markers || !appData.highlightDragging) return;
7389         for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) legal[r][f] = 0;
7390         r=BOARD_HEIGHT-1; f=BOARD_LEFT;
7391         while(*fen) {
7392             int s = 0;
7393             marker[r][f] = 0;
7394             if(*fen == 'M') legal[r][f] = 2; else // request promotion choice
7395             if(*fen >= 'A' && *fen <= 'Z') legal[r][f] = 3; else
7396             if(*fen >= 'a' && *fen <= 'z') *fen += 'A' - 'a';
7397             if(*fen == '/' && f > BOARD_LEFT) f = BOARD_LEFT, r--; else
7398             if(*fen == 'T') marker[r][f++] = 0; else
7399             if(*fen == 'Y') marker[r][f++] = 1; else
7400             if(*fen == 'G') marker[r][f++] = 3; else
7401             if(*fen == 'B') marker[r][f++] = 4; else
7402             if(*fen == 'C') marker[r][f++] = 5; else
7403             if(*fen == 'M') marker[r][f++] = 6; else
7404             if(*fen == 'W') marker[r][f++] = 7; else
7405             if(*fen == 'D') marker[r][f++] = 8; else
7406             if(*fen == 'R') marker[r][f++] = 2; else {
7407                 while(*fen <= '9' && *fen >= '0') s = 10*s + *fen++ - '0';
7408               f += s; fen -= s>0;
7409             }
7410             while(f >= BOARD_RGHT) f -= BOARD_RGHT - BOARD_LEFT, r--;
7411             if(r < 0) break;
7412             fen++;
7413         }
7414         DrawPosition(TRUE, NULL);
7415 }
7416
7417 static char baseMarker[BOARD_RANKS][BOARD_FILES], baseLegal[BOARD_RANKS][BOARD_FILES];
7418
7419 void
7420 Mark (Board board, int flags, ChessMove kind, int rf, int ff, int rt, int ft, VOIDSTAR closure)
7421 {
7422     typedef char Markers[BOARD_RANKS][BOARD_FILES];
7423     Markers *m = (Markers *) closure;
7424     if(rf == fromY && ff == fromX && (killX < 0 ? !(rt == rf && ft == ff) && legNr & 1 :
7425                                       kill2X < 0 ? rt == killY && ft == killX || legNr & 2 : rt == killY && ft == killX || legNr & 4))
7426         (*m)[rt][ft] = 1 + (board[rt][ft] != EmptySquare
7427                          || kind == WhiteCapturesEnPassant
7428                          || kind == BlackCapturesEnPassant) + 3*(kind == FirstLeg && (killX < 0 & legNr || legNr & 2 && kill2X < 0)), legal[rt][ft] = 3;
7429     else if(flags & F_MANDATORY_CAPTURE && board[rt][ft] != EmptySquare) (*m)[rt][ft] = 3, legal[rt][ft] = 3;
7430 }
7431
7432 static int hoverSavedValid;
7433
7434 void
7435 MarkTargetSquares (int clear)
7436 {
7437   int x, y, sum=0;
7438   if(clear) { // no reason to ever suppress clearing
7439     for(x=0; x<BOARD_WIDTH; x++) for(y=0; y<BOARD_HEIGHT; y++) sum += marker[y][x], marker[y][x] = 0;
7440     hoverSavedValid = 0;
7441     if(!sum || clear < 0) return; // nothing was cleared,no redraw needed
7442   } else {
7443     int capt = 0;
7444     if(!appData.markers || !appData.highlightDragging || appData.icsActive && gameInfo.variant < VariantShogi ||
7445        !appData.testLegality && !pieceDefs || gameMode == EditPosition) return;
7446     GenLegal(boards[currentMove], PosFlags(currentMove), Mark, (void*) marker, EmptySquare);
7447     if(PosFlags(0) & F_MANDATORY_CAPTURE) {
7448       for(x=0; x<BOARD_WIDTH; x++) for(y=0; y<BOARD_HEIGHT; y++) if(marker[y][x]>1) capt++;
7449       if(capt)
7450       for(x=0; x<BOARD_WIDTH; x++) for(y=0; y<BOARD_HEIGHT; y++) if(marker[y][x] == 1) marker[y][x] = 0;
7451     }
7452   }
7453   DrawPosition(FALSE, NULL);
7454 }
7455
7456 int
7457 Explode (Board board, int fromX, int fromY, int toX, int toY)
7458 {
7459     if(gameInfo.variant == VariantAtomic &&
7460        (board[toY][toX] != EmptySquare ||                     // capture?
7461         toX != fromX && (board[fromY][fromX] == WhitePawn ||  // e.p. ?
7462                          board[fromY][fromX] == BlackPawn   )
7463       )) {
7464         AnimateAtomicCapture(board, fromX, fromY, toX, toY);
7465         return TRUE;
7466     }
7467     return FALSE;
7468 }
7469
7470 ChessSquare gatingPiece = EmptySquare; // exported to front-end, for dragging
7471
7472 int
7473 CanPromote (ChessSquare piece, int y)
7474 {
7475         int zone = (gameInfo.variant == VariantChuChess ? 3 : 1);
7476         if(gameMode == EditPosition) return FALSE; // no promotions when editing position
7477         // some variants have fixed promotion piece, no promotion at all, or another selection mechanism
7478         if(IS_SHOGI(gameInfo.variant)          || gameInfo.variant == VariantXiangqi ||
7479            gameInfo.variant == VariantSuper    || gameInfo.variant == VariantGreat   ||
7480           (gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier ||
7481            gameInfo.variant == VariantMakruk) && !*engineVariant) return FALSE;
7482         return (piece == BlackPawn && y <= zone ||
7483                 piece == WhitePawn && y >= BOARD_HEIGHT-1-zone ||
7484                 piece == BlackLance && y <= zone ||
7485                 piece == WhiteLance && y >= BOARD_HEIGHT-1-zone );
7486 }
7487
7488 void
7489 HoverEvent (int xPix, int yPix, int x, int y)
7490 {
7491         static int oldX = -1, oldY = -1, oldFromX = -1, oldFromY = -1;
7492         int r, f;
7493         if(!first.highlight) return;
7494         if(fromX != oldFromX || fromY != oldFromY)  oldX = oldY = -1; // kludge to fake entry on from-click
7495         if(x == oldX && y == oldY) return; // only do something if we enter new square
7496         oldFromX = fromX; oldFromY = fromY;
7497         if(oldX == -1 && oldY == -1 && x == fromX && y == fromY) { // record markings after from-change
7498           for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++)
7499             baseMarker[r][f] = marker[r][f], baseLegal[r][f] = legal[r][f];
7500           hoverSavedValid = 1;
7501         } else if(oldX != x || oldY != y) {
7502           // [HGM] lift: entered new to-square; redraw arrow, and inform engine
7503           if(hoverSavedValid) // don't restore markers that are supposed to be cleared
7504           for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++)
7505             marker[r][f] = baseMarker[r][f], legal[r][f] = baseLegal[r][f];
7506           if((marker[y][x] == 2 || marker[y][x] == 6) && legal[y][x]) {
7507             char buf[MSG_SIZ];
7508             snprintf(buf, MSG_SIZ, "hover %c%d\n", x + AAA, y + ONE - '0');
7509             SendToProgram(buf, &first);
7510           }
7511           oldX = x; oldY = y;
7512 //        SetHighlights(fromX, fromY, x, y);
7513         }
7514 }
7515
7516 void ReportClick(char *action, int x, int y)
7517 {
7518         char buf[MSG_SIZ]; // Inform engine of what user does
7519         int r, f;
7520         if(action[0] == 'l') // mark any target square of a lifted piece as legal to-square, clear markers
7521           for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++)
7522             legal[r][f] = !pieceDefs || !appData.markers, marker[r][f] = 0;
7523         if(!first.highlight || gameMode == EditPosition) return;
7524         snprintf(buf, MSG_SIZ, "%s %c%d%s\n", action, x+AAA, y+ONE-'0', controlKey && action[0]=='p' ? "," : "");
7525         SendToProgram(buf, &first);
7526 }
7527
7528 Boolean right; // instructs front-end to use button-1 events as if they were button 3
7529
7530 void
7531 LeftClick (ClickType clickType, int xPix, int yPix)
7532 {
7533     int x, y;
7534     Boolean saveAnimate;
7535     static int second = 0, promotionChoice = 0, clearFlag = 0, sweepSelecting = 0, flashing = 0, saveFlash;
7536     char promoChoice = NULLCHAR;
7537     ChessSquare piece;
7538     static TimeMark lastClickTime, prevClickTime;
7539
7540     if(flashing) return;
7541
7542     x = EventToSquare(xPix, BOARD_WIDTH);
7543     y = EventToSquare(yPix, BOARD_HEIGHT);
7544     if (!flipView && y >= 0) {
7545         y = BOARD_HEIGHT - 1 - y;
7546     }
7547     if (flipView && x >= 0) {
7548         x = BOARD_WIDTH - 1 - x;
7549     }
7550
7551     if(appData.monoMouse && gameMode == EditPosition && fromX < 0 && clickType == Press && boards[currentMove][y][x] == EmptySquare) {
7552         static int dummy;
7553         RightClick(clickType, xPix, yPix, &dummy, &dummy);
7554         right = TRUE;
7555         return;
7556     }
7557
7558     if(SeekGraphClick(clickType, xPix, yPix, 0)) return;
7559
7560     prevClickTime = lastClickTime; GetTimeMark(&lastClickTime);
7561
7562     if (clickType == Press) ErrorPopDown();
7563     lastClickType = clickType, lastLeftX = xPix, lastLeftY = yPix; // [HGM] alien: remember state
7564
7565     if(promoSweep != EmptySquare) { // up-click during sweep-select of promo-piece
7566         defaultPromoChoice = promoSweep;
7567         promoSweep = EmptySquare;   // terminate sweep
7568         promoDefaultAltered = TRUE;
7569         if(!selectFlag && !sweepSelecting && (x != toX || y != toY)) x = fromX, y = fromY; // and fake up-click on same square if we were still selecting
7570     }
7571
7572     if(promotionChoice) { // we are waiting for a click to indicate promotion piece
7573         if(clickType == Release) return; // ignore upclick of click-click destination
7574         promotionChoice = FALSE; // only one chance: if click not OK it is interpreted as cancel
7575         if(appData.debugMode) fprintf(debugFP, "promotion click, x=%d, y=%d\n", x, y);
7576         if(gameInfo.holdingsWidth &&
7577                 (WhiteOnMove(currentMove)
7578                         ? x == BOARD_WIDTH-1 && y < gameInfo.holdingsSize && y >= 0
7579                         : x == 0 && y >= BOARD_HEIGHT - gameInfo.holdingsSize && y < BOARD_HEIGHT) ) {
7580             // click in right holdings, for determining promotion piece
7581             ChessSquare p = boards[currentMove][y][x];
7582             if(appData.debugMode) fprintf(debugFP, "square contains %d\n", (int)p);
7583             if(p == WhitePawn || p == BlackPawn) p = EmptySquare; // [HGM] Pawns could be valid as deferral
7584             if(p != EmptySquare || gameInfo.variant == VariantGrand && toY != 0 && toY != BOARD_HEIGHT-1) { // [HGM] grand: empty square means defer
7585                 FinishMove(NormalMove, fromX, fromY, toX, toY, p==EmptySquare ? NULLCHAR : ToLower(PieceToChar(p)));
7586                 fromX = fromY = -1;
7587                 return;
7588             }
7589         }
7590         DrawPosition(FALSE, boards[currentMove]);
7591         return;
7592     }
7593
7594     /* [HGM] holdings: next 5 lines: ignore all clicks between board and holdings */
7595     if(clickType == Press
7596             && ( x == BOARD_LEFT-1 || x == BOARD_RGHT
7597               || x == BOARD_LEFT-2 && y < BOARD_HEIGHT-gameInfo.holdingsSize
7598               || x == BOARD_RGHT+1 && y >= gameInfo.holdingsSize) )
7599         return;
7600
7601     if(gotPremove && x == premoveFromX && y == premoveFromY && clickType == Release) {
7602         // could be static click on premove from-square: abort premove
7603         gotPremove = 0;
7604         ClearPremoveHighlights();
7605     }
7606
7607     if(clickType == Press && fromX == x && fromY == y && promoDefaultAltered && SubtractTimeMarks(&lastClickTime, &prevClickTime) >= 200)
7608         fromX = fromY = -1; // second click on piece after altering default promo piece treated as first click
7609
7610     if(!promoDefaultAltered) { // determine default promotion piece, based on the side the user is moving for
7611         int side = (gameMode == IcsPlayingWhite || gameMode == MachinePlaysBlack ||
7612                     gameMode != MachinePlaysWhite && gameMode != IcsPlayingBlack && WhiteOnMove(currentMove));
7613         defaultPromoChoice = DefaultPromoChoice(side);
7614     }
7615
7616     autoQueen = appData.alwaysPromoteToQueen;
7617
7618     if (fromX == -1) {
7619       int originalY = y;
7620       gatingPiece = EmptySquare;
7621       if (clickType != Press) {
7622         if(dragging) { // [HGM] from-square must have been reset due to game end since last press
7623             DragPieceEnd(xPix, yPix); dragging = 0;
7624             DrawPosition(FALSE, NULL);
7625         }
7626         return;
7627       }
7628       doubleClick = FALSE;
7629       if(gameMode == AnalyzeMode && (pausing || controlKey) && first.excludeMoves) { // use pause state to exclude moves
7630         doubleClick = TRUE; gatingPiece = boards[currentMove][y][x];
7631       }
7632       fromX = x; fromY = y; toX = toY = killX = killY = kill2X = kill2Y = -1;
7633       if(!appData.oneClick || !OnlyMove(&x, &y, FALSE) ||
7634          // even if only move, we treat as normal when this would trigger a promotion popup, to allow sweep selection
7635          appData.sweepSelect && CanPromote(boards[currentMove][fromY][fromX], fromY) && originalY != y) {
7636             /* First square */
7637             if (OKToStartUserMove(fromX, fromY)) {
7638                 second = 0;
7639                 ReportClick("lift", x, y);
7640                 MarkTargetSquares(0);
7641                 if(gameMode == EditPosition && controlKey) gatingPiece = boards[currentMove][fromY][fromX];
7642                 DragPieceBegin(xPix, yPix, FALSE); dragging = 1;
7643                 if(appData.sweepSelect && CanPromote(piece = boards[currentMove][fromY][fromX], fromY)) {
7644                     promoSweep = defaultPromoChoice;
7645                     selectFlag = 0; lastX = xPix; lastY = yPix; *promoRestrict = 0;
7646                     Sweep(0); // Pawn that is going to promote: preview promotion piece
7647                     DisplayMessage("", _("Pull pawn backwards to under-promote"));
7648                 }
7649                 if (appData.highlightDragging) {
7650                     SetHighlights(fromX, fromY, -1, -1);
7651                 } else {
7652                     ClearHighlights();
7653                 }
7654             } else fromX = fromY = -1;
7655             return;
7656         }
7657     }
7658
7659     /* fromX != -1 */
7660     if (clickType == Press && gameMode != EditPosition) {
7661         ChessSquare fromP;
7662         ChessSquare toP;
7663         int frc;
7664
7665         // ignore off-board to clicks
7666         if(y < 0 || x < 0) return;
7667
7668         /* Check if clicking again on the same color piece */
7669         fromP = boards[currentMove][fromY][fromX];
7670         toP = boards[currentMove][y][x];
7671         frc = appData.fischerCastling || gameInfo.variant == VariantSChess;
7672         if( (killX < 0 || x != fromX || y != fromY) && // [HGM] lion: do not interpret igui as deselect!
7673             marker[y][x] == 0 && // if engine told we can move to here, do it even if own piece
7674            ((WhitePawn <= fromP && fromP <= WhiteKing &&
7675              WhitePawn <= toP && toP <= WhiteKing &&
7676              !(fromP == WhiteKing && toP == WhiteRook && frc) &&
7677              !(fromP == WhiteRook && toP == WhiteKing && frc)) ||
7678             (BlackPawn <= fromP && fromP <= BlackKing &&
7679              BlackPawn <= toP && toP <= BlackKing &&
7680              !(fromP == BlackRook && toP == BlackKing && frc) && // allow also RxK as FRC castling
7681              !(fromP == BlackKing && toP == BlackRook && frc)))) {
7682             /* Clicked again on same color piece -- changed his mind */
7683             second = (x == fromX && y == fromY);
7684             killX = killY = kill2X = kill2Y = -1;
7685             if(second && gameMode == AnalyzeMode && SubtractTimeMarks(&lastClickTime, &prevClickTime) < 200) {
7686                 second = FALSE; // first double-click rather than scond click
7687                 doubleClick = first.excludeMoves; // used by UserMoveEvent to recognize exclude moves
7688             }
7689             promoDefaultAltered = FALSE;
7690            if(!second) MarkTargetSquares(1);
7691            if(!(second && appData.oneClick && OnlyMove(&x, &y, TRUE))) {
7692             if (appData.highlightDragging) {
7693                 SetHighlights(x, y, -1, -1);
7694             } else {
7695                 ClearHighlights();
7696             }
7697             if (OKToStartUserMove(x, y)) {
7698                 if(gameInfo.variant == VariantSChess && // S-Chess: back-rank piece selected after holdings means gating
7699                   (fromX == BOARD_LEFT-2 || fromX == BOARD_RGHT+1) &&
7700                y == (toP < BlackPawn ? 0 : BOARD_HEIGHT-1))
7701                  gatingPiece = boards[currentMove][fromY][fromX];
7702                 else gatingPiece = doubleClick ? fromP : EmptySquare;
7703                 fromX = x;
7704                 fromY = y; dragging = 1;
7705                 if(!second) ReportClick("lift", x, y);
7706                 MarkTargetSquares(0);
7707                 DragPieceBegin(xPix, yPix, FALSE);
7708                 if(appData.sweepSelect && CanPromote(piece = boards[currentMove][y][x], y)) {
7709                     promoSweep = defaultPromoChoice;
7710                     selectFlag = 0; lastX = xPix; lastY = yPix; *promoRestrict = 0;
7711                     Sweep(0); // Pawn that is going to promote: preview promotion piece
7712                 }
7713             }
7714            }
7715            if(x == fromX && y == fromY) return; // if OnlyMove altered (x,y) we go on
7716            second = FALSE;
7717         }
7718         // ignore clicks on holdings
7719         if(x < BOARD_LEFT || x >= BOARD_RGHT) return;
7720     }
7721
7722     if(x == fromX && y == fromY && clickType == Press && gameMode == EditPosition && SubtractTimeMarks(&lastClickTime, &prevClickTime) < 200) {
7723         gatingPiece = boards[currentMove][fromY][fromX]; // prepare to copy rather than move
7724         DragPieceBegin(xPix, yPix, FALSE); dragging = 1;
7725         return;
7726     }
7727
7728     if (clickType == Release && x == fromX && y == fromY && killX < 0 && !sweepSelecting) {
7729         DragPieceEnd(xPix, yPix); dragging = 0;
7730         if(clearFlag) {
7731             // a deferred attempt to click-click move an empty square on top of a piece
7732             boards[currentMove][y][x] = EmptySquare;
7733             ClearHighlights();
7734             DrawPosition(FALSE, boards[currentMove]);
7735             fromX = fromY = -1; clearFlag = 0;
7736             return;
7737         }
7738         if (appData.animateDragging) {
7739             /* Undo animation damage if any */
7740             DrawPosition(FALSE, NULL);
7741         }
7742         if (second) {
7743             /* Second up/down in same square; just abort move */
7744             second = 0;
7745             fromX = fromY = -1;
7746             gatingPiece = EmptySquare;
7747             ClearHighlights();
7748             gotPremove = 0;
7749             ClearPremoveHighlights();
7750             MarkTargetSquares(-1);
7751             DrawPosition(FALSE, NULL); // make user highlights are drawn (and deferred marker clearing)
7752         } else {
7753             /* First upclick in same square; start click-click mode */
7754             SetHighlights(x, y, -1, -1);
7755         }
7756         return;
7757     }
7758
7759     clearFlag = 0;
7760
7761     if(gameMode != EditPosition && !appData.testLegality && !legal[y][x] &&
7762        fromX >= BOARD_LEFT && fromX < BOARD_RGHT && (x != killX || y != killY) && !sweepSelecting) {
7763         if(dragging) DragPieceEnd(xPix, yPix), dragging = 0;
7764         DisplayMessage(_("only marked squares are legal"),"");
7765         DrawPosition(TRUE, NULL);
7766         return; // ignore to-click
7767     }
7768
7769     /* we now have a different from- and (possibly off-board) to-square */
7770     /* Completed move */
7771     if(!sweepSelecting) {
7772         toX = x;
7773         toY = y;
7774     }
7775
7776     piece = boards[currentMove][fromY][fromX];
7777
7778     saveAnimate = appData.animate;
7779     if (clickType == Press) {
7780         if(gameInfo.variant == VariantChuChess && piece != WhitePawn && piece != BlackPawn) defaultPromoChoice = piece;
7781         if(gameMode == EditPosition && boards[currentMove][fromY][fromX] == EmptySquare) {
7782             // must be Edit Position mode with empty-square selected
7783             fromX = x; fromY = y; DragPieceBegin(xPix, yPix, FALSE); dragging = 1; // consider this a new attempt to drag
7784             if(x >= BOARD_LEFT && x < BOARD_RGHT) clearFlag = 1; // and defer click-click move of empty-square to up-click
7785             return;
7786         }
7787         if(dragging == 2) {  // [HGM] lion: just turn buttonless drag into normal drag, and let release to the job
7788             return;
7789         }
7790         if(x == killX && y == killY) {              // second click on this square, which was selected as first-leg target
7791             killX = kill2X; killY = kill2Y; kill2X = kill2Y = -1;   // this informs us no second leg is coming, so treat as to-click without intermediate
7792         } else
7793         if(marker[y][x] == 5) return; // [HGM] lion: to-click on cyan square; defer action to release
7794         if(legal[y][x] == 2 || HasPromotionChoice(fromX, fromY, toX, toY, &promoChoice, FALSE)) {
7795           if(appData.sweepSelect) {
7796             promoSweep = defaultPromoChoice;
7797             if(gameInfo.variant != VariantChuChess && PieceToChar(CHUPROMOTED(piece)) == '+') promoSweep = CHUPROMOTED(piece);
7798             selectFlag = 0; lastX = xPix; lastY = yPix;
7799             ReportClick("put", x, y); // extra put to prompt engine for 'choice' command
7800             saveFlash = appData.flashCount; appData.flashCount = 0;
7801             Sweep(0); // Pawn that is going to promote: preview promotion piece
7802             sweepSelecting = 1;
7803             DisplayMessage("", _("Pull pawn backwards to under-promote"));
7804             MarkTargetSquares(1);
7805           }
7806           return; // promo popup appears on up-click
7807         }
7808         /* Finish clickclick move */
7809         if (appData.animate || appData.highlightLastMove) {
7810             SetHighlights(fromX, fromY, toX, toY);
7811         } else {
7812             ClearHighlights();
7813         }
7814         MarkTargetSquares(1);
7815     } else if(sweepSelecting) { // this must be the up-click corresponding to the down-click that started the sweep
7816         sweepSelecting = 0; appData.animate = FALSE; // do not animate, a selected piece already on to-square
7817         *promoRestrict = 0; appData.flashCount = saveFlash;
7818         if (appData.animate || appData.highlightLastMove) {
7819             SetHighlights(fromX, fromY, toX, toY);
7820         } else {
7821             ClearHighlights();
7822         }
7823         MarkTargetSquares(1);
7824     } else {
7825 #if 0
7826 // [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
7827         /* Finish drag move */
7828         if (appData.highlightLastMove) {
7829             SetHighlights(fromX, fromY, toX, toY);
7830         } else {
7831             ClearHighlights();
7832         }
7833 #endif
7834         if(PieceToChar(CHUPROMOTED(boards[currentMove][fromY][fromX])) == '+')
7835           defaultPromoChoice = CHUPROMOTED(boards[currentMove][fromY][fromX]);
7836         if(gameInfo.variant == VariantChuChess && piece != WhitePawn && piece != BlackPawn) defaultPromoChoice = piece;
7837         if(marker[y][x] == 5) { // [HGM] lion: this was the release of a to-click or drag on a cyan square
7838           dragging *= 2;            // flag button-less dragging if we are dragging
7839           MarkTargetSquares(1);
7840           if(x == killX && y == killY) killX = kill2X, killY = kill2Y, kill2X = kill2Y = -1; // cancel last kill
7841           else {
7842             kill2X = killX; kill2Y = killY;
7843             killX = x; killY = y;     // remember this square as intermediate
7844             ReportClick("put", x, y); // and inform engine
7845             ReportClick("lift", x, y);
7846             MarkTargetSquares(0);
7847             return;
7848           }
7849         }
7850         DragPieceEnd(xPix, yPix); dragging = 0;
7851         /* Don't animate move and drag both */
7852         appData.animate = FALSE;
7853         MarkTargetSquares(-1); // -1 defers displaying marker change to prevent piece reappearing on from-square!
7854     }
7855
7856     // moves into holding are invalid for now (except in EditPosition, adapting to-square)
7857     if(x >= 0 && x < BOARD_LEFT || x >= BOARD_RGHT) {
7858         ChessSquare piece = boards[currentMove][fromY][fromX];
7859         if(gameMode == EditPosition && piece != EmptySquare &&
7860            fromX >= BOARD_LEFT && fromX < BOARD_RGHT) {
7861             int n;
7862
7863             if(x == BOARD_LEFT-2 && piece >= BlackPawn) {
7864                 n = PieceToNumber(piece - (int)BlackPawn);
7865                 if(n >= gameInfo.holdingsSize) { n = 0; piece = BlackPawn; }
7866                 boards[currentMove][BOARD_HEIGHT-1 - n][0] = piece;
7867                 boards[currentMove][BOARD_HEIGHT-1 - n][1]++;
7868             } else
7869             if(x == BOARD_RGHT+1 && piece < BlackPawn) {
7870                 n = PieceToNumber(piece);
7871                 if(n >= gameInfo.holdingsSize) { n = 0; piece = WhitePawn; }
7872                 boards[currentMove][n][BOARD_WIDTH-1] = piece;
7873                 boards[currentMove][n][BOARD_WIDTH-2]++;
7874             }
7875             boards[currentMove][fromY][fromX] = EmptySquare;
7876         }
7877         ClearHighlights();
7878         fromX = fromY = -1;
7879         MarkTargetSquares(1);
7880         DrawPosition(TRUE, boards[currentMove]);
7881         return;
7882     }
7883
7884     // off-board moves should not be highlighted
7885     if(x < 0 || y < 0) ClearHighlights();
7886     else ReportClick("put", x, y);
7887
7888     if(gatingPiece != EmptySquare && gameInfo.variant == VariantSChess) promoChoice = ToLower(PieceToChar(gatingPiece));
7889
7890     if(legal[toY][toX] == 2) promoChoice = ToLower(PieceToChar(defaultPromoChoice)); // highlight-induced promotion
7891
7892     if (legal[toY][toX] == 2 && !appData.sweepSelect || HasPromotionChoice(fromX, fromY, toX, toY, &promoChoice, appData.sweepSelect)) {
7893         SetHighlights(fromX, fromY, toX, toY);
7894         MarkTargetSquares(1);
7895         if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat || gameInfo.variant == VariantGrand) {
7896             // [HGM] super: promotion to captured piece selected from holdings
7897             ChessSquare p = boards[currentMove][fromY][fromX], q = boards[currentMove][toY][toX];
7898             promotionChoice = TRUE;
7899             // kludge follows to temporarily execute move on display, without promoting yet
7900             boards[currentMove][fromY][fromX] = EmptySquare; // move Pawn to 8th rank
7901             boards[currentMove][toY][toX] = p;
7902             DrawPosition(FALSE, boards[currentMove]);
7903             boards[currentMove][fromY][fromX] = p; // take back, but display stays
7904             boards[currentMove][toY][toX] = q;
7905             DisplayMessage("Click in holdings to choose piece", "");
7906             return;
7907         }
7908         PromotionPopUp(promoChoice);
7909     } else {
7910         int oldMove = currentMove;
7911         flashing = 1; // prevent recursive calling (by release of to-click) while flashing piece
7912         UserMoveEvent(fromX, fromY, toX, toY, promoChoice);
7913         if (!appData.highlightLastMove || gotPremove) ClearHighlights();
7914         if (gotPremove) SetPremoveHighlights(fromX, fromY, toX, toY);
7915         if(saveAnimate && !appData.animate && currentMove != oldMove && // drag-move was performed
7916            Explode(boards[currentMove-1], fromX, fromY, toX, toY))
7917             DrawPosition(TRUE, boards[currentMove]);
7918         fromX = fromY = -1;
7919         flashing = 0;
7920     }
7921     appData.animate = saveAnimate;
7922     if (appData.animate || appData.animateDragging) {
7923         /* Undo animation damage if needed */
7924 //      DrawPosition(FALSE, NULL);
7925     }
7926 }
7927
7928 int
7929 RightClick (ClickType action, int x, int y, int *fromX, int *fromY)
7930 {   // front-end-free part taken out of PieceMenuPopup
7931     int whichMenu; int xSqr, ySqr;
7932
7933     if(seekGraphUp) { // [HGM] seekgraph
7934         if(action == Press)   SeekGraphClick(Press, x, y, 2); // 2 indicates right-click: no pop-down on miss
7935         if(action == Release) SeekGraphClick(Release, x, y, 2); // and no challenge on hit
7936         return -2;
7937     }
7938
7939     if((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack)
7940          && !appData.zippyPlay && appData.bgObserve) { // [HGM] bughouse: show background game
7941         if(!partnerBoardValid) return -2; // suppress display of uninitialized boards
7942         if( appData.dualBoard) return -2; // [HGM] dual: is already displayed
7943         if(action == Press)   {
7944             originalFlip = flipView;
7945             flipView = !flipView; // temporarily flip board to see game from partners perspective
7946             DrawPosition(TRUE, partnerBoard);
7947             DisplayMessage(partnerStatus, "");
7948             partnerUp = TRUE;
7949         } else if(action == Release) {
7950             flipView = originalFlip;
7951             DrawPosition(TRUE, boards[currentMove]);
7952             partnerUp = FALSE;
7953         }
7954         return -2;
7955     }
7956
7957     xSqr = EventToSquare(x, BOARD_WIDTH);
7958     ySqr = EventToSquare(y, BOARD_HEIGHT);
7959     if (action == Release) {
7960         if(pieceSweep != EmptySquare) {
7961             EditPositionMenuEvent(pieceSweep, toX, toY);
7962             pieceSweep = EmptySquare;
7963         } else UnLoadPV(); // [HGM] pv
7964     }
7965     if (action != Press) return -2; // return code to be ignored
7966     switch (gameMode) {
7967       case IcsExamining:
7968         if(xSqr < BOARD_LEFT || xSqr >= BOARD_RGHT) return -1;
7969       case EditPosition:
7970         if (xSqr == BOARD_LEFT-1 || xSqr == BOARD_RGHT) return -1;
7971         if (xSqr < 0 || ySqr < 0) return -1;
7972         if(appData.pieceMenu) { whichMenu = 0; break; } // edit-position menu
7973         pieceSweep = shiftKey ? BlackPawn : WhitePawn;  // [HGM] sweep: prepare selecting piece by mouse sweep
7974         toX = xSqr; toY = ySqr; lastX = x, lastY = y;
7975         if(flipView) toX = BOARD_WIDTH - 1 - toX; else toY = BOARD_HEIGHT - 1 - toY;
7976         NextPiece(0);
7977         return 2; // grab
7978       case IcsObserving:
7979         if(!appData.icsEngineAnalyze) return -1;
7980       case IcsPlayingWhite:
7981       case IcsPlayingBlack:
7982         if(!appData.zippyPlay) goto noZip;
7983       case AnalyzeMode:
7984       case AnalyzeFile:
7985       case MachinePlaysWhite:
7986       case MachinePlaysBlack:
7987       case TwoMachinesPlay: // [HGM] pv: use for showing PV
7988         if (!appData.dropMenu) {
7989           LoadPV(x, y);
7990           return 2; // flag front-end to grab mouse events
7991         }
7992         if(gameMode == TwoMachinesPlay || gameMode == AnalyzeMode ||
7993            gameMode == AnalyzeFile || gameMode == IcsObserving) return -1;
7994       case EditGame:
7995       noZip:
7996         if (xSqr < 0 || ySqr < 0) return -1;
7997         if (!appData.dropMenu || appData.testLegality &&
7998             gameInfo.variant != VariantBughouse &&
7999             gameInfo.variant != VariantCrazyhouse) return -1;
8000         whichMenu = 1; // drop menu
8001         break;
8002       default:
8003         return -1;
8004     }
8005
8006     if (((*fromX = xSqr) < 0) ||
8007         ((*fromY = ySqr) < 0)) {
8008         *fromX = *fromY = -1;
8009         return -1;
8010     }
8011     if (flipView)
8012       *fromX = BOARD_WIDTH - 1 - *fromX;
8013     else
8014       *fromY = BOARD_HEIGHT - 1 - *fromY;
8015
8016     return whichMenu;
8017 }
8018
8019 void
8020 Wheel (int dir, int x, int y)
8021 {
8022     if(gameMode == EditPosition) {
8023         int xSqr = EventToSquare(x, BOARD_WIDTH);
8024         int ySqr = EventToSquare(y, BOARD_HEIGHT);
8025         if(ySqr < 0 || xSqr < BOARD_LEFT || xSqr >= BOARD_RGHT) return;
8026         if(flipView) xSqr = BOARD_WIDTH - 1 - xSqr; else ySqr = BOARD_HEIGHT - 1 - ySqr;
8027         do {
8028             boards[currentMove][ySqr][xSqr] += dir;
8029             if((int) boards[currentMove][ySqr][xSqr] < WhitePawn) boards[currentMove][ySqr][xSqr] = BlackKing;
8030             if((int) boards[currentMove][ySqr][xSqr] > BlackKing) boards[currentMove][ySqr][xSqr] = WhitePawn;
8031         } while(PieceToChar(boards[currentMove][ySqr][xSqr]) == '.');
8032         DrawPosition(FALSE, boards[currentMove]);
8033     } else if(dir > 0) ForwardEvent(); else BackwardEvent();
8034 }
8035
8036 void
8037 SendProgramStatsToFrontend (ChessProgramState * cps, ChessProgramStats * cpstats)
8038 {
8039 //    char * hint = lastHint;
8040     FrontEndProgramStats stats;
8041
8042     stats.which = cps == &first ? 0 : 1;
8043     stats.depth = cpstats->depth;
8044     stats.nodes = cpstats->nodes;
8045     stats.score = cpstats->score;
8046     stats.time = cpstats->time;
8047     stats.pv = cpstats->movelist;
8048     stats.hint = lastHint;
8049     stats.an_move_index = 0;
8050     stats.an_move_count = 0;
8051
8052     if( gameMode == AnalyzeMode || gameMode == AnalyzeFile ) {
8053         stats.hint = cpstats->move_name;
8054         stats.an_move_index = cpstats->nr_moves - cpstats->moves_left;
8055         stats.an_move_count = cpstats->nr_moves;
8056     }
8057
8058     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
8059
8060     if( gameMode == AnalyzeMode && stats.pv && stats.pv[0]
8061         && appData.analysisBell && stats.time >= 100*appData.analysisBell ) RingBell();
8062
8063     SetProgramStats( &stats );
8064 }
8065
8066 void
8067 ClearEngineOutputPane (int which)
8068 {
8069     static FrontEndProgramStats dummyStats;
8070     dummyStats.which = which;
8071     dummyStats.pv = "#";
8072     SetProgramStats( &dummyStats );
8073 }
8074
8075 #define MAXPLAYERS 500
8076
8077 char *
8078 TourneyStandings (int display)
8079 {
8080     int i, w, b, color, wScore, bScore, dummy, nr=0, nPlayers=0;
8081     int score[MAXPLAYERS], ranking[MAXPLAYERS], points[MAXPLAYERS], games[MAXPLAYERS];
8082     char result, *p, *names[MAXPLAYERS];
8083
8084     if(appData.tourneyType < 0 && !strchr(appData.results, '*'))
8085         return strdup(_("Swiss tourney finished")); // standings of Swiss yet TODO
8086     names[0] = p = strdup(appData.participants);
8087     while(p = strchr(p, '\n')) *p++ = NULLCHAR, names[++nPlayers] = p; // count participants
8088
8089     for(i=0; i<nPlayers; i++) score[i] = games[i] = 0;
8090
8091     while(result = appData.results[nr]) {
8092         color = Pairing(nr, nPlayers, &w, &b, &dummy);
8093         if(!(color ^ matchGame & 1)) { dummy = w; w = b; b = dummy; }
8094         wScore = bScore = 0;
8095         switch(result) {
8096           case '+': wScore = 2; break;
8097           case '-': bScore = 2; break;
8098           case '=': wScore = bScore = 1; break;
8099           case ' ':
8100           case '*': return strdup("busy"); // tourney not finished
8101         }
8102         score[w] += wScore;
8103         score[b] += bScore;
8104         games[w]++;
8105         games[b]++;
8106         nr++;
8107     }
8108     if(appData.tourneyType > 0) nPlayers = appData.tourneyType; // in gauntlet, list only gauntlet engine(s)
8109     for(w=0; w<nPlayers; w++) {
8110         bScore = -1;
8111         for(i=0; i<nPlayers; i++) if(score[i] > bScore) bScore = score[i], b = i;
8112         ranking[w] = b; points[w] = bScore; score[b] = -2;
8113     }
8114     p = malloc(nPlayers*34+1);
8115     for(w=0; w<nPlayers && w<display; w++)
8116         sprintf(p+34*w, "%2d. %5.1f/%-3d %-19.19s\n", w+1, points[w]/2., games[ranking[w]], names[ranking[w]]);
8117     free(names[0]);
8118     return p;
8119 }
8120
8121 void
8122 Count (Board board, int pCnt[], int *nW, int *nB, int *wStale, int *bStale, int *bishopColor)
8123 {       // count all piece types
8124         int p, f, r;
8125         *nB = *nW = *wStale = *bStale = *bishopColor = 0;
8126         for(p=WhitePawn; p<=EmptySquare; p++) pCnt[p] = 0;
8127         for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
8128                 p = board[r][f];
8129                 pCnt[p]++;
8130                 if(p == WhitePawn && r == BOARD_HEIGHT-1) (*wStale)++; else
8131                 if(p == BlackPawn && r == 0) (*bStale)++; // count last-Rank Pawns (XQ) separately
8132                 if(p <= WhiteKing) (*nW)++; else if(p <= BlackKing) (*nB)++;
8133                 if(p == WhiteBishop || p == WhiteFerz || p == WhiteAlfil ||
8134                    p == BlackBishop || p == BlackFerz || p == BlackAlfil   )
8135                         *bishopColor |= 1 << ((f^r)&1); // track square color of color-bound pieces
8136         }
8137 }
8138
8139 int
8140 SufficientDefence (int pCnt[], int side, int nMine, int nHis)
8141 {
8142         int myPawns = pCnt[WhitePawn+side]; // my total Pawn count;
8143         int majorDefense = pCnt[BlackRook-side] + pCnt[BlackCannon-side] + pCnt[BlackKnight-side];
8144
8145         nMine -= pCnt[WhiteFerz+side] + pCnt[WhiteAlfil+side]; // discount defenders
8146         if(nMine - myPawns > 2) return FALSE; // no trivial draws with more than 1 major
8147         if(myPawns == 2 && nMine == 3) // KPP
8148             return majorDefense || pCnt[BlackFerz-side] + pCnt[BlackAlfil-side] >= 3;
8149         if(myPawns == 1 && nMine == 2) // KP
8150             return majorDefense || pCnt[BlackFerz-side] + pCnt[BlackAlfil-side]  + pCnt[BlackPawn-side] >= 1;
8151         if(myPawns == 1 && nMine == 3 && pCnt[WhiteKnight+side]) // KHP
8152             return majorDefense || pCnt[BlackFerz-side] + pCnt[BlackAlfil-side]*2 >= 5;
8153         if(myPawns) return FALSE;
8154         if(pCnt[WhiteRook+side])
8155             return pCnt[BlackRook-side] ||
8156                    pCnt[BlackCannon-side] && (pCnt[BlackFerz-side] >= 2 || pCnt[BlackAlfil-side] >= 2) ||
8157                    pCnt[BlackKnight-side] && pCnt[BlackFerz-side] + pCnt[BlackAlfil-side] > 2 ||
8158                    pCnt[BlackFerz-side] + pCnt[BlackAlfil-side] >= 4;
8159         if(pCnt[WhiteCannon+side]) {
8160             if(pCnt[WhiteFerz+side] + myPawns == 0) return TRUE; // Cannon needs platform
8161             return majorDefense || pCnt[BlackAlfil-side] >= 2;
8162         }
8163         if(pCnt[WhiteKnight+side])
8164             return majorDefense || pCnt[BlackFerz-side] >= 2 || pCnt[BlackAlfil-side] + pCnt[BlackPawn-side] >= 1;
8165         return FALSE;
8166 }
8167
8168 int
8169 MatingPotential (int pCnt[], int side, int nMine, int nHis, int stale, int bisColor)
8170 {
8171         VariantClass v = gameInfo.variant;
8172
8173         if(v == VariantShogi || v == VariantCrazyhouse || v == VariantBughouse) return TRUE; // drop games always winnable
8174         if(v == VariantShatranj) return TRUE; // always winnable through baring
8175         if(v == VariantLosers || v == VariantSuicide || v == VariantGiveaway) return TRUE;
8176         if(v == Variant3Check || v == VariantAtomic) return nMine > 1; // can win through checking / exploding King
8177
8178         if(v == VariantXiangqi) {
8179                 int majors = 5*pCnt[BlackKnight-side] + 7*pCnt[BlackCannon-side] + 7*pCnt[BlackRook-side];
8180
8181                 nMine -= pCnt[WhiteFerz+side] + pCnt[WhiteAlfil+side] + stale; // discount defensive pieces and back-rank Pawns
8182                 if(nMine + stale == 1) return (pCnt[BlackFerz-side] > 1 && pCnt[BlackKnight-side] > 0); // bare K can stalemate KHAA (!)
8183                 if(nMine > 2) return TRUE; // if we don't have P, H or R, we must have CC
8184                 if(nMine == 2 && pCnt[WhiteCannon+side] == 0) return TRUE; // We have at least one P, H or R
8185                 // if we get here, we must have KC... or KP..., possibly with additional A, E or last-rank P
8186                 if(stale) // we have at least one last-rank P plus perhaps C
8187                     return majors // KPKX
8188                         || pCnt[BlackFerz-side] && pCnt[BlackFerz-side] + pCnt[WhiteCannon+side] + stale > 2; // KPKAA, KPPKA and KCPKA
8189                 else // KCA*E*
8190                     return pCnt[WhiteFerz+side] // KCAK
8191                         || pCnt[WhiteAlfil+side] && pCnt[BlackRook-side] + pCnt[BlackCannon-side] + pCnt[BlackFerz-side] // KCEKA, KCEKX (X!=H)
8192                         || majors + (12*pCnt[BlackFerz-side] | 6*pCnt[BlackAlfil-side]) > 16; // KCKAA, KCKAX, KCKEEX, KCKEXX (XX!=HH), KCKXXX
8193                 // TO DO: cases wih an unpromoted f-Pawn acting as platform for an opponent Cannon
8194
8195         } else if(v == VariantKnightmate) {
8196                 if(nMine == 1) return FALSE;
8197                 if(nMine == 2 && nHis == 1 && pCnt[WhiteBishop+side] + pCnt[WhiteFerz+side] + pCnt[WhiteKnight+side]) return FALSE; // KBK is only draw
8198         } else if(pCnt[WhiteKing] == 1 && pCnt[BlackKing] == 1) { // other variants with orthodox Kings
8199                 int nBishops = pCnt[WhiteBishop+side] + pCnt[WhiteFerz+side];
8200
8201                 if(nMine == 1) return FALSE; // bare King
8202                 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
8203                 nMine += (nBishops > 0) - nBishops; // By now all Bishops (and Ferz) on like-colored squares, so count as one
8204                 if(nMine > 2 && nMine != pCnt[WhiteAlfil+side] + 1) return TRUE; // At least two pieces, not all Alfils
8205                 // by now we have King + 1 piece (or multiple Bishops on the same color)
8206                 if(pCnt[WhiteKnight+side])
8207                         return (pCnt[BlackKnight-side] + pCnt[BlackBishop-side] + pCnt[BlackMan-side] +
8208                                 pCnt[BlackWazir-side] + pCnt[BlackSilver-side] + bisColor // KNKN, KNKB, KNKF, KNKE, KNKW, KNKM, KNKS
8209                              || nHis > 3); // be sure to cover suffocation mates in corner (e.g. KNKQCA)
8210                 if(nBishops)
8211                         return (pCnt[BlackKnight-side]); // KBKN, KFKN
8212                 if(pCnt[WhiteAlfil+side])
8213                         return (nHis > 2); // Alfils can in general not reach a corner square, but there might be edge (suffocation) mates
8214                 if(pCnt[WhiteWazir+side])
8215                         return (pCnt[BlackKnight-side] + pCnt[BlackWazir-side] + pCnt[BlackAlfil-side]); // KWKN, KWKW, KWKE
8216         }
8217
8218         return TRUE;
8219 }
8220
8221 int
8222 CompareWithRights (Board b1, Board b2)
8223 {
8224     int rights = 0;
8225     if(!CompareBoards(b1, b2)) return FALSE;
8226     if(b1[EP_STATUS] != b2[EP_STATUS]) return FALSE;
8227     /* compare castling rights */
8228     if( b1[CASTLING][2] != b2[CASTLING][2] && (b2[CASTLING][0] != NoRights || b2[CASTLING][1] != NoRights) )
8229            rights++; /* King lost rights, while rook still had them */
8230     if( b1[CASTLING][2] != NoRights ) { /* king has rights */
8231         if( b1[CASTLING][0] != b2[CASTLING][0] || b1[CASTLING][1] != b2[CASTLING][1] )
8232            rights++; /* but at least one rook lost them */
8233     }
8234     if( b1[CASTLING][5] != b1[CASTLING][5] && (b2[CASTLING][3] != NoRights || b2[CASTLING][4] != NoRights) )
8235            rights++;
8236     if( b1[CASTLING][5] != NoRights ) {
8237         if( b1[CASTLING][3] != b2[CASTLING][3] || b1[CASTLING][4] != b2[CASTLING][4] )
8238            rights++;
8239     }
8240     return rights == 0;
8241 }
8242
8243 int
8244 Adjudicate (ChessProgramState *cps)
8245 {       // [HGM] some adjudications useful with buggy engines
8246         // [HGM] adjudicate: made into separate routine, which now can be called after every move
8247         //       In any case it determnes if the game is a claimable draw (filling in EP_STATUS).
8248         //       Actually ending the game is now based on the additional internal condition canAdjudicate.
8249         //       Only when the game is ended, and the opponent is a computer, this opponent gets the move relayed.
8250         int k, drop, count = 0; static int bare = 1;
8251         ChessProgramState *engineOpponent = (gameMode == TwoMachinesPlay ? cps->other : (cps ? NULL : &first));
8252         Boolean canAdjudicate = !appData.icsActive;
8253
8254         // most tests only when we understand the game, i.e. legality-checking on
8255             if( appData.testLegality )
8256             {   /* [HGM] Some more adjudications for obstinate engines */
8257                 int nrW, nrB, bishopColor, staleW, staleB, nr[EmptySquare+2], i;
8258                 static int moveCount = 6;
8259                 ChessMove result;
8260                 char *reason = NULL;
8261
8262                 /* Count what is on board. */
8263                 Count(boards[forwardMostMove], nr, &nrW, &nrB, &staleW, &staleB, &bishopColor);
8264
8265                 /* Some material-based adjudications that have to be made before stalemate test */
8266                 if(gameInfo.variant == VariantAtomic && nr[WhiteKing] + nr[BlackKing] < 2) {
8267                     // [HGM] atomic: stm must have lost his King on previous move, as destroying own K is illegal
8268                      boards[forwardMostMove][EP_STATUS] = EP_CHECKMATE; // make claimable as if stm is checkmated
8269                      if(canAdjudicate && appData.checkMates) {
8270                          if(engineOpponent)
8271                            SendMoveToProgram(forwardMostMove-1, engineOpponent); // make sure opponent gets move
8272                          GameEnds( WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins,
8273                                                         "Xboard adjudication: King destroyed", GE_XBOARD );
8274                          return 1;
8275                      }
8276                 }
8277
8278                 /* Bare King in Shatranj (loses) or Losers (wins) */
8279                 if( nrW == 1 || nrB == 1) {
8280                   if( gameInfo.variant == VariantLosers) { // [HGM] losers: bare King wins (stm must have it first)
8281                      boards[forwardMostMove][EP_STATUS] = EP_WINS;  // mark as win, so it becomes claimable
8282                      if(canAdjudicate && appData.checkMates) {
8283                          if(engineOpponent)
8284                            SendMoveToProgram(forwardMostMove-1, engineOpponent); // make sure opponent gets to see move
8285                          GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
8286                                                         "Xboard adjudication: Bare king", GE_XBOARD );
8287                          return 1;
8288                      }
8289                   } else
8290                   if( gameInfo.variant == VariantShatranj && --bare < 0)
8291                   {    /* bare King */
8292                         boards[forwardMostMove][EP_STATUS] = EP_WINS; // make claimable as win for stm
8293                         if(canAdjudicate && appData.checkMates) {
8294                             /* but only adjudicate if adjudication enabled */
8295                             if(engineOpponent)
8296                               SendMoveToProgram(forwardMostMove-1, engineOpponent); // make sure opponent gets move
8297                             GameEnds( nrW > 1 ? WhiteWins : nrB > 1 ? BlackWins : GameIsDrawn,
8298                                                         "Xboard adjudication: Bare king", GE_XBOARD );
8299                             return 1;
8300                         }
8301                   }
8302                 } else bare = 1;
8303
8304
8305             // don't wait for engine to announce game end if we can judge ourselves
8306             switch (MateTest(boards[forwardMostMove], PosFlags(forwardMostMove)) ) {
8307               case MT_CHECK:
8308                 if(gameInfo.variant == Variant3Check) { // [HGM] 3check: when in check, test if 3rd time
8309                     int i, checkCnt = 0;    // (should really be done by making nr of checks part of game state)
8310                     for(i=forwardMostMove-2; i>=backwardMostMove; i-=2) {
8311                         if(MateTest(boards[i], PosFlags(i)) == MT_CHECK)
8312                             checkCnt++;
8313                         if(checkCnt >= 2) {
8314                             reason = "Xboard adjudication: 3rd check";
8315                             boards[forwardMostMove][EP_STATUS] = EP_CHECKMATE;
8316                             break;
8317                         }
8318                     }
8319                 }
8320               case MT_NONE:
8321               default:
8322                 break;
8323               case MT_STEALMATE:
8324               case MT_STALEMATE:
8325               case MT_STAINMATE:
8326                 reason = "Xboard adjudication: Stalemate";
8327                 if((signed char)boards[forwardMostMove][EP_STATUS] != EP_CHECKMATE) { // [HGM] don't touch win through baring or K-capt
8328                     boards[forwardMostMove][EP_STATUS] = EP_STALEMATE;   // default result for stalemate is draw
8329                     if(gameInfo.variant == VariantLosers  || gameInfo.variant == VariantGiveaway) // [HGM] losers:
8330                         boards[forwardMostMove][EP_STATUS] = EP_WINS;    // in these variants stalemated is always a win
8331                     else if(gameInfo.variant == VariantSuicide) // in suicide it depends
8332                         boards[forwardMostMove][EP_STATUS] = nrW == nrB ? EP_STALEMATE :
8333                                                    ((nrW < nrB) != WhiteOnMove(forwardMostMove) ?
8334                                                                         EP_CHECKMATE : EP_WINS);
8335                     else if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantXiangqi || gameInfo.variant == VariantShogi)
8336                         boards[forwardMostMove][EP_STATUS] = EP_CHECKMATE; // and in these variants being stalemated loses
8337                 }
8338                 break;
8339               case MT_CHECKMATE:
8340                 reason = "Xboard adjudication: Checkmate";
8341                 boards[forwardMostMove][EP_STATUS] = (gameInfo.variant == VariantLosers ? EP_WINS : EP_CHECKMATE);
8342                 if(gameInfo.variant == VariantShogi) {
8343                     if(forwardMostMove > backwardMostMove
8344                        && moveList[forwardMostMove-1][1] == '@'
8345                        && CharToPiece(ToUpper(moveList[forwardMostMove-1][0])) == WhitePawn) {
8346                         reason = "XBoard adjudication: pawn-drop mate";
8347                         boards[forwardMostMove][EP_STATUS] = EP_WINS;
8348                     }
8349                 }
8350                 break;
8351             }
8352
8353                 switch(i = (signed char)boards[forwardMostMove][EP_STATUS]) {
8354                     case EP_STALEMATE:
8355                         result = GameIsDrawn; break;
8356                     case EP_CHECKMATE:
8357                         result = WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins; break;
8358                     case EP_WINS:
8359                         result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins; break;
8360                     default:
8361                         result = EndOfFile;
8362                 }
8363                 if(canAdjudicate && appData.checkMates && result) { // [HGM] mates: adjudicate finished games if requested
8364                     if(engineOpponent)
8365                       SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
8366                     GameEnds( result, reason, GE_XBOARD );
8367                     return 1;
8368                 }
8369
8370                 /* Next absolutely insufficient mating material. */
8371                 if(!MatingPotential(nr, WhitePawn, nrW, nrB, staleW, bishopColor) &&
8372                    !MatingPotential(nr, BlackPawn, nrB, nrW, staleB, bishopColor))
8373                 {    /* includes KBK, KNK, KK of KBKB with like Bishops */
8374
8375                      /* always flag draws, for judging claims */
8376                      boards[forwardMostMove][EP_STATUS] = EP_INSUF_DRAW;
8377
8378                      if(canAdjudicate && appData.materialDraws) {
8379                          /* but only adjudicate them if adjudication enabled */
8380                          if(engineOpponent) {
8381                            SendToProgram("force\n", engineOpponent); // suppress reply
8382                            SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see last move */
8383                          }
8384                          GameEnds( GameIsDrawn, "Xboard adjudication: Insufficient mating material", GE_XBOARD );
8385                          return 1;
8386                      }
8387                 }
8388
8389                 /* Then some trivial draws (only adjudicate, cannot be claimed) */
8390                 if(gameInfo.variant == VariantXiangqi ?
8391                        SufficientDefence(nr, WhitePawn, nrW, nrB) && SufficientDefence(nr, BlackPawn, nrB, nrW)
8392                  : nrW + nrB == 4 &&
8393                    (   nr[WhiteRook] == 1 && nr[BlackRook] == 1 /* KRKR */
8394                    || nr[WhiteQueen] && nr[BlackQueen]==1     /* KQKQ */
8395                    || nr[WhiteKnight]==2 || nr[BlackKnight]==2     /* KNNK */
8396                    || nr[WhiteKnight]+nr[WhiteBishop] == 1 && nr[BlackKnight]+nr[BlackBishop] == 1 /* KBKN, KBKB, KNKN */
8397                    ) ) {
8398                      if(--moveCount < 0 && appData.trivialDraws && canAdjudicate)
8399                      {    /* if the first 3 moves do not show a tactical win, declare draw */
8400                           if(engineOpponent) {
8401                             SendToProgram("force\n", engineOpponent); // suppress reply
8402                             SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
8403                           }
8404                           GameEnds( GameIsDrawn, "Xboard adjudication: Trivial draw", GE_XBOARD );
8405                           return 1;
8406                      }
8407                 } else moveCount = 6;
8408             }
8409
8410         // Repetition draws and 50-move rule can be applied independently of legality testing
8411
8412                 /* Check for rep-draws */
8413                 count = 0;
8414                 drop = gameInfo.holdingsSize && (gameInfo.variant != VariantSuper && gameInfo.variant != VariantSChess
8415                                               && gameInfo.variant != VariantGreat && gameInfo.variant != VariantGrand);
8416                 for(k = forwardMostMove-2;
8417                     k>=backwardMostMove && k>=forwardMostMove-100 && (drop ||
8418                         (signed char)boards[k][EP_STATUS] < EP_UNKNOWN &&
8419                         (signed char)boards[k+2][EP_STATUS] <= EP_NONE && (signed char)boards[k+1][EP_STATUS] <= EP_NONE);
8420                     k-=2)
8421                 {   int rights=0;
8422                     if(CompareBoards(boards[k], boards[forwardMostMove])) {
8423                         /* compare castling rights */
8424                         if( boards[forwardMostMove][CASTLING][2] != boards[k][CASTLING][2] &&
8425                              (boards[k][CASTLING][0] != NoRights || boards[k][CASTLING][1] != NoRights) )
8426                                 rights++; /* King lost rights, while rook still had them */
8427                         if( boards[forwardMostMove][CASTLING][2] != NoRights ) { /* king has rights */
8428                             if( boards[forwardMostMove][CASTLING][0] != boards[k][CASTLING][0] ||
8429                                 boards[forwardMostMove][CASTLING][1] != boards[k][CASTLING][1] )
8430                                    rights++; /* but at least one rook lost them */
8431                         }
8432                         if( boards[forwardMostMove][CASTLING][5] != boards[k][CASTLING][5] &&
8433                              (boards[k][CASTLING][3] != NoRights || boards[k][CASTLING][4] != NoRights) )
8434                                 rights++;
8435                         if( boards[forwardMostMove][CASTLING][5] != NoRights ) {
8436                             if( boards[forwardMostMove][CASTLING][3] != boards[k][CASTLING][3] ||
8437                                 boards[forwardMostMove][CASTLING][4] != boards[k][CASTLING][4] )
8438                                    rights++;
8439                         }
8440                         if( rights == 0 && ++count > appData.drawRepeats-2 && canAdjudicate
8441                             && appData.drawRepeats > 1) {
8442                              /* adjudicate after user-specified nr of repeats */
8443                              int result = GameIsDrawn;
8444                              char *details = "XBoard adjudication: repetition draw";
8445                              if((gameInfo.variant == VariantXiangqi || gameInfo.variant == VariantShogi) && appData.testLegality) {
8446                                 // [HGM] xiangqi: check for forbidden perpetuals
8447                                 int m, ourPerpetual = 1, hisPerpetual = 1;
8448                                 for(m=forwardMostMove; m>k; m-=2) {
8449                                     if(MateTest(boards[m], PosFlags(m)) != MT_CHECK)
8450                                         ourPerpetual = 0; // the current mover did not always check
8451                                     if(MateTest(boards[m-1], PosFlags(m-1)) != MT_CHECK)
8452                                         hisPerpetual = 0; // the opponent did not always check
8453                                 }
8454                                 if(appData.debugMode) fprintf(debugFP, "XQ perpetual test, our=%d, his=%d\n",
8455                                                                         ourPerpetual, hisPerpetual);
8456                                 if(ourPerpetual && !hisPerpetual) { // we are actively checking him: forfeit
8457                                     result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
8458                                     details = "Xboard adjudication: perpetual checking";
8459                                 } else
8460                                 if(hisPerpetual && !ourPerpetual) { // he is checking us, but did not repeat yet
8461                                     break; // (or we would have caught him before). Abort repetition-checking loop.
8462                                 } else
8463                                 if(gameInfo.variant == VariantShogi) { // in Shogi other repetitions are draws
8464                                     if(BOARD_HEIGHT == 5 && BOARD_RGHT - BOARD_LEFT == 5) { // but in mini-Shogi gote wins!
8465                                         result = BlackWins;
8466                                         details = "Xboard adjudication: repetition";
8467                                     }
8468                                 } else // it must be XQ
8469                                 // Now check for perpetual chases
8470                                 if(!ourPerpetual && !hisPerpetual) { // no perpetual check, test for chase
8471                                     hisPerpetual = PerpetualChase(k, forwardMostMove);
8472                                     ourPerpetual = PerpetualChase(k+1, forwardMostMove);
8473                                     if(ourPerpetual && !hisPerpetual) { // we are actively chasing him: forfeit
8474                                         static char resdet[MSG_SIZ];
8475                                         result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
8476                                         details = resdet;
8477                                         snprintf(resdet, MSG_SIZ, "Xboard adjudication: perpetual chasing of %c%c", ourPerpetual>>8, ourPerpetual&255);
8478                                     } else
8479                                     if(hisPerpetual && !ourPerpetual)   // he is chasing us, but did not repeat yet
8480                                         break; // Abort repetition-checking loop.
8481                                 }
8482                                 // if neither of us is checking or chasing all the time, or both are, it is draw
8483                              }
8484                              if(engineOpponent) {
8485                                SendToProgram("force\n", engineOpponent); // suppress reply
8486                                SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
8487                              }
8488                              GameEnds( result, details, GE_XBOARD );
8489                              return 1;
8490                         }
8491                         if( rights == 0 && count > 1 ) /* occurred 2 or more times before */
8492                              boards[forwardMostMove][EP_STATUS] = EP_REP_DRAW;
8493                     }
8494                 }
8495
8496                 /* Now we test for 50-move draws. Determine ply count */
8497                 count = forwardMostMove;
8498                 /* look for last irreversble move */
8499                 while( (signed char)boards[count][EP_STATUS] <= EP_NONE && count > backwardMostMove )
8500                     count--;
8501                 /* if we hit starting position, add initial plies */
8502                 if( count == backwardMostMove )
8503                     count -= initialRulePlies;
8504                 count = forwardMostMove - count;
8505                 if(gameInfo.variant == VariantXiangqi && ( count >= 100 || count >= 2*appData.ruleMoves ) ) {
8506                         // adjust reversible move counter for checks in Xiangqi
8507                         int i = forwardMostMove - count, inCheck = 0, lastCheck;
8508                         if(i < backwardMostMove) i = backwardMostMove;
8509                         while(i <= forwardMostMove) {
8510                                 lastCheck = inCheck; // check evasion does not count
8511                                 inCheck = (MateTest(boards[i], PosFlags(i)) == MT_CHECK);
8512                                 if(inCheck || lastCheck) count--; // check does not count
8513                                 i++;
8514                         }
8515                 }
8516                 if( count >= 100)
8517                          boards[forwardMostMove][EP_STATUS] = EP_RULE_DRAW;
8518                          /* this is used to judge if draw claims are legal */
8519                 if(canAdjudicate && appData.ruleMoves > 0 && count >= 2*appData.ruleMoves) {
8520                          if(engineOpponent) {
8521                            SendToProgram("force\n", engineOpponent); // suppress reply
8522                            SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
8523                          }
8524                          GameEnds( GameIsDrawn, "Xboard adjudication: 50-move rule", GE_XBOARD );
8525                          return 1;
8526                 }
8527
8528                 /* if draw offer is pending, treat it as a draw claim
8529                  * when draw condition present, to allow engines a way to
8530                  * claim draws before making their move to avoid a race
8531                  * condition occurring after their move
8532                  */
8533                 if((gameMode == TwoMachinesPlay ? second.offeredDraw : userOfferedDraw) || first.offeredDraw ) {
8534                          char *p = NULL;
8535                          if((signed char)boards[forwardMostMove][EP_STATUS] == EP_RULE_DRAW)
8536                              p = "Draw claim: 50-move rule";
8537                          if((signed char)boards[forwardMostMove][EP_STATUS] == EP_REP_DRAW)
8538                              p = "Draw claim: 3-fold repetition";
8539                          if((signed char)boards[forwardMostMove][EP_STATUS] == EP_INSUF_DRAW)
8540                              p = "Draw claim: insufficient mating material";
8541                          if( p != NULL && canAdjudicate) {
8542                              if(engineOpponent) {
8543                                SendToProgram("force\n", engineOpponent); // suppress reply
8544                                SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
8545                              }
8546                              GameEnds( GameIsDrawn, p, GE_XBOARD );
8547                              return 1;
8548                          }
8549                 }
8550
8551                 if( canAdjudicate && appData.adjudicateDrawMoves > 0 && forwardMostMove > (2*appData.adjudicateDrawMoves) ) {
8552                     if(engineOpponent) {
8553                       SendToProgram("force\n", engineOpponent); // suppress reply
8554                       SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
8555                     }
8556                     GameEnds( GameIsDrawn, "Xboard adjudication: long game", GE_XBOARD );
8557                     return 1;
8558                 }
8559         return 0;
8560 }
8561
8562 typedef int (CDECL *PPROBE_EGBB) (int player, int *piece, int *square);
8563 typedef int (CDECL *PLOAD_EGBB) (char *path, int cache_size, int load_options);
8564 static int egbbCode[] = { 6, 5, 4, 3, 2, 1 };
8565
8566 static int
8567 BitbaseProbe ()
8568 {
8569     int pieces[10], squares[10], cnt=0, r, f, res;
8570     static int loaded;
8571     static PPROBE_EGBB probeBB;
8572     if(!appData.testLegality) return 10;
8573     if(BOARD_HEIGHT != 8 || BOARD_RGHT-BOARD_LEFT != 8) return 12;
8574     if(gameInfo.holdingsSize && gameInfo.variant != VariantSuper && gameInfo.variant != VariantSChess) return 12;
8575     if(loaded == 2 && forwardMostMove < 2) loaded = 0; // retry on new game
8576     for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
8577         ChessSquare piece = boards[forwardMostMove][r][f];
8578         int black = (piece >= BlackPawn);
8579         int type = piece - black*BlackPawn;
8580         if(piece == EmptySquare) continue;
8581         if(type != WhiteKing && type > WhiteQueen) return 12; // unorthodox piece
8582         if(type == WhiteKing) type = WhiteQueen + 1;
8583         type = egbbCode[type];
8584         squares[cnt] = r*(BOARD_RGHT - BOARD_LEFT) + f - BOARD_LEFT;
8585         pieces[cnt] = type + black*6;
8586         if(++cnt > 5) return 11;
8587     }
8588     pieces[cnt] = squares[cnt] = 0;
8589     // probe EGBB
8590     if(loaded == 2) return 13; // loading failed before
8591     if(loaded == 0) {
8592         char *p, *path = strstr(appData.egtFormats, "scorpio:"), buf[MSG_SIZ];
8593         HMODULE lib;
8594         PLOAD_EGBB loadBB;
8595         loaded = 2; // prepare for failure
8596         if(!path) return 13; // no egbb installed
8597         strncpy(buf, path + 8, MSG_SIZ);
8598         if(p = strchr(buf, ',')) *p = NULLCHAR; else p = buf + strlen(buf);
8599         snprintf(p, MSG_SIZ - strlen(buf), "%c%s", SLASH, EGBB_NAME);
8600         lib = LoadLibrary(buf);
8601         if(!lib) { DisplayError(_("could not load EGBB library"), 0); return 13; }
8602         loadBB = (PLOAD_EGBB) GetProcAddress(lib, "load_egbb_xmen");
8603         probeBB = (PPROBE_EGBB) GetProcAddress(lib, "probe_egbb_xmen");
8604         if(!loadBB || !probeBB) { DisplayError(_("wrong EGBB version"), 0); return 13; }
8605         p[1] = NULLCHAR; loadBB(buf, 64*1028, 2); // 2 = SMART_LOAD
8606         loaded = 1; // success!
8607     }
8608     res = probeBB(forwardMostMove & 1, pieces, squares);
8609     return res > 0 ? 1 : res < 0 ? -1 : 0;
8610 }
8611
8612 char *
8613 SendMoveToBookUser (int moveNr, ChessProgramState *cps, int initial)
8614 {   // [HGM] book: this routine intercepts moves to simulate book replies
8615     char *bookHit = NULL;
8616
8617     if(cps->drawDepth && BitbaseProbe() == 0) { // [HG} egbb: reduce depth in drawn position
8618         char buf[MSG_SIZ];
8619         snprintf(buf, MSG_SIZ, "sd %d\n", cps->drawDepth);
8620         SendToProgram(buf, cps);
8621     }
8622     //first determine if the incoming move brings opponent into his book
8623     if(appData.usePolyglotBook && (cps == &first ? !appData.firstHasOwnBookUCI : !appData.secondHasOwnBookUCI))
8624         bookHit = ProbeBook(moveNr+1, appData.polyglotBook); // returns move
8625     if(appData.debugMode) fprintf(debugFP, "book hit = %s\n", bookHit ? bookHit : "(NULL)");
8626     if(bookHit != NULL && !cps->bookSuspend) {
8627         // make sure opponent is not going to reply after receiving move to book position
8628         SendToProgram("force\n", cps);
8629         cps->bookSuspend = TRUE; // flag indicating it has to be restarted
8630     }
8631     if(bookHit) setboardSpoiledMachineBlack = FALSE; // suppress 'go' in SendMoveToProgram
8632     if(!initial) SendMoveToProgram(moveNr, cps); // with hit on initial position there is no move
8633     // now arrange restart after book miss
8634     if(bookHit) {
8635         // after a book hit we never send 'go', and the code after the call to this routine
8636         // has '&& !bookHit' added to suppress potential sending there (based on 'firstMove').
8637         char buf[MSG_SIZ], *move = bookHit;
8638         if(cps->useSAN) {
8639             int fromX, fromY, toX, toY;
8640             char promoChar;
8641             ChessMove moveType;
8642             move = buf + 30;
8643             if (ParseOneMove(bookHit, forwardMostMove, &moveType,
8644                                  &fromX, &fromY, &toX, &toY, &promoChar)) {
8645                 (void) CoordsToAlgebraic(boards[forwardMostMove],
8646                                     PosFlags(forwardMostMove),
8647                                     fromY, fromX, toY, toX, promoChar, move);
8648             } else {
8649                 if(appData.debugMode) fprintf(debugFP, "Book move could not be parsed\n");
8650                 bookHit = NULL;
8651             }
8652         }
8653         snprintf(buf, MSG_SIZ, "%s%s\n", (cps->useUsermove ? "usermove " : ""), move); // force book move into program supposed to play it
8654         SendToProgram(buf, cps);
8655         if(!initial) firstMove = FALSE; // normally we would clear the firstMove condition after return & sending 'go'
8656     } else if(initial) { // 'go' was needed irrespective of firstMove, and it has to be done in this routine
8657         SendToProgram("go\n", cps);
8658         cps->bookSuspend = FALSE; // after a 'go' we are never suspended
8659     } else { // 'go' might be sent based on 'firstMove' after this routine returns
8660         if(cps->bookSuspend && !firstMove) // 'go' needed, and it will not be done after we return
8661             SendToProgram("go\n", cps);
8662         cps->bookSuspend = FALSE; // anyhow, we will not be suspended after a miss
8663     }
8664     return bookHit; // notify caller of hit, so it can take action to send move to opponent
8665 }
8666
8667 int
8668 LoadError (char *errmess, ChessProgramState *cps)
8669 {   // unloads engine and switches back to -ncp mode if it was first
8670     if(cps->initDone) return FALSE;
8671     cps->isr = NULL; // this should suppress further error popups from breaking pipes
8672     DestroyChildProcess(cps->pr, 9 ); // just to be sure
8673     cps->pr = NoProc;
8674     if(cps == &first) {
8675         appData.noChessProgram = TRUE;
8676         gameMode = MachinePlaysBlack; ModeHighlight(); // kludge to unmark Machine Black menu
8677         gameMode = BeginningOfGame; ModeHighlight();
8678         SetNCPMode();
8679     }
8680     if(GetDelayedEvent()) CancelDelayedEvent(), ThawUI(); // [HGM] cancel remaining loading effort scheduled after feature timeout
8681     DisplayMessage("", ""); // erase waiting message
8682     if(errmess) DisplayError(errmess, 0); // announce reason, if given
8683     return TRUE;
8684 }
8685
8686 char *savedMessage;
8687 ChessProgramState *savedState;
8688 void
8689 DeferredBookMove (void)
8690 {
8691         if(savedState->lastPing != savedState->lastPong)
8692                     ScheduleDelayedEvent(DeferredBookMove, 10);
8693         else
8694         HandleMachineMove(savedMessage, savedState);
8695 }
8696
8697 static int savedWhitePlayer, savedBlackPlayer, pairingReceived;
8698 static ChessProgramState *stalledEngine;
8699 static char stashedInputMove[MSG_SIZ], abortEngineThink;
8700
8701 void
8702 HandleMachineMove (char *message, ChessProgramState *cps)
8703 {
8704     static char firstLeg[20], legs;
8705     char machineMove[MSG_SIZ], buf1[MSG_SIZ*10], buf2[MSG_SIZ];
8706     char realname[MSG_SIZ];
8707     int fromX, fromY, toX, toY;
8708     ChessMove moveType;
8709     char promoChar, roar;
8710     char *p, *pv=buf1;
8711     int oldError;
8712     char *bookHit;
8713
8714     if(cps == &pairing && sscanf(message, "%d-%d", &savedWhitePlayer, &savedBlackPlayer) == 2) {
8715         // [HGM] pairing: Mega-hack! Pairing engine also uses this routine (so it could give other WB commands).
8716         if(savedWhitePlayer == 0 || savedBlackPlayer == 0) {
8717             DisplayError(_("Invalid pairing from pairing engine"), 0);
8718             return;
8719         }
8720         pairingReceived = 1;
8721         NextMatchGame();
8722         return; // Skim the pairing messages here.
8723     }
8724
8725     oldError = cps->userError; cps->userError = 0;
8726
8727 FakeBookMove: // [HGM] book: we jump here to simulate machine moves after book hit
8728     /*
8729      * Kludge to ignore BEL characters
8730      */
8731     while (*message == '\007') message++;
8732
8733     /*
8734      * [HGM] engine debug message: ignore lines starting with '#' character
8735      */
8736     if(cps->debug && *message == '#') return;
8737
8738     /*
8739      * Look for book output
8740      */
8741     if (cps == &first && bookRequested) {
8742         if (message[0] == '\t' || message[0] == ' ') {
8743             /* Part of the book output is here; append it */
8744             strcat(bookOutput, message);
8745             strcat(bookOutput, "  \n");
8746             return;
8747         } else if (bookOutput[0] != NULLCHAR) {
8748             /* All of book output has arrived; display it */
8749             char *p = bookOutput;
8750             while (*p != NULLCHAR) {
8751                 if (*p == '\t') *p = ' ';
8752                 p++;
8753             }
8754             DisplayInformation(bookOutput);
8755             bookRequested = FALSE;
8756             /* Fall through to parse the current output */
8757         }
8758     }
8759
8760     /*
8761      * Look for machine move.
8762      */
8763     if ((sscanf(message, "%s %s %s", buf1, buf2, machineMove) == 3 && strcmp(buf2, "...") == 0) ||
8764         (sscanf(message, "%s %s", buf1, machineMove) == 2 && strcmp(buf1, "move") == 0))
8765     {
8766         if(pausing && !cps->pause) { // for pausing engine that does not support 'pause', we stash its move for processing when we resume.
8767             if(appData.debugMode) fprintf(debugFP, "pause %s engine after move\n", cps->which);
8768             safeStrCpy(stashedInputMove, message, MSG_SIZ);
8769             stalledEngine = cps;
8770             if(appData.ponderNextMove) { // bring opponent out of ponder
8771                 if(gameMode == TwoMachinesPlay) {
8772                     if(cps->other->pause)
8773                         PauseEngine(cps->other);
8774                     else
8775                         SendToProgram("easy\n", cps->other);
8776                 }
8777             }
8778             StopClocks();
8779             return;
8780         }
8781
8782       if(cps->usePing) {
8783
8784         /* This method is only useful on engines that support ping */
8785         if(abortEngineThink) {
8786             if (appData.debugMode) {
8787                 fprintf(debugFP, "Undoing move from aborted think of %s\n", cps->which);
8788             }
8789             SendToProgram("undo\n", cps);
8790             return;
8791         }
8792
8793         if (cps->lastPing != cps->lastPong) {
8794             /* Extra move from before last new; ignore */
8795             if (appData.debugMode) {
8796                 fprintf(debugFP, "Ignoring extra move from %s\n", cps->which);
8797             }
8798           return;
8799         }
8800
8801       } else {
8802
8803         int machineWhite = FALSE;
8804
8805         switch (gameMode) {
8806           case BeginningOfGame:
8807             /* Extra move from before last reset; ignore */
8808             if (appData.debugMode) {
8809                 fprintf(debugFP, "Ignoring extra move from %s\n", cps->which);
8810             }
8811             return;
8812
8813           case EndOfGame:
8814           case IcsIdle:
8815           default:
8816             /* Extra move after we tried to stop.  The mode test is
8817                not a reliable way of detecting this problem, but it's
8818                the best we can do on engines that don't support ping.
8819             */
8820             if (appData.debugMode) {
8821                 fprintf(debugFP, "Undoing extra move from %s, gameMode %d\n",
8822                         cps->which, gameMode);
8823             }
8824             SendToProgram("undo\n", cps);
8825             return;
8826
8827           case MachinePlaysWhite:
8828           case IcsPlayingWhite:
8829             machineWhite = TRUE;
8830             break;
8831
8832           case MachinePlaysBlack:
8833           case IcsPlayingBlack:
8834             machineWhite = FALSE;
8835             break;
8836
8837           case TwoMachinesPlay:
8838             machineWhite = (cps->twoMachinesColor[0] == 'w');
8839             break;
8840         }
8841         if (WhiteOnMove(forwardMostMove) != machineWhite) {
8842             if (appData.debugMode) {
8843                 fprintf(debugFP,
8844                         "Ignoring move out of turn by %s, gameMode %d"
8845                         ", forwardMost %d\n",
8846                         cps->which, gameMode, forwardMostMove);
8847             }
8848             return;
8849         }
8850       }
8851
8852         if(cps->alphaRank) AlphaRank(machineMove, 4);
8853
8854         // [HGM] lion: (some very limited) support for Alien protocol
8855         killX = killY = kill2X = kill2Y = -1;
8856         if(machineMove[strlen(machineMove)-1] == ',') { // move ends in coma: non-final leg of composite move
8857             if(legs++) return;                     // middle leg contains only redundant info, ignore (but count it)
8858             safeStrCpy(firstLeg, machineMove, 20); // just remember it for processing when second leg arrives
8859             return;
8860         }
8861         if(p = strchr(machineMove, ',')) {         // we got both legs in one (happens on book move)
8862             char *q = strchr(p+1, ',');            // second comma?
8863             safeStrCpy(firstLeg, machineMove, 20); // kludge: fake we received the first leg earlier, and clip it off
8864             if(q) legs = 2, p = q; else legs = 1;  // with 3-leg move we clipof first two legs!
8865             safeStrCpy(machineMove, firstLeg + (p - machineMove) + 1, 20);
8866         }
8867         if(firstLeg[0]) { // there was a previous leg;
8868             // only support case where same piece makes two step
8869             char buf[20], *p = machineMove+1, *q = buf+1, f;
8870             safeStrCpy(buf, machineMove, 20);
8871             while(isdigit(*q)) q++; // find start of to-square
8872             safeStrCpy(machineMove, firstLeg, 20);
8873             while(isdigit(*p)) p++; // to-square of first leg (which is now copied to machineMove)
8874             if(legs == 2) sscanf(p, "%c%d", &f, &kill2Y), kill2X = f - AAA, kill2Y -= ONE - '0'; // in 3-leg move 2nd kill is to-sqr of 1st leg
8875             else if(*p == *buf)   // if first-leg to not equal to second-leg from first leg says unmodified (assume it is King move of castling)
8876             safeStrCpy(p, q, 20); // glue to-square of second leg to from-square of first, to process over-all move
8877             sscanf(buf, "%c%d", &f, &killY); killX = f - AAA; killY -= ONE - '0'; // pass intermediate square to MakeMove in global
8878             firstLeg[0] = NULLCHAR; legs = 0;
8879         }
8880
8881         if (!ParseOneMove(machineMove, forwardMostMove, &moveType,
8882                               &fromX, &fromY, &toX, &toY, &promoChar)) {
8883             /* Machine move could not be parsed; ignore it. */
8884           snprintf(buf1, MSG_SIZ*10, _("Illegal move \"%s\" from %s machine"),
8885                     machineMove, _(cps->which));
8886             DisplayMoveError(buf1);
8887             snprintf(buf1, MSG_SIZ*10, "Xboard: Forfeit due to invalid move: %s (%c%c%c%c via %c%c, %c%c) res=%d",
8888                     machineMove, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, killX+AAA, killY+ONE, kill2X+AAA, kill2Y+ONE, moveType);
8889             if (gameMode == TwoMachinesPlay) {
8890               GameEnds(cps->twoMachinesColor[0] == 'w' ? BlackWins : WhiteWins,
8891                        buf1, GE_XBOARD);
8892             }
8893             return;
8894         }
8895
8896         /* [HGM] Apparently legal, but so far only tested with EP_UNKOWN */
8897         /* So we have to redo legality test with true e.p. status here,  */
8898         /* to make sure an illegal e.p. capture does not slip through,   */
8899         /* to cause a forfeit on a justified illegal-move complaint      */
8900         /* of the opponent.                                              */
8901         if( gameMode==TwoMachinesPlay && appData.testLegality ) {
8902            ChessMove moveType;
8903            moveType = LegalityTest(boards[forwardMostMove], PosFlags(forwardMostMove),
8904                              fromY, fromX, toY, toX, promoChar);
8905             if(moveType == IllegalMove) {
8906               snprintf(buf1, MSG_SIZ*10, "Xboard: Forfeit due to illegal move: %s (%c%c%c%c)%c",
8907                         machineMove, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, 0);
8908                 GameEnds(cps->twoMachinesColor[0] == 'w' ? BlackWins : WhiteWins,
8909                            buf1, GE_XBOARD);
8910                 return;
8911            } else if(!appData.fischerCastling)
8912            /* [HGM] Kludge to handle engines that send FRC-style castling
8913               when they shouldn't (like TSCP-Gothic) */
8914            switch(moveType) {
8915              case WhiteASideCastleFR:
8916              case BlackASideCastleFR:
8917                toX+=2;
8918                currentMoveString[2]++;
8919                break;
8920              case WhiteHSideCastleFR:
8921              case BlackHSideCastleFR:
8922                toX--;
8923                currentMoveString[2]--;
8924                break;
8925              default: ; // nothing to do, but suppresses warning of pedantic compilers
8926            }
8927         }
8928         hintRequested = FALSE;
8929         lastHint[0] = NULLCHAR;
8930         bookRequested = FALSE;
8931         /* Program may be pondering now */
8932         cps->maybeThinking = TRUE;
8933         if (cps->sendTime == 2) cps->sendTime = 1;
8934         if (cps->offeredDraw) cps->offeredDraw--;
8935
8936         /* [AS] Save move info*/
8937         pvInfoList[ forwardMostMove ].score = programStats.score;
8938         pvInfoList[ forwardMostMove ].depth = programStats.depth;
8939         pvInfoList[ forwardMostMove ].time =  programStats.time; // [HGM] PGNtime: take time from engine stats
8940
8941         MakeMove(fromX, fromY, toX, toY, promoChar);/*updates forwardMostMove*/
8942
8943         /* Test suites abort the 'game' after one move */
8944         if(*appData.finger) {
8945            static FILE *f;
8946            char *fen = PositionToFEN(backwardMostMove, NULL, 0); // no counts in EPD
8947            if(!f) f = fopen(appData.finger, "w");
8948            if(f) fprintf(f, "%s bm %s;\n", fen, parseList[backwardMostMove]), fflush(f);
8949            else { DisplayFatalError("Bad output file", errno, 0); return; }
8950            free(fen);
8951            GameEnds(GameUnfinished, NULL, GE_XBOARD);
8952         }
8953         if(appData.epd) {
8954            if(solvingTime >= 0) {
8955               snprintf(buf1, MSG_SIZ, _("%d. solved %4.2fs\n"), matchGame, solvingTime/100.);
8956               totalTime += solvingTime; first.matchWins++; solvingTime = -1;
8957            } else {
8958               snprintf(buf1, MSG_SIZ, _("%d. wrong (%s)\n"), matchGame, parseList[backwardMostMove]);
8959               second.matchWins++;
8960            }
8961            OutputKibitz(2, buf1);
8962            GameEnds(GameUnfinished, NULL, GE_XBOARD);
8963         }
8964
8965         /* [AS] Adjudicate game if needed (note: remember that forwardMostMove now points past the last move) */
8966         if( gameMode == TwoMachinesPlay && appData.adjudicateLossThreshold != 0 && forwardMostMove >= adjudicateLossPlies ) {
8967             int count = 0;
8968
8969             while( count < adjudicateLossPlies ) {
8970                 int score = pvInfoList[ forwardMostMove - count - 1 ].score;
8971
8972                 if( count & 1 ) {
8973                     score = -score; /* Flip score for winning side */
8974                 }
8975
8976                 if( score > appData.adjudicateLossThreshold ) {
8977                     break;
8978                 }
8979
8980                 count++;
8981             }
8982
8983             if( count >= adjudicateLossPlies ) {
8984                 ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
8985
8986                 GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
8987                     "Xboard adjudication",
8988                     GE_XBOARD );
8989
8990                 return;
8991             }
8992         }
8993
8994         if(Adjudicate(cps)) {
8995             ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
8996             return; // [HGM] adjudicate: for all automatic game ends
8997         }
8998
8999 #if ZIPPY
9000         if ((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack) &&
9001             first.initDone) {
9002           if(cps->offeredDraw && (signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
9003                 SendToICS(ics_prefix); // [HGM] drawclaim: send caim and move on one line for FICS
9004                 SendToICS("draw ");
9005                 SendMoveToICS(moveType, fromX, fromY, toX, toY, promoChar);
9006           }
9007           SendMoveToICS(moveType, fromX, fromY, toX, toY, promoChar);
9008           ics_user_moved = 1;
9009           if(appData.autoKibitz && !appData.icsEngineAnalyze ) { /* [HGM] kibitz: send most-recent PV info to ICS */
9010                 char buf[3*MSG_SIZ];
9011
9012                 snprintf(buf, 3*MSG_SIZ, "kibitz !!! %+.2f/%d (%.2f sec, %u nodes, %.0f knps) PV=%s\n",
9013                         programStats.score / 100.,
9014                         programStats.depth,
9015                         programStats.time / 100.,
9016                         (unsigned int)programStats.nodes,
9017                         (unsigned int)programStats.nodes / (10*abs(programStats.time) + 1.),
9018                         programStats.movelist);
9019                 SendToICS(buf);
9020           }
9021         }
9022 #endif
9023
9024         /* [AS] Clear stats for next move */
9025         ClearProgramStats();
9026         thinkOutput[0] = NULLCHAR;
9027         hiddenThinkOutputState = 0;
9028
9029         bookHit = NULL;
9030         if (gameMode == TwoMachinesPlay) {
9031             /* [HGM] relaying draw offers moved to after reception of move */
9032             /* and interpreting offer as claim if it brings draw condition */
9033             if (cps->offeredDraw == 1 && cps->other->sendDrawOffers) {
9034                 SendToProgram("draw\n", cps->other);
9035             }
9036             if (cps->other->sendTime) {
9037                 SendTimeRemaining(cps->other,
9038                                   cps->other->twoMachinesColor[0] == 'w');
9039             }
9040             bookHit = SendMoveToBookUser(forwardMostMove-1, cps->other, FALSE);
9041             if (firstMove && !bookHit) {
9042                 firstMove = FALSE;
9043                 if (cps->other->useColors) {
9044                   SendToProgram(cps->other->twoMachinesColor, cps->other);
9045                 }
9046                 SendToProgram("go\n", cps->other);
9047             }
9048             cps->other->maybeThinking = TRUE;
9049         }
9050
9051         roar = (killX >= 0 && IS_LION(boards[forwardMostMove][toY][toX]));
9052
9053         ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
9054
9055         if (!pausing && appData.ringBellAfterMoves) {
9056             if(!roar) RingBell();
9057         }
9058
9059         /*
9060          * Reenable menu items that were disabled while
9061          * machine was thinking
9062          */
9063         if (gameMode != TwoMachinesPlay)
9064             SetUserThinkingEnables();
9065
9066         // [HGM] book: after book hit opponent has received move and is now in force mode
9067         // force the book reply into it, and then fake that it outputted this move by jumping
9068         // back to the beginning of HandleMachineMove, with cps toggled and message set to this move
9069         if(bookHit) {
9070                 static char bookMove[MSG_SIZ]; // a bit generous?
9071
9072                 safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
9073                 strcat(bookMove, bookHit);
9074                 message = bookMove;
9075                 cps = cps->other;
9076                 programStats.nodes = programStats.depth = programStats.time =
9077                 programStats.score = programStats.got_only_move = 0;
9078                 sprintf(programStats.movelist, "%s (xbook)", bookHit);
9079
9080                 if(cps->lastPing != cps->lastPong) {
9081                     savedMessage = message; // args for deferred call
9082                     savedState = cps;
9083                     ScheduleDelayedEvent(DeferredBookMove, 10);
9084                     return;
9085                 }
9086                 goto FakeBookMove;
9087         }
9088
9089         return;
9090     }
9091
9092     /* Set special modes for chess engines.  Later something general
9093      *  could be added here; for now there is just one kludge feature,
9094      *  needed because Crafty 15.10 and earlier don't ignore SIGINT
9095      *  when "xboard" is given as an interactive command.
9096      */
9097     if (strncmp(message, "kibitz Hello from Crafty", 24) == 0) {
9098         cps->useSigint = FALSE;
9099         cps->useSigterm = FALSE;
9100     }
9101     if (strncmp(message, "feature ", 8) == 0) { // [HGM] moved forward to pre-empt non-compliant commands
9102       ParseFeatures(message+8, cps);
9103       return; // [HGM] This return was missing, causing option features to be recognized as non-compliant commands!
9104     }
9105
9106     if (!strncmp(message, "setup ", 6) &&
9107         (!appData.testLegality || gameInfo.variant == VariantFairy || gameInfo.variant == VariantUnknown ||
9108           NonStandardBoardSize(gameInfo.variant, gameInfo.boardWidth, gameInfo.boardHeight, gameInfo.holdingsSize))
9109                                         ) { // [HGM] allow first engine to define opening position
9110       int dummy, w, h, hand, s=6; char buf[MSG_SIZ], varName[MSG_SIZ];
9111       if(appData.icsActive || forwardMostMove != 0 || cps != &first) return;
9112       *buf = NULLCHAR;
9113       if(sscanf(message, "setup (%s", buf) == 1) {
9114         s = 8 + strlen(buf), buf[s-9] = NULLCHAR, SetCharTableEsc(pieceToChar, buf, SUFFIXES);
9115         ASSIGN(appData.pieceToCharTable, buf);
9116       }
9117       dummy = sscanf(message+s, "%dx%d+%d_%s", &w, &h, &hand, varName);
9118       if(dummy >= 3) {
9119         while(message[s] && message[s++] != ' ');
9120         if(BOARD_HEIGHT != h || BOARD_WIDTH != w + 4*(hand != 0) || gameInfo.holdingsSize != hand ||
9121            dummy == 4 && gameInfo.variant != StringToVariant(varName) ) { // engine wants to change board format or variant
9122             appData.NrFiles = w; appData.NrRanks = h; appData.holdingsSize = hand;
9123             if(dummy == 4) gameInfo.variant = StringToVariant(varName);     // parent variant
9124           InitPosition(1); // calls InitDrawingSizes to let new parameters take effect
9125           if(*buf) SetCharTableEsc(pieceToChar, buf, SUFFIXES); // do again, for it was spoiled by InitPosition
9126           startedFromSetupPosition = FALSE;
9127         }
9128       }
9129       if(startedFromSetupPosition) return;
9130       ParseFEN(boards[0], &dummy, message+s, FALSE);
9131       DrawPosition(TRUE, boards[0]);
9132       CopyBoard(initialPosition, boards[0]);
9133       startedFromSetupPosition = TRUE;
9134       return;
9135     }
9136     if(sscanf(message, "piece %s %s", buf2, buf1) == 2) {
9137       ChessSquare piece = WhitePawn;
9138       char *p=message+6, *q, *s = SUFFIXES, ID = *p;
9139       if(*p == '+') piece = CHUPROMOTED(WhitePawn), ID = *++p;
9140       if(q = strchr(s, p[1])) ID += 64*(q - s + 1), p++;
9141       piece += CharToPiece(ID & 255) - WhitePawn;
9142       if(cps != &first || appData.testLegality && *engineVariant == NULLCHAR
9143       /* always accept definition of  */       && piece != WhiteFalcon && piece != BlackFalcon
9144       /* wild-card pieces.            */       && piece != WhiteCobra  && piece != BlackCobra
9145       /* For variants we don't have   */       && gameInfo.variant != VariantBerolina
9146       /* correct rules for, we cannot */       && gameInfo.variant != VariantCylinder
9147       /* enforce legality on our own! */       && gameInfo.variant != VariantUnknown
9148                                                && gameInfo.variant != VariantGreat
9149                                                && gameInfo.variant != VariantFairy    ) return;
9150       if(piece < EmptySquare) {
9151         pieceDefs = TRUE;
9152         ASSIGN(pieceDesc[piece], buf1);
9153         if((ID & 32) == 0 && p[1] == '&') { ASSIGN(pieceDesc[WHITE_TO_BLACK piece], buf1); }
9154       }
9155       return;
9156     }
9157     if(sscanf(message, "choice %s", promoRestrict) == 1 && promoSweep != EmptySquare) {
9158       promoSweep = CharToPiece(currentMove&1 ? ToLower(*promoRestrict) : ToUpper(*promoRestrict));
9159       Sweep(0);
9160       return;
9161     }
9162     /* [HGM] Allow engine to set up a position. Don't ask me why one would
9163      * want this, I was asked to put it in, and obliged.
9164      */
9165     if (!strncmp(message, "setboard ", 9)) {
9166         Board initial_position;
9167
9168         GameEnds(GameUnfinished, "Engine aborts game", GE_XBOARD);
9169
9170         if (!ParseFEN(initial_position, &blackPlaysFirst, message + 9, FALSE)) {
9171             DisplayError(_("Bad FEN received from engine"), 0);
9172             return ;
9173         } else {
9174            Reset(TRUE, FALSE);
9175            CopyBoard(boards[0], initial_position);
9176            initialRulePlies = FENrulePlies;
9177            if(blackPlaysFirst) gameMode = MachinePlaysWhite;
9178            else gameMode = MachinePlaysBlack;
9179            DrawPosition(FALSE, boards[currentMove]);
9180         }
9181         return;
9182     }
9183
9184     /*
9185      * Look for communication commands
9186      */
9187     if (!strncmp(message, "telluser ", 9)) {
9188         if(message[9] == '\\' && message[10] == '\\')
9189             EscapeExpand(message+9, message+11); // [HGM] esc: allow escape sequences in popup box
9190         PlayTellSound();
9191         DisplayNote(message + 9);
9192         return;
9193     }
9194     if (!strncmp(message, "tellusererror ", 14)) {
9195         cps->userError = 1;
9196         if(message[14] == '\\' && message[15] == '\\')
9197             EscapeExpand(message+14, message+16); // [HGM] esc: allow escape sequences in popup box
9198         PlayTellSound();
9199         DisplayError(message + 14, 0);
9200         return;
9201     }
9202     if (!strncmp(message, "tellopponent ", 13)) {
9203       if (appData.icsActive) {
9204         if (loggedOn) {
9205           snprintf(buf1, sizeof(buf1), "%ssay %s\n", ics_prefix, message + 13);
9206           SendToICS(buf1);
9207         }
9208       } else {
9209         DisplayNote(message + 13);
9210       }
9211       return;
9212     }
9213     if (!strncmp(message, "tellothers ", 11)) {
9214       if (appData.icsActive) {
9215         if (loggedOn) {
9216           snprintf(buf1, sizeof(buf1), "%swhisper %s\n", ics_prefix, message + 11);
9217           SendToICS(buf1);
9218         }
9219       } else if(appData.autoComment) AppendComment (forwardMostMove, message + 11, 1); // in local mode, add as move comment
9220       return;
9221     }
9222     if (!strncmp(message, "tellall ", 8)) {
9223       if (appData.icsActive) {
9224         if (loggedOn) {
9225           snprintf(buf1, sizeof(buf1), "%skibitz %s\n", ics_prefix, message + 8);
9226           SendToICS(buf1);
9227         }
9228       } else {
9229         DisplayNote(message + 8);
9230       }
9231       return;
9232     }
9233     if (strncmp(message, "warning", 7) == 0) {
9234         /* Undocumented feature, use tellusererror in new code */
9235         DisplayError(message, 0);
9236         return;
9237     }
9238     if (sscanf(message, "askuser %s %[^\n]", buf1, buf2) == 2) {
9239         safeStrCpy(realname, cps->tidy, sizeof(realname)/sizeof(realname[0]));
9240         strcat(realname, " query");
9241         AskQuestion(realname, buf2, buf1, cps->pr);
9242         return;
9243     }
9244     /* Commands from the engine directly to ICS.  We don't allow these to be
9245      *  sent until we are logged on. Crafty kibitzes have been known to
9246      *  interfere with the login process.
9247      */
9248     if (loggedOn) {
9249         if (!strncmp(message, "tellics ", 8)) {
9250             SendToICS(message + 8);
9251             SendToICS("\n");
9252             return;
9253         }
9254         if (!strncmp(message, "tellicsnoalias ", 15)) {
9255             SendToICS(ics_prefix);
9256             SendToICS(message + 15);
9257             SendToICS("\n");
9258             return;
9259         }
9260         /* The following are for backward compatibility only */
9261         if (!strncmp(message,"whisper",7) || !strncmp(message,"kibitz",6) ||
9262             !strncmp(message,"draw",4) || !strncmp(message,"tell",3)) {
9263             SendToICS(ics_prefix);
9264             SendToICS(message);
9265             SendToICS("\n");
9266             return;
9267         }
9268     }
9269     if (sscanf(message, "pong %d", &cps->lastPong) == 1) {
9270         if(initPing == cps->lastPong) {
9271             if(gameInfo.variant == VariantUnknown) {
9272                 DisplayError(_("Engine did not send setup for non-standard variant"), 0);
9273                 *engineVariant = NULLCHAR; appData.variant = VariantNormal; // back to normal as error recovery?
9274                 GameEnds(GameUnfinished, NULL, GE_XBOARD);
9275             }
9276             initPing = -1;
9277         }
9278         if(cps->lastPing == cps->lastPong && abortEngineThink) {
9279             abortEngineThink = FALSE;
9280             DisplayMessage("", "");
9281             ThawUI();
9282         }
9283         return;
9284     }
9285     if(!strncmp(message, "highlight ", 10)) {
9286         if(appData.testLegality && !*engineVariant && appData.markers) return;
9287         MarkByFEN(message+10); // [HGM] alien: allow engine to mark board squares
9288         return;
9289     }
9290     if(!strncmp(message, "click ", 6)) {
9291         char f, c=0; int x, y; // [HGM] alien: allow engine to finish user moves (i.e. engine-driven one-click moving)
9292         if(appData.testLegality || !appData.oneClick) return;
9293         sscanf(message+6, "%c%d%c", &f, &y, &c);
9294         x = f - 'a' + BOARD_LEFT, y -= ONE - '0';
9295         if(flipView) x = BOARD_WIDTH-1 - x; else y = BOARD_HEIGHT-1 - y;
9296         x = x*squareSize + (x+1)*lineGap + squareSize/2;
9297         y = y*squareSize + (y+1)*lineGap + squareSize/2;
9298         f = first.highlight; first.highlight = 0; // kludge to suppress lift/put in response to own clicks
9299         if(lastClickType == Press) // if button still down, fake release on same square, to be ready for next click
9300             LeftClick(Release, lastLeftX, lastLeftY);
9301         controlKey  = (c == ',');
9302         LeftClick(Press, x, y);
9303         LeftClick(Release, x, y);
9304         first.highlight = f;
9305         return;
9306     }
9307     /*
9308      * If the move is illegal, cancel it and redraw the board.
9309      * Also deal with other error cases.  Matching is rather loose
9310      * here to accommodate engines written before the spec.
9311      */
9312     if (strncmp(message + 1, "llegal move", 11) == 0 ||
9313         strncmp(message, "Error", 5) == 0) {
9314         if (StrStr(message, "name") ||
9315             StrStr(message, "rating") || StrStr(message, "?") ||
9316             StrStr(message, "result") || StrStr(message, "board") ||
9317             StrStr(message, "bk") || StrStr(message, "computer") ||
9318             StrStr(message, "variant") || StrStr(message, "hint") ||
9319             StrStr(message, "random") || StrStr(message, "depth") ||
9320             StrStr(message, "accepted")) {
9321             return;
9322         }
9323         if (StrStr(message, "protover")) {
9324           /* Program is responding to input, so it's apparently done
9325              initializing, and this error message indicates it is
9326              protocol version 1.  So we don't need to wait any longer
9327              for it to initialize and send feature commands. */
9328           FeatureDone(cps, 1);
9329           cps->protocolVersion = 1;
9330           return;
9331         }
9332         cps->maybeThinking = FALSE;
9333
9334         if (StrStr(message, "draw")) {
9335             /* Program doesn't have "draw" command */
9336             cps->sendDrawOffers = 0;
9337             return;
9338         }
9339         if (cps->sendTime != 1 &&
9340             (StrStr(message, "time") || StrStr(message, "otim"))) {
9341           /* Program apparently doesn't have "time" or "otim" command */
9342           cps->sendTime = 0;
9343           return;
9344         }
9345         if (StrStr(message, "analyze")) {
9346             cps->analysisSupport = FALSE;
9347             cps->analyzing = FALSE;
9348 //          Reset(FALSE, TRUE); // [HGM] this caused discrepancy between display and internal state!
9349             EditGameEvent(); // [HGM] try to preserve loaded game
9350             snprintf(buf2,MSG_SIZ, _("%s does not support analysis"), cps->tidy);
9351             DisplayError(buf2, 0);
9352             return;
9353         }
9354         if (StrStr(message, "(no matching move)st")) {
9355           /* Special kludge for GNU Chess 4 only */
9356           cps->stKludge = TRUE;
9357           SendTimeControl(cps, movesPerSession, timeControl,
9358                           timeIncrement, appData.searchDepth,
9359                           searchTime);
9360           return;
9361         }
9362         if (StrStr(message, "(no matching move)sd")) {
9363           /* Special kludge for GNU Chess 4 only */
9364           cps->sdKludge = TRUE;
9365           SendTimeControl(cps, movesPerSession, timeControl,
9366                           timeIncrement, appData.searchDepth,
9367                           searchTime);
9368           return;
9369         }
9370         if (!StrStr(message, "llegal")) {
9371             return;
9372         }
9373         if (gameMode == BeginningOfGame || gameMode == EndOfGame ||
9374             gameMode == IcsIdle) return;
9375         if (forwardMostMove <= backwardMostMove) return;
9376         if (pausing) PauseEvent();
9377       if(appData.forceIllegal) {
9378             // [HGM] illegal: machine refused move; force position after move into it
9379           SendToProgram("force\n", cps);
9380           if(!cps->useSetboard) { // hideous kludge on kludge, because SendBoard sucks.
9381                 // we have a real problem now, as SendBoard will use the a2a3 kludge
9382                 // when black is to move, while there might be nothing on a2 or black
9383                 // might already have the move. So send the board as if white has the move.
9384                 // But first we must change the stm of the engine, as it refused the last move
9385                 SendBoard(cps, 0); // always kludgeless, as white is to move on boards[0]
9386                 if(WhiteOnMove(forwardMostMove)) {
9387                     SendToProgram("a7a6\n", cps); // for the engine black still had the move
9388                     SendBoard(cps, forwardMostMove); // kludgeless board
9389                 } else {
9390                     SendToProgram("a2a3\n", cps); // for the engine white still had the move
9391                     CopyBoard(boards[forwardMostMove+1], boards[forwardMostMove]);
9392                     SendBoard(cps, forwardMostMove+1); // kludgeless board
9393                 }
9394           } else SendBoard(cps, forwardMostMove); // FEN case, also sets stm properly
9395             if(gameMode == MachinePlaysWhite || gameMode == MachinePlaysBlack ||
9396                  gameMode == TwoMachinesPlay)
9397               SendToProgram("go\n", cps);
9398             return;
9399       } else
9400         if (gameMode == PlayFromGameFile) {
9401             /* Stop reading this game file */
9402             gameMode = EditGame;
9403             ModeHighlight();
9404         }
9405         /* [HGM] illegal-move claim should forfeit game when Xboard */
9406         /* only passes fully legal moves                            */
9407         if( appData.testLegality && gameMode == TwoMachinesPlay ) {
9408             GameEnds( cps->twoMachinesColor[0] == 'w' ? BlackWins : WhiteWins,
9409                                 "False illegal-move claim", GE_XBOARD );
9410             return; // do not take back move we tested as valid
9411         }
9412         currentMove = forwardMostMove-1;
9413         DisplayMove(currentMove-1); /* before DisplayMoveError */
9414         SwitchClocks(forwardMostMove-1); // [HGM] race
9415         DisplayBothClocks();
9416         snprintf(buf1, 10*MSG_SIZ, _("Illegal move \"%s\" (rejected by %s chess program)"),
9417                 parseList[currentMove], _(cps->which));
9418         DisplayMoveError(buf1);
9419         DrawPosition(FALSE, boards[currentMove]);
9420
9421         SetUserThinkingEnables();
9422         return;
9423     }
9424     if (strncmp(message, "time", 4) == 0 && StrStr(message, "Illegal")) {
9425         /* Program has a broken "time" command that
9426            outputs a string not ending in newline.
9427            Don't use it. */
9428         cps->sendTime = 0;
9429     }
9430     if (cps->pseudo) { // [HGM] pseudo-engine, granted unusual powers
9431         if (sscanf(message, "wtime %ld\n", &whiteTimeRemaining) == 1 || // adjust clock times
9432             sscanf(message, "btime %ld\n", &blackTimeRemaining) == 1   ) return;
9433     }
9434
9435     /*
9436      * If chess program startup fails, exit with an error message.
9437      * Attempts to recover here are futile. [HGM] Well, we try anyway
9438      */
9439     if ((StrStr(message, "unknown host") != NULL)
9440         || (StrStr(message, "No remote directory") != NULL)
9441         || (StrStr(message, "not found") != NULL)
9442         || (StrStr(message, "No such file") != NULL)
9443         || (StrStr(message, "can't alloc") != NULL)
9444         || (StrStr(message, "Permission denied") != NULL)) {
9445
9446         cps->maybeThinking = FALSE;
9447         snprintf(buf1, sizeof(buf1), _("Failed to start %s chess program %s on %s: %s\n"),
9448                 _(cps->which), cps->program, cps->host, message);
9449         RemoveInputSource(cps->isr);
9450         if(appData.icsActive) DisplayFatalError(buf1, 0, 1); else {
9451             if(LoadError(oldError ? NULL : buf1, cps)) return; // error has then been handled by LoadError
9452             if(!oldError) DisplayError(buf1, 0); // if reason neatly announced, suppress general error popup
9453         }
9454         return;
9455     }
9456
9457     /*
9458      * Look for hint output
9459      */
9460     if (sscanf(message, "Hint: %s", buf1) == 1) {
9461         if (cps == &first && hintRequested) {
9462             hintRequested = FALSE;
9463             if (ParseOneMove(buf1, forwardMostMove, &moveType,
9464                                  &fromX, &fromY, &toX, &toY, &promoChar)) {
9465                 (void) CoordsToAlgebraic(boards[forwardMostMove],
9466                                     PosFlags(forwardMostMove),
9467                                     fromY, fromX, toY, toX, promoChar, buf1);
9468                 snprintf(buf2, sizeof(buf2), _("Hint: %s"), buf1);
9469                 DisplayInformation(buf2);
9470             } else {
9471                 /* Hint move could not be parsed!? */
9472               snprintf(buf2, sizeof(buf2),
9473                         _("Illegal hint move \"%s\"\nfrom %s chess program"),
9474                         buf1, _(cps->which));
9475                 DisplayError(buf2, 0);
9476             }
9477         } else {
9478           safeStrCpy(lastHint, buf1, sizeof(lastHint)/sizeof(lastHint[0]));
9479         }
9480         return;
9481     }
9482
9483     /*
9484      * Ignore other messages if game is not in progress
9485      */
9486     if (gameMode == BeginningOfGame || gameMode == EndOfGame ||
9487         gameMode == IcsIdle || cps->lastPing != cps->lastPong) return;
9488
9489     /*
9490      * look for win, lose, draw, or draw offer
9491      */
9492     if (strncmp(message, "1-0", 3) == 0) {
9493         char *p, *q, *r = "";
9494         p = strchr(message, '{');
9495         if (p) {
9496             q = strchr(p, '}');
9497             if (q) {
9498                 *q = NULLCHAR;
9499                 r = p + 1;
9500             }
9501         }
9502         GameEnds(WhiteWins, r, GE_ENGINE1 + (cps != &first)); /* [HGM] pass claimer indication for claim test */
9503         return;
9504     } else if (strncmp(message, "0-1", 3) == 0) {
9505         char *p, *q, *r = "";
9506         p = strchr(message, '{');
9507         if (p) {
9508             q = strchr(p, '}');
9509             if (q) {
9510                 *q = NULLCHAR;
9511                 r = p + 1;
9512             }
9513         }
9514         /* Kludge for Arasan 4.1 bug */
9515         if (strcmp(r, "Black resigns") == 0) {
9516             GameEnds(WhiteWins, r, GE_ENGINE1 + (cps != &first));
9517             return;
9518         }
9519         GameEnds(BlackWins, r, GE_ENGINE1 + (cps != &first));
9520         return;
9521     } else if (strncmp(message, "1/2", 3) == 0) {
9522         char *p, *q, *r = "";
9523         p = strchr(message, '{');
9524         if (p) {
9525             q = strchr(p, '}');
9526             if (q) {
9527                 *q = NULLCHAR;
9528                 r = p + 1;
9529             }
9530         }
9531
9532         GameEnds(GameIsDrawn, r, GE_ENGINE1 + (cps != &first));
9533         return;
9534
9535     } else if (strncmp(message, "White resign", 12) == 0) {
9536         GameEnds(BlackWins, "White resigns", GE_ENGINE1 + (cps != &first));
9537         return;
9538     } else if (strncmp(message, "Black resign", 12) == 0) {
9539         GameEnds(WhiteWins, "Black resigns", GE_ENGINE1 + (cps != &first));
9540         return;
9541     } else if (strncmp(message, "White matches", 13) == 0 ||
9542                strncmp(message, "Black matches", 13) == 0   ) {
9543         /* [HGM] ignore GNUShogi noises */
9544         return;
9545     } else if (strncmp(message, "White", 5) == 0 &&
9546                message[5] != '(' &&
9547                StrStr(message, "Black") == NULL) {
9548         GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
9549         return;
9550     } else if (strncmp(message, "Black", 5) == 0 &&
9551                message[5] != '(') {
9552         GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
9553         return;
9554     } else if (strcmp(message, "resign") == 0 ||
9555                strcmp(message, "computer resigns") == 0) {
9556         switch (gameMode) {
9557           case MachinePlaysBlack:
9558           case IcsPlayingBlack:
9559             GameEnds(WhiteWins, "Black resigns", GE_ENGINE);
9560             break;
9561           case MachinePlaysWhite:
9562           case IcsPlayingWhite:
9563             GameEnds(BlackWins, "White resigns", GE_ENGINE);
9564             break;
9565           case TwoMachinesPlay:
9566             if (cps->twoMachinesColor[0] == 'w')
9567               GameEnds(BlackWins, "White resigns", GE_ENGINE1 + (cps != &first));
9568             else
9569               GameEnds(WhiteWins, "Black resigns", GE_ENGINE1 + (cps != &first));
9570             break;
9571           default:
9572             /* can't happen */
9573             break;
9574         }
9575         return;
9576     } else if (strncmp(message, "opponent mates", 14) == 0) {
9577         switch (gameMode) {
9578           case MachinePlaysBlack:
9579           case IcsPlayingBlack:
9580             GameEnds(WhiteWins, "White mates", GE_ENGINE);
9581             break;
9582           case MachinePlaysWhite:
9583           case IcsPlayingWhite:
9584             GameEnds(BlackWins, "Black mates", GE_ENGINE);
9585             break;
9586           case TwoMachinesPlay:
9587             if (cps->twoMachinesColor[0] == 'w')
9588               GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
9589             else
9590               GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
9591             break;
9592           default:
9593             /* can't happen */
9594             break;
9595         }
9596         return;
9597     } else if (strncmp(message, "computer mates", 14) == 0) {
9598         switch (gameMode) {
9599           case MachinePlaysBlack:
9600           case IcsPlayingBlack:
9601             GameEnds(BlackWins, "Black mates", GE_ENGINE1);
9602             break;
9603           case MachinePlaysWhite:
9604           case IcsPlayingWhite:
9605             GameEnds(WhiteWins, "White mates", GE_ENGINE);
9606             break;
9607           case TwoMachinesPlay:
9608             if (cps->twoMachinesColor[0] == 'w')
9609               GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
9610             else
9611               GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
9612             break;
9613           default:
9614             /* can't happen */
9615             break;
9616         }
9617         return;
9618     } else if (strncmp(message, "checkmate", 9) == 0) {
9619         if (WhiteOnMove(forwardMostMove)) {
9620             GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
9621         } else {
9622             GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
9623         }
9624         return;
9625     } else if (strstr(message, "Draw") != NULL ||
9626                strstr(message, "game is a draw") != NULL) {
9627         GameEnds(GameIsDrawn, "Draw", GE_ENGINE1 + (cps != &first));
9628         return;
9629     } else if (strstr(message, "offer") != NULL &&
9630                strstr(message, "draw") != NULL) {
9631 #if ZIPPY
9632         if (appData.zippyPlay && first.initDone) {
9633             /* Relay offer to ICS */
9634             SendToICS(ics_prefix);
9635             SendToICS("draw\n");
9636         }
9637 #endif
9638         cps->offeredDraw = 2; /* valid until this engine moves twice */
9639         if (gameMode == TwoMachinesPlay) {
9640             if (cps->other->offeredDraw) {
9641                 GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
9642             /* [HGM] in two-machine mode we delay relaying draw offer      */
9643             /* until after we also have move, to see if it is really claim */
9644             }
9645         } else if (gameMode == MachinePlaysWhite ||
9646                    gameMode == MachinePlaysBlack) {
9647           if (userOfferedDraw) {
9648             DisplayInformation(_("Machine accepts your draw offer"));
9649             GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
9650           } else {
9651             DisplayInformation(_("Machine offers a draw.\nSelect Action / Draw to accept."));
9652           }
9653         }
9654     }
9655
9656
9657     /*
9658      * Look for thinking output
9659      */
9660     if ( appData.showThinking // [HGM] thinking: test all options that cause this output
9661           || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp()
9662                                 ) {
9663         int plylev, mvleft, mvtot, curscore, time;
9664         char mvname[MOVE_LEN];
9665         u64 nodes; // [DM]
9666         char plyext;
9667         int ignore = FALSE;
9668         int prefixHint = FALSE;
9669         mvname[0] = NULLCHAR;
9670
9671         switch (gameMode) {
9672           case MachinePlaysBlack:
9673           case IcsPlayingBlack:
9674             if (WhiteOnMove(forwardMostMove)) prefixHint = TRUE;
9675             break;
9676           case MachinePlaysWhite:
9677           case IcsPlayingWhite:
9678             if (!WhiteOnMove(forwardMostMove)) prefixHint = TRUE;
9679             break;
9680           case AnalyzeMode:
9681           case AnalyzeFile:
9682             break;
9683           case IcsObserving: /* [DM] icsEngineAnalyze */
9684             if (!appData.icsEngineAnalyze) ignore = TRUE;
9685             break;
9686           case TwoMachinesPlay:
9687             if ((cps->twoMachinesColor[0] == 'w') != WhiteOnMove(forwardMostMove)) {
9688                 ignore = TRUE;
9689             }
9690             break;
9691           default:
9692             ignore = TRUE;
9693             break;
9694         }
9695
9696         if (!ignore) {
9697             ChessProgramStats tempStats = programStats; // [HGM] info: filter out info lines
9698             buf1[0] = NULLCHAR;
9699             if (sscanf(message, "%d%c %d %d " u64Display " %[^\n]\n",
9700                        &plylev, &plyext, &curscore, &time, &nodes, buf1) >= 5) {
9701                 char score_buf[MSG_SIZ];
9702
9703                 if(nodes>>32 == u64Const(0xFFFFFFFF))   // [HGM] negative node count read
9704                     nodes += u64Const(0x100000000);
9705
9706                 if (plyext != ' ' && plyext != '\t') {
9707                     time *= 100;
9708                 }
9709
9710                 /* [AS] Negate score if machine is playing black and reporting absolute scores */
9711                 if( cps->scoreIsAbsolute &&
9712                     ( gameMode == MachinePlaysBlack ||
9713                       gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b' ||
9714                       gameMode == IcsPlayingBlack ||     // [HGM] also add other situations where engine should report black POV
9715                      (gameMode == AnalyzeMode || gameMode == AnalyzeFile || gameMode == IcsObserving && appData.icsEngineAnalyze) &&
9716                      !WhiteOnMove(currentMove)
9717                     ) )
9718                 {
9719                     curscore = -curscore;
9720                 }
9721
9722                 if(appData.pvSAN[cps==&second]) pv = PvToSAN(buf1);
9723
9724                 if(*bestMove) { // rememer time best EPD move was first found
9725                     int ff1, tf1, fr1, tr1, ff2, tf2, fr2, tr2; char pp1, pp2;
9726                     ChessMove mt; char *p = bestMove, solved = 0;
9727                     int ok = ParseOneMove(pv, forwardMostMove, &mt, &ff2, &fr2, &tf2, &tr2, &pp2);
9728                     while(ok && *p && ParseOneMove(p, forwardMostMove, &mt, &ff1, &fr1, &tf1, &tr1, &pp1)) {
9729                         if(ff1==ff2 && fr1==fr2 && tf1==tf2 && tr1==tr2 && pp1==pp2) {
9730                             solvingTime = (solvingTime < 0 ? time : solvingTime);
9731                             solved = 1;
9732                             break;
9733                         }
9734                         while(*p && *p != ' ') p++;
9735                         while(*p == ' ') p++;
9736                     }
9737                     if(!solved) solvingTime = -1;
9738                 }
9739
9740                 if(serverMoves && (time > 100 || time == 0 && plylev > 7)) {
9741                         char buf[MSG_SIZ];
9742                         FILE *f;
9743                         snprintf(buf, MSG_SIZ, "%s", appData.serverMovesName);
9744                         buf[strlen(buf)-1] = gameMode == MachinePlaysWhite ? 'w' :
9745                                              gameMode == MachinePlaysBlack ? 'b' : cps->twoMachinesColor[0];
9746                         if(appData.debugMode) fprintf(debugFP, "write PV on file '%s'\n", buf);
9747                         if(f = fopen(buf, "w")) { // export PV to applicable PV file
9748                                 fprintf(f, "%5.2f/%-2d %s", curscore/100., plylev, pv);
9749                                 fclose(f);
9750                         }
9751                         else
9752                           /* TRANSLATORS: PV = principal variation, the variation the chess engine thinks is the best for everyone */
9753                           DisplayError(_("failed writing PV"), 0);
9754                 }
9755
9756                 tempStats.depth = plylev;
9757                 tempStats.nodes = nodes;
9758                 tempStats.time = time;
9759                 tempStats.score = curscore;
9760                 tempStats.got_only_move = 0;
9761
9762                 if(cps->nps >= 0) { /* [HGM] nps: use engine nodes or time to decrement clock */
9763                         int ticklen;
9764
9765                         if(cps->nps == 0) ticklen = 10*time;                    // use engine reported time
9766                         else ticklen = (1000. * u64ToDouble(nodes)) / cps->nps; // convert node count to time
9767                         if(WhiteOnMove(forwardMostMove) && (gameMode == MachinePlaysWhite ||
9768                                                 gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'w'))
9769                              whiteTimeRemaining = timeRemaining[0][forwardMostMove] - ticklen;
9770                         if(!WhiteOnMove(forwardMostMove) && (gameMode == MachinePlaysBlack ||
9771                                                 gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b'))
9772                              blackTimeRemaining = timeRemaining[1][forwardMostMove] - ticklen;
9773                 }
9774
9775                 /* Buffer overflow protection */
9776                 if (pv[0] != NULLCHAR) {
9777                     if (strlen(pv) >= sizeof(tempStats.movelist)
9778                         && appData.debugMode) {
9779                         fprintf(debugFP,
9780                                 "PV is too long; using the first %u bytes.\n",
9781                                 (unsigned) sizeof(tempStats.movelist) - 1);
9782                     }
9783
9784                     safeStrCpy( tempStats.movelist, pv, sizeof(tempStats.movelist)/sizeof(tempStats.movelist[0]) );
9785                 } else {
9786                     sprintf(tempStats.movelist, " no PV\n");
9787                 }
9788
9789                 if (tempStats.seen_stat) {
9790                     tempStats.ok_to_send = 1;
9791                 }
9792
9793                 if (strchr(tempStats.movelist, '(') != NULL) {
9794                     tempStats.line_is_book = 1;
9795                     tempStats.nr_moves = 0;
9796                     tempStats.moves_left = 0;
9797                 } else {
9798                     tempStats.line_is_book = 0;
9799                 }
9800
9801                     if(tempStats.score != 0 || tempStats.nodes != 0 || tempStats.time != 0)
9802                         programStats = tempStats; // [HGM] info: only set stats if genuine PV and not an info line
9803
9804                 SendProgramStatsToFrontend( cps, &tempStats );
9805
9806                 /*
9807                     [AS] Protect the thinkOutput buffer from overflow... this
9808                     is only useful if buf1 hasn't overflowed first!
9809                 */
9810                 if((gameMode == AnalyzeMode && appData.whitePOV || appData.scoreWhite) && !WhiteOnMove(forwardMostMove)) curscore *= -1;
9811                 if(curscore >= MATE_SCORE)
9812                     snprintf(score_buf, MSG_SIZ, "#%d", curscore - MATE_SCORE);
9813                 else if(curscore <= -MATE_SCORE)
9814                     snprintf(score_buf, MSG_SIZ, "#%d", curscore + MATE_SCORE);
9815                 else
9816                     snprintf(score_buf, MSG_SIZ, "%+.2f", ((double) curscore) / 100.0);
9817                 snprintf(thinkOutput, sizeof(thinkOutput)/sizeof(thinkOutput[0]), "[%d]%c%s %s%s",
9818                          plylev,
9819                          (gameMode == TwoMachinesPlay ?
9820                           ToUpper(cps->twoMachinesColor[0]) : ' '),
9821                          score_buf,
9822                          prefixHint ? lastHint : "",
9823                          prefixHint ? " " : "" );
9824
9825                 if( buf1[0] != NULLCHAR ) {
9826                     unsigned max_len = sizeof(thinkOutput) - strlen(thinkOutput) - 1;
9827
9828                     if( strlen(pv) > max_len ) {
9829                         if( appData.debugMode) {
9830                             fprintf(debugFP,"PV is too long for thinkOutput, truncating.\n");
9831                         }
9832                         pv[max_len+1] = '\0';
9833                     }
9834
9835                     strcat( thinkOutput, pv);
9836                 }
9837
9838                 if (currentMove == forwardMostMove || gameMode == AnalyzeMode
9839                         || gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
9840                     DisplayMove(currentMove - 1);
9841                 }
9842                 return;
9843
9844             } else if ((p=StrStr(message, "(only move)")) != NULL) {
9845                 /* crafty (9.25+) says "(only move) <move>"
9846                  * if there is only 1 legal move
9847                  */
9848                 sscanf(p, "(only move) %s", buf1);
9849                 snprintf(thinkOutput, sizeof(thinkOutput)/sizeof(thinkOutput[0]), "%s (only move)", buf1);
9850                 sprintf(programStats.movelist, "%s (only move)", buf1);
9851                 programStats.depth = 1;
9852                 programStats.nr_moves = 1;
9853                 programStats.moves_left = 1;
9854                 programStats.nodes = 1;
9855                 programStats.time = 1;
9856                 programStats.got_only_move = 1;
9857
9858                 /* Not really, but we also use this member to
9859                    mean "line isn't going to change" (Crafty
9860                    isn't searching, so stats won't change) */
9861                 programStats.line_is_book = 1;
9862
9863                 SendProgramStatsToFrontend( cps, &programStats );
9864
9865                 if (currentMove == forwardMostMove || gameMode==AnalyzeMode ||
9866                            gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
9867                     DisplayMove(currentMove - 1);
9868                 }
9869                 return;
9870             } else if (sscanf(message,"stat01: %d " u64Display " %d %d %d %s",
9871                               &time, &nodes, &plylev, &mvleft,
9872                               &mvtot, mvname) >= 5) {
9873                 /* The stat01: line is from Crafty (9.29+) in response
9874                    to the "." command */
9875                 programStats.seen_stat = 1;
9876                 cps->maybeThinking = TRUE;
9877
9878                 if (programStats.got_only_move || !appData.periodicUpdates)
9879                   return;
9880
9881                 programStats.depth = plylev;
9882                 programStats.time = time;
9883                 programStats.nodes = nodes;
9884                 programStats.moves_left = mvleft;
9885                 programStats.nr_moves = mvtot;
9886                 safeStrCpy(programStats.move_name, mvname, sizeof(programStats.move_name)/sizeof(programStats.move_name[0]));
9887                 programStats.ok_to_send = 1;
9888                 programStats.movelist[0] = '\0';
9889
9890                 SendProgramStatsToFrontend( cps, &programStats );
9891
9892                 return;
9893
9894             } else if (strncmp(message,"++",2) == 0) {
9895                 /* Crafty 9.29+ outputs this */
9896                 programStats.got_fail = 2;
9897                 return;
9898
9899             } else if (strncmp(message,"--",2) == 0) {
9900                 /* Crafty 9.29+ outputs this */
9901                 programStats.got_fail = 1;
9902                 return;
9903
9904             } else if (thinkOutput[0] != NULLCHAR &&
9905                        strncmp(message, "    ", 4) == 0) {
9906                 unsigned message_len;
9907
9908                 p = message;
9909                 while (*p && *p == ' ') p++;
9910
9911                 message_len = strlen( p );
9912
9913                 /* [AS] Avoid buffer overflow */
9914                 if( sizeof(thinkOutput) - strlen(thinkOutput) - 1 > message_len ) {
9915                     strcat(thinkOutput, " ");
9916                     strcat(thinkOutput, p);
9917                 }
9918
9919                 if( sizeof(programStats.movelist) - strlen(programStats.movelist) - 1 > message_len ) {
9920                     strcat(programStats.movelist, " ");
9921                     strcat(programStats.movelist, p);
9922                 }
9923
9924                 if (currentMove == forwardMostMove || gameMode==AnalyzeMode ||
9925                            gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
9926                     DisplayMove(currentMove - 1);
9927                 }
9928                 return;
9929             }
9930         }
9931         else {
9932             buf1[0] = NULLCHAR;
9933
9934             if (sscanf(message, "%d%c %d %d " u64Display " %[^\n]\n",
9935                        &plylev, &plyext, &curscore, &time, &nodes, buf1) >= 5)
9936             {
9937                 ChessProgramStats cpstats;
9938
9939                 if (plyext != ' ' && plyext != '\t') {
9940                     time *= 100;
9941                 }
9942
9943                 /* [AS] Negate score if machine is playing black and reporting absolute scores */
9944                 if( cps->scoreIsAbsolute && ((gameMode == MachinePlaysBlack) || (gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b')) ) {
9945                     curscore = -curscore;
9946                 }
9947
9948                 cpstats.depth = plylev;
9949                 cpstats.nodes = nodes;
9950                 cpstats.time = time;
9951                 cpstats.score = curscore;
9952                 cpstats.got_only_move = 0;
9953                 cpstats.movelist[0] = '\0';
9954
9955                 if (buf1[0] != NULLCHAR) {
9956                     safeStrCpy( cpstats.movelist, buf1, sizeof(cpstats.movelist)/sizeof(cpstats.movelist[0]) );
9957                 }
9958
9959                 cpstats.ok_to_send = 0;
9960                 cpstats.line_is_book = 0;
9961                 cpstats.nr_moves = 0;
9962                 cpstats.moves_left = 0;
9963
9964                 SendProgramStatsToFrontend( cps, &cpstats );
9965             }
9966         }
9967     }
9968 }
9969
9970
9971 /* Parse a game score from the character string "game", and
9972    record it as the history of the current game.  The game
9973    score is NOT assumed to start from the standard position.
9974    The display is not updated in any way.
9975    */
9976 void
9977 ParseGameHistory (char *game)
9978 {
9979     ChessMove moveType;
9980     int fromX, fromY, toX, toY, boardIndex;
9981     char promoChar;
9982     char *p, *q;
9983     char buf[MSG_SIZ];
9984
9985     if (appData.debugMode)
9986       fprintf(debugFP, "Parsing game history: %s\n", game);
9987
9988     if (gameInfo.event == NULL) gameInfo.event = StrSave("ICS game");
9989     gameInfo.site = StrSave(appData.icsHost);
9990     gameInfo.date = PGNDate();
9991     gameInfo.round = StrSave("-");
9992
9993     /* Parse out names of players */
9994     while (*game == ' ') game++;
9995     p = buf;
9996     while (*game != ' ') *p++ = *game++;
9997     *p = NULLCHAR;
9998     gameInfo.white = StrSave(buf);
9999     while (*game == ' ') game++;
10000     p = buf;
10001     while (*game != ' ' && *game != '\n') *p++ = *game++;
10002     *p = NULLCHAR;
10003     gameInfo.black = StrSave(buf);
10004
10005     /* Parse moves */
10006     boardIndex = blackPlaysFirst ? 1 : 0;
10007     yynewstr(game);
10008     for (;;) {
10009         yyboardindex = boardIndex;
10010         moveType = (ChessMove) Myylex();
10011         switch (moveType) {
10012           case IllegalMove:             /* maybe suicide chess, etc. */
10013   if (appData.debugMode) {
10014     fprintf(debugFP, "Illegal move from ICS: '%s'\n", yy_text);
10015     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
10016     setbuf(debugFP, NULL);
10017   }
10018           case WhitePromotion:
10019           case BlackPromotion:
10020           case WhiteNonPromotion:
10021           case BlackNonPromotion:
10022           case NormalMove:
10023           case FirstLeg:
10024           case WhiteCapturesEnPassant:
10025           case BlackCapturesEnPassant:
10026           case WhiteKingSideCastle:
10027           case WhiteQueenSideCastle:
10028           case BlackKingSideCastle:
10029           case BlackQueenSideCastle:
10030           case WhiteKingSideCastleWild:
10031           case WhiteQueenSideCastleWild:
10032           case BlackKingSideCastleWild:
10033           case BlackQueenSideCastleWild:
10034           /* PUSH Fabien */
10035           case WhiteHSideCastleFR:
10036           case WhiteASideCastleFR:
10037           case BlackHSideCastleFR:
10038           case BlackASideCastleFR:
10039           /* POP Fabien */
10040             fromX = currentMoveString[0] - AAA;
10041             fromY = currentMoveString[1] - ONE;
10042             toX = currentMoveString[2] - AAA;
10043             toY = currentMoveString[3] - ONE;
10044             promoChar = currentMoveString[4];
10045             break;
10046           case WhiteDrop:
10047           case BlackDrop:
10048             if(currentMoveString[0] == '@') continue; // no null moves in ICS mode!
10049             fromX = moveType == WhiteDrop ?
10050               (int) CharToPiece(ToUpper(currentMoveString[0])) :
10051             (int) CharToPiece(ToLower(currentMoveString[0]));
10052             fromY = DROP_RANK;
10053             toX = currentMoveString[2] - AAA;
10054             toY = currentMoveString[3] - ONE;
10055             promoChar = NULLCHAR;
10056             break;
10057           case AmbiguousMove:
10058             /* bug? */
10059             snprintf(buf, MSG_SIZ, _("Ambiguous move in ICS output: \"%s\""), yy_text);
10060   if (appData.debugMode) {
10061     fprintf(debugFP, "Ambiguous move from ICS: '%s'\n", yy_text);
10062     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
10063     setbuf(debugFP, NULL);
10064   }
10065             DisplayError(buf, 0);
10066             return;
10067           case ImpossibleMove:
10068             /* bug? */
10069             snprintf(buf, MSG_SIZ, _("Illegal move in ICS output: \"%s\""), yy_text);
10070   if (appData.debugMode) {
10071     fprintf(debugFP, "Impossible move from ICS: '%s'\n", yy_text);
10072     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
10073     setbuf(debugFP, NULL);
10074   }
10075             DisplayError(buf, 0);
10076             return;
10077           case EndOfFile:
10078             if (boardIndex < backwardMostMove) {
10079                 /* Oops, gap.  How did that happen? */
10080                 DisplayError(_("Gap in move list"), 0);
10081                 return;
10082             }
10083             backwardMostMove =  blackPlaysFirst ? 1 : 0;
10084             if (boardIndex > forwardMostMove) {
10085                 forwardMostMove = boardIndex;
10086             }
10087             return;
10088           case ElapsedTime:
10089             if (boardIndex > (blackPlaysFirst ? 1 : 0)) {
10090                 strcat(parseList[boardIndex-1], " ");
10091                 strcat(parseList[boardIndex-1], yy_text);
10092             }
10093             continue;
10094           case Comment:
10095           case PGNTag:
10096           case NAG:
10097           default:
10098             /* ignore */
10099             continue;
10100           case WhiteWins:
10101           case BlackWins:
10102           case GameIsDrawn:
10103           case GameUnfinished:
10104             if (gameMode == IcsExamining) {
10105                 if (boardIndex < backwardMostMove) {
10106                     /* Oops, gap.  How did that happen? */
10107                     return;
10108                 }
10109                 backwardMostMove = blackPlaysFirst ? 1 : 0;
10110                 return;
10111             }
10112             gameInfo.result = moveType;
10113             p = strchr(yy_text, '{');
10114             if (p == NULL) p = strchr(yy_text, '(');
10115             if (p == NULL) {
10116                 p = yy_text;
10117                 if (p[0] == '0' || p[0] == '1' || p[0] == '*') p = "";
10118             } else {
10119                 q = strchr(p, *p == '{' ? '}' : ')');
10120                 if (q != NULL) *q = NULLCHAR;
10121                 p++;
10122             }
10123             while(q = strchr(p, '\n')) *q = ' '; // [HGM] crush linefeeds in result message
10124             gameInfo.resultDetails = StrSave(p);
10125             continue;
10126         }
10127         if (boardIndex >= forwardMostMove &&
10128             !(gameMode == IcsObserving && ics_gamenum == -1)) {
10129             backwardMostMove = blackPlaysFirst ? 1 : 0;
10130             return;
10131         }
10132         (void) CoordsToAlgebraic(boards[boardIndex], PosFlags(boardIndex),
10133                                  fromY, fromX, toY, toX, promoChar,
10134                                  parseList[boardIndex]);
10135         CopyBoard(boards[boardIndex + 1], boards[boardIndex]);
10136         /* currentMoveString is set as a side-effect of yylex */
10137         safeStrCpy(moveList[boardIndex], currentMoveString, sizeof(moveList[boardIndex])/sizeof(moveList[boardIndex][0]));
10138         strcat(moveList[boardIndex], "\n");
10139         boardIndex++;
10140         ApplyMove(fromX, fromY, toX, toY, promoChar, boards[boardIndex]);
10141         switch (MateTest(boards[boardIndex], PosFlags(boardIndex)) ) {
10142           case MT_NONE:
10143           case MT_STALEMATE:
10144           default:
10145             break;
10146           case MT_CHECK:
10147             if(!IS_SHOGI(gameInfo.variant))
10148                 strcat(parseList[boardIndex - 1], "+");
10149             break;
10150           case MT_CHECKMATE:
10151           case MT_STAINMATE:
10152             strcat(parseList[boardIndex - 1], "#");
10153             break;
10154         }
10155     }
10156 }
10157
10158
10159 /* Apply a move to the given board  */
10160 void
10161 ApplyMove (int fromX, int fromY, int toX, int toY, int promoChar, Board board)
10162 {
10163   ChessSquare captured = board[toY][toX], piece, pawn, king, killed, killed2; int p, rookX, oldEP, epRank, berolina = 0;
10164   int promoRank = gameInfo.variant == VariantMakruk || gameInfo.variant == VariantGrand || gameInfo.variant == VariantChuChess ? 3 : 1;
10165
10166     /* [HGM] compute & store e.p. status and castling rights for new position */
10167     /* we can always do that 'in place', now pointers to these rights are passed to ApplyMove */
10168
10169       if(gameInfo.variant == VariantBerolina) berolina = EP_BEROLIN_A;
10170       oldEP = (signed char)board[EP_FILE]; epRank = board[EP_RANK];
10171       board[EP_STATUS] = EP_NONE;
10172       board[EP_FILE] = board[EP_RANK] = 100;
10173
10174   if (fromY == DROP_RANK) {
10175         /* must be first */
10176         if(fromX == EmptySquare) { // [HGM] pass: empty drop encodes null move; nothing to change.
10177             board[EP_STATUS] = EP_CAPTURE; // null move considered irreversible
10178             return;
10179         }
10180         piece = board[toY][toX] = (ChessSquare) fromX;
10181   } else {
10182 //      ChessSquare victim;
10183       int i;
10184
10185       if( killX >= 0 && killY >= 0 ) { // [HGM] lion: Lion trampled over something
10186 //           victim = board[killY][killX],
10187            killed = board[killY][killX],
10188            board[killY][killX] = EmptySquare,
10189            board[EP_STATUS] = EP_CAPTURE;
10190            if( kill2X >= 0 && kill2Y >= 0)
10191              killed2 = board[kill2Y][kill2X], board[kill2Y][kill2X] = EmptySquare;
10192       }
10193
10194       if( board[toY][toX] != EmptySquare ) {
10195            board[EP_STATUS] = EP_CAPTURE;
10196            if( (fromX != toX || fromY != toY) && // not igui!
10197                (captured == WhiteLion && board[fromY][fromX] != BlackLion ||
10198                 captured == BlackLion && board[fromY][fromX] != WhiteLion   ) ) { // [HGM] lion: Chu Lion-capture rules
10199                board[EP_STATUS] = EP_IRON_LION; // non-Lion x Lion: no counter-strike allowed
10200            }
10201       }
10202
10203       pawn = board[fromY][fromX];
10204       if( pawn == WhiteLance || pawn == BlackLance ) {
10205            if( gameInfo.variant != VariantSuper && gameInfo.variant != VariantChu ) {
10206                if(gameInfo.variant == VariantSpartan) board[EP_STATUS] = EP_PAWN_MOVE; // in Spartan no e.p. rights must be set
10207                else pawn += WhitePawn - WhiteLance; // Lance is Pawn-like in most variants, so let Pawn code treat it by this kludge
10208            }
10209       }
10210       if( pawn == WhitePawn ) {
10211            if(fromY != toY) // [HGM] Xiangqi sideway Pawn moves should not count as 50-move breakers
10212                board[EP_STATUS] = EP_PAWN_MOVE;
10213            if( toY-fromY>=2) {
10214                board[EP_FILE] = (fromX + toX)/2; board[EP_RANK] = toY - 1 | 128*(toY - fromY > 2);
10215                if(toX>BOARD_LEFT   && board[toY][toX-1] == BlackPawn &&
10216                         gameInfo.variant != VariantBerolina || toX < fromX)
10217                       board[EP_STATUS] = toX | berolina;
10218                if(toX<BOARD_RGHT-1 && board[toY][toX+1] == BlackPawn &&
10219                         gameInfo.variant != VariantBerolina || toX > fromX)
10220                       board[EP_STATUS] = toX;
10221            }
10222       } else
10223       if( pawn == BlackPawn ) {
10224            if(fromY != toY) // [HGM] Xiangqi sideway Pawn moves should not count as 50-move breakers
10225                board[EP_STATUS] = EP_PAWN_MOVE;
10226            if( toY-fromY<= -2) {
10227                board[EP_FILE] = (fromX + toX)/2; board[EP_RANK] = toY + 1 | 128*(fromY - toY > 2);
10228                if(toX>BOARD_LEFT   && board[toY][toX-1] == WhitePawn &&
10229                         gameInfo.variant != VariantBerolina || toX < fromX)
10230                       board[EP_STATUS] = toX | berolina;
10231                if(toX<BOARD_RGHT-1 && board[toY][toX+1] == WhitePawn &&
10232                         gameInfo.variant != VariantBerolina || toX > fromX)
10233                       board[EP_STATUS] = toX;
10234            }
10235        }
10236
10237        if(fromY == 0) board[TOUCHED_W] |= 1<<fromX; else // new way to keep track of virginity
10238        if(fromY == BOARD_HEIGHT-1) board[TOUCHED_B] |= 1<<fromX;
10239        if(toY == 0) board[TOUCHED_W] |= 1<<toX; else
10240        if(toY == BOARD_HEIGHT-1) board[TOUCHED_B] |= 1<<toX;
10241
10242        for(i=0; i<nrCastlingRights; i++) {
10243            if(board[CASTLING][i] == fromX && castlingRank[i] == fromY ||
10244               board[CASTLING][i] == toX   && castlingRank[i] == toY
10245              ) board[CASTLING][i] = NoRights; // revoke for moved or captured piece
10246        }
10247
10248        if(gameInfo.variant == VariantSChess) { // update virginity
10249            if(fromY == 0)              board[VIRGIN][fromX] &= ~VIRGIN_W; // loss by moving
10250            if(fromY == BOARD_HEIGHT-1) board[VIRGIN][fromX] &= ~VIRGIN_B;
10251            if(toY == 0)                board[VIRGIN][toX]   &= ~VIRGIN_W; // loss by capture
10252            if(toY == BOARD_HEIGHT-1)   board[VIRGIN][toX]   &= ~VIRGIN_B;
10253        }
10254
10255      if (fromX == toX && fromY == toY && killX < 0) return;
10256
10257      piece = board[fromY][fromX]; /* [HGM] remember, for Shogi promotion */
10258      king = piece < (int) BlackPawn ? WhiteKing : BlackKing; /* [HGM] Knightmate simplify testing for castling */
10259      if(gameInfo.variant == VariantKnightmate)
10260          king += (int) WhiteUnicorn - (int) WhiteKing;
10261
10262     if(pieceDesc[piece] && killX >= 0 && strchr(pieceDesc[piece], 'O') // Betza castling-enabled
10263        && (piece < BlackPawn ? killed < BlackPawn : killed >= BlackPawn)) {    // and tramples own
10264         board[toY][toX] = piece; board[fromY][fromX] = EmptySquare;
10265         board[toY][toX + (killX < fromX ? 1 : -1)] = killed;
10266         board[EP_STATUS] = EP_NONE; // capture was fake!
10267     } else
10268     if(nrCastlingRights == 0 && board[toY][toX] < EmptySquare && (piece < BlackPawn) == (board[toY][toX] < BlackPawn)) {
10269         board[fromY][fromX] = board[toY][toX]; // capture own will lead to swapping
10270         board[toY][toX] = piece;
10271         board[EP_STATUS] = EP_NONE; // capture was fake!
10272     } else
10273     /* Code added by Tord: */
10274     /* FRC castling assumed when king captures friendly rook. [HGM] or RxK for S-Chess */
10275     if (board[fromY][fromX] == WhiteKing && board[toY][toX] == WhiteRook ||
10276         board[fromY][fromX] == WhiteRook && board[toY][toX] == WhiteKing) {
10277       board[EP_STATUS] = EP_NONE; // capture was fake!
10278       board[fromY][fromX] = EmptySquare;
10279       board[toY][toX] = EmptySquare;
10280       if((toX > fromX) != (piece == WhiteRook)) {
10281         board[0][BOARD_RGHT-2] = WhiteKing; board[0][BOARD_RGHT-3] = WhiteRook;
10282       } else {
10283         board[0][BOARD_LEFT+2] = WhiteKing; board[0][BOARD_LEFT+3] = WhiteRook;
10284       }
10285     } else if (board[fromY][fromX] == BlackKing && board[toY][toX] == BlackRook ||
10286                board[fromY][fromX] == BlackRook && board[toY][toX] == BlackKing) {
10287       board[EP_STATUS] = EP_NONE;
10288       board[fromY][fromX] = EmptySquare;
10289       board[toY][toX] = EmptySquare;
10290       if((toX > fromX) != (piece == BlackRook)) {
10291         board[BOARD_HEIGHT-1][BOARD_RGHT-2] = BlackKing; board[BOARD_HEIGHT-1][BOARD_RGHT-3] = BlackRook;
10292       } else {
10293         board[BOARD_HEIGHT-1][BOARD_LEFT+2] = BlackKing; board[BOARD_HEIGHT-1][BOARD_LEFT+3] = BlackRook;
10294       }
10295     /* End of code added by Tord */
10296
10297     } else if (pieceDesc[piece] && piece == king && !strchr(pieceDesc[piece], 'O') && strchr(pieceDesc[piece], 'i')) {
10298         board[fromY][fromX] = EmptySquare; // never castle if King has virgin moves defined on it other than castling
10299         board[toY][toX] = piece;
10300     } else if (board[fromY][fromX] == king
10301         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
10302         && toY == fromY && toX > fromX+1) {
10303         for(rookX=fromX+1; board[toY][rookX] == EmptySquare && rookX < BOARD_RGHT-1; rookX++); // castle with nearest piece
10304         board[fromY][toX-1] = board[fromY][rookX];
10305         board[fromY][rookX] = EmptySquare;
10306         board[fromY][fromX] = EmptySquare;
10307         board[toY][toX] = king;
10308     } else if (board[fromY][fromX] == king
10309         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
10310                && toY == fromY && toX < fromX-1) {
10311         for(rookX=fromX-1; board[toY][rookX] == EmptySquare && rookX > 0; rookX--); // castle with nearest piece
10312         board[fromY][toX+1] = board[fromY][rookX];
10313         board[fromY][rookX] = EmptySquare;
10314         board[fromY][fromX] = EmptySquare;
10315         board[toY][toX] = king;
10316     } else if ((board[fromY][fromX] == WhitePawn && gameInfo.variant != VariantXiangqi ||
10317                 board[fromY][fromX] == WhiteLance && gameInfo.variant != VariantSuper && gameInfo.variant != VariantChu)
10318                && toY >= BOARD_HEIGHT-promoRank && promoChar // defaulting to Q is done elsewhere
10319                ) {
10320         /* white pawn promotion */
10321         board[toY][toX] = CharToPiece(ToUpper(promoChar));
10322         if(board[toY][toX] < WhiteCannon && PieceToChar(PROMOTED(board[toY][toX])) == '~') /* [HGM] use shadow piece (if available) */
10323             board[toY][toX] = (ChessSquare) (PROMOTED(board[toY][toX]));
10324         board[fromY][fromX] = EmptySquare;
10325     } else if ((fromY >= BOARD_HEIGHT>>1)
10326                && (oldEP == toX || oldEP == EP_UNKNOWN || appData.testLegality || abs(toX - fromX) > 4)
10327                && (toX != fromX)
10328                && gameInfo.variant != VariantXiangqi
10329                && gameInfo.variant != VariantBerolina
10330                && (pawn == WhitePawn)
10331                && (board[toY][toX] == EmptySquare)) {
10332         board[fromY][fromX] = EmptySquare;
10333         board[toY][toX] = piece;
10334         if(toY == epRank - 128 + 1)
10335             captured = board[toY - 2][toX], board[toY - 2][toX] = EmptySquare;
10336         else
10337             captured = board[toY - 1][toX], board[toY - 1][toX] = EmptySquare;
10338     } else if ((fromY == BOARD_HEIGHT-4)
10339                && (toX == fromX)
10340                && gameInfo.variant == VariantBerolina
10341                && (board[fromY][fromX] == WhitePawn)
10342                && (board[toY][toX] == EmptySquare)) {
10343         board[fromY][fromX] = EmptySquare;
10344         board[toY][toX] = WhitePawn;
10345         if(oldEP & EP_BEROLIN_A) {
10346                 captured = board[fromY][fromX-1];
10347                 board[fromY][fromX-1] = EmptySquare;
10348         }else{  captured = board[fromY][fromX+1];
10349                 board[fromY][fromX+1] = EmptySquare;
10350         }
10351     } else if (board[fromY][fromX] == king
10352         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
10353                && toY == fromY && toX > fromX+1) {
10354         for(rookX=toX+1; board[toY][rookX] == EmptySquare && rookX < BOARD_RGHT - 1; rookX++);
10355         board[fromY][toX-1] = board[fromY][rookX];
10356         board[fromY][rookX] = EmptySquare;
10357         board[fromY][fromX] = EmptySquare;
10358         board[toY][toX] = king;
10359     } else if (board[fromY][fromX] == king
10360         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
10361                && toY == fromY && toX < fromX-1) {
10362         for(rookX=toX-1; board[toY][rookX] == EmptySquare && rookX > 0; rookX--);
10363         board[fromY][toX+1] = board[fromY][rookX];
10364         board[fromY][rookX] = EmptySquare;
10365         board[fromY][fromX] = EmptySquare;
10366         board[toY][toX] = king;
10367     } else if (fromY == 7 && fromX == 3
10368                && board[fromY][fromX] == BlackKing
10369                && toY == 7 && toX == 5) {
10370         board[fromY][fromX] = EmptySquare;
10371         board[toY][toX] = BlackKing;
10372         board[fromY][7] = EmptySquare;
10373         board[toY][4] = BlackRook;
10374     } else if (fromY == 7 && fromX == 3
10375                && board[fromY][fromX] == BlackKing
10376                && toY == 7 && toX == 1) {
10377         board[fromY][fromX] = EmptySquare;
10378         board[toY][toX] = BlackKing;
10379         board[fromY][0] = EmptySquare;
10380         board[toY][2] = BlackRook;
10381     } else if ((board[fromY][fromX] == BlackPawn && gameInfo.variant != VariantXiangqi ||
10382                 board[fromY][fromX] == BlackLance && gameInfo.variant != VariantSuper && gameInfo.variant != VariantChu)
10383                && toY < promoRank && promoChar
10384                ) {
10385         /* black pawn promotion */
10386         board[toY][toX] = CharToPiece(ToLower(promoChar));
10387         if(board[toY][toX] < BlackCannon && PieceToChar(PROMOTED(board[toY][toX])) == '~') /* [HGM] use shadow piece (if available) */
10388             board[toY][toX] = (ChessSquare) (PROMOTED(board[toY][toX]));
10389         board[fromY][fromX] = EmptySquare;
10390     } else if ((fromY < BOARD_HEIGHT>>1)
10391                && (oldEP == toX || oldEP == EP_UNKNOWN || appData.testLegality || abs(toX - fromX) > 4)
10392                && (toX != fromX)
10393                && gameInfo.variant != VariantXiangqi
10394                && gameInfo.variant != VariantBerolina
10395                && (pawn == BlackPawn)
10396                && (board[toY][toX] == EmptySquare)) {
10397         board[fromY][fromX] = EmptySquare;
10398         board[toY][toX] = piece;
10399         if(toY == epRank - 128 - 1)
10400             captured = board[toY + 2][toX], board[toY + 2][toX] = EmptySquare;
10401         else
10402             captured = board[toY + 1][toX], board[toY + 1][toX] = EmptySquare;
10403     } else if ((fromY == 3)
10404                && (toX == fromX)
10405                && gameInfo.variant == VariantBerolina
10406                && (board[fromY][fromX] == BlackPawn)
10407                && (board[toY][toX] == EmptySquare)) {
10408         board[fromY][fromX] = EmptySquare;
10409         board[toY][toX] = BlackPawn;
10410         if(oldEP & EP_BEROLIN_A) {
10411                 captured = board[fromY][fromX-1];
10412                 board[fromY][fromX-1] = EmptySquare;
10413         }else{  captured = board[fromY][fromX+1];
10414                 board[fromY][fromX+1] = EmptySquare;
10415         }
10416     } else {
10417         ChessSquare piece = board[fromY][fromX]; // [HGM] lion: allow for igui (where from == to)
10418         board[fromY][fromX] = EmptySquare;
10419         board[toY][toX] = piece;
10420     }
10421   }
10422
10423     if (gameInfo.holdingsWidth != 0) {
10424
10425       /* !!A lot more code needs to be written to support holdings  */
10426       /* [HGM] OK, so I have written it. Holdings are stored in the */
10427       /* penultimate board files, so they are automaticlly stored   */
10428       /* in the game history.                                       */
10429       if (fromY == DROP_RANK || gameInfo.variant == VariantSChess
10430                                 && promoChar && piece != WhitePawn && piece != BlackPawn) {
10431         /* Delete from holdings, by decreasing count */
10432         /* and erasing image if necessary            */
10433         p = fromY == DROP_RANK ? (int) fromX : CharToPiece(piece > BlackPawn ? ToLower(promoChar) : ToUpper(promoChar));
10434         if(p < (int) BlackPawn) { /* white drop */
10435              p -= (int)WhitePawn;
10436                  p = PieceToNumber((ChessSquare)p);
10437              if(p >= gameInfo.holdingsSize) p = 0;
10438              if(--board[p][BOARD_WIDTH-2] <= 0)
10439                   board[p][BOARD_WIDTH-1] = EmptySquare;
10440              if((int)board[p][BOARD_WIDTH-2] < 0)
10441                         board[p][BOARD_WIDTH-2] = 0;
10442         } else {                  /* black drop */
10443              p -= (int)BlackPawn;
10444                  p = PieceToNumber((ChessSquare)p);
10445              if(p >= gameInfo.holdingsSize) p = 0;
10446              if(--board[BOARD_HEIGHT-1-p][1] <= 0)
10447                   board[BOARD_HEIGHT-1-p][0] = EmptySquare;
10448              if((int)board[BOARD_HEIGHT-1-p][1] < 0)
10449                         board[BOARD_HEIGHT-1-p][1] = 0;
10450         }
10451       }
10452       if (captured != EmptySquare && gameInfo.holdingsSize > 0
10453           && gameInfo.variant != VariantBughouse && gameInfo.variant != VariantSChess        ) {
10454         /* [HGM] holdings: Add to holdings, if holdings exist */
10455         if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat || gameInfo.variant == VariantGrand) {
10456                 // [HGM] superchess: suppress flipping color of captured pieces by reverse pre-flip
10457                 captured = (int) captured >= (int) BlackPawn ? BLACK_TO_WHITE captured : WHITE_TO_BLACK captured;
10458         }
10459         p = (int) captured;
10460         if (p >= (int) BlackPawn) {
10461           p -= (int)BlackPawn;
10462           if(DEMOTED(p) >= 0 && PieceToChar(p) == '+') {
10463                   /* Restore shogi-promoted piece to its original  first */
10464                   captured = (ChessSquare) (DEMOTED(captured));
10465                   p = DEMOTED(p);
10466           }
10467           p = PieceToNumber((ChessSquare)p);
10468           if(p >= gameInfo.holdingsSize) { p = 0; captured = BlackPawn; }
10469           board[p][BOARD_WIDTH-2]++;
10470           board[p][BOARD_WIDTH-1] = BLACK_TO_WHITE captured;
10471         } else {
10472           p -= (int)WhitePawn;
10473           if(DEMOTED(p) >= 0 && PieceToChar(p) == '+') {
10474                   captured = (ChessSquare) (DEMOTED(captured));
10475                   p = DEMOTED(p);
10476           }
10477           p = PieceToNumber((ChessSquare)p);
10478           if(p >= gameInfo.holdingsSize) { p = 0; captured = WhitePawn; }
10479           board[BOARD_HEIGHT-1-p][1]++;
10480           board[BOARD_HEIGHT-1-p][0] = WHITE_TO_BLACK captured;
10481         }
10482       }
10483     } else if (gameInfo.variant == VariantAtomic) {
10484       if (captured != EmptySquare) {
10485         int y, x;
10486         for (y = toY-1; y <= toY+1; y++) {
10487           for (x = toX-1; x <= toX+1; x++) {
10488             if (y >= 0 && y < BOARD_HEIGHT && x >= BOARD_LEFT && x < BOARD_RGHT &&
10489                 board[y][x] != WhitePawn && board[y][x] != BlackPawn) {
10490               board[y][x] = EmptySquare;
10491             }
10492           }
10493         }
10494         board[toY][toX] = EmptySquare;
10495       }
10496     }
10497
10498     if(gameInfo.variant == VariantSChess && promoChar != NULLCHAR && promoChar != '=' && piece != WhitePawn && piece != BlackPawn) {
10499         board[fromY][fromX] = CharToPiece(piece < BlackPawn ? ToUpper(promoChar) : ToLower(promoChar)); // S-Chess gating
10500     } else
10501     if(promoChar == '+') {
10502         /* [HGM] Shogi-style promotions, to piece implied by original (Might overwrite ordinary Pawn promotion) */
10503         board[toY][toX] = (ChessSquare) (CHUPROMOTED(piece));
10504         if(gameInfo.variant == VariantChuChess && (piece == WhiteKnight || piece == BlackKnight))
10505           board[toY][toX] = piece + WhiteLion - WhiteKnight; // adjust Knight promotions to Lion
10506     } else if(!appData.testLegality && promoChar != NULLCHAR && promoChar != '=') { // without legality testing, unconditionally believe promoChar
10507         ChessSquare newPiece = CharToPiece(piece < BlackPawn ? ToUpper(promoChar) : ToLower(promoChar));
10508         if((newPiece <= WhiteMan || newPiece >= BlackPawn && newPiece <= BlackMan)  // unpromoted piece specified
10509            && pieceToChar[PROMOTED(newPiece)] == '~') newPiece = PROMOTED(newPiece);// but promoted version available
10510         board[toY][toX] = newPiece;
10511     }
10512     if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat || gameInfo.variant == VariantGrand)
10513                 && promoChar != NULLCHAR && gameInfo.holdingsSize) {
10514         // [HGM] superchess: take promotion piece out of holdings
10515         int k = PieceToNumber(CharToPiece(ToUpper(promoChar)));
10516         if((int)piece < (int)BlackPawn) { // determine stm from piece color
10517             if(!--board[k][BOARD_WIDTH-2])
10518                 board[k][BOARD_WIDTH-1] = EmptySquare;
10519         } else {
10520             if(!--board[BOARD_HEIGHT-1-k][1])
10521                 board[BOARD_HEIGHT-1-k][0] = EmptySquare;
10522         }
10523     }
10524 }
10525
10526 /* Updates forwardMostMove */
10527 void
10528 MakeMove (int fromX, int fromY, int toX, int toY, int promoChar)
10529 {
10530     int x = toX, y = toY;
10531     char *s = parseList[forwardMostMove];
10532     ChessSquare p = boards[forwardMostMove][toY][toX];
10533 //    forwardMostMove++; // [HGM] bare: moved downstream
10534
10535     if(kill2X >= 0) x = kill2X, y = kill2Y; else
10536     if(killX >= 0 && killY >= 0) x = killX, y = killY; // [HGM] lion: make SAN move to intermediate square, if there is one
10537     (void) CoordsToAlgebraic(boards[forwardMostMove],
10538                              PosFlags(forwardMostMove),
10539                              fromY, fromX, y, x, (killX < 0)*promoChar,
10540                              s);
10541     if(kill2X >= 0 && kill2Y >= 0)
10542         sprintf(s + strlen(s), "x%c%d", killX + AAA, killY + ONE - '0'); // 2nd leg of 3-leg move is always capture
10543     if(killX >= 0 && killY >= 0)
10544         sprintf(s + strlen(s), "%c%c%d%c", p == EmptySquare || toX == fromX && toY == fromY || toX== kill2X && toY == kill2Y ? '-' : 'x',
10545                                            toX + AAA, toY + ONE - '0', promoChar);
10546
10547     if(serverMoves != NULL) { /* [HGM] write moves on file for broadcasting (should be separate routine, really) */
10548         int timeLeft; static int lastLoadFlag=0; int king, piece;
10549         piece = boards[forwardMostMove][fromY][fromX];
10550         king = piece < (int) BlackPawn ? WhiteKing : BlackKing;
10551         if(gameInfo.variant == VariantKnightmate)
10552             king += (int) WhiteUnicorn - (int) WhiteKing;
10553         if(forwardMostMove == 0) {
10554             if(gameMode == MachinePlaysBlack || gameMode == BeginningOfGame)
10555                 fprintf(serverMoves, "%s;", UserName());
10556             else if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b')
10557                 fprintf(serverMoves, "%s;", second.tidy);
10558             fprintf(serverMoves, "%s;", first.tidy);
10559             if(gameMode == MachinePlaysWhite)
10560                 fprintf(serverMoves, "%s;", UserName());
10561             else if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'w')
10562                 fprintf(serverMoves, "%s;", second.tidy);
10563         } else fprintf(serverMoves, loadFlag|lastLoadFlag ? ":" : ";");
10564         lastLoadFlag = loadFlag;
10565         // print base move
10566         fprintf(serverMoves, "%c%c:%c%c", AAA+fromX, ONE+fromY, AAA+toX, ONE+toY);
10567         // print castling suffix
10568         if( toY == fromY && piece == king ) {
10569             if(toX-fromX > 1)
10570                 fprintf(serverMoves, ":%c%c:%c%c", AAA+BOARD_RGHT-1, ONE+fromY, AAA+toX-1,ONE+toY);
10571             if(fromX-toX >1)
10572                 fprintf(serverMoves, ":%c%c:%c%c", AAA+BOARD_LEFT, ONE+fromY, AAA+toX+1,ONE+toY);
10573         }
10574         // e.p. suffix
10575         if( (boards[forwardMostMove][fromY][fromX] == WhitePawn ||
10576              boards[forwardMostMove][fromY][fromX] == BlackPawn   ) &&
10577              boards[forwardMostMove][toY][toX] == EmptySquare
10578              && fromX != toX && fromY != toY)
10579                 fprintf(serverMoves, ":%c%c:%c%c", AAA+fromX, ONE+fromY, AAA+toX, ONE+fromY);
10580         // promotion suffix
10581         if(promoChar != NULLCHAR) {
10582             if(fromY == 0 || fromY == BOARD_HEIGHT-1)
10583                  fprintf(serverMoves, ":%c%c:%c%c", WhiteOnMove(forwardMostMove) ? 'w' : 'b',
10584                                                  ToLower(promoChar), AAA+fromX, ONE+fromY); // Seirawan gating
10585             else fprintf(serverMoves, ":%c:%c%c", ToLower(promoChar), AAA+toX, ONE+toY);
10586         }
10587         if(!loadFlag) {
10588                 char buf[MOVE_LEN*2], *p; int len;
10589             fprintf(serverMoves, "/%d/%d",
10590                pvInfoList[forwardMostMove].depth, pvInfoList[forwardMostMove].score);
10591             if(forwardMostMove+1 & 1) timeLeft = whiteTimeRemaining/1000;
10592             else                      timeLeft = blackTimeRemaining/1000;
10593             fprintf(serverMoves, "/%d", timeLeft);
10594                 strncpy(buf, parseList[forwardMostMove], MOVE_LEN*2);
10595                 if(p = strchr(buf, '/')) *p = NULLCHAR; else
10596                 if(p = strchr(buf, '=')) *p = NULLCHAR;
10597                 len = strlen(buf); if(len > 1 && buf[len-2] != '-') buf[len-2] = NULLCHAR; // strip to-square
10598             fprintf(serverMoves, "/%s", buf);
10599         }
10600         fflush(serverMoves);
10601     }
10602
10603     if (forwardMostMove+1 > framePtr) { // [HGM] vari: do not run into saved variations..
10604         GameEnds(GameUnfinished, _("Game too long; increase MAX_MOVES and recompile"), GE_XBOARD);
10605       return;
10606     }
10607     UnLoadPV(); // [HGM] pv: if we are looking at a PV, abort this
10608     if (commentList[forwardMostMove+1] != NULL) {
10609         free(commentList[forwardMostMove+1]);
10610         commentList[forwardMostMove+1] = NULL;
10611     }
10612     CopyBoard(boards[forwardMostMove+1], boards[forwardMostMove]);
10613     ApplyMove(fromX, fromY, toX, toY, promoChar, boards[forwardMostMove+1]);
10614     // forwardMostMove++; // [HGM] bare: moved to after ApplyMove, to make sure clock interrupt finds complete board
10615     SwitchClocks(forwardMostMove+1); // [HGM] race: incrementing move nr inside
10616     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
10617     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
10618     adjustedClock = FALSE;
10619     gameInfo.result = GameUnfinished;
10620     if (gameInfo.resultDetails != NULL) {
10621         free(gameInfo.resultDetails);
10622         gameInfo.resultDetails = NULL;
10623     }
10624     CoordsToComputerAlgebraic(fromY, fromX, toY, toX, promoChar,
10625                               moveList[forwardMostMove - 1]);
10626     switch (MateTest(boards[forwardMostMove], PosFlags(forwardMostMove)) ) {
10627       case MT_NONE:
10628       case MT_STALEMATE:
10629       default:
10630         break;
10631       case MT_CHECK:
10632         if(!IS_SHOGI(gameInfo.variant))
10633             strcat(parseList[forwardMostMove - 1], "+");
10634         break;
10635       case MT_CHECKMATE:
10636       case MT_STAINMATE:
10637         strcat(parseList[forwardMostMove - 1], "#");
10638         break;
10639     }
10640 }
10641
10642 /* Updates currentMove if not pausing */
10643 void
10644 ShowMove (int fromX, int fromY, int toX, int toY)
10645 {
10646     int instant = (gameMode == PlayFromGameFile) ?
10647         (matchMode || (appData.timeDelay == 0 && !pausing)) : pausing;
10648     if(appData.noGUI) return;
10649     if (!pausing || gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
10650         if (!instant) {
10651             if (forwardMostMove == currentMove + 1) {
10652                 AnimateMove(boards[forwardMostMove - 1],
10653                             fromX, fromY, toX, toY);
10654             }
10655         }
10656         currentMove = forwardMostMove;
10657     }
10658
10659     killX = killY = kill2X = kill2Y = -1; // [HGM] lion: used up
10660
10661     if (instant) return;
10662
10663     DisplayMove(currentMove - 1);
10664     if (!pausing || gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
10665             if (appData.highlightLastMove) { // [HGM] moved to after DrawPosition, as with arrow it could redraw old board
10666                 SetHighlights(fromX, fromY, toX, toY);
10667             }
10668     }
10669     DrawPosition(FALSE, boards[currentMove]);
10670     DisplayBothClocks();
10671     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
10672 }
10673
10674 void
10675 SendEgtPath (ChessProgramState *cps)
10676 {       /* [HGM] EGT: match formats given in feature with those given by user, and send info for each match */
10677         char buf[MSG_SIZ], name[MSG_SIZ], *p;
10678
10679         if((p = cps->egtFormats) == NULL || appData.egtFormats == NULL) return;
10680
10681         while(*p) {
10682             char c, *q = name+1, *r, *s;
10683
10684             name[0] = ','; // extract next format name from feature and copy with prefixed ','
10685             while(*p && *p != ',') *q++ = *p++;
10686             *q++ = ':'; *q = 0;
10687             if( appData.defaultPathEGTB && appData.defaultPathEGTB[0] &&
10688                 strcmp(name, ",nalimov:") == 0 ) {
10689                 // take nalimov path from the menu-changeable option first, if it is defined
10690               snprintf(buf, MSG_SIZ, "egtpath nalimov %s\n", appData.defaultPathEGTB);
10691                 SendToProgram(buf,cps);     // send egtbpath command for nalimov
10692             } else
10693             if( (s = StrStr(appData.egtFormats, name+1)) == appData.egtFormats ||
10694                 (s = StrStr(appData.egtFormats, name)) != NULL) {
10695                 // format name occurs amongst user-supplied formats, at beginning or immediately after comma
10696                 s = r = StrStr(s, ":") + 1; // beginning of path info
10697                 while(*r && *r != ',') r++; // path info is everything upto next ';' or end of string
10698                 c = *r; *r = 0;             // temporarily null-terminate path info
10699                     *--q = 0;               // strip of trailig ':' from name
10700                     snprintf(buf, MSG_SIZ, "egtpath %s %s\n", name+1, s);
10701                 *r = c;
10702                 SendToProgram(buf,cps);     // send egtbpath command for this format
10703             }
10704             if(*p == ',') p++; // read away comma to position for next format name
10705         }
10706 }
10707
10708 static int
10709 NonStandardBoardSize (VariantClass v, int boardWidth, int boardHeight, int holdingsSize)
10710 {
10711       int width = 8, height = 8, holdings = 0;             // most common sizes
10712       if( v == VariantUnknown || *engineVariant) return 0; // engine-defined name never needs prefix
10713       // correct the deviations default for each variant
10714       if( v == VariantXiangqi ) width = 9,  height = 10;
10715       if( v == VariantShogi )   width = 9,  height = 9,  holdings = 7;
10716       if( v == VariantBughouse || v == VariantCrazyhouse) holdings = 5;
10717       if( v == VariantCapablanca || v == VariantCapaRandom ||
10718           v == VariantGothic || v == VariantFalcon || v == VariantJanus )
10719                                 width = 10;
10720       if( v == VariantCourier ) width = 12;
10721       if( v == VariantSuper )                            holdings = 8;
10722       if( v == VariantGreat )   width = 10,              holdings = 8;
10723       if( v == VariantSChess )                           holdings = 7;
10724       if( v == VariantGrand )   width = 10, height = 10, holdings = 7;
10725       if( v == VariantChuChess) width = 10, height = 10;
10726       if( v == VariantChu )     width = 12, height = 12;
10727       return boardWidth >= 0   && boardWidth   != width  || // -1 is default,
10728              boardHeight >= 0  && boardHeight  != height || // and thus by definition OK
10729              holdingsSize >= 0 && holdingsSize != holdings;
10730 }
10731
10732 char variantError[MSG_SIZ];
10733
10734 char *
10735 SupportedVariant (char *list, VariantClass v, int boardWidth, int boardHeight, int holdingsSize, int proto, char *engine)
10736 {     // returns error message (recognizable by upper-case) if engine does not support the variant
10737       char *p, *variant = VariantName(v);
10738       static char b[MSG_SIZ];
10739       if(NonStandardBoardSize(v, boardWidth, boardHeight, holdingsSize)) { /* [HGM] make prefix for non-standard board size. */
10740            snprintf(b, MSG_SIZ, "%dx%d+%d_%s", boardWidth, boardHeight,
10741                                                holdingsSize, variant); // cook up sized variant name
10742            /* [HGM] varsize: try first if this deviant size variant is specifically known */
10743            if(StrStr(list, b) == NULL) {
10744                // specific sized variant not known, check if general sizing allowed
10745                if(proto != 1 && StrStr(list, "boardsize") == NULL) {
10746                    snprintf(variantError, MSG_SIZ, "Board size %dx%d+%d not supported by %s",
10747                             boardWidth, boardHeight, holdingsSize, engine);
10748                    return NULL;
10749                }
10750                /* [HGM] here we really should compare with the maximum supported board size */
10751            }
10752       } else snprintf(b, MSG_SIZ,"%s", variant);
10753       if(proto == 1) return b; // for protocol 1 we cannot check and hope for the best
10754       p = StrStr(list, b);
10755       while(p && (p != list && p[-1] != ',' || p[strlen(b)] && p[strlen(b)] != ',') ) p = StrStr(p+1, b);
10756       if(p == NULL) {
10757           // occurs not at all in list, or only as sub-string
10758           snprintf(variantError, MSG_SIZ, _("Variant %s not supported by %s"), b, engine);
10759           if(p = StrStr(list, b)) { // handle requesting parent variant when only size-overridden is supported
10760               int l = strlen(variantError);
10761               char *q;
10762               while(p != list && p[-1] != ',') p--;
10763               q = strchr(p, ',');
10764               if(q) *q = NULLCHAR;
10765               snprintf(variantError + l, MSG_SIZ - l,  _(", but %s is"), p);
10766               if(q) *q= ',';
10767           }
10768           return NULL;
10769       }
10770       return b;
10771 }
10772
10773 void
10774 InitChessProgram (ChessProgramState *cps, int setup)
10775 /* setup needed to setup FRC opening position */
10776 {
10777     char buf[MSG_SIZ], *b;
10778     if (appData.noChessProgram) return;
10779     hintRequested = FALSE;
10780     bookRequested = FALSE;
10781
10782     ParseFeatures(appData.features[cps == &second], cps); // [HGM] allow user to overrule features
10783     /* [HGM] some new WB protocol commands to configure engine are sent now, if engine supports them */
10784     /*       moved to before sending initstring in 4.3.15, so Polyglot can delay UCI 'isready' to recepton of 'new' */
10785     if(cps->memSize) { /* [HGM] memory */
10786       snprintf(buf, MSG_SIZ, "memory %d\n", appData.defaultHashSize + appData.defaultCacheSizeEGTB);
10787         SendToProgram(buf, cps);
10788     }
10789     SendEgtPath(cps); /* [HGM] EGT */
10790     if(cps->maxCores) { /* [HGM] SMP: (protocol specified must be last settings command before new!) */
10791       snprintf(buf, MSG_SIZ, "cores %d\n", appData.smpCores);
10792         SendToProgram(buf, cps);
10793     }
10794
10795     setboardSpoiledMachineBlack = FALSE;
10796     SendToProgram(cps->initString, cps);
10797     if (gameInfo.variant != VariantNormal &&
10798         gameInfo.variant != VariantLoadable
10799         /* [HGM] also send variant if board size non-standard */
10800         || gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0) {
10801
10802       b = SupportedVariant(cps->variants, gameInfo.variant, gameInfo.boardWidth,
10803                            gameInfo.boardHeight, gameInfo.holdingsSize, cps->protocolVersion, cps->tidy);
10804
10805       if (b == NULL) {
10806         VariantClass v;
10807         char c, *q = cps->variants, *p = strchr(q, ',');
10808         if(p) *p = NULLCHAR;
10809         v = StringToVariant(q);
10810         DisplayError(variantError, 0);
10811         if(v != VariantUnknown && cps == &first) {
10812             int w, h, s;
10813             if(sscanf(q, "%dx%d+%d_%c", &w, &h, &s, &c) == 4) // get size overrides the engine needs with it (if any)
10814                 appData.NrFiles = w, appData.NrRanks = h, appData.holdingsSize = s, q = strchr(q, '_') + 1;
10815             ASSIGN(appData.variant, q);
10816             Reset(TRUE, FALSE);
10817         }
10818         if(p) *p = ',';
10819         return;
10820       }
10821
10822       snprintf(buf, MSG_SIZ, "variant %s\n", b);
10823       SendToProgram(buf, cps);
10824     }
10825     currentlyInitializedVariant = gameInfo.variant;
10826
10827     /* [HGM] send opening position in FRC to first engine */
10828     if(setup) {
10829           SendToProgram("force\n", cps);
10830           SendBoard(cps, 0);
10831           /* engine is now in force mode! Set flag to wake it up after first move. */
10832           setboardSpoiledMachineBlack = 1;
10833     }
10834
10835     if (cps->sendICS) {
10836       snprintf(buf, sizeof(buf), "ics %s\n", appData.icsActive ? appData.icsHost : "-");
10837       SendToProgram(buf, cps);
10838     }
10839     cps->maybeThinking = FALSE;
10840     cps->offeredDraw = 0;
10841     if (!appData.icsActive) {
10842         SendTimeControl(cps, movesPerSession, timeControl,
10843                         timeIncrement, appData.searchDepth,
10844                         searchTime);
10845     }
10846     if (appData.showThinking
10847         // [HGM] thinking: four options require thinking output to be sent
10848         || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp()
10849                                 ) {
10850         SendToProgram("post\n", cps);
10851     }
10852     SendToProgram("hard\n", cps);
10853     if (!appData.ponderNextMove) {
10854         /* Warning: "easy" is a toggle in GNU Chess, so don't send
10855            it without being sure what state we are in first.  "hard"
10856            is not a toggle, so that one is OK.
10857          */
10858         SendToProgram("easy\n", cps);
10859     }
10860     if (cps->usePing) {
10861       snprintf(buf, MSG_SIZ, "ping %d\n", initPing = ++cps->lastPing);
10862       SendToProgram(buf, cps);
10863     }
10864     cps->initDone = TRUE;
10865     ClearEngineOutputPane(cps == &second);
10866 }
10867
10868
10869 void
10870 ResendOptions (ChessProgramState *cps)
10871 { // send the stored value of the options
10872   int i;
10873   char buf[MSG_SIZ];
10874   Option *opt = cps->option;
10875   for(i=0; i<cps->nrOptions; i++, opt++) {
10876       switch(opt->type) {
10877         case Spin:
10878         case Slider:
10879         case CheckBox:
10880             snprintf(buf, MSG_SIZ, "option %s=%d\n", opt->name, opt->value);
10881           break;
10882         case ComboBox:
10883           snprintf(buf, MSG_SIZ, "option %s=%s\n", opt->name, opt->choice[opt->value]);
10884           break;
10885         default:
10886             snprintf(buf, MSG_SIZ, "option %s=%s\n", opt->name, opt->textValue);
10887           break;
10888         case Button:
10889         case SaveButton:
10890           continue;
10891       }
10892       SendToProgram(buf, cps);
10893   }
10894 }
10895
10896 void
10897 StartChessProgram (ChessProgramState *cps)
10898 {
10899     char buf[MSG_SIZ];
10900     int err;
10901
10902     if (appData.noChessProgram) return;
10903     cps->initDone = FALSE;
10904
10905     if (strcmp(cps->host, "localhost") == 0) {
10906         err = StartChildProcess(cps->program, cps->dir, &cps->pr);
10907     } else if (*appData.remoteShell == NULLCHAR) {
10908         err = OpenRcmd(cps->host, appData.remoteUser, cps->program, &cps->pr);
10909     } else {
10910         if (*appData.remoteUser == NULLCHAR) {
10911           snprintf(buf, sizeof(buf), "%s %s %s", appData.remoteShell, cps->host,
10912                     cps->program);
10913         } else {
10914           snprintf(buf, sizeof(buf), "%s %s -l %s %s", appData.remoteShell,
10915                     cps->host, appData.remoteUser, cps->program);
10916         }
10917         err = StartChildProcess(buf, "", &cps->pr);
10918     }
10919
10920     if (err != 0) {
10921       snprintf(buf, MSG_SIZ, _("Startup failure on '%s'"), cps->program);
10922         DisplayError(buf, err); // [HGM] bit of a rough kludge: ignore failure, (which XBoard would do anyway), and let I/O discover it
10923         if(cps != &first) return;
10924         appData.noChessProgram = TRUE;
10925         ThawUI();
10926         SetNCPMode();
10927 //      DisplayFatalError(buf, err, 1);
10928 //      cps->pr = NoProc;
10929 //      cps->isr = NULL;
10930         return;
10931     }
10932
10933     cps->isr = AddInputSource(cps->pr, TRUE, ReceiveFromProgram, cps);
10934     if (cps->protocolVersion > 1) {
10935       snprintf(buf, MSG_SIZ, "xboard\nprotover %d\n", cps->protocolVersion);
10936       if(!cps->reload) { // do not clear options when reloading because of -xreuse
10937         cps->nrOptions = 0; // [HGM] options: clear all engine-specific options
10938         cps->comboCnt = 0;  //                and values of combo boxes
10939       }
10940       SendToProgram(buf, cps);
10941       if(cps->reload) ResendOptions(cps);
10942     } else {
10943       SendToProgram("xboard\n", cps);
10944     }
10945 }
10946
10947 void
10948 TwoMachinesEventIfReady P((void))
10949 {
10950   static int curMess = 0;
10951   if (first.lastPing != first.lastPong) {
10952     if(curMess != 1) DisplayMessage("", _("Waiting for first chess program")); curMess = 1;
10953     ScheduleDelayedEvent(TwoMachinesEventIfReady, 10); // [HGM] fast: lowered from 1000
10954     return;
10955   }
10956   if (second.lastPing != second.lastPong) {
10957     if(curMess != 2) DisplayMessage("", _("Waiting for second chess program")); curMess = 2;
10958     ScheduleDelayedEvent(TwoMachinesEventIfReady, 10); // [HGM] fast: lowered from 1000
10959     return;
10960   }
10961   DisplayMessage("", ""); curMess = 0;
10962   TwoMachinesEvent();
10963 }
10964
10965 char *
10966 MakeName (char *template)
10967 {
10968     time_t clock;
10969     struct tm *tm;
10970     static char buf[MSG_SIZ];
10971     char *p = buf;
10972     int i;
10973
10974     clock = time((time_t *)NULL);
10975     tm = localtime(&clock);
10976
10977     while(*p++ = *template++) if(p[-1] == '%') {
10978         switch(*template++) {
10979           case 0:   *p = 0; return buf;
10980           case 'Y': i = tm->tm_year+1900; break;
10981           case 'y': i = tm->tm_year-100; break;
10982           case 'M': i = tm->tm_mon+1; break;
10983           case 'd': i = tm->tm_mday; break;
10984           case 'h': i = tm->tm_hour; break;
10985           case 'm': i = tm->tm_min; break;
10986           case 's': i = tm->tm_sec; break;
10987           default:  i = 0;
10988         }
10989         snprintf(p-1, MSG_SIZ-10 - (p - buf), "%02d", i); p += strlen(p);
10990     }
10991     return buf;
10992 }
10993
10994 int
10995 CountPlayers (char *p)
10996 {
10997     int n = 0;
10998     while(p = strchr(p, '\n')) p++, n++; // count participants
10999     return n;
11000 }
11001
11002 FILE *
11003 WriteTourneyFile (char *results, FILE *f)
11004 {   // write tournament parameters on tourneyFile; on success return the stream pointer for closing
11005     if(f == NULL) f = fopen(appData.tourneyFile, "w");
11006     if(f == NULL) DisplayError(_("Could not write on tourney file"), 0); else {
11007         // create a file with tournament description
11008         fprintf(f, "-participants {%s}\n", appData.participants);
11009         fprintf(f, "-seedBase %d\n", appData.seedBase);
11010         fprintf(f, "-tourneyType %d\n", appData.tourneyType);
11011         fprintf(f, "-tourneyCycles %d\n", appData.tourneyCycles);
11012         fprintf(f, "-defaultMatchGames %d\n", appData.defaultMatchGames);
11013         fprintf(f, "-syncAfterRound %s\n", appData.roundSync ? "true" : "false");
11014         fprintf(f, "-syncAfterCycle %s\n", appData.cycleSync ? "true" : "false");
11015         fprintf(f, "-saveGameFile \"%s\"\n", appData.saveGameFile);
11016         fprintf(f, "-loadGameFile \"%s\"\n", appData.loadGameFile);
11017         fprintf(f, "-loadGameIndex %d\n", appData.loadGameIndex);
11018         fprintf(f, "-loadPositionFile \"%s\"\n", appData.loadPositionFile);
11019         fprintf(f, "-loadPositionIndex %d\n", appData.loadPositionIndex);
11020         fprintf(f, "-rewindIndex %d\n", appData.rewindIndex);
11021         fprintf(f, "-usePolyglotBook %s\n", appData.usePolyglotBook ? "true" : "false");
11022         fprintf(f, "-polyglotBook \"%s\"\n", appData.polyglotBook);
11023         fprintf(f, "-bookDepth %d\n", appData.bookDepth);
11024         fprintf(f, "-bookVariation %d\n", appData.bookStrength);
11025         fprintf(f, "-discourageOwnBooks %s\n", appData.defNoBook ? "true" : "false");
11026         fprintf(f, "-defaultHashSize %d\n", appData.defaultHashSize);
11027         fprintf(f, "-defaultCacheSizeEGTB %d\n", appData.defaultCacheSizeEGTB);
11028         fprintf(f, "-ponderNextMove %s\n", appData.ponderNextMove ? "true" : "false");
11029         fprintf(f, "-smpCores %d\n", appData.smpCores);
11030         if(searchTime > 0)
11031                 fprintf(f, "-searchTime \"%d:%02d\"\n", searchTime/60, searchTime%60);
11032         else {
11033                 fprintf(f, "-mps %d\n", appData.movesPerSession);
11034                 fprintf(f, "-tc %s\n", appData.timeControl);
11035                 fprintf(f, "-inc %.2f\n", appData.timeIncrement);
11036         }
11037         fprintf(f, "-results \"%s\"\n", results);
11038     }
11039     return f;
11040 }
11041
11042 char *command[MAXENGINES], *mnemonic[MAXENGINES];
11043
11044 void
11045 Substitute (char *participants, int expunge)
11046 {
11047     int i, changed, changes=0, nPlayers=0;
11048     char *p, *q, *r, buf[MSG_SIZ];
11049     if(participants == NULL) return;
11050     if(appData.tourneyFile[0] == NULLCHAR) { free(participants); return; }
11051     r = p = participants; q = appData.participants;
11052     while(*p && *p == *q) {
11053         if(*p == '\n') r = p+1, nPlayers++;
11054         p++; q++;
11055     }
11056     if(*p) { // difference
11057         while(*p && *p++ != '\n');
11058         while(*q && *q++ != '\n');
11059       changed = nPlayers;
11060         changes = 1 + (strcmp(p, q) != 0);
11061     }
11062     if(changes == 1) { // a single engine mnemonic was changed
11063         q = r; while(*q) nPlayers += (*q++ == '\n');
11064         p = buf; while(*r && (*p = *r++) != '\n') p++;
11065         *p = NULLCHAR;
11066         NamesToList(firstChessProgramNames, command, mnemonic, "all");
11067         for(i=1; mnemonic[i]; i++) if(!strcmp(buf, mnemonic[i])) break;
11068         if(mnemonic[i]) { // The substitute is valid
11069             FILE *f;
11070             if(appData.tourneyFile[0] && (f = fopen(appData.tourneyFile, "r+")) ) {
11071                 flock(fileno(f), LOCK_EX);
11072                 ParseArgsFromFile(f);
11073                 fseek(f, 0, SEEK_SET);
11074                 FREE(appData.participants); appData.participants = participants;
11075                 if(expunge) { // erase results of replaced engine
11076                     int len = strlen(appData.results), w, b, dummy;
11077                     for(i=0; i<len; i++) {
11078                         Pairing(i, nPlayers, &w, &b, &dummy);
11079                         if((w == changed || b == changed) && appData.results[i] == '*') {
11080                             DisplayError(_("You cannot replace an engine while it is engaged!\nTerminate its game first."), 0);
11081                             fclose(f);
11082                             return;
11083                         }
11084                     }
11085                     for(i=0; i<len; i++) {
11086                         Pairing(i, nPlayers, &w, &b, &dummy);
11087                         if(w == changed || b == changed) appData.results[i] = ' '; // mark as not played
11088                     }
11089                 }
11090                 WriteTourneyFile(appData.results, f);
11091                 fclose(f); // release lock
11092                 return;
11093             }
11094         } else DisplayError(_("No engine with the name you gave is installed"), 0);
11095     }
11096     if(changes == 0) DisplayError(_("First change an engine by editing the participants list\nof the Tournament Options dialog"), 0);
11097     if(changes > 1)  DisplayError(_("You can only change one engine at the time"), 0);
11098     free(participants);
11099     return;
11100 }
11101
11102 int
11103 CheckPlayers (char *participants)
11104 {
11105         int i;
11106         char buf[MSG_SIZ], *p;
11107         NamesToList(firstChessProgramNames, command, mnemonic, "all");
11108         while(p = strchr(participants, '\n')) {
11109             *p = NULLCHAR;
11110             for(i=1; mnemonic[i]; i++) if(!strcmp(participants, mnemonic[i])) break;
11111             if(!mnemonic[i]) {
11112                 snprintf(buf, MSG_SIZ, _("No engine %s is installed"), participants);
11113                 *p = '\n';
11114                 DisplayError(buf, 0);
11115                 return 1;
11116             }
11117             *p = '\n';
11118             participants = p + 1;
11119         }
11120         return 0;
11121 }
11122
11123 int
11124 CreateTourney (char *name)
11125 {
11126         FILE *f;
11127         if(matchMode && strcmp(name, appData.tourneyFile)) {
11128              ASSIGN(name, appData.tourneyFile); //do not allow change of tourneyfile while playing
11129         }
11130         if(name[0] == NULLCHAR) {
11131             if(appData.participants[0])
11132                 DisplayError(_("You must supply a tournament file,\nfor storing the tourney progress"), 0);
11133             return 0;
11134         }
11135         f = fopen(name, "r");
11136         if(f) { // file exists
11137             ASSIGN(appData.tourneyFile, name);
11138             ParseArgsFromFile(f); // parse it
11139         } else {
11140             if(!appData.participants[0]) return 0; // ignore tourney file if non-existing & no participants
11141             if(CountPlayers(appData.participants) < (appData.tourneyType>0 ? appData.tourneyType+1 : 2)) {
11142                 DisplayError(_("Not enough participants"), 0);
11143                 return 0;
11144             }
11145             if(CheckPlayers(appData.participants)) return 0;
11146             ASSIGN(appData.tourneyFile, name);
11147             if(appData.tourneyType < 0) appData.defaultMatchGames = 1; // Swiss forces games/pairing = 1
11148             if((f = WriteTourneyFile("", NULL)) == NULL) return 0;
11149         }
11150         fclose(f);
11151         appData.noChessProgram = FALSE;
11152         appData.clockMode = TRUE;
11153         SetGNUMode();
11154         return 1;
11155 }
11156
11157 int
11158 NamesToList (char *names, char **engineList, char **engineMnemonic, char *group)
11159 {
11160     char buf[MSG_SIZ], *p, *q;
11161     int i=1, header, skip, all = !strcmp(group, "all"), depth = 0;
11162     insert = names; // afterwards, this global will point just after last retrieved engine line or group end in the 'names'
11163     skip = !all && group[0]; // if group requested, we start in skip mode
11164     for(;*names && depth >= 0 && i < MAXENGINES-1; names = p) {
11165         p = names; q = buf; header = 0;
11166         while(*p && *p != '\n') *q++ = *p++;
11167         *q = 0;
11168         if(*p == '\n') p++;
11169         if(buf[0] == '#') {
11170             if(strstr(buf, "# end") == buf) { if(!--depth) insert = p; continue; } // leave group, and suppress printing label
11171             depth++; // we must be entering a new group
11172             if(all) continue; // suppress printing group headers when complete list requested
11173             header = 1;
11174             if(skip && !strcmp(group, buf)) { depth = 0; skip = FALSE; } // start when we reach requested group
11175         }
11176         if(depth != header && !all || skip) continue; // skip contents of group (but print first-level header)
11177         if(engineList[i]) free(engineList[i]);
11178         engineList[i] = strdup(buf);
11179         if(buf[0] != '#') insert = p, TidyProgramName(engineList[i], "localhost", buf); // group headers not tidied
11180         if(engineMnemonic[i]) free(engineMnemonic[i]);
11181         if((q = strstr(engineList[i]+2, "variant")) && q[-2]== ' ' && (q[-1]=='/' || q[-1]=='-') && (q[7]==' ' || q[7]=='=')) {
11182             strcat(buf, " (");
11183             sscanf(q + 8, "%s", buf + strlen(buf));
11184             strcat(buf, ")");
11185         }
11186         engineMnemonic[i] = strdup(buf);
11187         i++;
11188     }
11189     engineList[i] = engineMnemonic[i] = NULL;
11190     return i;
11191 }
11192
11193 // following implemented as macro to avoid type limitations
11194 #define SWAP(item, temp) temp = appData.item[0]; appData.item[0] = appData.item[n]; appData.item[n] = temp;
11195
11196 void
11197 SwapEngines (int n)
11198 {   // swap settings for first engine and other engine (so far only some selected options)
11199     int h;
11200     char *p;
11201     if(n == 0) return;
11202     SWAP(directory, p)
11203     SWAP(chessProgram, p)
11204     SWAP(isUCI, h)
11205     SWAP(hasOwnBookUCI, h)
11206     SWAP(protocolVersion, h)
11207     SWAP(reuse, h)
11208     SWAP(scoreIsAbsolute, h)
11209     SWAP(timeOdds, h)
11210     SWAP(logo, p)
11211     SWAP(pgnName, p)
11212     SWAP(pvSAN, h)
11213     SWAP(engOptions, p)
11214     SWAP(engInitString, p)
11215     SWAP(computerString, p)
11216     SWAP(features, p)
11217     SWAP(fenOverride, p)
11218     SWAP(NPS, h)
11219     SWAP(accumulateTC, h)
11220     SWAP(drawDepth, h)
11221     SWAP(host, p)
11222     SWAP(pseudo, h)
11223 }
11224
11225 int
11226 GetEngineLine (char *s, int n)
11227 {
11228     int i;
11229     char buf[MSG_SIZ];
11230     extern char *icsNames;
11231     if(!s || !*s) return 0;
11232     NamesToList(n >= 10 ? icsNames : firstChessProgramNames, command, mnemonic, "all");
11233     for(i=1; mnemonic[i]; i++) if(!strcmp(s, mnemonic[i])) break;
11234     if(!mnemonic[i]) return 0;
11235     if(n == 11) return 1; // just testing if there was a match
11236     snprintf(buf, MSG_SIZ, "-%s %s", n == 10 ? "icshost" : "fcp", command[i]);
11237     if(n == 1) SwapEngines(n);
11238     ParseArgsFromString(buf);
11239     if(n == 1) SwapEngines(n);
11240     if(n == 0 && *appData.secondChessProgram == NULLCHAR) {
11241         SwapEngines(1); // set second same as first if not yet set (to suppress WB startup dialog)
11242         ParseArgsFromString(buf);
11243     }
11244     return 1;
11245 }
11246
11247 int
11248 SetPlayer (int player, char *p)
11249 {   // [HGM] find the engine line of the partcipant given by number, and parse its options.
11250     int i;
11251     char buf[MSG_SIZ], *engineName;
11252     for(i=0; i<player; i++) p = strchr(p, '\n') + 1;
11253     engineName = strdup(p); if(p = strchr(engineName, '\n')) *p = NULLCHAR;
11254     for(i=1; command[i]; i++) if(!strcmp(mnemonic[i], engineName)) break;
11255     if(mnemonic[i]) {
11256         snprintf(buf, MSG_SIZ, "-fcp %s", command[i]);
11257         ParseArgsFromString(resetOptions); appData.fenOverride[0] = NULL; appData.pvSAN[0] = FALSE;
11258         appData.firstHasOwnBookUCI = !appData.defNoBook; appData.protocolVersion[0] = PROTOVER;
11259         ParseArgsFromString(buf);
11260     } else { // no engine with this nickname is installed!
11261         snprintf(buf, MSG_SIZ, _("No engine %s is installed"), engineName);
11262         ReserveGame(nextGame, ' '); // unreserve game and drop out of match mode with error
11263         matchMode = FALSE; appData.matchGames = matchGame = roundNr = 0;
11264         ModeHighlight();
11265         DisplayError(buf, 0);
11266         return 0;
11267     }
11268     free(engineName);
11269     return i;
11270 }
11271
11272 char *recentEngines;
11273
11274 void
11275 RecentEngineEvent (int nr)
11276 {
11277     int n;
11278 //    SwapEngines(1); // bump first to second
11279 //    ReplaceEngine(&second, 1); // and load it there
11280     NamesToList(firstChessProgramNames, command, mnemonic, "all"); // get mnemonics of installed engines
11281     n = SetPlayer(nr, recentEngines); // select new (using original menu order!)
11282     if(mnemonic[n]) { // if somehow the engine with the selected nickname is no longer found in the list, we skip
11283         ReplaceEngine(&first, 0);
11284         FloatToFront(&appData.recentEngineList, command[n]);
11285     }
11286 }
11287
11288 int
11289 Pairing (int nr, int nPlayers, int *whitePlayer, int *blackPlayer, int *syncInterval)
11290 {   // determine players from game number
11291     int curCycle, curRound, curPairing, gamesPerCycle, gamesPerRound, roundsPerCycle=1, pairingsPerRound=1;
11292
11293     if(appData.tourneyType == 0) {
11294         roundsPerCycle = (nPlayers - 1) | 1;
11295         pairingsPerRound = nPlayers / 2;
11296     } else if(appData.tourneyType > 0) {
11297         roundsPerCycle = nPlayers - appData.tourneyType;
11298         pairingsPerRound = appData.tourneyType;
11299     }
11300     gamesPerRound = pairingsPerRound * appData.defaultMatchGames;
11301     gamesPerCycle = gamesPerRound * roundsPerCycle;
11302     appData.matchGames = gamesPerCycle * appData.tourneyCycles - 1; // fake like all games are one big match
11303     curCycle = nr / gamesPerCycle; nr %= gamesPerCycle;
11304     curRound = nr / gamesPerRound; nr %= gamesPerRound;
11305     curPairing = nr / appData.defaultMatchGames; nr %= appData.defaultMatchGames;
11306     matchGame = nr + curCycle * appData.defaultMatchGames + 1; // fake game nr that loads correct game or position from file
11307     roundNr = (curCycle * roundsPerCycle + curRound) * appData.defaultMatchGames + nr + 1;
11308
11309     if(appData.cycleSync) *syncInterval = gamesPerCycle;
11310     if(appData.roundSync) *syncInterval = gamesPerRound;
11311
11312     if(appData.debugMode) fprintf(debugFP, "cycle=%d, round=%d, pairing=%d curGame=%d\n", curCycle, curRound, curPairing, matchGame);
11313
11314     if(appData.tourneyType == 0) {
11315         if(curPairing == (nPlayers-1)/2 ) {
11316             *whitePlayer = curRound;
11317             *blackPlayer = nPlayers - 1; // this is the 'bye' when nPlayer is odd
11318         } else {
11319             *whitePlayer = curRound - (nPlayers-1)/2 + curPairing;
11320             if(*whitePlayer < 0) *whitePlayer += nPlayers-1+(nPlayers&1);
11321             *blackPlayer = curRound + (nPlayers-1)/2 - curPairing;
11322             if(*blackPlayer >= nPlayers-1+(nPlayers&1)) *blackPlayer -= nPlayers-1+(nPlayers&1);
11323         }
11324     } else if(appData.tourneyType > 1) {
11325         *blackPlayer = curPairing; // in multi-gauntlet, assign gauntlet engines to second, so first an be kept loaded during round
11326         *whitePlayer = curRound + appData.tourneyType;
11327     } else if(appData.tourneyType > 0) {
11328         *whitePlayer = curPairing;
11329         *blackPlayer = curRound + appData.tourneyType;
11330     }
11331
11332     // take care of white/black alternation per round.
11333     // For cycles and games this is already taken care of by default, derived from matchGame!
11334     return curRound & 1;
11335 }
11336
11337 int
11338 NextTourneyGame (int nr, int *swapColors)
11339 {   // !!!major kludge!!! fiddle appData settings to get everything in order for next tourney game
11340     char *p, *q;
11341     int whitePlayer, blackPlayer, firstBusy=1000000000, syncInterval = 0, nPlayers, OK = 1;
11342     FILE *tf;
11343     if(appData.tourneyFile[0] == NULLCHAR) return 1; // no tourney, always allow next game
11344     tf = fopen(appData.tourneyFile, "r");
11345     if(tf == NULL) { DisplayFatalError(_("Bad tournament file"), 0, 1); return 0; }
11346     ParseArgsFromFile(tf); fclose(tf);
11347     InitTimeControls(); // TC might be altered from tourney file
11348
11349     nPlayers = CountPlayers(appData.participants); // count participants
11350     if(appData.tourneyType < 0) syncInterval = nPlayers/2; else
11351     *swapColors = Pairing(nr<0 ? 0 : nr, nPlayers, &whitePlayer, &blackPlayer, &syncInterval);
11352
11353     if(syncInterval) {
11354         p = q = appData.results;
11355         while(*q) if(*q++ == '*' || q[-1] == ' ') { firstBusy = q - p - 1; break; }
11356         if(firstBusy/syncInterval < (nextGame/syncInterval)) {
11357             DisplayMessage(_("Waiting for other game(s)"),"");
11358             waitingForGame = TRUE;
11359             ScheduleDelayedEvent(NextMatchGame, 1000); // wait for all games of previous round to finish
11360             return 0;
11361         }
11362         waitingForGame = FALSE;
11363     }
11364
11365     if(appData.tourneyType < 0) {
11366         if(nr>=0 && !pairingReceived) {
11367             char buf[1<<16];
11368             if(pairing.pr == NoProc) {
11369                 if(!appData.pairingEngine[0]) {
11370                     DisplayFatalError(_("No pairing engine specified"), 0, 1);
11371                     return 0;
11372                 }
11373                 StartChessProgram(&pairing); // starts the pairing engine
11374             }
11375             snprintf(buf, 1<<16, "results %d %s\n", nPlayers, appData.results);
11376             SendToProgram(buf, &pairing);
11377             snprintf(buf, 1<<16, "pairing %d\n", nr+1);
11378             SendToProgram(buf, &pairing);
11379             return 0; // wait for pairing engine to answer (which causes NextTourneyGame to be called again...
11380         }
11381         pairingReceived = 0;                              // ... so we continue here
11382         *swapColors = 0;
11383         appData.matchGames = appData.tourneyCycles * syncInterval - 1;
11384         whitePlayer = savedWhitePlayer-1; blackPlayer = savedBlackPlayer-1;
11385         matchGame = 1; roundNr = nr / syncInterval + 1;
11386     }
11387
11388     if(first.pr != NoProc && second.pr != NoProc || nr<0) return 1; // engines already loaded
11389
11390     // redefine engines, engine dir, etc.
11391     NamesToList(firstChessProgramNames, command, mnemonic, "all"); // get mnemonics of installed engines
11392     if(first.pr == NoProc) {
11393       if(!SetPlayer(whitePlayer, appData.participants)) OK = 0; // find white player amongst it, and parse its engine line
11394       InitEngine(&first, 0);  // initialize ChessProgramStates based on new settings.
11395     }
11396     if(second.pr == NoProc) {
11397       SwapEngines(1);
11398       if(!SetPlayer(blackPlayer, appData.participants)) OK = 0; // find black player amongst it, and parse its engine line
11399       SwapEngines(1);         // and make that valid for second engine by swapping
11400       InitEngine(&second, 1);
11401     }
11402     CommonEngineInit();     // after this TwoMachinesEvent will create correct engine processes
11403     UpdateLogos(FALSE);     // leave display to ModeHiglight()
11404     return OK;
11405 }
11406
11407 void
11408 NextMatchGame ()
11409 {   // performs game initialization that does not invoke engines, and then tries to start the game
11410     int res, firstWhite, swapColors = 0;
11411     if(!NextTourneyGame(nextGame, &swapColors)) return; // this sets matchGame, -fcp / -scp and other options for next game, if needed
11412     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
11413         char buf[MSG_SIZ];
11414         snprintf(buf, MSG_SIZ, appData.nameOfDebugFile, nextGame+1); // expand name of debug file with %d in it
11415         if(strcmp(buf, currentDebugFile)) { // name has changed
11416             FILE *f = fopen(buf, "w");
11417             if(f) { // if opening the new file failed, just keep using the old one
11418                 ASSIGN(currentDebugFile, buf);
11419                 fclose(debugFP);
11420                 debugFP = f;
11421             }
11422             if(appData.serverFileName) {
11423                 if(serverFP) fclose(serverFP);
11424                 serverFP = fopen(appData.serverFileName, "w");
11425                 if(serverFP && first.pr != NoProc) fprintf(serverFP, "StartChildProcess (dir=\".\") .\\%s\n", first.tidy);
11426                 if(serverFP && second.pr != NoProc) fprintf(serverFP, "StartChildProcess (dir=\".\") .\\%s\n", second.tidy);
11427             }
11428         }
11429     }
11430     firstWhite = appData.firstPlaysBlack ^ (matchGame & 1 | appData.sameColorGames > 1); // non-incremental default
11431     firstWhite ^= swapColors; // reverses if NextTourneyGame says we are in an odd round
11432     first.twoMachinesColor =  firstWhite ? "white\n" : "black\n";   // perform actual color assignement
11433     second.twoMachinesColor = firstWhite ? "black\n" : "white\n";
11434     appData.noChessProgram = (first.pr == NoProc); // kludge to prevent Reset from starting up chess program
11435     if(appData.loadGameIndex == -2) srandom(appData.seedBase + 68163*(nextGame & ~1)); // deterministic seed to force same opening
11436     Reset(FALSE, first.pr != NoProc);
11437     res = LoadGameOrPosition(matchGame); // setup game
11438     appData.noChessProgram = FALSE; // LoadGameOrPosition might call Reset too!
11439     if(!res) return; // abort when bad game/pos file
11440     if(appData.epd) {// in EPD mode we make sure first engine is to move
11441         firstWhite = !(forwardMostMove & 1);
11442         first.twoMachinesColor =  firstWhite ? "white\n" : "black\n";   // perform actual color assignement
11443         second.twoMachinesColor = firstWhite ? "black\n" : "white\n";
11444     }
11445     TwoMachinesEvent();
11446 }
11447
11448 void
11449 UserAdjudicationEvent (int result)
11450 {
11451     ChessMove gameResult = GameIsDrawn;
11452
11453     if( result > 0 ) {
11454         gameResult = WhiteWins;
11455     }
11456     else if( result < 0 ) {
11457         gameResult = BlackWins;
11458     }
11459
11460     if( gameMode == TwoMachinesPlay ) {
11461         GameEnds( gameResult, "User adjudication", GE_XBOARD );
11462     }
11463 }
11464
11465
11466 // [HGM] save: calculate checksum of game to make games easily identifiable
11467 int
11468 StringCheckSum (char *s)
11469 {
11470         int i = 0;
11471         if(s==NULL) return 0;
11472         while(*s) i = i*259 + *s++;
11473         return i;
11474 }
11475
11476 int
11477 GameCheckSum ()
11478 {
11479         int i, sum=0;
11480         for(i=backwardMostMove; i<forwardMostMove; i++) {
11481                 sum += pvInfoList[i].depth;
11482                 sum += StringCheckSum(parseList[i]);
11483                 sum += StringCheckSum(commentList[i]);
11484                 sum *= 261;
11485         }
11486         if(i>1 && sum==0) sum++; // make sure never zero for non-empty game
11487         return sum + StringCheckSum(commentList[i]);
11488 } // end of save patch
11489
11490 void
11491 GameEnds (ChessMove result, char *resultDetails, int whosays)
11492 {
11493     GameMode nextGameMode;
11494     int isIcsGame;
11495     char buf[MSG_SIZ], popupRequested = 0, *ranking = NULL;
11496
11497     if(endingGame) return; /* [HGM] crash: forbid recursion */
11498     endingGame = 1;
11499     if(twoBoards) { // [HGM] dual: switch back to one board
11500         twoBoards = partnerUp = 0; InitDrawingSizes(-2, 0);
11501         DrawPosition(TRUE, partnerBoard); // observed game becomes foreground
11502     }
11503     if (appData.debugMode) {
11504       fprintf(debugFP, "GameEnds(%d, %s, %d)\n",
11505               result, resultDetails ? resultDetails : "(null)", whosays);
11506     }
11507
11508     fromX = fromY = killX = killY = kill2X = kill2Y = -1; // [HGM] abort any move the user is entering. // [HGM] lion
11509
11510     if(pausing) PauseEvent(); // can happen when we abort a paused game (New Game or Quit)
11511
11512     if (appData.icsActive && (whosays == GE_ENGINE || whosays >= GE_ENGINE1)) {
11513         /* If we are playing on ICS, the server decides when the
11514            game is over, but the engine can offer to draw, claim
11515            a draw, or resign.
11516          */
11517 #if ZIPPY
11518         if (appData.zippyPlay && first.initDone) {
11519             if (result == GameIsDrawn) {
11520                 /* In case draw still needs to be claimed */
11521                 SendToICS(ics_prefix);
11522                 SendToICS("draw\n");
11523             } else if (StrCaseStr(resultDetails, "resign")) {
11524                 SendToICS(ics_prefix);
11525                 SendToICS("resign\n");
11526             }
11527         }
11528 #endif
11529         endingGame = 0; /* [HGM] crash */
11530         return;
11531     }
11532
11533     /* If we're loading the game from a file, stop */
11534     if (whosays == GE_FILE) {
11535       (void) StopLoadGameTimer();
11536       gameFileFP = NULL;
11537     }
11538
11539     /* Cancel draw offers */
11540     first.offeredDraw = second.offeredDraw = 0;
11541
11542     /* If this is an ICS game, only ICS can really say it's done;
11543        if not, anyone can. */
11544     isIcsGame = (gameMode == IcsPlayingWhite ||
11545                  gameMode == IcsPlayingBlack ||
11546                  gameMode == IcsObserving    ||
11547                  gameMode == IcsExamining);
11548
11549     if (!isIcsGame || whosays == GE_ICS) {
11550         /* OK -- not an ICS game, or ICS said it was done */
11551         StopClocks();
11552         if (!isIcsGame && !appData.noChessProgram)
11553           SetUserThinkingEnables();
11554
11555         /* [HGM] if a machine claims the game end we verify this claim */
11556         if(gameMode == TwoMachinesPlay && appData.testClaims) {
11557             if(appData.testLegality && whosays >= GE_ENGINE1 ) {
11558                 char claimer;
11559                 ChessMove trueResult = (ChessMove) -1;
11560
11561                 claimer = whosays == GE_ENGINE1 ?      /* color of claimer */
11562                                             first.twoMachinesColor[0] :
11563                                             second.twoMachinesColor[0] ;
11564
11565                 // [HGM] losers: because the logic is becoming a bit hairy, determine true result first
11566                 if((signed char)boards[forwardMostMove][EP_STATUS] == EP_CHECKMATE) {
11567                     /* [HGM] verify: engine mate claims accepted if they were flagged */
11568                     trueResult = WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins;
11569                 } else
11570                 if((signed char)boards[forwardMostMove][EP_STATUS] == EP_WINS) { // added code for games where being mated is a win
11571                     /* [HGM] verify: engine mate claims accepted if they were flagged */
11572                     trueResult = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
11573                 } else
11574                 if((signed char)boards[forwardMostMove][EP_STATUS] == EP_STALEMATE) { // only used to indicate draws now
11575                     trueResult = GameIsDrawn; // default; in variants where stalemate loses, Status is CHECKMATE
11576                 }
11577
11578                 // now verify win claims, but not in drop games, as we don't understand those yet
11579                 if( (gameInfo.holdingsWidth == 0 || gameInfo.variant == VariantSuper
11580                                                  || gameInfo.variant == VariantGreat || gameInfo.variant == VariantGrand) &&
11581                     (result == WhiteWins && claimer == 'w' ||
11582                      result == BlackWins && claimer == 'b'   ) ) { // case to verify: engine claims own win
11583                       if (appData.debugMode) {
11584                         fprintf(debugFP, "result=%d sp=%d move=%d\n",
11585                                 result, (signed char)boards[forwardMostMove][EP_STATUS], forwardMostMove);
11586                       }
11587                       if(result != trueResult) {
11588                         snprintf(buf, MSG_SIZ, "False win claim: '%s'", resultDetails);
11589                               result = claimer == 'w' ? BlackWins : WhiteWins;
11590                               resultDetails = buf;
11591                       }
11592                 } else
11593                 if( result == GameIsDrawn && (signed char)boards[forwardMostMove][EP_STATUS] > EP_DRAWS
11594                     && (forwardMostMove <= backwardMostMove ||
11595                         (signed char)boards[forwardMostMove-1][EP_STATUS] > EP_DRAWS ||
11596                         (claimer=='b')==(forwardMostMove&1))
11597                                                                                   ) {
11598                       /* [HGM] verify: draws that were not flagged are false claims */
11599                   snprintf(buf, MSG_SIZ, "False draw claim: '%s'", resultDetails);
11600                       result = claimer == 'w' ? BlackWins : WhiteWins;
11601                       resultDetails = buf;
11602                 }
11603                 /* (Claiming a loss is accepted no questions asked!) */
11604             } else if(matchMode && result == GameIsDrawn && !strcmp(resultDetails, "Engine Abort Request")) {
11605                 forwardMostMove = backwardMostMove; // [HGM] delete game to surpress saving
11606                 result = GameUnfinished;
11607                 if(!*appData.tourneyFile) matchGame--; // replay even in plain match
11608             }
11609             /* [HGM] bare: don't allow bare King to win */
11610             if((gameInfo.holdingsWidth == 0 || gameInfo.variant == VariantSuper
11611                                             || gameInfo.variant == VariantGreat || gameInfo.variant == VariantGrand)
11612                && gameInfo.variant != VariantLosers && gameInfo.variant != VariantGiveaway
11613                && gameInfo.variant != VariantSuicide // [HGM] losers: except in losers, of course...
11614                && result != GameIsDrawn)
11615             {   int i, j, k=0, oppoKings = 0, color = (result==WhiteWins ? (int)WhitePawn : (int)BlackPawn);
11616                 for(j=BOARD_LEFT; j<BOARD_RGHT; j++) for(i=0; i<BOARD_HEIGHT; i++) {
11617                         int p = (signed char)boards[forwardMostMove][i][j] - color;
11618                         if(p >= 0 && p <= (int)WhiteKing) k++;
11619                         oppoKings += (p + color == WhiteKing + BlackPawn - color);
11620                 }
11621                 if (appData.debugMode) {
11622                      fprintf(debugFP, "GE(%d, %s, %d) bare king k=%d color=%d\n",
11623                         result, resultDetails ? resultDetails : "(null)", whosays, k, color);
11624                 }
11625                 if(k <= 1 && oppoKings > 0) { // the latter needed in Atomic, where bare K wins if opponent King already destroyed
11626                         result = GameIsDrawn;
11627                         snprintf(buf, MSG_SIZ, "%s but bare king", resultDetails);
11628                         resultDetails = buf;
11629                 }
11630             }
11631         }
11632
11633
11634         if(serverMoves != NULL && !loadFlag) { char c = '=';
11635             if(result==WhiteWins) c = '+';
11636             if(result==BlackWins) c = '-';
11637             if(resultDetails != NULL)
11638                 fprintf(serverMoves, ";%c;%s\n", c, resultDetails), fflush(serverMoves);
11639         }
11640         if (resultDetails != NULL) {
11641             gameInfo.result = result;
11642             gameInfo.resultDetails = StrSave(resultDetails);
11643
11644             /* display last move only if game was not loaded from file */
11645             if ((whosays != GE_FILE) && (currentMove == forwardMostMove))
11646                 DisplayMove(currentMove - 1);
11647
11648             if (forwardMostMove != 0) {
11649                 if (gameMode != PlayFromGameFile && gameMode != EditGame
11650                     && lastSavedGame != GameCheckSum() // [HGM] save: suppress duplicates
11651                                                                 ) {
11652                     if (*appData.saveGameFile != NULLCHAR) {
11653                         if(result == GameUnfinished && matchMode && *appData.tourneyFile)
11654                             AutoSaveGame(); // [HGM] protect tourney PGN from aborted games, and prompt for name instead
11655                         else
11656                         SaveGameToFile(appData.saveGameFile, TRUE);
11657                     } else if (appData.autoSaveGames) {
11658                         if(gameMode != IcsObserving || !appData.onlyOwn) AutoSaveGame();
11659                     }
11660                     if (*appData.savePositionFile != NULLCHAR) {
11661                         SavePositionToFile(appData.savePositionFile);
11662                     }
11663                     AddGameToBook(FALSE); // Only does something during Monte-Carlo book building
11664                 }
11665             }
11666
11667             /* Tell program how game ended in case it is learning */
11668             /* [HGM] Moved this to after saving the PGN, just in case */
11669             /* engine died and we got here through time loss. In that */
11670             /* case we will get a fatal error writing the pipe, which */
11671             /* would otherwise lose us the PGN.                       */
11672             /* [HGM] crash: not needed anymore, but doesn't hurt;     */
11673             /* output during GameEnds should never be fatal anymore   */
11674             if (gameMode == MachinePlaysWhite ||
11675                 gameMode == MachinePlaysBlack ||
11676                 gameMode == TwoMachinesPlay ||
11677                 gameMode == IcsPlayingWhite ||
11678                 gameMode == IcsPlayingBlack ||
11679                 gameMode == BeginningOfGame) {
11680                 char buf[MSG_SIZ];
11681                 snprintf(buf, MSG_SIZ, "result %s {%s}\n", PGNResult(result),
11682                         resultDetails);
11683                 if (first.pr != NoProc) {
11684                     SendToProgram(buf, &first);
11685                 }
11686                 if (second.pr != NoProc &&
11687                     gameMode == TwoMachinesPlay) {
11688                     SendToProgram(buf, &second);
11689                 }
11690             }
11691         }
11692
11693         if (appData.icsActive) {
11694             if (appData.quietPlay &&
11695                 (gameMode == IcsPlayingWhite ||
11696                  gameMode == IcsPlayingBlack)) {
11697                 SendToICS(ics_prefix);
11698                 SendToICS("set shout 1\n");
11699             }
11700             nextGameMode = IcsIdle;
11701             ics_user_moved = FALSE;
11702             /* clean up premove.  It's ugly when the game has ended and the
11703              * premove highlights are still on the board.
11704              */
11705             if (gotPremove) {
11706               gotPremove = FALSE;
11707               ClearPremoveHighlights();
11708               DrawPosition(FALSE, boards[currentMove]);
11709             }
11710             if (whosays == GE_ICS) {
11711                 switch (result) {
11712                 case WhiteWins:
11713                     if (gameMode == IcsPlayingWhite)
11714                         PlayIcsWinSound();
11715                     else if(gameMode == IcsPlayingBlack)
11716                         PlayIcsLossSound();
11717                     break;
11718                 case BlackWins:
11719                     if (gameMode == IcsPlayingBlack)
11720                         PlayIcsWinSound();
11721                     else if(gameMode == IcsPlayingWhite)
11722                         PlayIcsLossSound();
11723                     break;
11724                 case GameIsDrawn:
11725                     PlayIcsDrawSound();
11726                     break;
11727                 default:
11728                     PlayIcsUnfinishedSound();
11729                 }
11730             }
11731             if(appData.quitNext) { ExitEvent(0); return; }
11732         } else if (gameMode == EditGame ||
11733                    gameMode == PlayFromGameFile ||
11734                    gameMode == AnalyzeMode ||
11735                    gameMode == AnalyzeFile) {
11736             nextGameMode = gameMode;
11737         } else {
11738             nextGameMode = EndOfGame;
11739         }
11740         pausing = FALSE;
11741         ModeHighlight();
11742     } else {
11743         nextGameMode = gameMode;
11744     }
11745
11746     if (appData.noChessProgram) {
11747         gameMode = nextGameMode;
11748         ModeHighlight();
11749         endingGame = 0; /* [HGM] crash */
11750         return;
11751     }
11752
11753     if (first.reuse) {
11754         /* Put first chess program into idle state */
11755         if (first.pr != NoProc &&
11756             (gameMode == MachinePlaysWhite ||
11757              gameMode == MachinePlaysBlack ||
11758              gameMode == TwoMachinesPlay ||
11759              gameMode == IcsPlayingWhite ||
11760              gameMode == IcsPlayingBlack ||
11761              gameMode == BeginningOfGame)) {
11762             SendToProgram("force\n", &first);
11763             if (first.usePing) {
11764               char buf[MSG_SIZ];
11765               snprintf(buf, MSG_SIZ, "ping %d\n", ++first.lastPing);
11766               SendToProgram(buf, &first);
11767             }
11768         }
11769     } else if (result != GameUnfinished || nextGameMode == IcsIdle) {
11770         /* Kill off first chess program */
11771         if (first.isr != NULL)
11772           RemoveInputSource(first.isr);
11773         first.isr = NULL;
11774
11775         if (first.pr != NoProc) {
11776             ExitAnalyzeMode();
11777             DoSleep( appData.delayBeforeQuit );
11778             SendToProgram("quit\n", &first);
11779             DestroyChildProcess(first.pr, 4 + first.useSigterm);
11780             first.reload = TRUE;
11781         }
11782         first.pr = NoProc;
11783     }
11784     if (second.reuse) {
11785         /* Put second chess program into idle state */
11786         if (second.pr != NoProc &&
11787             gameMode == TwoMachinesPlay) {
11788             SendToProgram("force\n", &second);
11789             if (second.usePing) {
11790               char buf[MSG_SIZ];
11791               snprintf(buf, MSG_SIZ, "ping %d\n", ++second.lastPing);
11792               SendToProgram(buf, &second);
11793             }
11794         }
11795     } else if (result != GameUnfinished || nextGameMode == IcsIdle) {
11796         /* Kill off second chess program */
11797         if (second.isr != NULL)
11798           RemoveInputSource(second.isr);
11799         second.isr = NULL;
11800
11801         if (second.pr != NoProc) {
11802             DoSleep( appData.delayBeforeQuit );
11803             SendToProgram("quit\n", &second);
11804             DestroyChildProcess(second.pr, 4 + second.useSigterm);
11805             second.reload = TRUE;
11806         }
11807         second.pr = NoProc;
11808     }
11809
11810     if (matchMode && (gameMode == TwoMachinesPlay || (waitingForGame || startingEngine) && exiting)) {
11811         char resChar = '=';
11812         switch (result) {
11813         case WhiteWins:
11814           resChar = '+';
11815           if (first.twoMachinesColor[0] == 'w') {
11816             first.matchWins++;
11817           } else {
11818             second.matchWins++;
11819           }
11820           break;
11821         case BlackWins:
11822           resChar = '-';
11823           if (first.twoMachinesColor[0] == 'b') {
11824             first.matchWins++;
11825           } else {
11826             second.matchWins++;
11827           }
11828           break;
11829         case GameUnfinished:
11830           resChar = ' ';
11831         default:
11832           break;
11833         }
11834
11835         if(exiting) resChar = ' '; // quit while waiting for round sync: unreserve already reserved game
11836         if(appData.tourneyFile[0]){ // [HGM] we are in a tourney; update tourney file with game result
11837             if(appData.afterGame && appData.afterGame[0]) RunCommand(appData.afterGame);
11838             ReserveGame(nextGame, resChar); // sets nextGame
11839             if(nextGame > appData.matchGames) appData.tourneyFile[0] = 0, ranking = TourneyStandings(3); // tourney is done
11840             else ranking = strdup("busy"); //suppress popup when aborted but not finished
11841         } else roundNr = nextGame = matchGame + 1; // normal match, just increment; round equals matchGame
11842
11843         if (nextGame <= appData.matchGames && !abortMatch) {
11844             gameMode = nextGameMode;
11845             matchGame = nextGame; // this will be overruled in tourney mode!
11846             GetTimeMark(&pauseStart); // [HGM] matchpause: stipulate a pause
11847             ScheduleDelayedEvent(NextMatchGame, 10); // but start game immediately (as it will wait out the pause itself)
11848             endingGame = 0; /* [HGM] crash */
11849             return;
11850         } else {
11851             gameMode = nextGameMode;
11852             if(appData.epd) {
11853                 snprintf(buf, MSG_SIZ, "-------------------------------------- ");
11854                 OutputKibitz(2, buf);
11855                 snprintf(buf, MSG_SIZ, _("Average solving time %4.2f sec "), totalTime/(100.*first.matchWins));
11856                 OutputKibitz(2, buf);
11857                 snprintf(buf, MSG_SIZ, _("Solved %d of %d (%3.1f%%) "), first.matchWins, nextGame, first.matchWins*100./nextGame);
11858                 OutputKibitz(2, buf);
11859             }
11860             snprintf(buf, MSG_SIZ, _("Match %s vs. %s: final score %d-%d-%d"),
11861                      first.tidy, second.tidy,
11862                      first.matchWins, second.matchWins,
11863                      appData.matchGames - (first.matchWins + second.matchWins));
11864             if(!appData.tourneyFile[0]) matchGame++, DisplayTwoMachinesTitle(); // [HGM] update result in window title
11865             if(ranking && strcmp(ranking, "busy") && appData.afterTourney && appData.afterTourney[0]) RunCommand(appData.afterTourney);
11866             popupRequested++; // [HGM] crash: postpone to after resetting endingGame
11867             if (appData.firstPlaysBlack) { // [HGM] match: back to original for next match
11868                 first.twoMachinesColor = "black\n";
11869                 second.twoMachinesColor = "white\n";
11870             } else {
11871                 first.twoMachinesColor = "white\n";
11872                 second.twoMachinesColor = "black\n";
11873             }
11874         }
11875     }
11876     if ((gameMode == AnalyzeMode || gameMode == AnalyzeFile) &&
11877         !(nextGameMode == AnalyzeMode || nextGameMode == AnalyzeFile))
11878       ExitAnalyzeMode();
11879     gameMode = nextGameMode;
11880     ModeHighlight();
11881     endingGame = 0;  /* [HGM] crash */
11882     if(popupRequested) { // [HGM] crash: this calls GameEnds recursively through ExitEvent! Make it a harmless tail recursion.
11883         if(matchMode == TRUE) { // match through command line: exit with or without popup
11884             if(ranking) {
11885                 ToNrEvent(forwardMostMove);
11886                 if(strcmp(ranking, "busy")) DisplayFatalError(ranking, 0, 0);
11887                 else ExitEvent(0);
11888             } else DisplayFatalError(buf, 0, 0);
11889         } else { // match through menu; just stop, with or without popup
11890             matchMode = FALSE; appData.matchGames = matchGame = roundNr = 0;
11891             ModeHighlight();
11892             if(ranking){
11893                 if(strcmp(ranking, "busy")) DisplayNote(ranking);
11894             } else DisplayNote(buf);
11895       }
11896       if(ranking) free(ranking);
11897     }
11898 }
11899
11900 /* Assumes program was just initialized (initString sent).
11901    Leaves program in force mode. */
11902 void
11903 FeedMovesToProgram (ChessProgramState *cps, int upto)
11904 {
11905     int i;
11906
11907     if (appData.debugMode)
11908       fprintf(debugFP, "Feeding %smoves %d through %d to %s chess program\n",
11909               startedFromSetupPosition ? "position and " : "",
11910               backwardMostMove, upto, cps->which);
11911     if(currentlyInitializedVariant != gameInfo.variant) {
11912       char buf[MSG_SIZ];
11913         // [HGM] variantswitch: make engine aware of new variant
11914         if(!SupportedVariant(cps->variants, gameInfo.variant, gameInfo.boardWidth,
11915                              gameInfo.boardHeight, gameInfo.holdingsSize, cps->protocolVersion, ""))
11916                 return; // [HGM] refrain from feeding moves altogether if variant is unsupported!
11917         snprintf(buf, MSG_SIZ, "variant %s\n", VariantName(gameInfo.variant));
11918         SendToProgram(buf, cps);
11919         currentlyInitializedVariant = gameInfo.variant;
11920     }
11921     SendToProgram("force\n", cps);
11922     if (startedFromSetupPosition) {
11923         SendBoard(cps, backwardMostMove);
11924     if (appData.debugMode) {
11925         fprintf(debugFP, "feedMoves\n");
11926     }
11927     }
11928     for (i = backwardMostMove; i < upto; i++) {
11929         SendMoveToProgram(i, cps);
11930     }
11931 }
11932
11933
11934 int
11935 ResurrectChessProgram ()
11936 {
11937      /* The chess program may have exited.
11938         If so, restart it and feed it all the moves made so far. */
11939     static int doInit = 0;
11940
11941     if (appData.noChessProgram) return 1;
11942
11943     if(matchMode /*&& appData.tourneyFile[0]*/) { // [HGM] tourney: make sure we get features after engine replacement. (Should we always do this?)
11944         if(WaitForEngine(&first, TwoMachinesEventIfReady)) { doInit = 1; return 0; } // request to do init on next visit, because we started engine
11945         if(!doInit) return 1; // this replaces testing first.pr != NoProc, which is true when we get here, but first time no reason to abort
11946         doInit = 0; // we fell through (first time after starting the engine); make sure it doesn't happen again
11947     } else {
11948         if (first.pr != NoProc) return 1;
11949         StartChessProgram(&first);
11950     }
11951     InitChessProgram(&first, FALSE);
11952     FeedMovesToProgram(&first, currentMove);
11953
11954     if (!first.sendTime) {
11955         /* can't tell gnuchess what its clock should read,
11956            so we bow to its notion. */
11957         ResetClocks();
11958         timeRemaining[0][currentMove] = whiteTimeRemaining;
11959         timeRemaining[1][currentMove] = blackTimeRemaining;
11960     }
11961
11962     if ((gameMode == AnalyzeMode || gameMode == AnalyzeFile ||
11963                 appData.icsEngineAnalyze) && first.analysisSupport) {
11964       SendToProgram("analyze\n", &first);
11965       first.analyzing = TRUE;
11966     }
11967     return 1;
11968 }
11969
11970 /*
11971  * Button procedures
11972  */
11973 void
11974 Reset (int redraw, int init)
11975 {
11976     int i;
11977
11978     if (appData.debugMode) {
11979         fprintf(debugFP, "Reset(%d, %d) from gameMode %d\n",
11980                 redraw, init, gameMode);
11981     }
11982     pieceDefs = FALSE; // [HGM] gen: reset engine-defined piece moves
11983     for(i=0; i<EmptySquare; i++) { FREE(pieceDesc[i]); pieceDesc[i] = NULL; }
11984     CleanupTail(); // [HGM] vari: delete any stored variations
11985     CommentPopDown(); // [HGM] make sure no comments to the previous game keep hanging on
11986     pausing = pauseExamInvalid = FALSE;
11987     startedFromSetupPosition = blackPlaysFirst = FALSE;
11988     firstMove = TRUE;
11989     whiteFlag = blackFlag = FALSE;
11990     userOfferedDraw = FALSE;
11991     hintRequested = bookRequested = FALSE;
11992     first.maybeThinking = FALSE;
11993     second.maybeThinking = FALSE;
11994     first.bookSuspend = FALSE; // [HGM] book
11995     second.bookSuspend = FALSE;
11996     thinkOutput[0] = NULLCHAR;
11997     lastHint[0] = NULLCHAR;
11998     ClearGameInfo(&gameInfo);
11999     gameInfo.variant = StringToVariant(appData.variant);
12000     if(gameInfo.variant == VariantNormal && strcmp(appData.variant, "normal")) {
12001         gameInfo.variant = VariantUnknown;
12002         strncpy(engineVariant, appData.variant, MSG_SIZ);
12003     }
12004     ics_user_moved = ics_clock_paused = FALSE;
12005     ics_getting_history = H_FALSE;
12006     ics_gamenum = -1;
12007     white_holding[0] = black_holding[0] = NULLCHAR;
12008     ClearProgramStats();
12009     opponentKibitzes = FALSE; // [HGM] kibitz: do not reserve space in engine-output window in zippy mode
12010
12011     ResetFrontEnd();
12012     ClearHighlights();
12013     flipView = appData.flipView;
12014     ClearPremoveHighlights();
12015     gotPremove = FALSE;
12016     alarmSounded = FALSE;
12017     killX = killY = kill2X = kill2Y = -1; // [HGM] lion
12018
12019     GameEnds(EndOfFile, NULL, GE_PLAYER);
12020     if(appData.serverMovesName != NULL) {
12021         /* [HGM] prepare to make moves file for broadcasting */
12022         clock_t t = clock();
12023         if(serverMoves != NULL) fclose(serverMoves);
12024         serverMoves = fopen(appData.serverMovesName, "r");
12025         if(serverMoves != NULL) {
12026             fclose(serverMoves);
12027             /* delay 15 sec before overwriting, so all clients can see end */
12028             while(clock()-t < appData.serverPause*CLOCKS_PER_SEC);
12029         }
12030         serverMoves = fopen(appData.serverMovesName, "w");
12031     }
12032
12033     ExitAnalyzeMode();
12034     gameMode = BeginningOfGame;
12035     ModeHighlight();
12036     if(appData.icsActive) gameInfo.variant = VariantNormal;
12037     currentMove = forwardMostMove = backwardMostMove = 0;
12038     MarkTargetSquares(1);
12039     InitPosition(redraw);
12040     for (i = 0; i < MAX_MOVES; i++) {
12041         if (commentList[i] != NULL) {
12042             free(commentList[i]);
12043             commentList[i] = NULL;
12044         }
12045     }
12046     ResetClocks();
12047     timeRemaining[0][0] = whiteTimeRemaining;
12048     timeRemaining[1][0] = blackTimeRemaining;
12049
12050     if (first.pr == NoProc) {
12051         StartChessProgram(&first);
12052     }
12053     if (init) {
12054             InitChessProgram(&first, startedFromSetupPosition);
12055     }
12056     DisplayTitle("");
12057     DisplayMessage("", "");
12058     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
12059     lastSavedGame = 0; // [HGM] save: make sure next game counts as unsaved
12060     ClearMap();        // [HGM] exclude: invalidate map
12061 }
12062
12063 void
12064 AutoPlayGameLoop ()
12065 {
12066     for (;;) {
12067         if (!AutoPlayOneMove())
12068           return;
12069         if (matchMode || appData.timeDelay == 0)
12070           continue;
12071         if (appData.timeDelay < 0)
12072           return;
12073         StartLoadGameTimer((long)(1000.0f * appData.timeDelay));
12074         break;
12075     }
12076 }
12077
12078 void
12079 AnalyzeNextGame()
12080 {
12081     ReloadGame(1); // next game
12082 }
12083
12084 int
12085 AutoPlayOneMove ()
12086 {
12087     int fromX, fromY, toX, toY;
12088
12089     if (appData.debugMode) {
12090       fprintf(debugFP, "AutoPlayOneMove(): current %d\n", currentMove);
12091     }
12092
12093     if (gameMode != PlayFromGameFile && gameMode != AnalyzeFile)
12094       return FALSE;
12095
12096     if (gameMode == AnalyzeFile && currentMove > backwardMostMove && programStats.depth) {
12097       pvInfoList[currentMove].depth = programStats.depth;
12098       pvInfoList[currentMove].score = programStats.score;
12099       pvInfoList[currentMove].time  = 0;
12100       if(currentMove < forwardMostMove) AppendComment(currentMove+1, lastPV[0], 2);
12101       else { // append analysis of final position as comment
12102         char buf[MSG_SIZ];
12103         snprintf(buf, MSG_SIZ, "{final score %+4.2f/%d}", programStats.score/100., programStats.depth);
12104         AppendComment(currentMove, buf, 3); // the 3 prevents stripping of the score/depth!
12105       }
12106       programStats.depth = 0;
12107     }
12108
12109     if (currentMove >= forwardMostMove) {
12110       if(gameMode == AnalyzeFile) {
12111           if(appData.loadGameIndex == -1) {
12112             GameEnds(gameInfo.result, gameInfo.resultDetails ? gameInfo.resultDetails : "", GE_FILE);
12113           ScheduleDelayedEvent(AnalyzeNextGame, 10);
12114           } else {
12115           ExitAnalyzeMode(); SendToProgram("force\n", &first);
12116         }
12117       }
12118 //      gameMode = EndOfGame;
12119 //      ModeHighlight();
12120
12121       /* [AS] Clear current move marker at the end of a game */
12122       /* HistorySet(parseList, backwardMostMove, forwardMostMove, -1); */
12123
12124       return FALSE;
12125     }
12126
12127     toX = moveList[currentMove][2] - AAA;
12128     toY = moveList[currentMove][3] - ONE;
12129
12130     if (moveList[currentMove][1] == '@') {
12131         if (appData.highlightLastMove) {
12132             SetHighlights(-1, -1, toX, toY);
12133         }
12134     } else {
12135         fromX = moveList[currentMove][0] - AAA;
12136         fromY = moveList[currentMove][1] - ONE;
12137
12138         HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove); /* [AS] */
12139
12140         if(moveList[currentMove][4] == ';') { // multi-leg
12141             killX = moveList[currentMove][5] - AAA;
12142             killY = moveList[currentMove][6] - ONE;
12143         }
12144         AnimateMove(boards[currentMove], fromX, fromY, toX, toY);
12145         killX = killY = -1;
12146
12147         if (appData.highlightLastMove) {
12148             SetHighlights(fromX, fromY, toX, toY);
12149         }
12150     }
12151     DisplayMove(currentMove);
12152     SendMoveToProgram(currentMove++, &first);
12153     DisplayBothClocks();
12154     DrawPosition(FALSE, boards[currentMove]);
12155     // [HGM] PV info: always display, routine tests if empty
12156     DisplayComment(currentMove - 1, commentList[currentMove]);
12157     return TRUE;
12158 }
12159
12160
12161 int
12162 LoadGameOneMove (ChessMove readAhead)
12163 {
12164     int fromX = 0, fromY = 0, toX = 0, toY = 0, done;
12165     char promoChar = NULLCHAR;
12166     ChessMove moveType;
12167     char move[MSG_SIZ];
12168     char *p, *q;
12169
12170     if (gameMode != PlayFromGameFile && gameMode != AnalyzeFile &&
12171         gameMode != AnalyzeMode && gameMode != Training) {
12172         gameFileFP = NULL;
12173         return FALSE;
12174     }
12175
12176     yyboardindex = forwardMostMove;
12177     if (readAhead != EndOfFile) {
12178       moveType = readAhead;
12179     } else {
12180       if (gameFileFP == NULL)
12181           return FALSE;
12182       moveType = (ChessMove) Myylex();
12183     }
12184
12185     done = FALSE;
12186     switch (moveType) {
12187       case Comment:
12188         if (appData.debugMode)
12189           fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
12190         p = yy_text;
12191
12192         /* append the comment but don't display it */
12193         AppendComment(currentMove, p, FALSE);
12194         return TRUE;
12195
12196       case WhiteCapturesEnPassant:
12197       case BlackCapturesEnPassant:
12198       case WhitePromotion:
12199       case BlackPromotion:
12200       case WhiteNonPromotion:
12201       case BlackNonPromotion:
12202       case NormalMove:
12203       case FirstLeg:
12204       case WhiteKingSideCastle:
12205       case WhiteQueenSideCastle:
12206       case BlackKingSideCastle:
12207       case BlackQueenSideCastle:
12208       case WhiteKingSideCastleWild:
12209       case WhiteQueenSideCastleWild:
12210       case BlackKingSideCastleWild:
12211       case BlackQueenSideCastleWild:
12212       /* PUSH Fabien */
12213       case WhiteHSideCastleFR:
12214       case WhiteASideCastleFR:
12215       case BlackHSideCastleFR:
12216       case BlackASideCastleFR:
12217       /* POP Fabien */
12218         if (appData.debugMode)
12219           fprintf(debugFP, "Parsed %s into %s virgin=%x,%x\n", yy_text, currentMoveString, boards[forwardMostMove][TOUCHED_W], boards[forwardMostMove][TOUCHED_B]);
12220         fromX = currentMoveString[0] - AAA;
12221         fromY = currentMoveString[1] - ONE;
12222         toX = currentMoveString[2] - AAA;
12223         toY = currentMoveString[3] - ONE;
12224         promoChar = currentMoveString[4];
12225         if(promoChar == ';') promoChar = currentMoveString[7];
12226         break;
12227
12228       case WhiteDrop:
12229       case BlackDrop:
12230         if (appData.debugMode)
12231           fprintf(debugFP, "Parsed %s into %s\n", yy_text, currentMoveString);
12232         fromX = moveType == WhiteDrop ?
12233           (int) CharToPiece(ToUpper(currentMoveString[0])) :
12234         (int) CharToPiece(ToLower(currentMoveString[0]));
12235         fromY = DROP_RANK;
12236         toX = currentMoveString[2] - AAA;
12237         toY = currentMoveString[3] - ONE;
12238         break;
12239
12240       case WhiteWins:
12241       case BlackWins:
12242       case GameIsDrawn:
12243       case GameUnfinished:
12244         if (appData.debugMode)
12245           fprintf(debugFP, "Parsed game end: %s\n", yy_text);
12246         p = strchr(yy_text, '{');
12247         if (p == NULL) p = strchr(yy_text, '(');
12248         if (p == NULL) {
12249             p = yy_text;
12250             if (p[0] == '0' || p[0] == '1' || p[0] == '*') p = "";
12251         } else {
12252             q = strchr(p, *p == '{' ? '}' : ')');
12253             if (q != NULL) *q = NULLCHAR;
12254             p++;
12255         }
12256         while(q = strchr(p, '\n')) *q = ' '; // [HGM] crush linefeeds in result message
12257         GameEnds(moveType, p, GE_FILE);
12258         done = TRUE;
12259         if (cmailMsgLoaded) {
12260             ClearHighlights();
12261             flipView = WhiteOnMove(currentMove);
12262             if (moveType == GameUnfinished) flipView = !flipView;
12263             if (appData.debugMode)
12264               fprintf(debugFP, "Setting flipView to %d\n", flipView) ;
12265         }
12266         break;
12267
12268       case EndOfFile:
12269         if (appData.debugMode)
12270           fprintf(debugFP, "Parser hit end of file\n");
12271         switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
12272           case MT_NONE:
12273           case MT_CHECK:
12274             break;
12275           case MT_CHECKMATE:
12276           case MT_STAINMATE:
12277             if (WhiteOnMove(currentMove)) {
12278                 GameEnds(BlackWins, "Black mates", GE_FILE);
12279             } else {
12280                 GameEnds(WhiteWins, "White mates", GE_FILE);
12281             }
12282             break;
12283           case MT_STALEMATE:
12284             GameEnds(GameIsDrawn, "Stalemate", GE_FILE);
12285             break;
12286         }
12287         done = TRUE;
12288         break;
12289
12290       case MoveNumberOne:
12291         if (lastLoadGameStart == GNUChessGame) {
12292             /* GNUChessGames have numbers, but they aren't move numbers */
12293             if (appData.debugMode)
12294               fprintf(debugFP, "Parser ignoring: '%s' (%d)\n",
12295                       yy_text, (int) moveType);
12296             return LoadGameOneMove(EndOfFile); /* tail recursion */
12297         }
12298         /* else fall thru */
12299
12300       case XBoardGame:
12301       case GNUChessGame:
12302       case PGNTag:
12303         /* Reached start of next game in file */
12304         if (appData.debugMode)
12305           fprintf(debugFP, "Parsed start of next game: %s\n", yy_text);
12306         switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
12307           case MT_NONE:
12308           case MT_CHECK:
12309             break;
12310           case MT_CHECKMATE:
12311           case MT_STAINMATE:
12312             if (WhiteOnMove(currentMove)) {
12313                 GameEnds(BlackWins, "Black mates", GE_FILE);
12314             } else {
12315                 GameEnds(WhiteWins, "White mates", GE_FILE);
12316             }
12317             break;
12318           case MT_STALEMATE:
12319             GameEnds(GameIsDrawn, "Stalemate", GE_FILE);
12320             break;
12321         }
12322         done = TRUE;
12323         break;
12324
12325       case PositionDiagram:     /* should not happen; ignore */
12326       case ElapsedTime:         /* ignore */
12327       case NAG:                 /* ignore */
12328         if (appData.debugMode)
12329           fprintf(debugFP, "Parser ignoring: '%s' (%d)\n",
12330                   yy_text, (int) moveType);
12331         return LoadGameOneMove(EndOfFile); /* tail recursion */
12332
12333       case IllegalMove:
12334         if (appData.testLegality) {
12335             if (appData.debugMode)
12336               fprintf(debugFP, "Parsed IllegalMove: %s\n", yy_text);
12337             snprintf(move, MSG_SIZ, _("Illegal move: %d.%s%s"),
12338                     (forwardMostMove / 2) + 1,
12339                     WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
12340             DisplayError(move, 0);
12341             done = TRUE;
12342         } else {
12343             if (appData.debugMode)
12344               fprintf(debugFP, "Parsed %s into IllegalMove %s\n",
12345                       yy_text, currentMoveString);
12346             if(currentMoveString[1] == '@') {
12347                 fromX = CharToPiece(WhiteOnMove(currentMove) ? ToUpper(currentMoveString[0]) : ToLower(currentMoveString[0]));
12348                 fromY = DROP_RANK;
12349             } else {
12350                 fromX = currentMoveString[0] - AAA;
12351                 fromY = currentMoveString[1] - ONE;
12352             }
12353             toX = currentMoveString[2] - AAA;
12354             toY = currentMoveString[3] - ONE;
12355             promoChar = currentMoveString[4];
12356         }
12357         break;
12358
12359       case AmbiguousMove:
12360         if (appData.debugMode)
12361           fprintf(debugFP, "Parsed AmbiguousMove: %s\n", yy_text);
12362         snprintf(move, MSG_SIZ, _("Ambiguous move: %d.%s%s"),
12363                 (forwardMostMove / 2) + 1,
12364                 WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
12365         DisplayError(move, 0);
12366         done = TRUE;
12367         break;
12368
12369       default:
12370       case ImpossibleMove:
12371         if (appData.debugMode)
12372           fprintf(debugFP, "Parsed ImpossibleMove (type = %d): %s\n", moveType, yy_text);
12373         snprintf(move, MSG_SIZ, _("Illegal move: %d.%s%s"),
12374                 (forwardMostMove / 2) + 1,
12375                 WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
12376         DisplayError(move, 0);
12377         done = TRUE;
12378         break;
12379     }
12380
12381     if (done) {
12382         if (appData.matchMode || (appData.timeDelay == 0 && !pausing)) {
12383             DrawPosition(FALSE, boards[currentMove]);
12384             DisplayBothClocks();
12385             if (!appData.matchMode) // [HGM] PV info: routine tests if empty
12386               DisplayComment(currentMove - 1, commentList[currentMove]);
12387         }
12388         (void) StopLoadGameTimer();
12389         gameFileFP = NULL;
12390         cmailOldMove = forwardMostMove;
12391         return FALSE;
12392     } else {
12393         /* currentMoveString is set as a side-effect of yylex */
12394
12395         thinkOutput[0] = NULLCHAR;
12396         MakeMove(fromX, fromY, toX, toY, promoChar);
12397         killX = killY = kill2X = kill2Y = -1; // [HGM] lion: used up
12398         currentMove = forwardMostMove;
12399         return TRUE;
12400     }
12401 }
12402
12403 /* Load the nth game from the given file */
12404 int
12405 LoadGameFromFile (char *filename, int n, char *title, int useList)
12406 {
12407     FILE *f;
12408     char buf[MSG_SIZ];
12409
12410     if (strcmp(filename, "-") == 0) {
12411         f = stdin;
12412         title = "stdin";
12413     } else {
12414         f = fopen(filename, "rb");
12415         if (f == NULL) {
12416           snprintf(buf, sizeof(buf),  _("Can't open \"%s\""), filename);
12417             DisplayError(buf, errno);
12418             return FALSE;
12419         }
12420     }
12421     if (fseek(f, 0, 0) == -1) {
12422         /* f is not seekable; probably a pipe */
12423         useList = FALSE;
12424     }
12425     if (useList && n == 0) {
12426         int error = GameListBuild(f);
12427         if (error) {
12428             DisplayError(_("Cannot build game list"), error);
12429         } else if (!ListEmpty(&gameList) &&
12430                    ((ListGame *) gameList.tailPred)->number > 1) {
12431             GameListPopUp(f, title);
12432             return TRUE;
12433         }
12434         GameListDestroy();
12435         n = 1;
12436     }
12437     if (n == 0) n = 1;
12438     return LoadGame(f, n, title, FALSE);
12439 }
12440
12441
12442 void
12443 MakeRegisteredMove ()
12444 {
12445     int fromX, fromY, toX, toY;
12446     char promoChar;
12447     if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
12448         switch (cmailMoveType[lastLoadGameNumber - 1]) {
12449           case CMAIL_MOVE:
12450           case CMAIL_DRAW:
12451             if (appData.debugMode)
12452               fprintf(debugFP, "Restoring %s for game %d\n",
12453                       cmailMove[lastLoadGameNumber - 1], lastLoadGameNumber);
12454
12455             thinkOutput[0] = NULLCHAR;
12456             safeStrCpy(moveList[currentMove], cmailMove[lastLoadGameNumber - 1], sizeof(moveList[currentMove])/sizeof(moveList[currentMove][0]));
12457             fromX = cmailMove[lastLoadGameNumber - 1][0] - AAA;
12458             fromY = cmailMove[lastLoadGameNumber - 1][1] - ONE;
12459             toX = cmailMove[lastLoadGameNumber - 1][2] - AAA;
12460             toY = cmailMove[lastLoadGameNumber - 1][3] - ONE;
12461             promoChar = cmailMove[lastLoadGameNumber - 1][4];
12462             MakeMove(fromX, fromY, toX, toY, promoChar);
12463             ShowMove(fromX, fromY, toX, toY);
12464
12465             switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
12466               case MT_NONE:
12467               case MT_CHECK:
12468                 break;
12469
12470               case MT_CHECKMATE:
12471               case MT_STAINMATE:
12472                 if (WhiteOnMove(currentMove)) {
12473                     GameEnds(BlackWins, "Black mates", GE_PLAYER);
12474                 } else {
12475                     GameEnds(WhiteWins, "White mates", GE_PLAYER);
12476                 }
12477                 break;
12478
12479               case MT_STALEMATE:
12480                 GameEnds(GameIsDrawn, "Stalemate", GE_PLAYER);
12481                 break;
12482             }
12483
12484             break;
12485
12486           case CMAIL_RESIGN:
12487             if (WhiteOnMove(currentMove)) {
12488                 GameEnds(BlackWins, "White resigns", GE_PLAYER);
12489             } else {
12490                 GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
12491             }
12492             break;
12493
12494           case CMAIL_ACCEPT:
12495             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
12496             break;
12497
12498           default:
12499             break;
12500         }
12501     }
12502
12503     return;
12504 }
12505
12506 /* Wrapper around LoadGame for use when a Cmail message is loaded */
12507 int
12508 CmailLoadGame (FILE *f, int gameNumber, char *title, int useList)
12509 {
12510     int retVal;
12511
12512     if (gameNumber > nCmailGames) {
12513         DisplayError(_("No more games in this message"), 0);
12514         return FALSE;
12515     }
12516     if (f == lastLoadGameFP) {
12517         int offset = gameNumber - lastLoadGameNumber;
12518         if (offset == 0) {
12519             cmailMsg[0] = NULLCHAR;
12520             if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
12521                 cmailMoveRegistered[lastLoadGameNumber - 1] = FALSE;
12522                 nCmailMovesRegistered--;
12523             }
12524             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
12525             if (cmailResult[lastLoadGameNumber - 1] == CMAIL_NEW_RESULT) {
12526                 cmailResult[lastLoadGameNumber - 1] = CMAIL_NOT_RESULT;
12527             }
12528         } else {
12529             if (! RegisterMove()) return FALSE;
12530         }
12531     }
12532
12533     retVal = LoadGame(f, gameNumber, title, useList);
12534
12535     /* Make move registered during previous look at this game, if any */
12536     MakeRegisteredMove();
12537
12538     if (cmailCommentList[lastLoadGameNumber - 1] != NULL) {
12539         commentList[currentMove]
12540           = StrSave(cmailCommentList[lastLoadGameNumber - 1]);
12541         DisplayComment(currentMove - 1, commentList[currentMove]);
12542     }
12543
12544     return retVal;
12545 }
12546
12547 /* Support for LoadNextGame, LoadPreviousGame, ReloadSameGame */
12548 int
12549 ReloadGame (int offset)
12550 {
12551     int gameNumber = lastLoadGameNumber + offset;
12552     if (lastLoadGameFP == NULL) {
12553         DisplayError(_("No game has been loaded yet"), 0);
12554         return FALSE;
12555     }
12556     if (gameNumber <= 0) {
12557         DisplayError(_("Can't back up any further"), 0);
12558         return FALSE;
12559     }
12560     if (cmailMsgLoaded) {
12561         return CmailLoadGame(lastLoadGameFP, gameNumber,
12562                              lastLoadGameTitle, lastLoadGameUseList);
12563     } else {
12564         return LoadGame(lastLoadGameFP, gameNumber,
12565                         lastLoadGameTitle, lastLoadGameUseList);
12566     }
12567 }
12568
12569 int keys[EmptySquare+1];
12570
12571 int
12572 PositionMatches (Board b1, Board b2)
12573 {
12574     int r, f, sum=0;
12575     switch(appData.searchMode) {
12576         case 1: return CompareWithRights(b1, b2);
12577         case 2:
12578             for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12579                 if(b2[r][f] != EmptySquare && b1[r][f] != b2[r][f]) return FALSE;
12580             }
12581             return TRUE;
12582         case 3:
12583             for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12584               if((b2[r][f] == WhitePawn || b2[r][f] == BlackPawn) && b1[r][f] != b2[r][f]) return FALSE;
12585                 sum += keys[b1[r][f]] - keys[b2[r][f]];
12586             }
12587             return sum==0;
12588         case 4:
12589             for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12590                 sum += keys[b1[r][f]] - keys[b2[r][f]];
12591             }
12592             return sum==0;
12593     }
12594     return TRUE;
12595 }
12596
12597 #define Q_PROMO  4
12598 #define Q_EP     3
12599 #define Q_BCASTL 2
12600 #define Q_WCASTL 1
12601
12602 int pieceList[256], quickBoard[256];
12603 ChessSquare pieceType[256] = { EmptySquare };
12604 Board soughtBoard, reverseBoard, flipBoard, rotateBoard;
12605 int counts[EmptySquare], minSought[EmptySquare], minReverse[EmptySquare], maxSought[EmptySquare], maxReverse[EmptySquare];
12606 int soughtTotal, turn;
12607 Boolean epOK, flipSearch;
12608
12609 typedef struct {
12610     unsigned char piece, to;
12611 } Move;
12612
12613 #define DSIZE (250000)
12614
12615 Move initialSpace[DSIZE+1000]; // gamble on that game will not be more than 500 moves
12616 Move *moveDatabase = initialSpace;
12617 unsigned int movePtr, dataSize = DSIZE;
12618
12619 int
12620 MakePieceList (Board board, int *counts)
12621 {
12622     int r, f, n=Q_PROMO, total=0;
12623     for(r=0;r<EmptySquare;r++) counts[r] = 0; // piece-type counts
12624     for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12625         int sq = f + (r<<4);
12626         if(board[r][f] == EmptySquare) quickBoard[sq] = 0; else {
12627             quickBoard[sq] = ++n;
12628             pieceList[n] = sq;
12629             pieceType[n] = board[r][f];
12630             counts[board[r][f]]++;
12631             if(board[r][f] == WhiteKing) pieceList[1] = n; else
12632             if(board[r][f] == BlackKing) pieceList[2] = n; // remember which are Kings, for castling
12633             total++;
12634         }
12635     }
12636     epOK = gameInfo.variant != VariantXiangqi && gameInfo.variant != VariantBerolina;
12637     return total;
12638 }
12639
12640 void
12641 PackMove (int fromX, int fromY, int toX, int toY, ChessSquare promoPiece)
12642 {
12643     int sq = fromX + (fromY<<4);
12644     int piece = quickBoard[sq], rook;
12645     quickBoard[sq] = 0;
12646     moveDatabase[movePtr].to = pieceList[piece] = sq = toX + (toY<<4);
12647     if(piece == pieceList[1] && fromY == toY) {
12648       if((toX > fromX+1 || toX < fromX-1) && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1) {
12649         int from = toX>fromX ? BOARD_RGHT-1 : BOARD_LEFT;
12650         moveDatabase[movePtr++].piece = Q_WCASTL;
12651         quickBoard[sq] = piece;
12652         piece = quickBoard[from]; quickBoard[from] = 0;
12653         moveDatabase[movePtr].to = pieceList[piece] = sq = toX>fromX ? sq-1 : sq+1;
12654       } else if((rook = quickBoard[sq]) && pieceType[rook] == WhiteRook) { // FRC castling
12655         quickBoard[sq] = 0; // remove Rook
12656         moveDatabase[movePtr].to = sq = (toX>fromX ? BOARD_RGHT-2 : BOARD_LEFT+2); // King to-square
12657         moveDatabase[movePtr++].piece = Q_WCASTL;
12658         quickBoard[sq] = pieceList[1]; // put King
12659         piece = rook;
12660         moveDatabase[movePtr].to = pieceList[rook] = sq = toX>fromX ? sq-1 : sq+1;
12661       }
12662     } else
12663     if(piece == pieceList[2] && fromY == toY) {
12664       if((toX > fromX+1 || toX < fromX-1) && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1) {
12665         int from = (toX>fromX ? BOARD_RGHT-1 : BOARD_LEFT) + (BOARD_HEIGHT-1 <<4);
12666         moveDatabase[movePtr++].piece = Q_BCASTL;
12667         quickBoard[sq] = piece;
12668         piece = quickBoard[from]; quickBoard[from] = 0;
12669         moveDatabase[movePtr].to = pieceList[piece] = sq = toX>fromX ? sq-1 : sq+1;
12670       } else if((rook = quickBoard[sq]) && pieceType[rook] == BlackRook) { // FRC castling
12671         quickBoard[sq] = 0; // remove Rook
12672         moveDatabase[movePtr].to = sq = (toX>fromX ? BOARD_RGHT-2 : BOARD_LEFT+2);
12673         moveDatabase[movePtr++].piece = Q_BCASTL;
12674         quickBoard[sq] = pieceList[2]; // put King
12675         piece = rook;
12676         moveDatabase[movePtr].to = pieceList[rook] = sq = toX>fromX ? sq-1 : sq+1;
12677       }
12678     } else
12679     if(epOK && (pieceType[piece] == WhitePawn || pieceType[piece] == BlackPawn) && fromX != toX && quickBoard[sq] == 0) {
12680         quickBoard[(fromY<<4)+toX] = 0;
12681         moveDatabase[movePtr].piece = Q_EP;
12682         moveDatabase[movePtr++].to = (fromY<<4)+toX;
12683         moveDatabase[movePtr].to = sq;
12684     } else
12685     if(promoPiece != pieceType[piece]) {
12686         moveDatabase[movePtr++].piece = Q_PROMO;
12687         moveDatabase[movePtr].to = pieceType[piece] = (int) promoPiece;
12688     }
12689     moveDatabase[movePtr].piece = piece;
12690     quickBoard[sq] = piece;
12691     movePtr++;
12692 }
12693
12694 int
12695 PackGame (Board board)
12696 {
12697     Move *newSpace = NULL;
12698     moveDatabase[movePtr].piece = 0; // terminate previous game
12699     if(movePtr > dataSize) {
12700         if(appData.debugMode) fprintf(debugFP, "move-cache overflow, enlarge to %d MB\n", dataSize/128);
12701         dataSize *= 8; // increase size by factor 8 (512KB -> 4MB -> 32MB -> 256MB -> 2GB)
12702         if(dataSize) newSpace = (Move*) calloc(dataSize + 1000, sizeof(Move));
12703         if(newSpace) {
12704             int i;
12705             Move *p = moveDatabase, *q = newSpace;
12706             for(i=0; i<movePtr; i++) *q++ = *p++;    // copy to newly allocated space
12707             if(dataSize > 8*DSIZE) free(moveDatabase); // and free old space (if it was allocated)
12708             moveDatabase = newSpace;
12709         } else { // calloc failed, we must be out of memory. Too bad...
12710             dataSize = 0; // prevent calloc events for all subsequent games
12711             return 0;     // and signal this one isn't cached
12712         }
12713     }
12714     movePtr++;
12715     MakePieceList(board, counts);
12716     return movePtr;
12717 }
12718
12719 int
12720 QuickCompare (Board board, int *minCounts, int *maxCounts)
12721 {   // compare according to search mode
12722     int r, f;
12723     switch(appData.searchMode)
12724     {
12725       case 1: // exact position match
12726         if(!(turn & board[EP_STATUS-1])) return FALSE; // wrong side to move
12727         for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12728             if(board[r][f] != pieceType[quickBoard[(r<<4)+f]]) return FALSE;
12729         }
12730         break;
12731       case 2: // can have extra material on empty squares
12732         for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12733             if(board[r][f] == EmptySquare) continue;
12734             if(board[r][f] != pieceType[quickBoard[(r<<4)+f]]) return FALSE;
12735         }
12736         break;
12737       case 3: // material with exact Pawn structure
12738         for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12739             if(board[r][f] != WhitePawn && board[r][f] != BlackPawn) continue;
12740             if(board[r][f] != pieceType[quickBoard[(r<<4)+f]]) return FALSE;
12741         } // fall through to material comparison
12742       case 4: // exact material
12743         for(r=0; r<EmptySquare; r++) if(counts[r] != maxCounts[r]) return FALSE;
12744         break;
12745       case 6: // material range with given imbalance
12746         for(r=0; r<BlackPawn; r++) if(counts[r] - minCounts[r] != counts[r+BlackPawn] - minCounts[r+BlackPawn]) return FALSE;
12747         // fall through to range comparison
12748       case 5: // material range
12749         for(r=0; r<EmptySquare; r++) if(counts[r] < minCounts[r] || counts[r] > maxCounts[r]) return FALSE;
12750     }
12751     return TRUE;
12752 }
12753
12754 int
12755 QuickScan (Board board, Move *move)
12756 {   // reconstruct game,and compare all positions in it
12757     int cnt=0, stretch=0, found = -1, total = MakePieceList(board, counts);
12758     do {
12759         int piece = move->piece;
12760         int to = move->to, from = pieceList[piece];
12761         if(found < 0) { // if already found just scan to game end for final piece count
12762           if(QuickCompare(soughtBoard, minSought, maxSought) ||
12763            appData.ignoreColors && QuickCompare(reverseBoard, minReverse, maxReverse) ||
12764            flipSearch && (QuickCompare(flipBoard, minSought, maxSought) ||
12765                                 appData.ignoreColors && QuickCompare(rotateBoard, minReverse, maxReverse))
12766             ) {
12767             static int lastCounts[EmptySquare+1];
12768             int i;
12769             if(stretch) for(i=0; i<EmptySquare; i++) if(lastCounts[i] != counts[i]) { stretch = 0; break; } // reset if material changes
12770             if(stretch++ == 0) for(i=0; i<EmptySquare; i++) lastCounts[i] = counts[i]; // remember actual material
12771           } else stretch = 0;
12772           if(stretch && (appData.searchMode == 1 || stretch >= appData.stretch)) found = cnt + 1 - stretch;
12773           if(found >= 0 && !appData.minPieces) return found;
12774         }
12775         if(piece <= Q_PROMO) { // special moves encoded by otherwise invalid piece numbers 1-4
12776           if(!piece) return (appData.minPieces && (total < appData.minPieces || total > appData.maxPieces) ? -1 : found);
12777           if(piece == Q_PROMO) { // promotion, encoded as (Q_PROMO, to) + (piece, promoType)
12778             piece = (++move)->piece;
12779             from = pieceList[piece];
12780             counts[pieceType[piece]]--;
12781             pieceType[piece] = (ChessSquare) move->to;
12782             counts[move->to]++;
12783           } else if(piece == Q_EP) { // e.p. capture, encoded as (Q_EP, ep-sqr) + (piece, to)
12784             counts[pieceType[quickBoard[to]]]--;
12785             quickBoard[to] = 0; total--;
12786             move++;
12787             continue;
12788           } else if(piece <= Q_BCASTL) { // castling, encoded as (Q_XCASTL, king-to) + (rook, rook-to)
12789             piece = pieceList[piece]; // first two elements of pieceList contain King numbers
12790             from  = pieceList[piece]; // so this must be King
12791             quickBoard[from] = 0;
12792             pieceList[piece] = to;
12793             from = pieceList[(++move)->piece]; // for FRC this has to be done here
12794             quickBoard[from] = 0; // rook
12795             quickBoard[to] = piece;
12796             to = move->to; piece = move->piece;
12797             goto aftercastle;
12798           }
12799         }
12800         if(appData.searchMode > 2) counts[pieceType[quickBoard[to]]]--; // account capture
12801         if((total -= (quickBoard[to] != 0)) < soughtTotal && found < 0) return -1; // piece count dropped below what we search for
12802         quickBoard[from] = 0;
12803       aftercastle:
12804         quickBoard[to] = piece;
12805         pieceList[piece] = to;
12806         cnt++; turn ^= 3;
12807         move++;
12808     } while(1);
12809 }
12810
12811 void
12812 InitSearch ()
12813 {
12814     int r, f;
12815     flipSearch = FALSE;
12816     CopyBoard(soughtBoard, boards[currentMove]);
12817     soughtTotal = MakePieceList(soughtBoard, maxSought);
12818     soughtBoard[EP_STATUS-1] = (currentMove & 1) + 1;
12819     if(currentMove == 0 && gameMode == EditPosition) soughtBoard[EP_STATUS-1] = blackPlaysFirst + 1; // (!)
12820     CopyBoard(reverseBoard, boards[currentMove]);
12821     for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12822         int piece = boards[currentMove][BOARD_HEIGHT-1-r][f];
12823         if(piece < BlackPawn) piece += BlackPawn; else if(piece < EmptySquare) piece -= BlackPawn; // color-flip
12824         reverseBoard[r][f] = piece;
12825     }
12826     reverseBoard[EP_STATUS-1] = soughtBoard[EP_STATUS-1] ^ 3;
12827     for(r=0; r<6; r++) reverseBoard[CASTLING][r] = boards[currentMove][CASTLING][(r+3)%6];
12828     if(appData.findMirror && appData.searchMode <= 3 && (!nrCastlingRights
12829                  || (boards[currentMove][CASTLING][2] == NoRights ||
12830                      boards[currentMove][CASTLING][0] == NoRights && boards[currentMove][CASTLING][1] == NoRights )
12831                  && (boards[currentMove][CASTLING][5] == NoRights ||
12832                      boards[currentMove][CASTLING][3] == NoRights && boards[currentMove][CASTLING][4] == NoRights ) )
12833       ) {
12834         flipSearch = TRUE;
12835         CopyBoard(flipBoard, soughtBoard);
12836         CopyBoard(rotateBoard, reverseBoard);
12837         for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12838             flipBoard[r][f]    = soughtBoard[r][BOARD_WIDTH-1-f];
12839             rotateBoard[r][f] = reverseBoard[r][BOARD_WIDTH-1-f];
12840         }
12841     }
12842     for(r=0; r<BlackPawn; r++) maxReverse[r] = maxSought[r+BlackPawn], maxReverse[r+BlackPawn] = maxSought[r];
12843     if(appData.searchMode >= 5) {
12844         for(r=BOARD_HEIGHT/2; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) soughtBoard[r][f] = EmptySquare;
12845         MakePieceList(soughtBoard, minSought);
12846         for(r=0; r<BlackPawn; r++) minReverse[r] = minSought[r+BlackPawn], minReverse[r+BlackPawn] = minSought[r];
12847     }
12848     if(gameInfo.variant == VariantCrazyhouse || gameInfo.variant == VariantShogi || gameInfo.variant == VariantBughouse)
12849         soughtTotal = 0; // in drop games nr of pieces does not fall monotonously
12850 }
12851
12852 GameInfo dummyInfo;
12853 static int creatingBook;
12854
12855 int
12856 GameContainsPosition (FILE *f, ListGame *lg)
12857 {
12858     int next, btm=0, plyNr=0, scratch=forwardMostMove+2&~1;
12859     int fromX, fromY, toX, toY;
12860     char promoChar;
12861     static int initDone=FALSE;
12862
12863     // weed out games based on numerical tag comparison
12864     if(lg->gameInfo.variant != gameInfo.variant) return -1; // wrong variant
12865     if(appData.eloThreshold1 && (lg->gameInfo.whiteRating < appData.eloThreshold1 && lg->gameInfo.blackRating < appData.eloThreshold1)) return -1;
12866     if(appData.eloThreshold2 && (lg->gameInfo.whiteRating < appData.eloThreshold2 || lg->gameInfo.blackRating < appData.eloThreshold2)) return -1;
12867     if(appData.dateThreshold && (!lg->gameInfo.date || atoi(lg->gameInfo.date) < appData.dateThreshold)) return -1;
12868     if(!initDone) {
12869         for(next = WhitePawn; next<EmptySquare; next++) keys[next] = random()>>8 ^ random()<<6 ^random()<<20;
12870         initDone = TRUE;
12871     }
12872     if(lg->gameInfo.fen) ParseFEN(boards[scratch], &btm, lg->gameInfo.fen, FALSE);
12873     else CopyBoard(boards[scratch], initialPosition); // default start position
12874     if(lg->moves) {
12875         turn = btm + 1;
12876         if((next = QuickScan( boards[scratch], &moveDatabase[lg->moves] )) < 0) return -1; // quick scan rules out it is there
12877         if(appData.searchMode >= 4) return next; // for material searches, trust QuickScan.
12878     }
12879     if(btm) plyNr++;
12880     if(PositionMatches(boards[scratch], boards[currentMove])) return plyNr;
12881     fseek(f, lg->offset, 0);
12882     yynewfile(f);
12883     while(1) {
12884         yyboardindex = scratch;
12885         quickFlag = plyNr+1;
12886         next = Myylex();
12887         quickFlag = 0;
12888         switch(next) {
12889             case PGNTag:
12890                 if(plyNr) return -1; // after we have seen moves, any tags will be start of next game
12891             default:
12892                 continue;
12893
12894             case XBoardGame:
12895             case GNUChessGame:
12896                 if(plyNr) return -1; // after we have seen moves, this is for new game
12897               continue;
12898
12899             case AmbiguousMove: // we cannot reconstruct the game beyond these two
12900             case ImpossibleMove:
12901             case WhiteWins: // game ends here with these four
12902             case BlackWins:
12903             case GameIsDrawn:
12904             case GameUnfinished:
12905                 return -1;
12906
12907             case IllegalMove:
12908                 if(appData.testLegality) return -1;
12909             case WhiteCapturesEnPassant:
12910             case BlackCapturesEnPassant:
12911             case WhitePromotion:
12912             case BlackPromotion:
12913             case WhiteNonPromotion:
12914             case BlackNonPromotion:
12915             case NormalMove:
12916             case FirstLeg:
12917             case WhiteKingSideCastle:
12918             case WhiteQueenSideCastle:
12919             case BlackKingSideCastle:
12920             case BlackQueenSideCastle:
12921             case WhiteKingSideCastleWild:
12922             case WhiteQueenSideCastleWild:
12923             case BlackKingSideCastleWild:
12924             case BlackQueenSideCastleWild:
12925             case WhiteHSideCastleFR:
12926             case WhiteASideCastleFR:
12927             case BlackHSideCastleFR:
12928             case BlackASideCastleFR:
12929                 fromX = currentMoveString[0] - AAA;
12930                 fromY = currentMoveString[1] - ONE;
12931                 toX = currentMoveString[2] - AAA;
12932                 toY = currentMoveString[3] - ONE;
12933                 promoChar = currentMoveString[4];
12934                 break;
12935             case WhiteDrop:
12936             case BlackDrop:
12937                 fromX = next == WhiteDrop ?
12938                   (int) CharToPiece(ToUpper(currentMoveString[0])) :
12939                   (int) CharToPiece(ToLower(currentMoveString[0]));
12940                 fromY = DROP_RANK;
12941                 toX = currentMoveString[2] - AAA;
12942                 toY = currentMoveString[3] - ONE;
12943                 promoChar = 0;
12944                 break;
12945         }
12946         // Move encountered; peform it. We need to shuttle between two boards, as even/odd index determines side to move
12947         plyNr++;
12948         ApplyMove(fromX, fromY, toX, toY, promoChar, boards[scratch]);
12949         if(PositionMatches(boards[scratch], boards[currentMove])) return plyNr;
12950         if(appData.ignoreColors && PositionMatches(boards[scratch], reverseBoard)) return plyNr;
12951         if(appData.findMirror) {
12952             if(PositionMatches(boards[scratch], flipBoard)) return plyNr;
12953             if(appData.ignoreColors && PositionMatches(boards[scratch], rotateBoard)) return plyNr;
12954         }
12955     }
12956 }
12957
12958 /* Load the nth game from open file f */
12959 int
12960 LoadGame (FILE *f, int gameNumber, char *title, int useList)
12961 {
12962     ChessMove cm;
12963     char buf[MSG_SIZ];
12964     int gn = gameNumber;
12965     ListGame *lg = NULL;
12966     int numPGNTags = 0, i;
12967     int err, pos = -1;
12968     GameMode oldGameMode;
12969     VariantClass v, oldVariant = gameInfo.variant; /* [HGM] PGNvariant */
12970     char oldName[MSG_SIZ];
12971
12972     safeStrCpy(oldName, engineVariant, MSG_SIZ); v = oldVariant;
12973
12974     if (appData.debugMode)
12975         fprintf(debugFP, "LoadGame(): on entry, gameMode %d\n", gameMode);
12976
12977     if (gameMode == Training )
12978         SetTrainingModeOff();
12979
12980     oldGameMode = gameMode;
12981     if (gameMode != BeginningOfGame) {
12982       Reset(FALSE, TRUE);
12983     }
12984     killX = killY = kill2X = kill2Y = -1; // [HGM] lion: in case we did not Reset
12985
12986     gameFileFP = f;
12987     if (lastLoadGameFP != NULL && lastLoadGameFP != f) {
12988         fclose(lastLoadGameFP);
12989     }
12990
12991     if (useList) {
12992         lg = (ListGame *) ListElem(&gameList, gameNumber-1);
12993
12994         if (lg) {
12995             fseek(f, lg->offset, 0);
12996             GameListHighlight(gameNumber);
12997             pos = lg->position;
12998             gn = 1;
12999         }
13000         else {
13001             if(oldGameMode == AnalyzeFile && appData.loadGameIndex == -1)
13002               appData.loadGameIndex = 0; // [HGM] suppress error message if we reach file end after auto-stepping analysis
13003             else
13004             DisplayError(_("Game number out of range"), 0);
13005             return FALSE;
13006         }
13007     } else {
13008         GameListDestroy();
13009         if (fseek(f, 0, 0) == -1) {
13010             if (f == lastLoadGameFP ?
13011                 gameNumber == lastLoadGameNumber + 1 :
13012                 gameNumber == 1) {
13013                 gn = 1;
13014             } else {
13015                 DisplayError(_("Can't seek on game file"), 0);
13016                 return FALSE;
13017             }
13018         }
13019     }
13020     lastLoadGameFP = f;
13021     lastLoadGameNumber = gameNumber;
13022     safeStrCpy(lastLoadGameTitle, title, sizeof(lastLoadGameTitle)/sizeof(lastLoadGameTitle[0]));
13023     lastLoadGameUseList = useList;
13024
13025     yynewfile(f);
13026
13027     if (lg && lg->gameInfo.white && lg->gameInfo.black) {
13028       snprintf(buf, sizeof(buf), "%s %s %s", lg->gameInfo.white, _("vs."),
13029                 lg->gameInfo.black);
13030             DisplayTitle(buf);
13031     } else if (*title != NULLCHAR) {
13032         if (gameNumber > 1) {
13033           snprintf(buf, MSG_SIZ, "%s %d", title, gameNumber);
13034             DisplayTitle(buf);
13035         } else {
13036             DisplayTitle(title);
13037         }
13038     }
13039
13040     if (gameMode != AnalyzeFile && gameMode != AnalyzeMode) {
13041         gameMode = PlayFromGameFile;
13042         ModeHighlight();
13043     }
13044
13045     currentMove = forwardMostMove = backwardMostMove = 0;
13046     CopyBoard(boards[0], initialPosition);
13047     StopClocks();
13048
13049     /*
13050      * Skip the first gn-1 games in the file.
13051      * Also skip over anything that precedes an identifiable
13052      * start of game marker, to avoid being confused by
13053      * garbage at the start of the file.  Currently
13054      * recognized start of game markers are the move number "1",
13055      * the pattern "gnuchess .* game", the pattern
13056      * "^[#;%] [^ ]* game file", and a PGN tag block.
13057      * A game that starts with one of the latter two patterns
13058      * will also have a move number 1, possibly
13059      * following a position diagram.
13060      * 5-4-02: Let's try being more lenient and allowing a game to
13061      * start with an unnumbered move.  Does that break anything?
13062      */
13063     cm = lastLoadGameStart = EndOfFile;
13064     while (gn > 0) {
13065         yyboardindex = forwardMostMove;
13066         cm = (ChessMove) Myylex();
13067         switch (cm) {
13068           case EndOfFile:
13069             if (cmailMsgLoaded) {
13070                 nCmailGames = CMAIL_MAX_GAMES - gn;
13071             } else {
13072                 Reset(TRUE, TRUE);
13073                 DisplayError(_("Game not found in file"), 0);
13074             }
13075             return FALSE;
13076
13077           case GNUChessGame:
13078           case XBoardGame:
13079             gn--;
13080             lastLoadGameStart = cm;
13081             break;
13082
13083           case MoveNumberOne:
13084             switch (lastLoadGameStart) {
13085               case GNUChessGame:
13086               case XBoardGame:
13087               case PGNTag:
13088                 break;
13089               case MoveNumberOne:
13090               case EndOfFile:
13091                 gn--;           /* count this game */
13092                 lastLoadGameStart = cm;
13093                 break;
13094               default:
13095                 /* impossible */
13096                 break;
13097             }
13098             break;
13099
13100           case PGNTag:
13101             switch (lastLoadGameStart) {
13102               case GNUChessGame:
13103               case PGNTag:
13104               case MoveNumberOne:
13105               case EndOfFile:
13106                 gn--;           /* count this game */
13107                 lastLoadGameStart = cm;
13108                 break;
13109               case XBoardGame:
13110                 lastLoadGameStart = cm; /* game counted already */
13111                 break;
13112               default:
13113                 /* impossible */
13114                 break;
13115             }
13116             if (gn > 0) {
13117                 do {
13118                     yyboardindex = forwardMostMove;
13119                     cm = (ChessMove) Myylex();
13120                 } while (cm == PGNTag || cm == Comment);
13121             }
13122             break;
13123
13124           case WhiteWins:
13125           case BlackWins:
13126           case GameIsDrawn:
13127             if (cmailMsgLoaded && (CMAIL_MAX_GAMES == lastLoadGameNumber)) {
13128                 if (   cmailResult[CMAIL_MAX_GAMES - gn - 1]
13129                     != CMAIL_OLD_RESULT) {
13130                     nCmailResults ++ ;
13131                     cmailResult[  CMAIL_MAX_GAMES
13132                                 - gn - 1] = CMAIL_OLD_RESULT;
13133                 }
13134             }
13135             break;
13136
13137           case NormalMove:
13138           case FirstLeg:
13139             /* Only a NormalMove can be at the start of a game
13140              * without a position diagram. */
13141             if (lastLoadGameStart == EndOfFile ) {
13142               gn--;
13143               lastLoadGameStart = MoveNumberOne;
13144             }
13145             break;
13146
13147           default:
13148             break;
13149         }
13150     }
13151
13152     if (appData.debugMode)
13153       fprintf(debugFP, "Parsed game start '%s' (%d)\n", yy_text, (int) cm);
13154
13155     for(i=0; i<EmptySquare; i++) { FREE(pieceDesc[i]); pieceDesc[i] = NULL; } // reset VariantMen
13156
13157     if (cm == XBoardGame) {
13158         /* Skip any header junk before position diagram and/or move 1 */
13159         for (;;) {
13160             yyboardindex = forwardMostMove;
13161             cm = (ChessMove) Myylex();
13162
13163             if (cm == EndOfFile ||
13164                 cm == GNUChessGame || cm == XBoardGame) {
13165                 /* Empty game; pretend end-of-file and handle later */
13166                 cm = EndOfFile;
13167                 break;
13168             }
13169
13170             if (cm == MoveNumberOne || cm == PositionDiagram ||
13171                 cm == PGNTag || cm == Comment)
13172               break;
13173         }
13174     } else if (cm == GNUChessGame) {
13175         if (gameInfo.event != NULL) {
13176             free(gameInfo.event);
13177         }
13178         gameInfo.event = StrSave(yy_text);
13179     }
13180
13181     startedFromSetupPosition = startedFromPositionFile; // [HGM]
13182     while (cm == PGNTag) {
13183         if (appData.debugMode)
13184           fprintf(debugFP, "Parsed PGNTag: %s\n", yy_text);
13185         err = ParsePGNTag(yy_text, &gameInfo);
13186         if (!err) numPGNTags++;
13187
13188         /* [HGM] PGNvariant: automatically switch to variant given in PGN tag */
13189         if(gameInfo.variant != oldVariant && (gameInfo.variant != VariantNormal || gameInfo.variantName == NULL || *gameInfo.variantName == NULLCHAR)) {
13190             startedFromPositionFile = FALSE; /* [HGM] loadPos: variant switch likely makes position invalid */
13191             ResetFrontEnd(); // [HGM] might need other bitmaps. Cannot use Reset() because it clears gameInfo :-(
13192             InitPosition(TRUE);
13193             oldVariant = gameInfo.variant;
13194             if (appData.debugMode)
13195               fprintf(debugFP, "New variant %d\n", (int) oldVariant);
13196         }
13197
13198
13199         if (gameInfo.fen != NULL) {
13200           Board initial_position;
13201           startedFromSetupPosition = TRUE;
13202           if (!ParseFEN(initial_position, &blackPlaysFirst, gameInfo.fen, TRUE)) {
13203             Reset(TRUE, TRUE);
13204             DisplayError(_("Bad FEN position in file"), 0);
13205             return FALSE;
13206           }
13207           CopyBoard(boards[0], initial_position);
13208           if(*engineVariant || gameInfo.variant == VariantFairy) // [HGM] for now, assume FEN in engine-defined variant game is default initial position
13209             CopyBoard(initialPosition, initial_position);
13210           if (blackPlaysFirst) {
13211             currentMove = forwardMostMove = backwardMostMove = 1;
13212             CopyBoard(boards[1], initial_position);
13213             safeStrCpy(moveList[0], "", sizeof(moveList[0])/sizeof(moveList[0][0]));
13214             safeStrCpy(parseList[0], "", sizeof(parseList[0])/sizeof(parseList[0][0]));
13215             timeRemaining[0][1] = whiteTimeRemaining;
13216             timeRemaining[1][1] = blackTimeRemaining;
13217             if (commentList[0] != NULL) {
13218               commentList[1] = commentList[0];
13219               commentList[0] = NULL;
13220             }
13221           } else {
13222             currentMove = forwardMostMove = backwardMostMove = 0;
13223           }
13224           /* [HGM] copy FEN attributes as well. Bugfix 4.3.14m and 4.3.15e: moved to after 'blackPlaysFirst' */
13225           {   int i;
13226               initialRulePlies = FENrulePlies;
13227               for( i=0; i< nrCastlingRights; i++ )
13228                   initialRights[i] = initial_position[CASTLING][i];
13229           }
13230           yyboardindex = forwardMostMove;
13231           free(gameInfo.fen);
13232           gameInfo.fen = NULL;
13233         }
13234
13235         yyboardindex = forwardMostMove;
13236         cm = (ChessMove) Myylex();
13237
13238         /* Handle comments interspersed among the tags */
13239         while (cm == Comment) {
13240             char *p;
13241             if (appData.debugMode)
13242               fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
13243             p = yy_text;
13244             AppendComment(currentMove, p, FALSE);
13245             yyboardindex = forwardMostMove;
13246             cm = (ChessMove) Myylex();
13247         }
13248     }
13249
13250     /* don't rely on existence of Event tag since if game was
13251      * pasted from clipboard the Event tag may not exist
13252      */
13253     if (numPGNTags > 0){
13254         char *tags;
13255         if (gameInfo.variant == VariantNormal) {
13256           VariantClass v = StringToVariant(gameInfo.event);
13257           // [HGM] do not recognize variants from event tag that were introduced after supporting variant tag
13258           if(v < VariantShogi) gameInfo.variant = v;
13259         }
13260         if (!matchMode) {
13261           if( appData.autoDisplayTags ) {
13262             tags = PGNTags(&gameInfo);
13263             TagsPopUp(tags, CmailMsg());
13264             free(tags);
13265           }
13266         }
13267     } else {
13268         /* Make something up, but don't display it now */
13269         SetGameInfo();
13270         TagsPopDown();
13271     }
13272
13273     if (cm == PositionDiagram) {
13274         int i, j;
13275         char *p;
13276         Board initial_position;
13277
13278         if (appData.debugMode)
13279           fprintf(debugFP, "Parsed PositionDiagram: %s\n", yy_text);
13280
13281         if (!startedFromSetupPosition) {
13282             p = yy_text;
13283             for (i = BOARD_HEIGHT - 1; i >= 0; i--)
13284               for (j = BOARD_LEFT; j < BOARD_RGHT; p++)
13285                 switch (*p) {
13286                   case '{':
13287                   case '[':
13288                   case '-':
13289                   case ' ':
13290                   case '\t':
13291                   case '\n':
13292                   case '\r':
13293                     break;
13294                   default:
13295                     initial_position[i][j++] = CharToPiece(*p);
13296                     break;
13297                 }
13298             while (*p == ' ' || *p == '\t' ||
13299                    *p == '\n' || *p == '\r') p++;
13300
13301             if (strncmp(p, "black", strlen("black"))==0)
13302               blackPlaysFirst = TRUE;
13303             else
13304               blackPlaysFirst = FALSE;
13305             startedFromSetupPosition = TRUE;
13306
13307             CopyBoard(boards[0], initial_position);
13308             if (blackPlaysFirst) {
13309                 currentMove = forwardMostMove = backwardMostMove = 1;
13310                 CopyBoard(boards[1], initial_position);
13311                 safeStrCpy(moveList[0], "", sizeof(moveList[0])/sizeof(moveList[0][0]));
13312                 safeStrCpy(parseList[0], "", sizeof(parseList[0])/sizeof(parseList[0][0]));
13313                 timeRemaining[0][1] = whiteTimeRemaining;
13314                 timeRemaining[1][1] = blackTimeRemaining;
13315                 if (commentList[0] != NULL) {
13316                     commentList[1] = commentList[0];
13317                     commentList[0] = NULL;
13318                 }
13319             } else {
13320                 currentMove = forwardMostMove = backwardMostMove = 0;
13321             }
13322         }
13323         yyboardindex = forwardMostMove;
13324         cm = (ChessMove) Myylex();
13325     }
13326
13327   if(!creatingBook) {
13328     if (first.pr == NoProc) {
13329         StartChessProgram(&first);
13330     }
13331     InitChessProgram(&first, FALSE);
13332     if(gameInfo.variant == VariantUnknown && *oldName) {
13333         safeStrCpy(engineVariant, oldName, MSG_SIZ);
13334         gameInfo.variant = v;
13335     }
13336     SendToProgram("force\n", &first);
13337     if (startedFromSetupPosition) {
13338         SendBoard(&first, forwardMostMove);
13339     if (appData.debugMode) {
13340         fprintf(debugFP, "Load Game\n");
13341     }
13342         DisplayBothClocks();
13343     }
13344   }
13345
13346     /* [HGM] server: flag to write setup moves in broadcast file as one */
13347     loadFlag = appData.suppressLoadMoves;
13348
13349     while (cm == Comment) {
13350         char *p;
13351         if (appData.debugMode)
13352           fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
13353         p = yy_text;
13354         AppendComment(currentMove, p, FALSE);
13355         yyboardindex = forwardMostMove;
13356         cm = (ChessMove) Myylex();
13357     }
13358
13359     if ((cm == EndOfFile && lastLoadGameStart != EndOfFile ) ||
13360         cm == WhiteWins || cm == BlackWins ||
13361         cm == GameIsDrawn || cm == GameUnfinished) {
13362         DisplayMessage("", _("No moves in game"));
13363         if (cmailMsgLoaded) {
13364             if (appData.debugMode)
13365               fprintf(debugFP, "Setting flipView to %d.\n", FALSE);
13366             ClearHighlights();
13367             flipView = FALSE;
13368         }
13369         DrawPosition(FALSE, boards[currentMove]);
13370         DisplayBothClocks();
13371         gameMode = EditGame;
13372         ModeHighlight();
13373         gameFileFP = NULL;
13374         cmailOldMove = 0;
13375         return TRUE;
13376     }
13377
13378     // [HGM] PV info: routine tests if comment empty
13379     if (!matchMode && (pausing || appData.timeDelay != 0)) {
13380         DisplayComment(currentMove - 1, commentList[currentMove]);
13381     }
13382     if (!matchMode && appData.timeDelay != 0)
13383       DrawPosition(FALSE, boards[currentMove]);
13384
13385     if (gameMode == AnalyzeFile || gameMode == AnalyzeMode) {
13386       programStats.ok_to_send = 1;
13387     }
13388
13389     /* if the first token after the PGN tags is a move
13390      * and not move number 1, retrieve it from the parser
13391      */
13392     if (cm != MoveNumberOne)
13393         LoadGameOneMove(cm);
13394
13395     /* load the remaining moves from the file */
13396     while (LoadGameOneMove(EndOfFile)) {
13397       timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
13398       timeRemaining[1][forwardMostMove] = blackTimeRemaining;
13399     }
13400
13401     /* rewind to the start of the game */
13402     currentMove = backwardMostMove;
13403
13404     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
13405
13406     if (oldGameMode == AnalyzeFile) {
13407       appData.loadGameIndex = -1; // [HGM] order auto-stepping through games
13408       AnalyzeFileEvent();
13409     } else
13410     if (oldGameMode == AnalyzeMode) {
13411       AnalyzeFileEvent();
13412     }
13413
13414     if(gameInfo.result == GameUnfinished && gameInfo.resultDetails && appData.clockMode) {
13415         long int w, b; // [HGM] adjourn: restore saved clock times
13416         char *p = strstr(gameInfo.resultDetails, "(Clocks:");
13417         if(p && sscanf(p+8, "%ld,%ld", &w, &b) == 2) {
13418             timeRemaining[0][forwardMostMove] = whiteTimeRemaining = 1000*w + 500;
13419             timeRemaining[1][forwardMostMove] = blackTimeRemaining = 1000*b + 500;
13420         }
13421     }
13422
13423     if(creatingBook) return TRUE;
13424     if (!matchMode && pos > 0) {
13425         ToNrEvent(pos); // [HGM] no autoplay if selected on position
13426     } else
13427     if (matchMode || appData.timeDelay == 0) {
13428       ToEndEvent();
13429     } else if (appData.timeDelay > 0) {
13430       AutoPlayGameLoop();
13431     }
13432
13433     if (appData.debugMode)
13434         fprintf(debugFP, "LoadGame(): on exit, gameMode %d\n", gameMode);
13435
13436     loadFlag = 0; /* [HGM] true game starts */
13437     return TRUE;
13438 }
13439
13440 /* Support for LoadNextPosition, LoadPreviousPosition, ReloadSamePosition */
13441 int
13442 ReloadPosition (int offset)
13443 {
13444     int positionNumber = lastLoadPositionNumber + offset;
13445     if (lastLoadPositionFP == NULL) {
13446         DisplayError(_("No position has been loaded yet"), 0);
13447         return FALSE;
13448     }
13449     if (positionNumber <= 0) {
13450         DisplayError(_("Can't back up any further"), 0);
13451         return FALSE;
13452     }
13453     return LoadPosition(lastLoadPositionFP, positionNumber,
13454                         lastLoadPositionTitle);
13455 }
13456
13457 /* Load the nth position from the given file */
13458 int
13459 LoadPositionFromFile (char *filename, int n, char *title)
13460 {
13461     FILE *f;
13462     char buf[MSG_SIZ];
13463
13464     if (strcmp(filename, "-") == 0) {
13465         return LoadPosition(stdin, n, "stdin");
13466     } else {
13467         f = fopen(filename, "rb");
13468         if (f == NULL) {
13469             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
13470             DisplayError(buf, errno);
13471             return FALSE;
13472         } else {
13473             return LoadPosition(f, n, title);
13474         }
13475     }
13476 }
13477
13478 /* Load the nth position from the given open file, and close it */
13479 int
13480 LoadPosition (FILE *f, int positionNumber, char *title)
13481 {
13482     char *p, line[MSG_SIZ];
13483     Board initial_position;
13484     int i, j, fenMode, pn;
13485
13486     if (gameMode == Training )
13487         SetTrainingModeOff();
13488
13489     if (gameMode != BeginningOfGame) {
13490         Reset(FALSE, TRUE);
13491     }
13492     if (lastLoadPositionFP != NULL && lastLoadPositionFP != f) {
13493         fclose(lastLoadPositionFP);
13494     }
13495     if (positionNumber == 0) positionNumber = 1;
13496     lastLoadPositionFP = f;
13497     lastLoadPositionNumber = positionNumber;
13498     safeStrCpy(lastLoadPositionTitle, title, sizeof(lastLoadPositionTitle)/sizeof(lastLoadPositionTitle[0]));
13499     if (first.pr == NoProc && !appData.noChessProgram) {
13500       StartChessProgram(&first);
13501       InitChessProgram(&first, FALSE);
13502     }
13503     pn = positionNumber;
13504     if (positionNumber < 0) {
13505         /* Negative position number means to seek to that byte offset */
13506         if (fseek(f, -positionNumber, 0) == -1) {
13507             DisplayError(_("Can't seek on position file"), 0);
13508             return FALSE;
13509         };
13510         pn = 1;
13511     } else {
13512         if (fseek(f, 0, 0) == -1) {
13513             if (f == lastLoadPositionFP ?
13514                 positionNumber == lastLoadPositionNumber + 1 :
13515                 positionNumber == 1) {
13516                 pn = 1;
13517             } else {
13518                 DisplayError(_("Can't seek on position file"), 0);
13519                 return FALSE;
13520             }
13521         }
13522     }
13523     /* See if this file is FEN or old-style xboard */
13524     if (fgets(line, MSG_SIZ, f) == NULL) {
13525         DisplayError(_("Position not found in file"), 0);
13526         return FALSE;
13527     }
13528     // [HGM] FEN can begin with digit, any piece letter valid in this variant, or a + for Shogi promoted pieces (or * for blackout)
13529     fenMode = line[0] >= '0' && line[0] <= '9' || line[0] == '+' || line[0] == '*' || CharToPiece(line[0]) != EmptySquare;
13530
13531     if (pn >= 2) {
13532         if (fenMode || line[0] == '#') pn--;
13533         while (pn > 0) {
13534             /* skip positions before number pn */
13535             if (fgets(line, MSG_SIZ, f) == NULL) {
13536                 Reset(TRUE, TRUE);
13537                 DisplayError(_("Position not found in file"), 0);
13538                 return FALSE;
13539             }
13540             if (fenMode || line[0] == '#') pn--;
13541         }
13542     }
13543
13544     if (fenMode) {
13545         char *p;
13546         if (!ParseFEN(initial_position, &blackPlaysFirst, line, TRUE)) {
13547             DisplayError(_("Bad FEN position in file"), 0);
13548             return FALSE;
13549         }
13550         if((strchr(line, ';')) && (p = strstr(line, " bm "))) { // EPD with best move
13551             sscanf(p+4, "%[^;]", bestMove);
13552         } else *bestMove = NULLCHAR;
13553     } else {
13554         (void) fgets(line, MSG_SIZ, f);
13555         (void) fgets(line, MSG_SIZ, f);
13556
13557         for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
13558             (void) fgets(line, MSG_SIZ, f);
13559             for (p = line, j = BOARD_LEFT; j < BOARD_RGHT; p++) {
13560                 if (*p == ' ')
13561                   continue;
13562                 initial_position[i][j++] = CharToPiece(*p);
13563             }
13564         }
13565
13566         blackPlaysFirst = FALSE;
13567         if (!feof(f)) {
13568             (void) fgets(line, MSG_SIZ, f);
13569             if (strncmp(line, "black", strlen("black"))==0)
13570               blackPlaysFirst = TRUE;
13571         }
13572     }
13573     startedFromSetupPosition = TRUE;
13574
13575     CopyBoard(boards[0], initial_position);
13576     if (blackPlaysFirst) {
13577         currentMove = forwardMostMove = backwardMostMove = 1;
13578         safeStrCpy(moveList[0], "", sizeof(moveList[0])/sizeof(moveList[0][0]));
13579         safeStrCpy(parseList[0], "", sizeof(parseList[0])/sizeof(parseList[0][0]));
13580         CopyBoard(boards[1], initial_position);
13581         DisplayMessage("", _("Black to play"));
13582     } else {
13583         currentMove = forwardMostMove = backwardMostMove = 0;
13584         DisplayMessage("", _("White to play"));
13585     }
13586     initialRulePlies = FENrulePlies; /* [HGM] copy FEN attributes as well */
13587     if(first.pr != NoProc) { // [HGM] in tourney-mode a position can be loaded before the chess engine is installed
13588         SendToProgram("force\n", &first);
13589         SendBoard(&first, forwardMostMove);
13590     }
13591     if (appData.debugMode) {
13592 int i, j;
13593   for(i=0;i<2;i++){for(j=0;j<6;j++)fprintf(debugFP, " %d", boards[i][CASTLING][j]);fprintf(debugFP,"\n");}
13594   for(j=0;j<6;j++)fprintf(debugFP, " %d", initialRights[j]);fprintf(debugFP,"\n");
13595         fprintf(debugFP, "Load Position\n");
13596     }
13597
13598     if (positionNumber > 1) {
13599       snprintf(line, MSG_SIZ, "%s %d", title, positionNumber);
13600         DisplayTitle(line);
13601     } else {
13602         DisplayTitle(title);
13603     }
13604     gameMode = EditGame;
13605     ModeHighlight();
13606     ResetClocks();
13607     timeRemaining[0][1] = whiteTimeRemaining;
13608     timeRemaining[1][1] = blackTimeRemaining;
13609     DrawPosition(FALSE, boards[currentMove]);
13610
13611     return TRUE;
13612 }
13613
13614
13615 void
13616 CopyPlayerNameIntoFileName (char **dest, char *src)
13617 {
13618     while (*src != NULLCHAR && *src != ',') {
13619         if (*src == ' ') {
13620             *(*dest)++ = '_';
13621             src++;
13622         } else {
13623             *(*dest)++ = *src++;
13624         }
13625     }
13626 }
13627
13628 char *
13629 DefaultFileName (char *ext)
13630 {
13631     static char def[MSG_SIZ];
13632     char *p;
13633
13634     if (gameInfo.white != NULL && gameInfo.white[0] != '-') {
13635         p = def;
13636         CopyPlayerNameIntoFileName(&p, gameInfo.white);
13637         *p++ = '-';
13638         CopyPlayerNameIntoFileName(&p, gameInfo.black);
13639         *p++ = '.';
13640         safeStrCpy(p, ext, MSG_SIZ-2-strlen(gameInfo.white)-strlen(gameInfo.black));
13641     } else {
13642         def[0] = NULLCHAR;
13643     }
13644     return def;
13645 }
13646
13647 /* Save the current game to the given file */
13648 int
13649 SaveGameToFile (char *filename, int append)
13650 {
13651     FILE *f;
13652     char buf[MSG_SIZ];
13653     int result, i, t,tot=0;
13654
13655     if (strcmp(filename, "-") == 0) {
13656         return SaveGame(stdout, 0, NULL);
13657     } else {
13658         for(i=0; i<10; i++) { // upto 10 tries
13659              f = fopen(filename, append ? "a" : "w");
13660              if(f && i) fprintf(f, "[Delay \"%d retries, %d msec\"]\n",i,tot);
13661              if(f || errno != 13) break;
13662              DoSleep(t = 5 + random()%11); // wait 5-15 msec
13663              tot += t;
13664         }
13665         if (f == NULL) {
13666             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
13667             DisplayError(buf, errno);
13668             return FALSE;
13669         } else {
13670             safeStrCpy(buf, lastMsg, MSG_SIZ);
13671             DisplayMessage(_("Waiting for access to save file"), "");
13672             flock(fileno(f), LOCK_EX); // [HGM] lock: lock file while we are writing
13673             DisplayMessage(_("Saving game"), "");
13674             if(lseek(fileno(f), 0, SEEK_END) == -1) DisplayError(_("Bad Seek"), errno);     // better safe than sorry...
13675             result = SaveGame(f, 0, NULL);
13676             DisplayMessage(buf, "");
13677             return result;
13678         }
13679     }
13680 }
13681
13682 char *
13683 SavePart (char *str)
13684 {
13685     static char buf[MSG_SIZ];
13686     char *p;
13687
13688     p = strchr(str, ' ');
13689     if (p == NULL) return str;
13690     strncpy(buf, str, p - str);
13691     buf[p - str] = NULLCHAR;
13692     return buf;
13693 }
13694
13695 #define PGN_MAX_LINE 75
13696
13697 #define PGN_SIDE_WHITE  0
13698 #define PGN_SIDE_BLACK  1
13699
13700 static int
13701 FindFirstMoveOutOfBook (int side)
13702 {
13703     int result = -1;
13704
13705     if( backwardMostMove == 0 && ! startedFromSetupPosition) {
13706         int index = backwardMostMove;
13707         int has_book_hit = 0;
13708
13709         if( (index % 2) != side ) {
13710             index++;
13711         }
13712
13713         while( index < forwardMostMove ) {
13714             /* Check to see if engine is in book */
13715             int depth = pvInfoList[index].depth;
13716             int score = pvInfoList[index].score;
13717             int in_book = 0;
13718
13719             if( depth <= 2 ) {
13720                 in_book = 1;
13721             }
13722             else if( score == 0 && depth == 63 ) {
13723                 in_book = 1; /* Zappa */
13724             }
13725             else if( score == 2 && depth == 99 ) {
13726                 in_book = 1; /* Abrok */
13727             }
13728
13729             has_book_hit += in_book;
13730
13731             if( ! in_book ) {
13732                 result = index;
13733
13734                 break;
13735             }
13736
13737             index += 2;
13738         }
13739     }
13740
13741     return result;
13742 }
13743
13744 void
13745 GetOutOfBookInfo (char * buf)
13746 {
13747     int oob[2];
13748     int i;
13749     int offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
13750
13751     oob[0] = FindFirstMoveOutOfBook( PGN_SIDE_WHITE );
13752     oob[1] = FindFirstMoveOutOfBook( PGN_SIDE_BLACK );
13753
13754     *buf = '\0';
13755
13756     if( oob[0] >= 0 || oob[1] >= 0 ) {
13757         for( i=0; i<2; i++ ) {
13758             int idx = oob[i];
13759
13760             if( idx >= 0 ) {
13761                 if( i > 0 && oob[0] >= 0 ) {
13762                     strcat( buf, "   " );
13763                 }
13764
13765                 sprintf( buf+strlen(buf), "%d%s. ", (idx - offset)/2 + 1, idx & 1 ? ".." : "" );
13766                 sprintf( buf+strlen(buf), "%s%.2f",
13767                     pvInfoList[idx].score >= 0 ? "+" : "",
13768                     pvInfoList[idx].score / 100.0 );
13769             }
13770         }
13771     }
13772 }
13773
13774 /* Save game in PGN style */
13775 static void
13776 SaveGamePGN2 (FILE *f)
13777 {
13778     int i, offset, linelen, newblock;
13779 //    char *movetext;
13780     char numtext[32];
13781     int movelen, numlen, blank;
13782     char move_buffer[100]; /* [AS] Buffer for move+PV info */
13783
13784     offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
13785
13786     PrintPGNTags(f, &gameInfo);
13787
13788     if(appData.numberTag && matchMode) fprintf(f, "[Number \"%d\"]\n", nextGame+1); // [HGM] number tag
13789
13790     if (backwardMostMove > 0 || startedFromSetupPosition) {
13791         char *fen = PositionToFEN(backwardMostMove, NULL, 1);
13792         fprintf(f, "[FEN \"%s\"]\n[SetUp \"1\"]\n", fen);
13793         fprintf(f, "\n{--------------\n");
13794         PrintPosition(f, backwardMostMove);
13795         fprintf(f, "--------------}\n");
13796         free(fen);
13797     }
13798     else {
13799         /* [AS] Out of book annotation */
13800         if( appData.saveOutOfBookInfo ) {
13801             char buf[64];
13802
13803             GetOutOfBookInfo( buf );
13804
13805             if( buf[0] != '\0' ) {
13806                 fprintf( f, "[%s \"%s\"]\n", PGN_OUT_OF_BOOK, buf );
13807             }
13808         }
13809
13810         fprintf(f, "\n");
13811     }
13812
13813     i = backwardMostMove;
13814     linelen = 0;
13815     newblock = TRUE;
13816
13817     while (i < forwardMostMove) {
13818         /* Print comments preceding this move */
13819         if (commentList[i] != NULL) {
13820             if (linelen > 0) fprintf(f, "\n");
13821             fprintf(f, "%s", commentList[i]);
13822             linelen = 0;
13823             newblock = TRUE;
13824         }
13825
13826         /* Format move number */
13827         if ((i % 2) == 0)
13828           snprintf(numtext, sizeof(numtext)/sizeof(numtext[0]),"%d.", (i - offset)/2 + 1);
13829         else
13830           if (newblock)
13831             snprintf(numtext, sizeof(numtext)/sizeof(numtext[0]), "%d...", (i - offset)/2 + 1);
13832           else
13833             numtext[0] = NULLCHAR;
13834
13835         numlen = strlen(numtext);
13836         newblock = FALSE;
13837
13838         /* Print move number */
13839         blank = linelen > 0 && numlen > 0;
13840         if (linelen + (blank ? 1 : 0) + numlen > PGN_MAX_LINE) {
13841             fprintf(f, "\n");
13842             linelen = 0;
13843             blank = 0;
13844         }
13845         if (blank) {
13846             fprintf(f, " ");
13847             linelen++;
13848         }
13849         fprintf(f, "%s", numtext);
13850         linelen += numlen;
13851
13852         /* Get move */
13853         safeStrCpy(move_buffer, SavePart(parseList[i]), sizeof(move_buffer)/sizeof(move_buffer[0])); // [HGM] pgn: print move via buffer, so it can be edited
13854         movelen = strlen(move_buffer); /* [HGM] pgn: line-break point before move */
13855
13856         /* Print move */
13857         blank = linelen > 0 && movelen > 0;
13858         if (linelen + (blank ? 1 : 0) + movelen > PGN_MAX_LINE) {
13859             fprintf(f, "\n");
13860             linelen = 0;
13861             blank = 0;
13862         }
13863         if (blank) {
13864             fprintf(f, " ");
13865             linelen++;
13866         }
13867         fprintf(f, "%s", move_buffer);
13868         linelen += movelen;
13869
13870         /* [AS] Add PV info if present */
13871         if( i >= 0 && appData.saveExtendedInfoInPGN && pvInfoList[i].depth > 0 ) {
13872             /* [HGM] add time */
13873             char buf[MSG_SIZ]; int seconds;
13874
13875             seconds = (pvInfoList[i].time+5)/10; // deci-seconds, rounded to nearest
13876
13877             if( seconds <= 0)
13878               buf[0] = 0;
13879             else
13880               if( seconds < 30 )
13881                 snprintf(buf, MSG_SIZ, " %3.1f%c", seconds/10., 0);
13882               else
13883                 {
13884                   seconds = (seconds + 4)/10; // round to full seconds
13885                   if( seconds < 60 )
13886                     snprintf(buf, MSG_SIZ, " %d%c", seconds, 0);
13887                   else
13888                     snprintf(buf, MSG_SIZ, " %d:%02d%c", seconds/60, seconds%60, 0);
13889                 }
13890
13891             snprintf( move_buffer, sizeof(move_buffer)/sizeof(move_buffer[0]),"{%s%.2f/%d%s}",
13892                       pvInfoList[i].score >= 0 ? "+" : "",
13893                       pvInfoList[i].score / 100.0,
13894                       pvInfoList[i].depth,
13895                       buf );
13896
13897             movelen = strlen(move_buffer); /* [HGM] pgn: line-break point after move */
13898
13899             /* Print score/depth */
13900             blank = linelen > 0 && movelen > 0;
13901             if (linelen + (blank ? 1 : 0) + movelen > PGN_MAX_LINE) {
13902                 fprintf(f, "\n");
13903                 linelen = 0;
13904                 blank = 0;
13905             }
13906             if (blank) {
13907                 fprintf(f, " ");
13908                 linelen++;
13909             }
13910             fprintf(f, "%s", move_buffer);
13911             linelen += movelen;
13912         }
13913
13914         i++;
13915     }
13916
13917     /* Start a new line */
13918     if (linelen > 0) fprintf(f, "\n");
13919
13920     /* Print comments after last move */
13921     if (commentList[i] != NULL) {
13922         fprintf(f, "%s\n", commentList[i]);
13923     }
13924
13925     /* Print result */
13926     if (gameInfo.resultDetails != NULL &&
13927         gameInfo.resultDetails[0] != NULLCHAR) {
13928         char buf[MSG_SIZ], *p = gameInfo.resultDetails;
13929         if(gameInfo.result == GameUnfinished && appData.clockMode &&
13930            (gameMode == MachinePlaysWhite || gameMode == MachinePlaysBlack || gameMode == TwoMachinesPlay)) // [HGM] adjourn: save clock settings
13931             snprintf(buf, MSG_SIZ, "%s (Clocks: %ld, %ld)", p, whiteTimeRemaining/1000, blackTimeRemaining/1000), p = buf;
13932         fprintf(f, "{%s} %s\n\n", p, PGNResult(gameInfo.result));
13933     } else {
13934         fprintf(f, "%s\n\n", PGNResult(gameInfo.result));
13935     }
13936 }
13937
13938 /* Save game in PGN style and close the file */
13939 int
13940 SaveGamePGN (FILE *f)
13941 {
13942     SaveGamePGN2(f);
13943     fclose(f);
13944     lastSavedGame = GameCheckSum(); // [HGM] save: remember ID of last saved game to prevent double saving
13945     return TRUE;
13946 }
13947
13948 /* Save game in old style and close the file */
13949 int
13950 SaveGameOldStyle (FILE *f)
13951 {
13952     int i, offset;
13953     time_t tm;
13954
13955     tm = time((time_t *) NULL);
13956
13957     fprintf(f, "# %s game file -- %s", programName, ctime(&tm));
13958     PrintOpponents(f);
13959
13960     if (backwardMostMove > 0 || startedFromSetupPosition) {
13961         fprintf(f, "\n[--------------\n");
13962         PrintPosition(f, backwardMostMove);
13963         fprintf(f, "--------------]\n");
13964     } else {
13965         fprintf(f, "\n");
13966     }
13967
13968     i = backwardMostMove;
13969     offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
13970
13971     while (i < forwardMostMove) {
13972         if (commentList[i] != NULL) {
13973             fprintf(f, "[%s]\n", commentList[i]);
13974         }
13975
13976         if ((i % 2) == 1) {
13977             fprintf(f, "%d. ...  %s\n", (i - offset)/2 + 1, parseList[i]);
13978             i++;
13979         } else {
13980             fprintf(f, "%d. %s  ", (i - offset)/2 + 1, parseList[i]);
13981             i++;
13982             if (commentList[i] != NULL) {
13983                 fprintf(f, "\n");
13984                 continue;
13985             }
13986             if (i >= forwardMostMove) {
13987                 fprintf(f, "\n");
13988                 break;
13989             }
13990             fprintf(f, "%s\n", parseList[i]);
13991             i++;
13992         }
13993     }
13994
13995     if (commentList[i] != NULL) {
13996         fprintf(f, "[%s]\n", commentList[i]);
13997     }
13998
13999     /* This isn't really the old style, but it's close enough */
14000     if (gameInfo.resultDetails != NULL &&
14001         gameInfo.resultDetails[0] != NULLCHAR) {
14002         fprintf(f, "%s (%s)\n\n", PGNResult(gameInfo.result),
14003                 gameInfo.resultDetails);
14004     } else {
14005         fprintf(f, "%s\n\n", PGNResult(gameInfo.result));
14006     }
14007
14008     fclose(f);
14009     return TRUE;
14010 }
14011
14012 /* Save the current game to open file f and close the file */
14013 int
14014 SaveGame (FILE *f, int dummy, char *dummy2)
14015 {
14016     if (gameMode == EditPosition) EditPositionDone(TRUE);
14017     lastSavedGame = GameCheckSum(); // [HGM] save: remember ID of last saved game to prevent double saving
14018     if (appData.oldSaveStyle)
14019       return SaveGameOldStyle(f);
14020     else
14021       return SaveGamePGN(f);
14022 }
14023
14024 /* Save the current position to the given file */
14025 int
14026 SavePositionToFile (char *filename)
14027 {
14028     FILE *f;
14029     char buf[MSG_SIZ];
14030
14031     if (strcmp(filename, "-") == 0) {
14032         return SavePosition(stdout, 0, NULL);
14033     } else {
14034         f = fopen(filename, "a");
14035         if (f == NULL) {
14036             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
14037             DisplayError(buf, errno);
14038             return FALSE;
14039         } else {
14040             safeStrCpy(buf, lastMsg, MSG_SIZ);
14041             DisplayMessage(_("Waiting for access to save file"), "");
14042             flock(fileno(f), LOCK_EX); // [HGM] lock
14043             DisplayMessage(_("Saving position"), "");
14044             lseek(fileno(f), 0, SEEK_END);     // better safe than sorry...
14045             SavePosition(f, 0, NULL);
14046             DisplayMessage(buf, "");
14047             return TRUE;
14048         }
14049     }
14050 }
14051
14052 /* Save the current position to the given open file and close the file */
14053 int
14054 SavePosition (FILE *f, int dummy, char *dummy2)
14055 {
14056     time_t tm;
14057     char *fen;
14058
14059     if (gameMode == EditPosition) EditPositionDone(TRUE);
14060     if (appData.oldSaveStyle) {
14061         tm = time((time_t *) NULL);
14062
14063         fprintf(f, "# %s position file -- %s", programName, ctime(&tm));
14064         PrintOpponents(f);
14065         fprintf(f, "[--------------\n");
14066         PrintPosition(f, currentMove);
14067         fprintf(f, "--------------]\n");
14068     } else {
14069         fen = PositionToFEN(currentMove, NULL, 1);
14070         fprintf(f, "%s\n", fen);
14071         free(fen);
14072     }
14073     fclose(f);
14074     return TRUE;
14075 }
14076
14077 void
14078 ReloadCmailMsgEvent (int unregister)
14079 {
14080 #if !WIN32
14081     static char *inFilename = NULL;
14082     static char *outFilename;
14083     int i;
14084     struct stat inbuf, outbuf;
14085     int status;
14086
14087     /* Any registered moves are unregistered if unregister is set, */
14088     /* i.e. invoked by the signal handler */
14089     if (unregister) {
14090         for (i = 0; i < CMAIL_MAX_GAMES; i ++) {
14091             cmailMoveRegistered[i] = FALSE;
14092             if (cmailCommentList[i] != NULL) {
14093                 free(cmailCommentList[i]);
14094                 cmailCommentList[i] = NULL;
14095             }
14096         }
14097         nCmailMovesRegistered = 0;
14098     }
14099
14100     for (i = 0; i < CMAIL_MAX_GAMES; i ++) {
14101         cmailResult[i] = CMAIL_NOT_RESULT;
14102     }
14103     nCmailResults = 0;
14104
14105     if (inFilename == NULL) {
14106         /* Because the filenames are static they only get malloced once  */
14107         /* and they never get freed                                      */
14108         inFilename = (char *) malloc(strlen(appData.cmailGameName) + 9);
14109         sprintf(inFilename, "%s.game.in", appData.cmailGameName);
14110
14111         outFilename = (char *) malloc(strlen(appData.cmailGameName) + 5);
14112         sprintf(outFilename, "%s.out", appData.cmailGameName);
14113     }
14114
14115     status = stat(outFilename, &outbuf);
14116     if (status < 0) {
14117         cmailMailedMove = FALSE;
14118     } else {
14119         status = stat(inFilename, &inbuf);
14120         cmailMailedMove = (inbuf.st_mtime < outbuf.st_mtime);
14121     }
14122
14123     /* LoadGameFromFile(CMAIL_MAX_GAMES) with cmailMsgLoaded == TRUE
14124        counts the games, notes how each one terminated, etc.
14125
14126        It would be nice to remove this kludge and instead gather all
14127        the information while building the game list.  (And to keep it
14128        in the game list nodes instead of having a bunch of fixed-size
14129        parallel arrays.)  Note this will require getting each game's
14130        termination from the PGN tags, as the game list builder does
14131        not process the game moves.  --mann
14132        */
14133     cmailMsgLoaded = TRUE;
14134     LoadGameFromFile(inFilename, CMAIL_MAX_GAMES, "", FALSE);
14135
14136     /* Load first game in the file or popup game menu */
14137     LoadGameFromFile(inFilename, 0, appData.cmailGameName, TRUE);
14138
14139 #endif /* !WIN32 */
14140     return;
14141 }
14142
14143 int
14144 RegisterMove ()
14145 {
14146     FILE *f;
14147     char string[MSG_SIZ];
14148
14149     if (   cmailMailedMove
14150         || (cmailResult[lastLoadGameNumber - 1] == CMAIL_OLD_RESULT)) {
14151         return TRUE;            /* Allow free viewing  */
14152     }
14153
14154     /* Unregister move to ensure that we don't leave RegisterMove        */
14155     /* with the move registered when the conditions for registering no   */
14156     /* longer hold                                                       */
14157     if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
14158         cmailMoveRegistered[lastLoadGameNumber - 1] = FALSE;
14159         nCmailMovesRegistered --;
14160
14161         if (cmailCommentList[lastLoadGameNumber - 1] != NULL)
14162           {
14163               free(cmailCommentList[lastLoadGameNumber - 1]);
14164               cmailCommentList[lastLoadGameNumber - 1] = NULL;
14165           }
14166     }
14167
14168     if (cmailOldMove == -1) {
14169         DisplayError(_("You have edited the game history.\nUse Reload Same Game and make your move again."), 0);
14170         return FALSE;
14171     }
14172
14173     if (currentMove > cmailOldMove + 1) {
14174         DisplayError(_("You have entered too many moves.\nBack up to the correct position and try again."), 0);
14175         return FALSE;
14176     }
14177
14178     if (currentMove < cmailOldMove) {
14179         DisplayError(_("Displayed position is not current.\nStep forward to the correct position and try again."), 0);
14180         return FALSE;
14181     }
14182
14183     if (forwardMostMove > currentMove) {
14184         /* Silently truncate extra moves */
14185         TruncateGame();
14186     }
14187
14188     if (   (currentMove == cmailOldMove + 1)
14189         || (   (currentMove == cmailOldMove)
14190             && (   (cmailMoveType[lastLoadGameNumber - 1] == CMAIL_ACCEPT)
14191                 || (cmailMoveType[lastLoadGameNumber - 1] == CMAIL_RESIGN)))) {
14192         if (gameInfo.result != GameUnfinished) {
14193             cmailResult[lastLoadGameNumber - 1] = CMAIL_NEW_RESULT;
14194         }
14195
14196         if (commentList[currentMove] != NULL) {
14197             cmailCommentList[lastLoadGameNumber - 1]
14198               = StrSave(commentList[currentMove]);
14199         }
14200         safeStrCpy(cmailMove[lastLoadGameNumber - 1], moveList[currentMove - 1], sizeof(cmailMove[lastLoadGameNumber - 1])/sizeof(cmailMove[lastLoadGameNumber - 1][0]));
14201
14202         if (appData.debugMode)
14203           fprintf(debugFP, "Saving %s for game %d\n",
14204                   cmailMove[lastLoadGameNumber - 1], lastLoadGameNumber);
14205
14206         snprintf(string, MSG_SIZ, "%s.game.out.%d", appData.cmailGameName, lastLoadGameNumber);
14207
14208         f = fopen(string, "w");
14209         if (appData.oldSaveStyle) {
14210             SaveGameOldStyle(f); /* also closes the file */
14211
14212             snprintf(string, MSG_SIZ, "%s.pos.out", appData.cmailGameName);
14213             f = fopen(string, "w");
14214             SavePosition(f, 0, NULL); /* also closes the file */
14215         } else {
14216             fprintf(f, "{--------------\n");
14217             PrintPosition(f, currentMove);
14218             fprintf(f, "--------------}\n\n");
14219
14220             SaveGame(f, 0, NULL); /* also closes the file*/
14221         }
14222
14223         cmailMoveRegistered[lastLoadGameNumber - 1] = TRUE;
14224         nCmailMovesRegistered ++;
14225     } else if (nCmailGames == 1) {
14226         DisplayError(_("You have not made a move yet"), 0);
14227         return FALSE;
14228     }
14229
14230     return TRUE;
14231 }
14232
14233 void
14234 MailMoveEvent ()
14235 {
14236 #if !WIN32
14237     static char *partCommandString = "cmail -xv%s -remail -game %s 2>&1";
14238     FILE *commandOutput;
14239     char buffer[MSG_SIZ], msg[MSG_SIZ], string[MSG_SIZ];
14240     int nBytes = 0;             /*  Suppress warnings on uninitialized variables    */
14241     int nBuffers;
14242     int i;
14243     int archived;
14244     char *arcDir;
14245
14246     if (! cmailMsgLoaded) {
14247         DisplayError(_("The cmail message is not loaded.\nUse Reload CMail Message and make your move again."), 0);
14248         return;
14249     }
14250
14251     if (nCmailGames == nCmailResults) {
14252         DisplayError(_("No unfinished games"), 0);
14253         return;
14254     }
14255
14256 #if CMAIL_PROHIBIT_REMAIL
14257     if (cmailMailedMove) {
14258       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);
14259         DisplayError(msg, 0);
14260         return;
14261     }
14262 #endif
14263
14264     if (! (cmailMailedMove || RegisterMove())) return;
14265
14266     if (   cmailMailedMove
14267         || (nCmailMovesRegistered + nCmailResults == nCmailGames)) {
14268       snprintf(string, MSG_SIZ, partCommandString,
14269                appData.debugMode ? " -v" : "", appData.cmailGameName);
14270         commandOutput = popen(string, "r");
14271
14272         if (commandOutput == NULL) {
14273             DisplayError(_("Failed to invoke cmail"), 0);
14274         } else {
14275             for (nBuffers = 0; (! feof(commandOutput)); nBuffers ++) {
14276                 nBytes = fread(buffer, 1, MSG_SIZ - 1, commandOutput);
14277             }
14278             if (nBuffers > 1) {
14279                 (void) memcpy(msg, buffer + nBytes, MSG_SIZ - nBytes - 1);
14280                 (void) memcpy(msg + MSG_SIZ - nBytes - 1, buffer, nBytes);
14281                 nBytes = MSG_SIZ - 1;
14282             } else {
14283                 (void) memcpy(msg, buffer, nBytes);
14284             }
14285             *(msg + nBytes) = '\0'; /* \0 for end-of-string*/
14286
14287             if(StrStr(msg, "Mailed cmail message to ") != NULL) {
14288                 cmailMailedMove = TRUE; /* Prevent >1 moves    */
14289
14290                 archived = TRUE;
14291                 for (i = 0; i < nCmailGames; i ++) {
14292                     if (cmailResult[i] == CMAIL_NOT_RESULT) {
14293                         archived = FALSE;
14294                     }
14295                 }
14296                 if (   archived
14297                     && (   (arcDir = (char *) getenv("CMAIL_ARCDIR"))
14298                         != NULL)) {
14299                   snprintf(buffer, MSG_SIZ, "%s/%s.%s.archive",
14300                            arcDir,
14301                            appData.cmailGameName,
14302                            gameInfo.date);
14303                     LoadGameFromFile(buffer, 1, buffer, FALSE);
14304                     cmailMsgLoaded = FALSE;
14305                 }
14306             }
14307
14308             DisplayInformation(msg);
14309             pclose(commandOutput);
14310         }
14311     } else {
14312         if ((*cmailMsg) != '\0') {
14313             DisplayInformation(cmailMsg);
14314         }
14315     }
14316
14317     return;
14318 #endif /* !WIN32 */
14319 }
14320
14321 char *
14322 CmailMsg ()
14323 {
14324 #if WIN32
14325     return NULL;
14326 #else
14327     int  prependComma = 0;
14328     char number[5];
14329     char string[MSG_SIZ];       /* Space for game-list */
14330     int  i;
14331
14332     if (!cmailMsgLoaded) return "";
14333
14334     if (cmailMailedMove) {
14335       snprintf(cmailMsg, MSG_SIZ, _("Waiting for reply from opponent\n"));
14336     } else {
14337         /* Create a list of games left */
14338       snprintf(string, MSG_SIZ, "[");
14339         for (i = 0; i < nCmailGames; i ++) {
14340             if (! (   cmailMoveRegistered[i]
14341                    || (cmailResult[i] == CMAIL_OLD_RESULT))) {
14342                 if (prependComma) {
14343                     snprintf(number, sizeof(number)/sizeof(number[0]), ",%d", i + 1);
14344                 } else {
14345                     snprintf(number, sizeof(number)/sizeof(number[0]), "%d", i + 1);
14346                     prependComma = 1;
14347                 }
14348
14349                 strcat(string, number);
14350             }
14351         }
14352         strcat(string, "]");
14353
14354         if (nCmailMovesRegistered + nCmailResults == 0) {
14355             switch (nCmailGames) {
14356               case 1:
14357                 snprintf(cmailMsg, MSG_SIZ, _("Still need to make move for game\n"));
14358                 break;
14359
14360               case 2:
14361                 snprintf(cmailMsg, MSG_SIZ, _("Still need to make moves for both games\n"));
14362                 break;
14363
14364               default:
14365                 snprintf(cmailMsg, MSG_SIZ, _("Still need to make moves for all %d games\n"),
14366                          nCmailGames);
14367                 break;
14368             }
14369         } else {
14370             switch (nCmailGames - nCmailMovesRegistered - nCmailResults) {
14371               case 1:
14372                 snprintf(cmailMsg, MSG_SIZ, _("Still need to make a move for game %s\n"),
14373                          string);
14374                 break;
14375
14376               case 0:
14377                 if (nCmailResults == nCmailGames) {
14378                   snprintf(cmailMsg, MSG_SIZ, _("No unfinished games\n"));
14379                 } else {
14380                   snprintf(cmailMsg, MSG_SIZ, _("Ready to send mail\n"));
14381                 }
14382                 break;
14383
14384               default:
14385                 snprintf(cmailMsg, MSG_SIZ, _("Still need to make moves for games %s\n"),
14386                          string);
14387             }
14388         }
14389     }
14390     return cmailMsg;
14391 #endif /* WIN32 */
14392 }
14393
14394 void
14395 ResetGameEvent ()
14396 {
14397     if (gameMode == Training)
14398       SetTrainingModeOff();
14399
14400     Reset(TRUE, TRUE);
14401     cmailMsgLoaded = FALSE;
14402     if (appData.icsActive) {
14403       SendToICS(ics_prefix);
14404       SendToICS("refresh\n");
14405     }
14406 }
14407
14408 void
14409 ExitEvent (int status)
14410 {
14411     exiting++;
14412     if (exiting > 2) {
14413       /* Give up on clean exit */
14414       exit(status);
14415     }
14416     if (exiting > 1) {
14417       /* Keep trying for clean exit */
14418       return;
14419     }
14420
14421     if (appData.icsActive) printf("\n"); // [HGM] end on new line after closing XBoard
14422     if (appData.icsActive && appData.colorize) Colorize(ColorNone, FALSE);
14423
14424     if (telnetISR != NULL) {
14425       RemoveInputSource(telnetISR);
14426     }
14427     if (icsPR != NoProc) {
14428       DestroyChildProcess(icsPR, TRUE);
14429     }
14430
14431     /* [HGM] crash: leave writing PGN and position entirely to GameEnds() */
14432     GameEnds(gameInfo.result, gameInfo.resultDetails==NULL ? "xboard exit" : gameInfo.resultDetails, GE_PLAYER);
14433
14434     /* [HGM] crash: the above GameEnds() is a dud if another one was running */
14435     /* make sure this other one finishes before killing it!                  */
14436     if(endingGame) { int count = 0;
14437         if(appData.debugMode) fprintf(debugFP, "ExitEvent() during GameEnds(), wait\n");
14438         while(endingGame && count++ < 10) DoSleep(1);
14439         if(appData.debugMode && endingGame) fprintf(debugFP, "GameEnds() seems stuck, proceed exiting\n");
14440     }
14441
14442     /* Kill off chess programs */
14443     if (first.pr != NoProc) {
14444         ExitAnalyzeMode();
14445
14446         DoSleep( appData.delayBeforeQuit );
14447         SendToProgram("quit\n", &first);
14448         DestroyChildProcess(first.pr, 4 + first.useSigterm /* [AS] first.useSigterm */ );
14449     }
14450     if (second.pr != NoProc) {
14451         DoSleep( appData.delayBeforeQuit );
14452         SendToProgram("quit\n", &second);
14453         DestroyChildProcess(second.pr, 4 + second.useSigterm /* [AS] second.useSigterm */ );
14454     }
14455     if (first.isr != NULL) {
14456         RemoveInputSource(first.isr);
14457     }
14458     if (second.isr != NULL) {
14459         RemoveInputSource(second.isr);
14460     }
14461
14462     if (pairing.pr != NoProc) SendToProgram("quit\n", &pairing);
14463     if (pairing.isr != NULL) RemoveInputSource(pairing.isr);
14464
14465     ShutDownFrontEnd();
14466     exit(status);
14467 }
14468
14469 void
14470 PauseEngine (ChessProgramState *cps)
14471 {
14472     SendToProgram("pause\n", cps);
14473     cps->pause = 2;
14474 }
14475
14476 void
14477 UnPauseEngine (ChessProgramState *cps)
14478 {
14479     SendToProgram("resume\n", cps);
14480     cps->pause = 1;
14481 }
14482
14483 void
14484 PauseEvent ()
14485 {
14486     if (appData.debugMode)
14487         fprintf(debugFP, "PauseEvent(): pausing %d\n", pausing);
14488     if (pausing) {
14489         pausing = FALSE;
14490         ModeHighlight();
14491         if(stalledEngine) { // [HGM] pause: resume game by releasing withheld move
14492             StartClocks();
14493             if(gameMode == TwoMachinesPlay) { // we might have to make the opponent resume pondering
14494                 if(stalledEngine->other->pause == 2) UnPauseEngine(stalledEngine->other);
14495                 else if(appData.ponderNextMove) SendToProgram("hard\n", stalledEngine->other);
14496             }
14497             if(appData.ponderNextMove) SendToProgram("hard\n", stalledEngine);
14498             HandleMachineMove(stashedInputMove, stalledEngine);
14499             stalledEngine = NULL;
14500             return;
14501         }
14502         if (gameMode == MachinePlaysWhite ||
14503             gameMode == TwoMachinesPlay   ||
14504             gameMode == MachinePlaysBlack) { // the thinking engine must have used pause mode, or it would have been stalledEngine
14505             if(first.pause)  UnPauseEngine(&first);
14506             else if(appData.ponderNextMove) SendToProgram("hard\n", &first);
14507             if(second.pause) UnPauseEngine(&second);
14508             else if(gameMode == TwoMachinesPlay && appData.ponderNextMove) SendToProgram("hard\n", &second);
14509             StartClocks();
14510         } else {
14511             DisplayBothClocks();
14512         }
14513         if (gameMode == PlayFromGameFile) {
14514             if (appData.timeDelay >= 0)
14515                 AutoPlayGameLoop();
14516         } else if (gameMode == IcsExamining && pauseExamInvalid) {
14517             Reset(FALSE, TRUE);
14518             SendToICS(ics_prefix);
14519             SendToICS("refresh\n");
14520         } else if (currentMove < forwardMostMove && gameMode != AnalyzeMode) {
14521             ForwardInner(forwardMostMove);
14522         }
14523         pauseExamInvalid = FALSE;
14524     } else {
14525         switch (gameMode) {
14526           default:
14527             return;
14528           case IcsExamining:
14529             pauseExamForwardMostMove = forwardMostMove;
14530             pauseExamInvalid = FALSE;
14531             /* fall through */
14532           case IcsObserving:
14533           case IcsPlayingWhite:
14534           case IcsPlayingBlack:
14535             pausing = TRUE;
14536             ModeHighlight();
14537             return;
14538           case PlayFromGameFile:
14539             (void) StopLoadGameTimer();
14540             pausing = TRUE;
14541             ModeHighlight();
14542             break;
14543           case BeginningOfGame:
14544             if (appData.icsActive) return;
14545             /* else fall through */
14546           case MachinePlaysWhite:
14547           case MachinePlaysBlack:
14548           case TwoMachinesPlay:
14549             if (forwardMostMove == 0)
14550               return;           /* don't pause if no one has moved */
14551             if(gameMode == TwoMachinesPlay) { // [HGM] pause: stop clocks if engine can be paused immediately
14552                 ChessProgramState *onMove = (WhiteOnMove(forwardMostMove) == (first.twoMachinesColor[0] == 'w') ? &first : &second);
14553                 if(onMove->pause) {           // thinking engine can be paused
14554                     PauseEngine(onMove);      // do it
14555                     if(onMove->other->pause)  // pondering opponent can always be paused immediately
14556                         PauseEngine(onMove->other);
14557                     else
14558                         SendToProgram("easy\n", onMove->other);
14559                     StopClocks();
14560                 } else if(appData.ponderNextMove) SendToProgram("easy\n", onMove); // pre-emptively bring out of ponder
14561             } else if(gameMode == (WhiteOnMove(forwardMostMove) ? MachinePlaysWhite : MachinePlaysBlack)) { // engine on move
14562                 if(first.pause) {
14563                     PauseEngine(&first);
14564                     StopClocks();
14565                 } else if(appData.ponderNextMove) SendToProgram("easy\n", &first); // pre-emptively bring out of ponder
14566             } else { // human on move, pause pondering by either method
14567                 if(first.pause)
14568                     PauseEngine(&first);
14569                 else if(appData.ponderNextMove)
14570                     SendToProgram("easy\n", &first);
14571                 StopClocks();
14572             }
14573             // if no immediate pausing is possible, wait for engine to move, and stop clocks then
14574           case AnalyzeMode:
14575             pausing = TRUE;
14576             ModeHighlight();
14577             break;
14578         }
14579     }
14580 }
14581
14582 void
14583 EditCommentEvent ()
14584 {
14585     char title[MSG_SIZ];
14586
14587     if (currentMove < 1 || parseList[currentMove - 1][0] == NULLCHAR) {
14588       safeStrCpy(title, _("Edit comment"), sizeof(title)/sizeof(title[0]));
14589     } else {
14590       snprintf(title, MSG_SIZ, _("Edit comment on %d.%s%s"), (currentMove - 1) / 2 + 1,
14591                WhiteOnMove(currentMove - 1) ? " " : ".. ",
14592                parseList[currentMove - 1]);
14593     }
14594
14595     EditCommentPopUp(currentMove, title, commentList[currentMove]);
14596 }
14597
14598
14599 void
14600 EditTagsEvent ()
14601 {
14602     char *tags = PGNTags(&gameInfo);
14603     bookUp = FALSE;
14604     EditTagsPopUp(tags, NULL);
14605     free(tags);
14606 }
14607
14608 void
14609 ToggleSecond ()
14610 {
14611   if(second.analyzing) {
14612     SendToProgram("exit\n", &second);
14613     second.analyzing = FALSE;
14614   } else {
14615     if (second.pr == NoProc) StartChessProgram(&second);
14616     InitChessProgram(&second, FALSE);
14617     FeedMovesToProgram(&second, currentMove);
14618
14619     SendToProgram("analyze\n", &second);
14620     second.analyzing = TRUE;
14621   }
14622 }
14623
14624 /* Toggle ShowThinking */
14625 void
14626 ToggleShowThinking()
14627 {
14628   appData.showThinking = !appData.showThinking;
14629   ShowThinkingEvent();
14630 }
14631
14632 int
14633 AnalyzeModeEvent ()
14634 {
14635     char buf[MSG_SIZ];
14636
14637     if (!first.analysisSupport) {
14638       snprintf(buf, sizeof(buf), _("%s does not support analysis"), first.tidy);
14639       DisplayError(buf, 0);
14640       return 0;
14641     }
14642     /* [DM] icsEngineAnalyze [HGM] This is horrible code; reverse the gameMode and isEngineAnalyze tests! */
14643     if (appData.icsActive) {
14644         if (gameMode != IcsObserving) {
14645           snprintf(buf, MSG_SIZ, _("You are not observing a game"));
14646             DisplayError(buf, 0);
14647             /* secure check */
14648             if (appData.icsEngineAnalyze) {
14649                 if (appData.debugMode)
14650                     fprintf(debugFP, "Found unexpected active ICS engine analyze \n");
14651                 ExitAnalyzeMode();
14652                 ModeHighlight();
14653             }
14654             return 0;
14655         }
14656         /* if enable, user wants to disable icsEngineAnalyze */
14657         if (appData.icsEngineAnalyze) {
14658                 ExitAnalyzeMode();
14659                 ModeHighlight();
14660                 return 0;
14661         }
14662         appData.icsEngineAnalyze = TRUE;
14663         if (appData.debugMode)
14664             fprintf(debugFP, "ICS engine analyze starting... \n");
14665     }
14666
14667     if (gameMode == AnalyzeMode) { ToggleSecond(); return 0; }
14668     if (appData.noChessProgram || gameMode == AnalyzeMode)
14669       return 0;
14670
14671     if (gameMode != AnalyzeFile) {
14672         if (!appData.icsEngineAnalyze) {
14673                EditGameEvent();
14674                if (gameMode != EditGame) return 0;
14675         }
14676         if (!appData.showThinking) ToggleShowThinking();
14677         ResurrectChessProgram();
14678         SendToProgram("analyze\n", &first);
14679         first.analyzing = TRUE;
14680         /*first.maybeThinking = TRUE;*/
14681         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
14682         EngineOutputPopUp();
14683     }
14684     if (!appData.icsEngineAnalyze) {
14685         gameMode = AnalyzeMode;
14686         ClearEngineOutputPane(0); // [TK] exclude: to print exclusion/multipv header
14687     }
14688     pausing = FALSE;
14689     ModeHighlight();
14690     SetGameInfo();
14691
14692     StartAnalysisClock();
14693     GetTimeMark(&lastNodeCountTime);
14694     lastNodeCount = 0;
14695     return 1;
14696 }
14697
14698 void
14699 AnalyzeFileEvent ()
14700 {
14701     if (appData.noChessProgram || gameMode == AnalyzeFile)
14702       return;
14703
14704     if (!first.analysisSupport) {
14705       char buf[MSG_SIZ];
14706       snprintf(buf, sizeof(buf), _("%s does not support analysis"), first.tidy);
14707       DisplayError(buf, 0);
14708       return;
14709     }
14710
14711     if (gameMode != AnalyzeMode) {
14712         keepInfo = 1; // mere annotating should not alter PGN tags
14713         EditGameEvent();
14714         keepInfo = 0;
14715         if (gameMode != EditGame) return;
14716         if (!appData.showThinking) ToggleShowThinking();
14717         ResurrectChessProgram();
14718         SendToProgram("analyze\n", &first);
14719         first.analyzing = TRUE;
14720         /*first.maybeThinking = TRUE;*/
14721         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
14722         EngineOutputPopUp();
14723     }
14724     gameMode = AnalyzeFile;
14725     pausing = FALSE;
14726     ModeHighlight();
14727
14728     StartAnalysisClock();
14729     GetTimeMark(&lastNodeCountTime);
14730     lastNodeCount = 0;
14731     if(appData.timeDelay > 0) StartLoadGameTimer((long)(1000.0f * appData.timeDelay));
14732     AnalysisPeriodicEvent(1);
14733 }
14734
14735 void
14736 MachineWhiteEvent ()
14737 {
14738     char buf[MSG_SIZ];
14739     char *bookHit = NULL;
14740
14741     if (appData.noChessProgram || (gameMode == MachinePlaysWhite))
14742       return;
14743
14744
14745     if (gameMode == PlayFromGameFile ||
14746         gameMode == TwoMachinesPlay  ||
14747         gameMode == Training         ||
14748         gameMode == AnalyzeMode      ||
14749         gameMode == EndOfGame)
14750         EditGameEvent();
14751
14752     if (gameMode == EditPosition)
14753         EditPositionDone(TRUE);
14754
14755     if (!WhiteOnMove(currentMove)) {
14756         DisplayError(_("It is not White's turn"), 0);
14757         return;
14758     }
14759
14760     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile)
14761       ExitAnalyzeMode();
14762
14763     if (gameMode == EditGame || gameMode == AnalyzeMode ||
14764         gameMode == AnalyzeFile)
14765         TruncateGame();
14766
14767     ResurrectChessProgram();    /* in case it isn't running */
14768     if(gameMode == BeginningOfGame) { /* [HGM] time odds: to get right odds in human mode */
14769         gameMode = MachinePlaysWhite;
14770         ResetClocks();
14771     } else
14772     gameMode = MachinePlaysWhite;
14773     pausing = FALSE;
14774     ModeHighlight();
14775     SetGameInfo();
14776     snprintf(buf, MSG_SIZ, "%s %s %s", gameInfo.white, _("vs."), gameInfo.black);
14777     DisplayTitle(buf);
14778     if (first.sendName) {
14779       snprintf(buf, MSG_SIZ, "name %s\n", gameInfo.black);
14780       SendToProgram(buf, &first);
14781     }
14782     if (first.sendTime) {
14783       if (first.useColors) {
14784         SendToProgram("black\n", &first); /*gnu kludge*/
14785       }
14786       SendTimeRemaining(&first, TRUE);
14787     }
14788     if (first.useColors) {
14789       SendToProgram("white\n", &first); // [HGM] book: send 'go' separately
14790     }
14791     bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: send go or retrieve book move
14792     SetMachineThinkingEnables();
14793     first.maybeThinking = TRUE;
14794     StartClocks();
14795     firstMove = FALSE;
14796
14797     if (appData.autoFlipView && !flipView) {
14798       flipView = !flipView;
14799       DrawPosition(FALSE, NULL);
14800       DisplayBothClocks();       // [HGM] logo: clocks might have to be exchanged;
14801     }
14802
14803     if(bookHit) { // [HGM] book: simulate book reply
14804         static char bookMove[MSG_SIZ]; // a bit generous?
14805
14806         programStats.nodes = programStats.depth = programStats.time =
14807         programStats.score = programStats.got_only_move = 0;
14808         sprintf(programStats.movelist, "%s (xbook)", bookHit);
14809
14810         safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
14811         strcat(bookMove, bookHit);
14812         HandleMachineMove(bookMove, &first);
14813     }
14814 }
14815
14816 void
14817 MachineBlackEvent ()
14818 {
14819   char buf[MSG_SIZ];
14820   char *bookHit = NULL;
14821
14822     if (appData.noChessProgram || (gameMode == MachinePlaysBlack))
14823         return;
14824
14825
14826     if (gameMode == PlayFromGameFile ||
14827         gameMode == TwoMachinesPlay  ||
14828         gameMode == Training         ||
14829         gameMode == AnalyzeMode      ||
14830         gameMode == EndOfGame)
14831         EditGameEvent();
14832
14833     if (gameMode == EditPosition)
14834         EditPositionDone(TRUE);
14835
14836     if (WhiteOnMove(currentMove)) {
14837         DisplayError(_("It is not Black's turn"), 0);
14838         return;
14839     }
14840
14841     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile)
14842       ExitAnalyzeMode();
14843
14844     if (gameMode == EditGame || gameMode == AnalyzeMode ||
14845         gameMode == AnalyzeFile)
14846         TruncateGame();
14847
14848     ResurrectChessProgram();    /* in case it isn't running */
14849     gameMode = MachinePlaysBlack;
14850     pausing = FALSE;
14851     ModeHighlight();
14852     SetGameInfo();
14853     snprintf(buf, MSG_SIZ, "%s %s %s", gameInfo.white, _("vs."), gameInfo.black);
14854     DisplayTitle(buf);
14855     if (first.sendName) {
14856       snprintf(buf, MSG_SIZ, "name %s\n", gameInfo.white);
14857       SendToProgram(buf, &first);
14858     }
14859     if (first.sendTime) {
14860       if (first.useColors) {
14861         SendToProgram("white\n", &first); /*gnu kludge*/
14862       }
14863       SendTimeRemaining(&first, FALSE);
14864     }
14865     if (first.useColors) {
14866       SendToProgram("black\n", &first); // [HGM] book: 'go' sent separately
14867     }
14868     bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: send go or retrieve book move
14869     SetMachineThinkingEnables();
14870     first.maybeThinking = TRUE;
14871     StartClocks();
14872
14873     if (appData.autoFlipView && flipView) {
14874       flipView = !flipView;
14875       DrawPosition(FALSE, NULL);
14876       DisplayBothClocks();       // [HGM] logo: clocks might have to be exchanged;
14877     }
14878     if(bookHit) { // [HGM] book: simulate book reply
14879         static char bookMove[MSG_SIZ]; // a bit generous?
14880
14881         programStats.nodes = programStats.depth = programStats.time =
14882         programStats.score = programStats.got_only_move = 0;
14883         sprintf(programStats.movelist, "%s (xbook)", bookHit);
14884
14885         safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
14886         strcat(bookMove, bookHit);
14887         HandleMachineMove(bookMove, &first);
14888     }
14889 }
14890
14891
14892 void
14893 DisplayTwoMachinesTitle ()
14894 {
14895     char buf[MSG_SIZ];
14896     if (appData.matchGames > 0) {
14897         if(appData.tourneyFile[0]) {
14898           snprintf(buf, MSG_SIZ, "%s %s %s (%d/%d%s)",
14899                    gameInfo.white, _("vs."), gameInfo.black,
14900                    nextGame+1, appData.matchGames+1,
14901                    appData.tourneyType>0 ? "gt" : appData.tourneyType<0 ? "sw" : "rr");
14902         } else
14903         if (first.twoMachinesColor[0] == 'w') {
14904           snprintf(buf, MSG_SIZ, "%s %s %s (%d-%d-%d)",
14905                    gameInfo.white, _("vs."),  gameInfo.black,
14906                    first.matchWins, second.matchWins,
14907                    matchGame - 1 - (first.matchWins + second.matchWins));
14908         } else {
14909           snprintf(buf, MSG_SIZ, "%s %s %s (%d-%d-%d)",
14910                    gameInfo.white, _("vs."), gameInfo.black,
14911                    second.matchWins, first.matchWins,
14912                    matchGame - 1 - (first.matchWins + second.matchWins));
14913         }
14914     } else {
14915       snprintf(buf, MSG_SIZ, "%s %s %s", gameInfo.white, _("vs."), gameInfo.black);
14916     }
14917     DisplayTitle(buf);
14918 }
14919
14920 void
14921 SettingsMenuIfReady ()
14922 {
14923   if (second.lastPing != second.lastPong) {
14924     DisplayMessage("", _("Waiting for second chess program"));
14925     ScheduleDelayedEvent(SettingsMenuIfReady, 10); // [HGM] fast: lowered from 1000
14926     return;
14927   }
14928   ThawUI();
14929   DisplayMessage("", "");
14930   SettingsPopUp(&second);
14931 }
14932
14933 int
14934 WaitForEngine (ChessProgramState *cps, DelayedEventCallback retry)
14935 {
14936     char buf[MSG_SIZ];
14937     if (cps->pr == NoProc) {
14938         StartChessProgram(cps);
14939         if (cps->protocolVersion == 1) {
14940           retry();
14941           ScheduleDelayedEvent(retry, 1); // Do this also through timeout to avoid recursive calling of 'retry'
14942         } else {
14943           /* kludge: allow timeout for initial "feature" command */
14944           if(retry != TwoMachinesEventIfReady) FreezeUI();
14945           snprintf(buf, MSG_SIZ, _("Starting %s chess program"), _(cps->which));
14946           DisplayMessage("", buf);
14947           ScheduleDelayedEvent(retry, FEATURE_TIMEOUT);
14948         }
14949         return 1;
14950     }
14951     return 0;
14952 }
14953
14954 void
14955 TwoMachinesEvent P((void))
14956 {
14957     int i;
14958     char buf[MSG_SIZ];
14959     ChessProgramState *onmove;
14960     char *bookHit = NULL;
14961     static int stalling = 0;
14962     TimeMark now;
14963     long wait;
14964
14965     if (appData.noChessProgram) return;
14966
14967     switch (gameMode) {
14968       case TwoMachinesPlay:
14969         return;
14970       case MachinePlaysWhite:
14971       case MachinePlaysBlack:
14972         if (WhiteOnMove(forwardMostMove) == (gameMode == MachinePlaysWhite)) {
14973             DisplayError(_("Wait until your turn,\nor select 'Move Now'."), 0);
14974             return;
14975         }
14976         /* fall through */
14977       case BeginningOfGame:
14978       case PlayFromGameFile:
14979       case EndOfGame:
14980         EditGameEvent();
14981         if (gameMode != EditGame) return;
14982         break;
14983       case EditPosition:
14984         EditPositionDone(TRUE);
14985         break;
14986       case AnalyzeMode:
14987       case AnalyzeFile:
14988         ExitAnalyzeMode();
14989         break;
14990       case EditGame:
14991       default:
14992         break;
14993     }
14994
14995 //    forwardMostMove = currentMove;
14996     TruncateGame(); // [HGM] vari: MachineWhite and MachineBlack do this...
14997     startingEngine = TRUE;
14998
14999     if(!ResurrectChessProgram()) return;   /* in case first program isn't running (unbalances its ping due to InitChessProgram!) */
15000
15001     if(!first.initDone && GetDelayedEvent() == TwoMachinesEventIfReady) return; // [HGM] engine #1 still waiting for feature timeout
15002     if(first.lastPing != first.lastPong) { // [HGM] wait till we are sure first engine has set up position
15003       ScheduleDelayedEvent(TwoMachinesEventIfReady, 10);
15004       return;
15005     }
15006     if(WaitForEngine(&second, TwoMachinesEventIfReady)) return; // (if needed:) started up second engine, so wait for features
15007
15008     if(!SupportedVariant(second.variants, gameInfo.variant, gameInfo.boardWidth,
15009                          gameInfo.boardHeight, gameInfo.holdingsSize, second.protocolVersion, second.tidy)) {
15010         startingEngine = matchMode = FALSE;
15011         DisplayError("second engine does not play this", 0);
15012         gameMode = TwoMachinesPlay; ModeHighlight(); // Needed to make sure menu item is unchecked
15013         EditGameEvent(); // switch back to EditGame mode
15014         return;
15015     }
15016
15017     if(!stalling) {
15018       InitChessProgram(&second, FALSE); // unbalances ping of second engine
15019       SendToProgram("force\n", &second);
15020       stalling = 1;
15021       ScheduleDelayedEvent(TwoMachinesEventIfReady, 10);
15022       return;
15023     }
15024     GetTimeMark(&now); // [HGM] matchpause: implement match pause after engine load
15025     if(appData.matchPause>10000 || appData.matchPause<10)
15026                 appData.matchPause = 10000; /* [HGM] make pause adjustable */
15027     wait = SubtractTimeMarks(&now, &pauseStart);
15028     if(wait < appData.matchPause) {
15029         ScheduleDelayedEvent(TwoMachinesEventIfReady, appData.matchPause - wait);
15030         return;
15031     }
15032     // we are now committed to starting the game
15033     stalling = 0;
15034     DisplayMessage("", "");
15035     if (startedFromSetupPosition) {
15036         SendBoard(&second, backwardMostMove);
15037     if (appData.debugMode) {
15038         fprintf(debugFP, "Two Machines\n");
15039     }
15040     }
15041     for (i = backwardMostMove; i < forwardMostMove; i++) {
15042         SendMoveToProgram(i, &second);
15043     }
15044
15045     gameMode = TwoMachinesPlay;
15046     pausing = startingEngine = FALSE;
15047     ModeHighlight(); // [HGM] logo: this triggers display update of logos
15048     SetGameInfo();
15049     DisplayTwoMachinesTitle();
15050     firstMove = TRUE;
15051     if ((first.twoMachinesColor[0] == 'w') == WhiteOnMove(forwardMostMove)) {
15052         onmove = &first;
15053     } else {
15054         onmove = &second;
15055     }
15056     if(appData.debugMode) fprintf(debugFP, "New game (%d): %s-%s (%c)\n", matchGame, first.tidy, second.tidy, first.twoMachinesColor[0]);
15057     SendToProgram(first.computerString, &first);
15058     if (first.sendName) {
15059       snprintf(buf, MSG_SIZ, "name %s\n", second.tidy);
15060       SendToProgram(buf, &first);
15061     }
15062     SendToProgram(second.computerString, &second);
15063     if (second.sendName) {
15064       snprintf(buf, MSG_SIZ, "name %s\n", first.tidy);
15065       SendToProgram(buf, &second);
15066     }
15067
15068     ResetClocks();
15069     if (!first.sendTime || !second.sendTime) {
15070         timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
15071         timeRemaining[1][forwardMostMove] = blackTimeRemaining;
15072     }
15073     if (onmove->sendTime) {
15074       if (onmove->useColors) {
15075         SendToProgram(onmove->other->twoMachinesColor, onmove); /*gnu kludge*/
15076       }
15077       SendTimeRemaining(onmove, WhiteOnMove(forwardMostMove));
15078     }
15079     if (onmove->useColors) {
15080       SendToProgram(onmove->twoMachinesColor, onmove);
15081     }
15082     bookHit = SendMoveToBookUser(forwardMostMove-1, onmove, TRUE); // [HGM] book: send go or retrieve book move
15083 //    SendToProgram("go\n", onmove);
15084     onmove->maybeThinking = TRUE;
15085     SetMachineThinkingEnables();
15086
15087     StartClocks();
15088
15089     if(bookHit) { // [HGM] book: simulate book reply
15090         static char bookMove[MSG_SIZ]; // a bit generous?
15091
15092         programStats.nodes = programStats.depth = programStats.time =
15093         programStats.score = programStats.got_only_move = 0;
15094         sprintf(programStats.movelist, "%s (xbook)", bookHit);
15095
15096         safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
15097         strcat(bookMove, bookHit);
15098         savedMessage = bookMove; // args for deferred call
15099         savedState = onmove;
15100         ScheduleDelayedEvent(DeferredBookMove, 1);
15101     }
15102 }
15103
15104 void
15105 TrainingEvent ()
15106 {
15107     if (gameMode == Training) {
15108       SetTrainingModeOff();
15109       gameMode = PlayFromGameFile;
15110       DisplayMessage("", _("Training mode off"));
15111     } else {
15112       gameMode = Training;
15113       animateTraining = appData.animate;
15114
15115       /* make sure we are not already at the end of the game */
15116       if (currentMove < forwardMostMove) {
15117         SetTrainingModeOn();
15118         DisplayMessage("", _("Training mode on"));
15119       } else {
15120         gameMode = PlayFromGameFile;
15121         DisplayError(_("Already at end of game"), 0);
15122       }
15123     }
15124     ModeHighlight();
15125 }
15126
15127 void
15128 IcsClientEvent ()
15129 {
15130     if (!appData.icsActive) return;
15131     switch (gameMode) {
15132       case IcsPlayingWhite:
15133       case IcsPlayingBlack:
15134       case IcsObserving:
15135       case IcsIdle:
15136       case BeginningOfGame:
15137       case IcsExamining:
15138         return;
15139
15140       case EditGame:
15141         break;
15142
15143       case EditPosition:
15144         EditPositionDone(TRUE);
15145         break;
15146
15147       case AnalyzeMode:
15148       case AnalyzeFile:
15149         ExitAnalyzeMode();
15150         break;
15151
15152       default:
15153         EditGameEvent();
15154         break;
15155     }
15156
15157     gameMode = IcsIdle;
15158     ModeHighlight();
15159     return;
15160 }
15161
15162 void
15163 EditGameEvent ()
15164 {
15165     int i;
15166
15167     switch (gameMode) {
15168       case Training:
15169         SetTrainingModeOff();
15170         break;
15171       case MachinePlaysWhite:
15172       case MachinePlaysBlack:
15173       case BeginningOfGame:
15174         SendToProgram("force\n", &first);
15175         if(gameMode == (forwardMostMove & 1 ? MachinePlaysBlack : MachinePlaysWhite)) { // engine is thinking
15176             if (first.usePing) { // [HGM] always send ping when we might interrupt machine thinking
15177                 char buf[MSG_SIZ];
15178                 abortEngineThink = TRUE;
15179                 snprintf(buf, MSG_SIZ, "ping %d\n", initPing = ++first.lastPing);
15180                 SendToProgram(buf, &first);
15181                 DisplayMessage("Aborting engine think", "");
15182                 FreezeUI();
15183             }
15184         }
15185         SetUserThinkingEnables();
15186         break;
15187       case PlayFromGameFile:
15188         (void) StopLoadGameTimer();
15189         if (gameFileFP != NULL) {
15190             gameFileFP = NULL;
15191         }
15192         break;
15193       case EditPosition:
15194         EditPositionDone(TRUE);
15195         break;
15196       case AnalyzeMode:
15197       case AnalyzeFile:
15198         ExitAnalyzeMode();
15199         SendToProgram("force\n", &first);
15200         break;
15201       case TwoMachinesPlay:
15202         GameEnds(EndOfFile, NULL, GE_PLAYER);
15203         ResurrectChessProgram();
15204         SetUserThinkingEnables();
15205         break;
15206       case EndOfGame:
15207         ResurrectChessProgram();
15208         break;
15209       case IcsPlayingBlack:
15210       case IcsPlayingWhite:
15211         DisplayError(_("Warning: You are still playing a game"), 0);
15212         break;
15213       case IcsObserving:
15214         DisplayError(_("Warning: You are still observing a game"), 0);
15215         break;
15216       case IcsExamining:
15217         DisplayError(_("Warning: You are still examining a game"), 0);
15218         break;
15219       case IcsIdle:
15220         break;
15221       case EditGame:
15222       default:
15223         return;
15224     }
15225
15226     pausing = FALSE;
15227     StopClocks();
15228     first.offeredDraw = second.offeredDraw = 0;
15229
15230     if (gameMode == PlayFromGameFile) {
15231         whiteTimeRemaining = timeRemaining[0][currentMove];
15232         blackTimeRemaining = timeRemaining[1][currentMove];
15233         DisplayTitle("");
15234     }
15235
15236     if (gameMode == MachinePlaysWhite ||
15237         gameMode == MachinePlaysBlack ||
15238         gameMode == TwoMachinesPlay ||
15239         gameMode == EndOfGame) {
15240         i = forwardMostMove;
15241         while (i > currentMove) {
15242             SendToProgram("undo\n", &first);
15243             i--;
15244         }
15245         if(!adjustedClock) {
15246         whiteTimeRemaining = timeRemaining[0][currentMove];
15247         blackTimeRemaining = timeRemaining[1][currentMove];
15248         DisplayBothClocks();
15249         }
15250         if (whiteFlag || blackFlag) {
15251             whiteFlag = blackFlag = 0;
15252         }
15253         DisplayTitle("");
15254     }
15255
15256     gameMode = EditGame;
15257     ModeHighlight();
15258     SetGameInfo();
15259 }
15260
15261
15262 void
15263 EditPositionEvent ()
15264 {
15265     if (gameMode == EditPosition) {
15266         EditGameEvent();
15267         return;
15268     }
15269
15270     EditGameEvent();
15271     if (gameMode != EditGame) return;
15272
15273     gameMode = EditPosition;
15274     ModeHighlight();
15275     SetGameInfo();
15276     if (currentMove > 0)
15277       CopyBoard(boards[0], boards[currentMove]);
15278
15279     blackPlaysFirst = !WhiteOnMove(currentMove);
15280     ResetClocks();
15281     currentMove = forwardMostMove = backwardMostMove = 0;
15282     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
15283     DisplayMove(-1);
15284     if(!appData.pieceMenu) DisplayMessage(_("Click clock to clear board"), "");
15285 }
15286
15287 void
15288 ExitAnalyzeMode ()
15289 {
15290     /* [DM] icsEngineAnalyze - possible call from other functions */
15291     if (appData.icsEngineAnalyze) {
15292         appData.icsEngineAnalyze = FALSE;
15293
15294         DisplayMessage("",_("Close ICS engine analyze..."));
15295     }
15296     if (first.analysisSupport && first.analyzing) {
15297       SendToBoth("exit\n");
15298       first.analyzing = second.analyzing = FALSE;
15299     }
15300     thinkOutput[0] = NULLCHAR;
15301 }
15302
15303 void
15304 EditPositionDone (Boolean fakeRights)
15305 {
15306     int king = gameInfo.variant == VariantKnightmate ? WhiteUnicorn : WhiteKing;
15307
15308     startedFromSetupPosition = TRUE;
15309     InitChessProgram(&first, FALSE);
15310     if(fakeRights) { // [HGM] suppress this if we just pasted a FEN.
15311       boards[0][EP_STATUS] = EP_NONE;
15312       boards[0][CASTLING][2] = boards[0][CASTLING][5] = BOARD_WIDTH>>1;
15313       if(boards[0][0][BOARD_WIDTH>>1] == king) {
15314         boards[0][CASTLING][1] = boards[0][0][BOARD_LEFT] == WhiteRook ? BOARD_LEFT : NoRights;
15315         boards[0][CASTLING][0] = boards[0][0][BOARD_RGHT-1] == WhiteRook ? BOARD_RGHT-1 : NoRights;
15316       } else boards[0][CASTLING][2] = NoRights;
15317       if(boards[0][BOARD_HEIGHT-1][BOARD_WIDTH>>1] == WHITE_TO_BLACK king) {
15318         boards[0][CASTLING][4] = boards[0][BOARD_HEIGHT-1][BOARD_LEFT] == BlackRook ? BOARD_LEFT : NoRights;
15319         boards[0][CASTLING][3] = boards[0][BOARD_HEIGHT-1][BOARD_RGHT-1] == BlackRook ? BOARD_RGHT-1 : NoRights;
15320       } else boards[0][CASTLING][5] = NoRights;
15321       if(gameInfo.variant == VariantSChess) {
15322         int i;
15323         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) { // pieces in their original position are assumed virgin
15324           boards[0][VIRGIN][i] = 0;
15325           if(boards[0][0][i]              == FIDEArray[0][i-BOARD_LEFT]) boards[0][VIRGIN][i] |= VIRGIN_W;
15326           if(boards[0][BOARD_HEIGHT-1][i] == FIDEArray[1][i-BOARD_LEFT]) boards[0][VIRGIN][i] |= VIRGIN_B;
15327         }
15328       }
15329     }
15330     SendToProgram("force\n", &first);
15331     if (blackPlaysFirst) {
15332         safeStrCpy(moveList[0], "", sizeof(moveList[0])/sizeof(moveList[0][0]));
15333         safeStrCpy(parseList[0], "", sizeof(parseList[0])/sizeof(parseList[0][0]));
15334         currentMove = forwardMostMove = backwardMostMove = 1;
15335         CopyBoard(boards[1], boards[0]);
15336     } else {
15337         currentMove = forwardMostMove = backwardMostMove = 0;
15338     }
15339     SendBoard(&first, forwardMostMove);
15340     if (appData.debugMode) {
15341         fprintf(debugFP, "EditPosDone\n");
15342     }
15343     DisplayTitle("");
15344     DisplayMessage("", "");
15345     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
15346     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
15347     gameMode = EditGame;
15348     ModeHighlight();
15349     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
15350     ClearHighlights(); /* [AS] */
15351 }
15352
15353 /* Pause for `ms' milliseconds */
15354 /* !! Ugh, this is a kludge. Fix it sometime. --tpm */
15355 void
15356 TimeDelay (long ms)
15357 {
15358     TimeMark m1, m2;
15359
15360     GetTimeMark(&m1);
15361     do {
15362         GetTimeMark(&m2);
15363     } while (SubtractTimeMarks(&m2, &m1) < ms);
15364 }
15365
15366 /* !! Ugh, this is a kludge. Fix it sometime. --tpm */
15367 void
15368 SendMultiLineToICS (char *buf)
15369 {
15370     char temp[MSG_SIZ+1], *p;
15371     int len;
15372
15373     len = strlen(buf);
15374     if (len > MSG_SIZ)
15375       len = MSG_SIZ;
15376
15377     strncpy(temp, buf, len);
15378     temp[len] = 0;
15379
15380     p = temp;
15381     while (*p) {
15382         if (*p == '\n' || *p == '\r')
15383           *p = ' ';
15384         ++p;
15385     }
15386
15387     strcat(temp, "\n");
15388     SendToICS(temp);
15389     SendToPlayer(temp, strlen(temp));
15390 }
15391
15392 void
15393 SetWhiteToPlayEvent ()
15394 {
15395     if (gameMode == EditPosition) {
15396         blackPlaysFirst = FALSE;
15397         DisplayBothClocks();    /* works because currentMove is 0 */
15398     } else if (gameMode == IcsExamining) {
15399         SendToICS(ics_prefix);
15400         SendToICS("tomove white\n");
15401     }
15402 }
15403
15404 void
15405 SetBlackToPlayEvent ()
15406 {
15407     if (gameMode == EditPosition) {
15408         blackPlaysFirst = TRUE;
15409         currentMove = 1;        /* kludge */
15410         DisplayBothClocks();
15411         currentMove = 0;
15412     } else if (gameMode == IcsExamining) {
15413         SendToICS(ics_prefix);
15414         SendToICS("tomove black\n");
15415     }
15416 }
15417
15418 void
15419 EditPositionMenuEvent (ChessSquare selection, int x, int y)
15420 {
15421     char buf[MSG_SIZ];
15422     ChessSquare piece = boards[0][y][x];
15423     static Board erasedBoard, currentBoard, menuBoard, nullBoard;
15424     static int lastVariant;
15425
15426     if (gameMode != EditPosition && gameMode != IcsExamining) return;
15427
15428     switch (selection) {
15429       case ClearBoard:
15430         fromX = fromY = killX = killY = kill2X = kill2Y = -1; // [HGM] abort any move entry in progress
15431         MarkTargetSquares(1);
15432         CopyBoard(currentBoard, boards[0]);
15433         CopyBoard(menuBoard, initialPosition);
15434         if (gameMode == IcsExamining && ics_type == ICS_FICS) {
15435             SendToICS(ics_prefix);
15436             SendToICS("bsetup clear\n");
15437         } else if (gameMode == IcsExamining && ics_type == ICS_ICC) {
15438             SendToICS(ics_prefix);
15439             SendToICS("clearboard\n");
15440         } else {
15441             int nonEmpty = 0;
15442             for (x = 0; x < BOARD_WIDTH; x++) { ChessSquare p = EmptySquare;
15443                 if(x == BOARD_LEFT-1 || x == BOARD_RGHT) p = (ChessSquare) 0; /* [HGM] holdings */
15444                 for (y = 0; y < BOARD_HEIGHT; y++) {
15445                     if (gameMode == IcsExamining) {
15446                         if (boards[currentMove][y][x] != EmptySquare) {
15447                           snprintf(buf, MSG_SIZ, "%sx@%c%c\n", ics_prefix,
15448                                     AAA + x, ONE + y);
15449                             SendToICS(buf);
15450                         }
15451                     } else if(boards[0][y][x] != DarkSquare) {
15452                         if(boards[0][y][x] != p) nonEmpty++;
15453                         boards[0][y][x] = p;
15454                     }
15455                 }
15456             }
15457             if(gameMode != IcsExamining) { // [HGM] editpos: cycle trough boards
15458                 int r;
15459                 for(r = 0; r < BOARD_HEIGHT; r++) {
15460                   for(x = BOARD_LEFT; x < BOARD_RGHT; x++) { // create 'menu board' by removing duplicates
15461                     ChessSquare p = menuBoard[r][x];
15462                     for(y = x + 1; y < BOARD_RGHT; y++) if(menuBoard[r][y] == p) menuBoard[r][y] = EmptySquare;
15463                   }
15464                 }
15465                 DisplayMessage("Clicking clock again restores position", "");
15466                 if(gameInfo.variant != lastVariant) lastVariant = gameInfo.variant, CopyBoard(erasedBoard, boards[0]);
15467                 if(!nonEmpty) { // asked to clear an empty board
15468                     CopyBoard(boards[0], menuBoard);
15469                 } else
15470                 if(CompareBoards(currentBoard, menuBoard)) { // asked to clear an empty board
15471                     CopyBoard(boards[0], initialPosition);
15472                 } else
15473                 if(CompareBoards(currentBoard, initialPosition) && !CompareBoards(currentBoard, erasedBoard)
15474                                                                  && !CompareBoards(nullBoard, erasedBoard)) {
15475                     CopyBoard(boards[0], erasedBoard);
15476                 } else
15477                     CopyBoard(erasedBoard, currentBoard);
15478
15479             }
15480         }
15481         if (gameMode == EditPosition) {
15482             DrawPosition(FALSE, boards[0]);
15483         }
15484         break;
15485
15486       case WhitePlay:
15487         SetWhiteToPlayEvent();
15488         break;
15489
15490       case BlackPlay:
15491         SetBlackToPlayEvent();
15492         break;
15493
15494       case EmptySquare:
15495         if (gameMode == IcsExamining) {
15496             if (x < BOARD_LEFT || x >= BOARD_RGHT) break; // [HGM] holdings
15497             snprintf(buf, MSG_SIZ, "%sx@%c%c\n", ics_prefix, AAA + x, ONE + y);
15498             SendToICS(buf);
15499         } else {
15500             if(x < BOARD_LEFT || x >= BOARD_RGHT) {
15501                 if(x == BOARD_LEFT-2) {
15502                     if(y < BOARD_HEIGHT-1-gameInfo.holdingsSize) break;
15503                     boards[0][y][1] = 0;
15504                 } else
15505                 if(x == BOARD_RGHT+1) {
15506                     if(y >= gameInfo.holdingsSize) break;
15507                     boards[0][y][BOARD_WIDTH-2] = 0;
15508                 } else break;
15509             }
15510             boards[0][y][x] = EmptySquare;
15511             DrawPosition(FALSE, boards[0]);
15512         }
15513         break;
15514
15515       case PromotePiece:
15516         if(piece >= (int)WhitePawn && piece < (int)WhiteMan ||
15517            piece >= (int)BlackPawn && piece < (int)BlackMan   ) {
15518             selection = (ChessSquare) (PROMOTED(piece));
15519         } else if(piece == EmptySquare) selection = WhiteSilver;
15520         else selection = (ChessSquare)((int)piece - 1);
15521         goto defaultlabel;
15522
15523       case DemotePiece:
15524         if(piece > (int)WhiteMan && piece <= (int)WhiteKing ||
15525            piece > (int)BlackMan && piece <= (int)BlackKing   ) {
15526             selection = (ChessSquare) (DEMOTED(piece));
15527         } else if(piece == EmptySquare) selection = BlackSilver;
15528         else selection = (ChessSquare)((int)piece + 1);
15529         goto defaultlabel;
15530
15531       case WhiteQueen:
15532       case BlackQueen:
15533         if(gameInfo.variant == VariantShatranj ||
15534            gameInfo.variant == VariantXiangqi  ||
15535            gameInfo.variant == VariantCourier  ||
15536            gameInfo.variant == VariantASEAN    ||
15537            gameInfo.variant == VariantMakruk     )
15538             selection = (ChessSquare)((int)selection - (int)WhiteQueen + (int)WhiteFerz);
15539         goto defaultlabel;
15540
15541       case WhiteKing:
15542       case BlackKing:
15543         if(gameInfo.variant == VariantXiangqi)
15544             selection = (ChessSquare)((int)selection - (int)WhiteKing + (int)WhiteWazir);
15545         if(gameInfo.variant == VariantKnightmate)
15546             selection = (ChessSquare)((int)selection - (int)WhiteKing + (int)WhiteUnicorn);
15547       default:
15548         defaultlabel:
15549         if (gameMode == IcsExamining) {
15550             if (x < BOARD_LEFT || x >= BOARD_RGHT) break; // [HGM] holdings
15551             snprintf(buf, MSG_SIZ, "%s%c@%c%c\n", ics_prefix,
15552                      PieceToChar(selection), AAA + x, ONE + y);
15553             SendToICS(buf);
15554         } else {
15555             if(x < BOARD_LEFT || x >= BOARD_RGHT) {
15556                 int n;
15557                 if(x == BOARD_LEFT-2 && selection >= BlackPawn) {
15558                     n = PieceToNumber(selection - BlackPawn);
15559                     if(n >= gameInfo.holdingsSize) { n = 0; selection = BlackPawn; }
15560                     boards[0][BOARD_HEIGHT-1-n][0] = selection;
15561                     boards[0][BOARD_HEIGHT-1-n][1]++;
15562                 } else
15563                 if(x == BOARD_RGHT+1 && selection < BlackPawn) {
15564                     n = PieceToNumber(selection);
15565                     if(n >= gameInfo.holdingsSize) { n = 0; selection = WhitePawn; }
15566                     boards[0][n][BOARD_WIDTH-1] = selection;
15567                     boards[0][n][BOARD_WIDTH-2]++;
15568                 }
15569             } else
15570             boards[0][y][x] = selection;
15571             DrawPosition(TRUE, boards[0]);
15572             ClearHighlights();
15573             fromX = fromY = -1;
15574         }
15575         break;
15576     }
15577 }
15578
15579
15580 void
15581 DropMenuEvent (ChessSquare selection, int x, int y)
15582 {
15583     ChessMove moveType;
15584
15585     switch (gameMode) {
15586       case IcsPlayingWhite:
15587       case MachinePlaysBlack:
15588         if (!WhiteOnMove(currentMove)) {
15589             DisplayMoveError(_("It is Black's turn"));
15590             return;
15591         }
15592         moveType = WhiteDrop;
15593         break;
15594       case IcsPlayingBlack:
15595       case MachinePlaysWhite:
15596         if (WhiteOnMove(currentMove)) {
15597             DisplayMoveError(_("It is White's turn"));
15598             return;
15599         }
15600         moveType = BlackDrop;
15601         break;
15602       case EditGame:
15603         moveType = WhiteOnMove(currentMove) ? WhiteDrop : BlackDrop;
15604         break;
15605       default:
15606         return;
15607     }
15608
15609     if (moveType == BlackDrop && selection < BlackPawn) {
15610       selection = (ChessSquare) ((int) selection
15611                                  + (int) BlackPawn - (int) WhitePawn);
15612     }
15613     if (boards[currentMove][y][x] != EmptySquare) {
15614         DisplayMoveError(_("That square is occupied"));
15615         return;
15616     }
15617
15618     FinishMove(moveType, (int) selection, DROP_RANK, x, y, NULLCHAR);
15619 }
15620
15621 void
15622 AcceptEvent ()
15623 {
15624     /* Accept a pending offer of any kind from opponent */
15625
15626     if (appData.icsActive) {
15627         SendToICS(ics_prefix);
15628         SendToICS("accept\n");
15629     } else if (cmailMsgLoaded) {
15630         if (currentMove == cmailOldMove &&
15631             commentList[cmailOldMove] != NULL &&
15632             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
15633                    "Black offers a draw" : "White offers a draw")) {
15634             TruncateGame();
15635             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
15636             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_ACCEPT;
15637         } else {
15638             DisplayError(_("There is no pending offer on this move"), 0);
15639             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
15640         }
15641     } else {
15642         /* Not used for offers from chess program */
15643     }
15644 }
15645
15646 void
15647 DeclineEvent ()
15648 {
15649     /* Decline a pending offer of any kind from opponent */
15650
15651     if (appData.icsActive) {
15652         SendToICS(ics_prefix);
15653         SendToICS("decline\n");
15654     } else if (cmailMsgLoaded) {
15655         if (currentMove == cmailOldMove &&
15656             commentList[cmailOldMove] != NULL &&
15657             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
15658                    "Black offers a draw" : "White offers a draw")) {
15659 #ifdef NOTDEF
15660             AppendComment(cmailOldMove, "Draw declined", TRUE);
15661             DisplayComment(cmailOldMove - 1, "Draw declined");
15662 #endif /*NOTDEF*/
15663         } else {
15664             DisplayError(_("There is no pending offer on this move"), 0);
15665         }
15666     } else {
15667         /* Not used for offers from chess program */
15668     }
15669 }
15670
15671 void
15672 RematchEvent ()
15673 {
15674     /* Issue ICS rematch command */
15675     if (appData.icsActive) {
15676         SendToICS(ics_prefix);
15677         SendToICS("rematch\n");
15678     }
15679 }
15680
15681 void
15682 CallFlagEvent ()
15683 {
15684     /* Call your opponent's flag (claim a win on time) */
15685     if (appData.icsActive) {
15686         SendToICS(ics_prefix);
15687         SendToICS("flag\n");
15688     } else {
15689         switch (gameMode) {
15690           default:
15691             return;
15692           case MachinePlaysWhite:
15693             if (whiteFlag) {
15694                 if (blackFlag)
15695                   GameEnds(GameIsDrawn, "Both players ran out of time",
15696                            GE_PLAYER);
15697                 else
15698                   GameEnds(BlackWins, "Black wins on time", GE_PLAYER);
15699             } else {
15700                 DisplayError(_("Your opponent is not out of time"), 0);
15701             }
15702             break;
15703           case MachinePlaysBlack:
15704             if (blackFlag) {
15705                 if (whiteFlag)
15706                   GameEnds(GameIsDrawn, "Both players ran out of time",
15707                            GE_PLAYER);
15708                 else
15709                   GameEnds(WhiteWins, "White wins on time", GE_PLAYER);
15710             } else {
15711                 DisplayError(_("Your opponent is not out of time"), 0);
15712             }
15713             break;
15714         }
15715     }
15716 }
15717
15718 void
15719 ClockClick (int which)
15720 {       // [HGM] code moved to back-end from winboard.c
15721         if(which) { // black clock
15722           if (gameMode == EditPosition || gameMode == IcsExamining) {
15723             if(!appData.pieceMenu && blackPlaysFirst) EditPositionMenuEvent(ClearBoard, 0, 0);
15724             SetBlackToPlayEvent();
15725           } else if ((gameMode == AnalyzeMode || gameMode == EditGame ||
15726                       gameMode == MachinePlaysBlack && PosFlags(0) & F_NULL_MOVE && !blackFlag && !shiftKey) && WhiteOnMove(currentMove)) {
15727           UserMoveEvent((int)EmptySquare, DROP_RANK, 0, 0, 0); // [HGM] multi-move: if not out of time, enters null move
15728           } else if (shiftKey) {
15729             AdjustClock(which, -1);
15730           } else if (gameMode == IcsPlayingWhite ||
15731                      gameMode == MachinePlaysBlack) {
15732             CallFlagEvent();
15733           }
15734         } else { // white clock
15735           if (gameMode == EditPosition || gameMode == IcsExamining) {
15736             if(!appData.pieceMenu && !blackPlaysFirst) EditPositionMenuEvent(ClearBoard, 0, 0);
15737             SetWhiteToPlayEvent();
15738           } else if ((gameMode == AnalyzeMode || gameMode == EditGame ||
15739                       gameMode == MachinePlaysWhite && PosFlags(0) & F_NULL_MOVE && !whiteFlag && !shiftKey) && !WhiteOnMove(currentMove)) {
15740           UserMoveEvent((int)EmptySquare, DROP_RANK, 0, 0, 0); // [HGM] multi-move
15741           } else if (shiftKey) {
15742             AdjustClock(which, -1);
15743           } else if (gameMode == IcsPlayingBlack ||
15744                    gameMode == MachinePlaysWhite) {
15745             CallFlagEvent();
15746           }
15747         }
15748 }
15749
15750 void
15751 DrawEvent ()
15752 {
15753     /* Offer draw or accept pending draw offer from opponent */
15754
15755     if (appData.icsActive) {
15756         /* Note: tournament rules require draw offers to be
15757            made after you make your move but before you punch
15758            your clock.  Currently ICS doesn't let you do that;
15759            instead, you immediately punch your clock after making
15760            a move, but you can offer a draw at any time. */
15761
15762         SendToICS(ics_prefix);
15763         SendToICS("draw\n");
15764         userOfferedDraw = TRUE; // [HGM] drawclaim: also set flag in ICS play
15765     } else if (cmailMsgLoaded) {
15766         if (currentMove == cmailOldMove &&
15767             commentList[cmailOldMove] != NULL &&
15768             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
15769                    "Black offers a draw" : "White offers a draw")) {
15770             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
15771             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_ACCEPT;
15772         } else if (currentMove == cmailOldMove + 1) {
15773             char *offer = WhiteOnMove(cmailOldMove) ?
15774               "White offers a draw" : "Black offers a draw";
15775             AppendComment(currentMove, offer, TRUE);
15776             DisplayComment(currentMove - 1, offer);
15777             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_DRAW;
15778         } else {
15779             DisplayError(_("You must make your move before offering a draw"), 0);
15780             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
15781         }
15782     } else if (first.offeredDraw) {
15783         GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
15784     } else {
15785         if (first.sendDrawOffers) {
15786             SendToProgram("draw\n", &first);
15787             userOfferedDraw = TRUE;
15788         }
15789     }
15790 }
15791
15792 void
15793 AdjournEvent ()
15794 {
15795     /* Offer Adjourn or accept pending Adjourn offer from opponent */
15796
15797     if (appData.icsActive) {
15798         SendToICS(ics_prefix);
15799         SendToICS("adjourn\n");
15800     } else {
15801         /* Currently GNU Chess doesn't offer or accept Adjourns */
15802     }
15803 }
15804
15805
15806 void
15807 AbortEvent ()
15808 {
15809     /* Offer Abort or accept pending Abort offer from opponent */
15810
15811     if (appData.icsActive) {
15812         SendToICS(ics_prefix);
15813         SendToICS("abort\n");
15814     } else {
15815         GameEnds(GameUnfinished, "Game aborted", GE_PLAYER);
15816     }
15817 }
15818
15819 void
15820 ResignEvent ()
15821 {
15822     /* Resign.  You can do this even if it's not your turn. */
15823
15824     if (appData.icsActive) {
15825         SendToICS(ics_prefix);
15826         SendToICS("resign\n");
15827     } else {
15828         switch (gameMode) {
15829           case MachinePlaysWhite:
15830             GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
15831             break;
15832           case MachinePlaysBlack:
15833             GameEnds(BlackWins, "White resigns", GE_PLAYER);
15834             break;
15835           case EditGame:
15836             if (cmailMsgLoaded) {
15837                 TruncateGame();
15838                 if (WhiteOnMove(cmailOldMove)) {
15839                     GameEnds(BlackWins, "White resigns", GE_PLAYER);
15840                 } else {
15841                     GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
15842                 }
15843                 cmailMoveType[lastLoadGameNumber - 1] = CMAIL_RESIGN;
15844             }
15845             break;
15846           default:
15847             break;
15848         }
15849     }
15850 }
15851
15852
15853 void
15854 StopObservingEvent ()
15855 {
15856     /* Stop observing current games */
15857     SendToICS(ics_prefix);
15858     SendToICS("unobserve\n");
15859 }
15860
15861 void
15862 StopExaminingEvent ()
15863 {
15864     /* Stop observing current game */
15865     SendToICS(ics_prefix);
15866     SendToICS("unexamine\n");
15867 }
15868
15869 void
15870 ForwardInner (int target)
15871 {
15872     int limit; int oldSeekGraphUp = seekGraphUp;
15873
15874     if (appData.debugMode)
15875         fprintf(debugFP, "ForwardInner(%d), current %d, forward %d\n",
15876                 target, currentMove, forwardMostMove);
15877
15878     if (gameMode == EditPosition)
15879       return;
15880
15881     seekGraphUp = FALSE;
15882     MarkTargetSquares(1);
15883     fromX = fromY = killX = killY = kill2X = kill2Y = -1; // [HGM] abort any move entry in progress
15884
15885     if (gameMode == PlayFromGameFile && !pausing)
15886       PauseEvent();
15887
15888     if (gameMode == IcsExamining && pausing)
15889       limit = pauseExamForwardMostMove;
15890     else
15891       limit = forwardMostMove;
15892
15893     if (target > limit) target = limit;
15894
15895     if (target > 0 && moveList[target - 1][0]) {
15896         int fromX, fromY, toX, toY;
15897         toX = moveList[target - 1][2] - AAA;
15898         toY = moveList[target - 1][3] - ONE;
15899         if (moveList[target - 1][1] == '@') {
15900             if (appData.highlightLastMove) {
15901                 SetHighlights(-1, -1, toX, toY);
15902             }
15903         } else {
15904             fromX = moveList[target - 1][0] - AAA;
15905             fromY = moveList[target - 1][1] - ONE;
15906             if (target == currentMove + 1) {
15907                 if(moveList[target - 1][4] == ';') { // multi-leg
15908                     killX = moveList[target - 1][5] - AAA;
15909                     killY = moveList[target - 1][6] - ONE;
15910                 }
15911                 AnimateMove(boards[currentMove], fromX, fromY, toX, toY);
15912                 killX = killY = -1;
15913             }
15914             if (appData.highlightLastMove) {
15915                 SetHighlights(fromX, fromY, toX, toY);
15916             }
15917         }
15918     }
15919     if (gameMode == EditGame || gameMode == AnalyzeMode ||
15920         gameMode == Training || gameMode == PlayFromGameFile ||
15921         gameMode == AnalyzeFile) {
15922         while (currentMove < target) {
15923             if(second.analyzing) SendMoveToProgram(currentMove, &second);
15924             SendMoveToProgram(currentMove++, &first);
15925         }
15926     } else {
15927         currentMove = target;
15928     }
15929
15930     if (gameMode == EditGame || gameMode == EndOfGame) {
15931         whiteTimeRemaining = timeRemaining[0][currentMove];
15932         blackTimeRemaining = timeRemaining[1][currentMove];
15933     }
15934     DisplayBothClocks();
15935     DisplayMove(currentMove - 1);
15936     DrawPosition(oldSeekGraphUp, boards[currentMove]);
15937     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
15938     if ( !matchMode && gameMode != Training) { // [HGM] PV info: routine tests if empty
15939         DisplayComment(currentMove - 1, commentList[currentMove]);
15940     }
15941     ClearMap(); // [HGM] exclude: invalidate map
15942 }
15943
15944
15945 void
15946 ForwardEvent ()
15947 {
15948     if (gameMode == IcsExamining && !pausing) {
15949         SendToICS(ics_prefix);
15950         SendToICS("forward\n");
15951     } else {
15952         ForwardInner(currentMove + 1);
15953     }
15954 }
15955
15956 void
15957 ToEndEvent ()
15958 {
15959     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
15960         /* to optimze, we temporarily turn off analysis mode while we feed
15961          * the remaining moves to the engine. Otherwise we get analysis output
15962          * after each move.
15963          */
15964         if (first.analysisSupport) {
15965           SendToProgram("exit\nforce\n", &first);
15966           first.analyzing = FALSE;
15967         }
15968     }
15969
15970     if (gameMode == IcsExamining && !pausing) {
15971         SendToICS(ics_prefix);
15972         SendToICS("forward 999999\n");
15973     } else {
15974         ForwardInner(forwardMostMove);
15975     }
15976
15977     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
15978         /* we have fed all the moves, so reactivate analysis mode */
15979         SendToProgram("analyze\n", &first);
15980         first.analyzing = TRUE;
15981         /*first.maybeThinking = TRUE;*/
15982         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
15983     }
15984 }
15985
15986 void
15987 BackwardInner (int target)
15988 {
15989     int full_redraw = TRUE; /* [AS] Was FALSE, had to change it! */
15990
15991     if (appData.debugMode)
15992         fprintf(debugFP, "BackwardInner(%d), current %d, forward %d\n",
15993                 target, currentMove, forwardMostMove);
15994
15995     if (gameMode == EditPosition) return;
15996     seekGraphUp = FALSE;
15997     MarkTargetSquares(1);
15998     fromX = fromY = killX = killY = kill2X = kill2Y = -1; // [HGM] abort any move entry in progress
15999     if (currentMove <= backwardMostMove) {
16000         ClearHighlights();
16001         DrawPosition(full_redraw, boards[currentMove]);
16002         return;
16003     }
16004     if (gameMode == PlayFromGameFile && !pausing)
16005       PauseEvent();
16006
16007     if (moveList[target][0]) {
16008         int fromX, fromY, toX, toY;
16009         toX = moveList[target][2] - AAA;
16010         toY = moveList[target][3] - ONE;
16011         if (moveList[target][1] == '@') {
16012             if (appData.highlightLastMove) {
16013                 SetHighlights(-1, -1, toX, toY);
16014             }
16015         } else {
16016             fromX = moveList[target][0] - AAA;
16017             fromY = moveList[target][1] - ONE;
16018             if (target == currentMove - 1) {
16019                 AnimateMove(boards[currentMove], toX, toY, fromX, fromY);
16020             }
16021             if (appData.highlightLastMove) {
16022                 SetHighlights(fromX, fromY, toX, toY);
16023             }
16024         }
16025     }
16026     if (gameMode == EditGame || gameMode==AnalyzeMode ||
16027         gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
16028         while (currentMove > target) {
16029             if(moveList[currentMove-1][1] == '@' && moveList[currentMove-1][0] == '@') {
16030                 // null move cannot be undone. Reload program with move history before it.
16031                 int i;
16032                 for(i=target; i>backwardMostMove; i--) { // seek back to start or previous null move
16033                     if(moveList[i-1][1] == '@' && moveList[i-1][0] == '@') break;
16034                 }
16035                 SendBoard(&first, i);
16036               if(second.analyzing) SendBoard(&second, i);
16037                 for(currentMove=i; currentMove<target; currentMove++) {
16038                     SendMoveToProgram(currentMove, &first);
16039                     if(second.analyzing) SendMoveToProgram(currentMove, &second);
16040                 }
16041                 break;
16042             }
16043             SendToBoth("undo\n");
16044             currentMove--;
16045         }
16046     } else {
16047         currentMove = target;
16048     }
16049
16050     if (gameMode == EditGame || gameMode == EndOfGame) {
16051         whiteTimeRemaining = timeRemaining[0][currentMove];
16052         blackTimeRemaining = timeRemaining[1][currentMove];
16053     }
16054     DisplayBothClocks();
16055     DisplayMove(currentMove - 1);
16056     DrawPosition(full_redraw, boards[currentMove]);
16057     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
16058     // [HGM] PV info: routine tests if comment empty
16059     DisplayComment(currentMove - 1, commentList[currentMove]);
16060     ClearMap(); // [HGM] exclude: invalidate map
16061 }
16062
16063 void
16064 BackwardEvent ()
16065 {
16066     if (gameMode == IcsExamining && !pausing) {
16067         SendToICS(ics_prefix);
16068         SendToICS("backward\n");
16069     } else {
16070         BackwardInner(currentMove - 1);
16071     }
16072 }
16073
16074 void
16075 ToStartEvent ()
16076 {
16077     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
16078         /* to optimize, we temporarily turn off analysis mode while we undo
16079          * all the moves. Otherwise we get analysis output after each undo.
16080          */
16081         if (first.analysisSupport) {
16082           SendToProgram("exit\nforce\n", &first);
16083           first.analyzing = FALSE;
16084         }
16085     }
16086
16087     if (gameMode == IcsExamining && !pausing) {
16088         SendToICS(ics_prefix);
16089         SendToICS("backward 999999\n");
16090     } else {
16091         BackwardInner(backwardMostMove);
16092     }
16093
16094     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
16095         /* we have fed all the moves, so reactivate analysis mode */
16096         SendToProgram("analyze\n", &first);
16097         first.analyzing = TRUE;
16098         /*first.maybeThinking = TRUE;*/
16099         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
16100     }
16101 }
16102
16103 void
16104 ToNrEvent (int to)
16105 {
16106   if (gameMode == PlayFromGameFile && !pausing) PauseEvent();
16107   if (to >= forwardMostMove) to = forwardMostMove;
16108   if (to <= backwardMostMove) to = backwardMostMove;
16109   if (to < currentMove) {
16110     BackwardInner(to);
16111   } else {
16112     ForwardInner(to);
16113   }
16114 }
16115
16116 void
16117 RevertEvent (Boolean annotate)
16118 {
16119     if(PopTail(annotate)) { // [HGM] vari: restore old game tail
16120         return;
16121     }
16122     if (gameMode != IcsExamining) {
16123         DisplayError(_("You are not examining a game"), 0);
16124         return;
16125     }
16126     if (pausing) {
16127         DisplayError(_("You can't revert while pausing"), 0);
16128         return;
16129     }
16130     SendToICS(ics_prefix);
16131     SendToICS("revert\n");
16132 }
16133
16134 void
16135 RetractMoveEvent ()
16136 {
16137     switch (gameMode) {
16138       case MachinePlaysWhite:
16139       case MachinePlaysBlack:
16140         if (WhiteOnMove(forwardMostMove) == (gameMode == MachinePlaysWhite)) {
16141             DisplayError(_("Wait until your turn,\nor select 'Move Now'."), 0);
16142             return;
16143         }
16144         if (forwardMostMove < 2) return;
16145         currentMove = forwardMostMove = forwardMostMove - 2;
16146         whiteTimeRemaining = timeRemaining[0][currentMove];
16147         blackTimeRemaining = timeRemaining[1][currentMove];
16148         DisplayBothClocks();
16149         DisplayMove(currentMove - 1);
16150         ClearHighlights();/*!! could figure this out*/
16151         DrawPosition(TRUE, boards[currentMove]); /* [AS] Changed to full redraw! */
16152         SendToProgram("remove\n", &first);
16153         /*first.maybeThinking = TRUE;*/ /* GNU Chess does not ponder here */
16154         break;
16155
16156       case BeginningOfGame:
16157       default:
16158         break;
16159
16160       case IcsPlayingWhite:
16161       case IcsPlayingBlack:
16162         if (WhiteOnMove(forwardMostMove) == (gameMode == IcsPlayingWhite)) {
16163             SendToICS(ics_prefix);
16164             SendToICS("takeback 2\n");
16165         } else {
16166             SendToICS(ics_prefix);
16167             SendToICS("takeback 1\n");
16168         }
16169         break;
16170     }
16171 }
16172
16173 void
16174 MoveNowEvent ()
16175 {
16176     ChessProgramState *cps;
16177
16178     switch (gameMode) {
16179       case MachinePlaysWhite:
16180         if (!WhiteOnMove(forwardMostMove)) {
16181             DisplayError(_("It is your turn"), 0);
16182             return;
16183         }
16184         cps = &first;
16185         break;
16186       case MachinePlaysBlack:
16187         if (WhiteOnMove(forwardMostMove)) {
16188             DisplayError(_("It is your turn"), 0);
16189             return;
16190         }
16191         cps = &first;
16192         break;
16193       case TwoMachinesPlay:
16194         if (WhiteOnMove(forwardMostMove) ==
16195             (first.twoMachinesColor[0] == 'w')) {
16196             cps = &first;
16197         } else {
16198             cps = &second;
16199         }
16200         break;
16201       case BeginningOfGame:
16202       default:
16203         return;
16204     }
16205     SendToProgram("?\n", cps);
16206 }
16207
16208 void
16209 TruncateGameEvent ()
16210 {
16211     EditGameEvent();
16212     if (gameMode != EditGame) return;
16213     TruncateGame();
16214 }
16215
16216 void
16217 TruncateGame ()
16218 {
16219     CleanupTail(); // [HGM] vari: only keep current variation if we explicitly truncate
16220     if (forwardMostMove > currentMove) {
16221         if (gameInfo.resultDetails != NULL) {
16222             free(gameInfo.resultDetails);
16223             gameInfo.resultDetails = NULL;
16224             gameInfo.result = GameUnfinished;
16225         }
16226         forwardMostMove = currentMove;
16227         HistorySet(parseList, backwardMostMove, forwardMostMove,
16228                    currentMove-1);
16229     }
16230 }
16231
16232 void
16233 HintEvent ()
16234 {
16235     if (appData.noChessProgram) return;
16236     switch (gameMode) {
16237       case MachinePlaysWhite:
16238         if (WhiteOnMove(forwardMostMove)) {
16239             DisplayError(_("Wait until your turn."), 0);
16240             return;
16241         }
16242         break;
16243       case BeginningOfGame:
16244       case MachinePlaysBlack:
16245         if (!WhiteOnMove(forwardMostMove)) {
16246             DisplayError(_("Wait until your turn."), 0);
16247             return;
16248         }
16249         break;
16250       default:
16251         DisplayError(_("No hint available"), 0);
16252         return;
16253     }
16254     SendToProgram("hint\n", &first);
16255     hintRequested = TRUE;
16256 }
16257
16258 int
16259 SaveSelected (FILE *g, int dummy, char *dummy2)
16260 {
16261     ListGame * lg = (ListGame *) gameList.head;
16262     int nItem, cnt=0;
16263     FILE *f;
16264
16265     if( !(f = GameFile()) || ((ListGame *) gameList.tailPred)->number <= 0 ) {
16266         DisplayError(_("Game list not loaded or empty"), 0);
16267         return 0;
16268     }
16269
16270     creatingBook = TRUE; // suppresses stuff during load game
16271
16272     /* Get list size */
16273     for (nItem = 1; nItem <= ((ListGame *) gameList.tailPred)->number; nItem++){
16274         if(lg->position >= 0) { // selected?
16275             LoadGame(f, nItem, "", TRUE);
16276             SaveGamePGN2(g); // leaves g open
16277             cnt++; DoEvents();
16278         }
16279         lg = (ListGame *) lg->node.succ;
16280     }
16281
16282     fclose(g);
16283     creatingBook = FALSE;
16284
16285     return cnt;
16286 }
16287
16288 void
16289 CreateBookEvent ()
16290 {
16291     ListGame * lg = (ListGame *) gameList.head;
16292     FILE *f, *g;
16293     int nItem;
16294     static int secondTime = FALSE;
16295
16296     if( !(f = GameFile()) || ((ListGame *) gameList.tailPred)->number <= 0 ) {
16297         DisplayError(_("Game list not loaded or empty"), 0);
16298         return;
16299     }
16300
16301     if(!secondTime && (g = fopen(appData.polyglotBook, "r"))) {
16302         fclose(g);
16303         secondTime++;
16304         DisplayNote(_("Book file exists! Try again for overwrite."));
16305         return;
16306     }
16307
16308     creatingBook = TRUE;
16309     secondTime = FALSE;
16310
16311     /* Get list size */
16312     for (nItem = 1; nItem <= ((ListGame *) gameList.tailPred)->number; nItem++){
16313         if(lg->position >= 0) {
16314             LoadGame(f, nItem, "", TRUE);
16315             AddGameToBook(TRUE);
16316             DoEvents();
16317         }
16318         lg = (ListGame *) lg->node.succ;
16319     }
16320
16321     creatingBook = FALSE;
16322     FlushBook();
16323 }
16324
16325 void
16326 BookEvent ()
16327 {
16328     if (appData.noChessProgram) return;
16329     switch (gameMode) {
16330       case MachinePlaysWhite:
16331         if (WhiteOnMove(forwardMostMove)) {
16332             DisplayError(_("Wait until your turn."), 0);
16333             return;
16334         }
16335         break;
16336       case BeginningOfGame:
16337       case MachinePlaysBlack:
16338         if (!WhiteOnMove(forwardMostMove)) {
16339             DisplayError(_("Wait until your turn."), 0);
16340             return;
16341         }
16342         break;
16343       case EditPosition:
16344         EditPositionDone(TRUE);
16345         break;
16346       case TwoMachinesPlay:
16347         return;
16348       default:
16349         break;
16350     }
16351     SendToProgram("bk\n", &first);
16352     bookOutput[0] = NULLCHAR;
16353     bookRequested = TRUE;
16354 }
16355
16356 void
16357 AboutGameEvent ()
16358 {
16359     char *tags = PGNTags(&gameInfo);
16360     TagsPopUp(tags, CmailMsg());
16361     free(tags);
16362 }
16363
16364 /* end button procedures */
16365
16366 void
16367 PrintPosition (FILE *fp, int move)
16368 {
16369     int i, j;
16370
16371     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
16372         for (j = BOARD_LEFT; j < BOARD_RGHT; j++) {
16373             char c = PieceToChar(boards[move][i][j]);
16374             fputc(c == '?' ? '.' : c, fp);
16375             fputc(j == BOARD_RGHT - 1 ? '\n' : ' ', fp);
16376         }
16377     }
16378     if ((gameMode == EditPosition) ? !blackPlaysFirst : (move % 2 == 0))
16379       fprintf(fp, "white to play\n");
16380     else
16381       fprintf(fp, "black to play\n");
16382 }
16383
16384 void
16385 PrintOpponents (FILE *fp)
16386 {
16387     if (gameInfo.white != NULL) {
16388         fprintf(fp, "\t%s vs. %s\n", gameInfo.white, gameInfo.black);
16389     } else {
16390         fprintf(fp, "\n");
16391     }
16392 }
16393
16394 /* Find last component of program's own name, using some heuristics */
16395 void
16396 TidyProgramName (char *prog, char *host, char buf[MSG_SIZ])
16397 {
16398     char *p, *q, c;
16399     int local = (strcmp(host, "localhost") == 0);
16400     while (!local && (p = strchr(prog, ';')) != NULL) {
16401         p++;
16402         while (*p == ' ') p++;
16403         prog = p;
16404     }
16405     if (*prog == '"' || *prog == '\'') {
16406         q = strchr(prog + 1, *prog);
16407     } else {
16408         q = strchr(prog, ' ');
16409     }
16410     if (q == NULL) q = prog + strlen(prog);
16411     p = q;
16412     while (p >= prog && *p != '/' && *p != '\\') p--;
16413     p++;
16414     if(p == prog && *p == '"') p++;
16415     c = *q; *q = 0;
16416     if (q - p >= 4 && StrCaseCmp(q - 4, ".exe") == 0) *q = c, q -= 4; else *q = c;
16417     memcpy(buf, p, q - p);
16418     buf[q - p] = NULLCHAR;
16419     if (!local) {
16420         strcat(buf, "@");
16421         strcat(buf, host);
16422     }
16423 }
16424
16425 char *
16426 TimeControlTagValue ()
16427 {
16428     char buf[MSG_SIZ];
16429     if (!appData.clockMode) {
16430       safeStrCpy(buf, "-", sizeof(buf)/sizeof(buf[0]));
16431     } else if (movesPerSession > 0) {
16432       snprintf(buf, MSG_SIZ, "%d/%ld", movesPerSession, timeControl/1000);
16433     } else if (timeIncrement == 0) {
16434       snprintf(buf, MSG_SIZ, "%ld", timeControl/1000);
16435     } else {
16436       snprintf(buf, MSG_SIZ, "%ld+%ld", timeControl/1000, timeIncrement/1000);
16437     }
16438     return StrSave(buf);
16439 }
16440
16441 void
16442 SetGameInfo ()
16443 {
16444     /* This routine is used only for certain modes */
16445     VariantClass v = gameInfo.variant;
16446     ChessMove r = GameUnfinished;
16447     char *p = NULL;
16448
16449     if(keepInfo) return;
16450
16451     if(gameMode == EditGame) { // [HGM] vari: do not erase result on EditGame
16452         r = gameInfo.result;
16453         p = gameInfo.resultDetails;
16454         gameInfo.resultDetails = NULL;
16455     }
16456     ClearGameInfo(&gameInfo);
16457     gameInfo.variant = v;
16458
16459     switch (gameMode) {
16460       case MachinePlaysWhite:
16461         gameInfo.event = StrSave( appData.pgnEventHeader );
16462         gameInfo.site = StrSave(HostName());
16463         gameInfo.date = PGNDate();
16464         gameInfo.round = StrSave("-");
16465         gameInfo.white = StrSave(first.tidy);
16466         gameInfo.black = StrSave(UserName());
16467         gameInfo.timeControl = TimeControlTagValue();
16468         break;
16469
16470       case MachinePlaysBlack:
16471         gameInfo.event = StrSave( appData.pgnEventHeader );
16472         gameInfo.site = StrSave(HostName());
16473         gameInfo.date = PGNDate();
16474         gameInfo.round = StrSave("-");
16475         gameInfo.white = StrSave(UserName());
16476         gameInfo.black = StrSave(first.tidy);
16477         gameInfo.timeControl = TimeControlTagValue();
16478         break;
16479
16480       case TwoMachinesPlay:
16481         gameInfo.event = StrSave( appData.pgnEventHeader );
16482         gameInfo.site = StrSave(HostName());
16483         gameInfo.date = PGNDate();
16484         if (roundNr > 0) {
16485             char buf[MSG_SIZ];
16486             snprintf(buf, MSG_SIZ, "%d", roundNr);
16487             gameInfo.round = StrSave(buf);
16488         } else {
16489             gameInfo.round = StrSave("-");
16490         }
16491         if (first.twoMachinesColor[0] == 'w') {
16492             gameInfo.white = StrSave(appData.pgnName[0][0] ? appData.pgnName[0] : first.tidy);
16493             gameInfo.black = StrSave(appData.pgnName[1][0] ? appData.pgnName[1] : second.tidy);
16494         } else {
16495             gameInfo.white = StrSave(appData.pgnName[1][0] ? appData.pgnName[1] : second.tidy);
16496             gameInfo.black = StrSave(appData.pgnName[0][0] ? appData.pgnName[0] : first.tidy);
16497         }
16498         gameInfo.timeControl = TimeControlTagValue();
16499         break;
16500
16501       case EditGame:
16502         gameInfo.event = StrSave("Edited game");
16503         gameInfo.site = StrSave(HostName());
16504         gameInfo.date = PGNDate();
16505         gameInfo.round = StrSave("-");
16506         gameInfo.white = StrSave("-");
16507         gameInfo.black = StrSave("-");
16508         gameInfo.result = r;
16509         gameInfo.resultDetails = p;
16510         break;
16511
16512       case EditPosition:
16513         gameInfo.event = StrSave("Edited position");
16514         gameInfo.site = StrSave(HostName());
16515         gameInfo.date = PGNDate();
16516         gameInfo.round = StrSave("-");
16517         gameInfo.white = StrSave("-");
16518         gameInfo.black = StrSave("-");
16519         break;
16520
16521       case IcsPlayingWhite:
16522       case IcsPlayingBlack:
16523       case IcsObserving:
16524       case IcsExamining:
16525         break;
16526
16527       case PlayFromGameFile:
16528         gameInfo.event = StrSave("Game from non-PGN file");
16529         gameInfo.site = StrSave(HostName());
16530         gameInfo.date = PGNDate();
16531         gameInfo.round = StrSave("-");
16532         gameInfo.white = StrSave("?");
16533         gameInfo.black = StrSave("?");
16534         break;
16535
16536       default:
16537         break;
16538     }
16539 }
16540
16541 void
16542 ReplaceComment (int index, char *text)
16543 {
16544     int len;
16545     char *p;
16546     float score;
16547
16548     if(index && sscanf(text, "%f/%d", &score, &len) == 2 &&
16549        pvInfoList[index-1].depth == len &&
16550        fabs(pvInfoList[index-1].score - score*100.) < 0.5 &&
16551        (p = strchr(text, '\n'))) text = p; // [HGM] strip off first line with PV info, if any
16552     while (*text == '\n') text++;
16553     len = strlen(text);
16554     while (len > 0 && text[len - 1] == '\n') len--;
16555
16556     if (commentList[index] != NULL)
16557       free(commentList[index]);
16558
16559     if (len == 0) {
16560         commentList[index] = NULL;
16561         return;
16562     }
16563   if( *text == '{' && strchr(text, '}') || // [HGM] braces: if certainy malformed, put braces
16564       *text == '[' && strchr(text, ']') || // otherwise hope the user knows what he is doing
16565       *text == '(' && strchr(text, ')')) { // (perhaps check if this parses as comment-only?)
16566     commentList[index] = (char *) malloc(len + 2);
16567     strncpy(commentList[index], text, len);
16568     commentList[index][len] = '\n';
16569     commentList[index][len + 1] = NULLCHAR;
16570   } else {
16571     // [HGM] braces: if text does not start with known OK delimiter, put braces around it.
16572     char *p;
16573     commentList[index] = (char *) malloc(len + 7);
16574     safeStrCpy(commentList[index], "{\n", 3);
16575     safeStrCpy(commentList[index]+2, text, len+1);
16576     commentList[index][len+2] = NULLCHAR;
16577     while(p = strchr(commentList[index], '}')) *p = ')'; // kill all } to make it one comment
16578     strcat(commentList[index], "\n}\n");
16579   }
16580 }
16581
16582 void
16583 CrushCRs (char *text)
16584 {
16585   char *p = text;
16586   char *q = text;
16587   char ch;
16588
16589   do {
16590     ch = *p++;
16591     if (ch == '\r') continue;
16592     *q++ = ch;
16593   } while (ch != '\0');
16594 }
16595
16596 void
16597 AppendComment (int index, char *text, Boolean addBraces)
16598 /* addBraces  tells if we should add {} */
16599 {
16600     int oldlen, len;
16601     char *old;
16602
16603 if(appData.debugMode) fprintf(debugFP, "Append: in='%s' %d\n", text, addBraces);
16604     if(addBraces == 3) addBraces = 0; else // force appending literally
16605     text = GetInfoFromComment( index, text ); /* [HGM] PV time: strip PV info from comment */
16606
16607     CrushCRs(text);
16608     while (*text == '\n') text++;
16609     len = strlen(text);
16610     while (len > 0 && text[len - 1] == '\n') len--;
16611     text[len] = NULLCHAR;
16612
16613     if (len == 0) return;
16614
16615     if (commentList[index] != NULL) {
16616       Boolean addClosingBrace = addBraces;
16617         old = commentList[index];
16618         oldlen = strlen(old);
16619         while(commentList[index][oldlen-1] ==  '\n')
16620           commentList[index][--oldlen] = NULLCHAR;
16621         commentList[index] = (char *) malloc(oldlen + len + 6); // might waste 4
16622         safeStrCpy(commentList[index], old, oldlen + len + 6);
16623         free(old);
16624         // [HGM] braces: join "{A\n}\n" + "{\nB}" as "{A\nB\n}"
16625         if(commentList[index][oldlen-1] == '}' && (text[0] == '{' || addBraces == TRUE)) {
16626           if(addBraces == TRUE) addBraces = FALSE; else { text++; len--; }
16627           while (*text == '\n') { text++; len--; }
16628           commentList[index][--oldlen] = NULLCHAR;
16629       }
16630         if(addBraces) strcat(commentList[index], addBraces == 2 ? "\n(" : "\n{\n");
16631         else          strcat(commentList[index], "\n");
16632         strcat(commentList[index], text);
16633         if(addClosingBrace) strcat(commentList[index], addClosingBrace == 2 ? ")\n" : "\n}\n");
16634         else          strcat(commentList[index], "\n");
16635     } else {
16636         commentList[index] = (char *) malloc(len + 6); // perhaps wastes 4...
16637         if(addBraces)
16638           safeStrCpy(commentList[index], addBraces == 2 ? "(" : "{\n", 3);
16639         else commentList[index][0] = NULLCHAR;
16640         strcat(commentList[index], text);
16641         strcat(commentList[index], addBraces == 2 ? ")\n" : "\n");
16642         if(addBraces == TRUE) strcat(commentList[index], "}\n");
16643     }
16644 }
16645
16646 static char *
16647 FindStr (char * text, char * sub_text)
16648 {
16649     char * result = strstr( text, sub_text );
16650
16651     if( result != NULL ) {
16652         result += strlen( sub_text );
16653     }
16654
16655     return result;
16656 }
16657
16658 /* [AS] Try to extract PV info from PGN comment */
16659 /* [HGM] PV time: and then remove it, to prevent it appearing twice */
16660 char *
16661 GetInfoFromComment (int index, char * text)
16662 {
16663     char * sep = text, *p;
16664
16665     if( text != NULL && index > 0 ) {
16666         int score = 0;
16667         int depth = 0;
16668         int time = -1, sec = 0, deci;
16669         char * s_eval = FindStr( text, "[%eval " );
16670         char * s_emt = FindStr( text, "[%emt " );
16671 #if 0
16672         if( s_eval != NULL || s_emt != NULL ) {
16673 #else
16674         if(0) { // [HGM] this code is not finished, and could actually be detrimental
16675 #endif
16676             /* New style */
16677             char delim;
16678
16679             if( s_eval != NULL ) {
16680                 if( sscanf( s_eval, "%d,%d%c", &score, &depth, &delim ) != 3 ) {
16681                     return text;
16682                 }
16683
16684                 if( delim != ']' ) {
16685                     return text;
16686                 }
16687             }
16688
16689             if( s_emt != NULL ) {
16690             }
16691                 return text;
16692         }
16693         else {
16694             /* We expect something like: [+|-]nnn.nn/dd */
16695             int score_lo = 0;
16696
16697             if(*text != '{') return text; // [HGM] braces: must be normal comment
16698
16699             sep = strchr( text, '/' );
16700             if( sep == NULL || sep < (text+4) ) {
16701                 return text;
16702             }
16703
16704             p = text;
16705             if(!strncmp(p+1, "final score ", 12)) p += 12, index++; else
16706             if(p[1] == '(') { // comment starts with PV
16707                p = strchr(p, ')'); // locate end of PV
16708                if(p == NULL || sep < p+5) return text;
16709                // at this point we have something like "{(.*) +0.23/6 ..."
16710                p = text; while(*++p != ')') p[-1] = *p; p[-1] = ')';
16711                *p = '\n'; while(*p == ' ' || *p == '\n') p++; *--p = '{';
16712                // we now moved the brace to behind the PV: "(.*) {+0.23/6 ..."
16713             }
16714             time = -1; sec = -1; deci = -1;
16715             if( sscanf( p+1, "%d.%d/%d %d:%d", &score, &score_lo, &depth, &time, &sec ) != 5 &&
16716                 sscanf( p+1, "%d.%d/%d %d.%d", &score, &score_lo, &depth, &time, &deci ) != 5 &&
16717                 sscanf( p+1, "%d.%d/%d %d", &score, &score_lo, &depth, &time ) != 4 &&
16718                 sscanf( p+1, "%d.%d/%d", &score, &score_lo, &depth ) != 3   ) {
16719                 return text;
16720             }
16721
16722             if( score_lo < 0 || score_lo >= 100 ) {
16723                 return text;
16724             }
16725
16726             if(sec >= 0) time = 600*time + 10*sec; else
16727             if(deci >= 0) time = 10*time + deci; else time *= 10; // deci-sec
16728
16729             score = score > 0 || !score & p[1] != '-' ? score*100 + score_lo : score*100 - score_lo;
16730
16731             /* [HGM] PV time: now locate end of PV info */
16732             while( *++sep >= '0' && *sep <= '9'); // strip depth
16733             if(time >= 0)
16734             while( *++sep >= '0' && *sep <= '9' || *sep == '\n'); // strip time
16735             if(sec >= 0)
16736             while( *++sep >= '0' && *sep <= '9'); // strip seconds
16737             if(deci >= 0)
16738             while( *++sep >= '0' && *sep <= '9'); // strip fractional seconds
16739             while(*sep == ' ' || *sep == '\n' || *sep == '\r') sep++;
16740         }
16741
16742         if( depth <= 0 ) {
16743             return text;
16744         }
16745
16746         if( time < 0 ) {
16747             time = -1;
16748         }
16749
16750         pvInfoList[index-1].depth = depth;
16751         pvInfoList[index-1].score = score;
16752         pvInfoList[index-1].time  = 10*time; // centi-sec
16753         if(*sep == '}') *sep = 0; else *--sep = '{';
16754         if(p != text) { while(*p++ = *sep++); sep = text; } // squeeze out space between PV and comment, and return both
16755     }
16756     return sep;
16757 }
16758
16759 void
16760 SendToProgram (char *message, ChessProgramState *cps)
16761 {
16762     int count, outCount, error;
16763     char buf[MSG_SIZ];
16764
16765     if (cps->pr == NoProc) return;
16766     Attention(cps);
16767
16768     if (appData.debugMode) {
16769         TimeMark now;
16770         GetTimeMark(&now);
16771         fprintf(debugFP, "%ld >%-6s: %s",
16772                 SubtractTimeMarks(&now, &programStartTime),
16773                 cps->which, message);
16774         if(serverFP)
16775             fprintf(serverFP, "%ld >%-6s: %s",
16776                 SubtractTimeMarks(&now, &programStartTime),
16777                 cps->which, message), fflush(serverFP);
16778     }
16779
16780     count = strlen(message);
16781     outCount = OutputToProcess(cps->pr, message, count, &error);
16782     if (outCount < count && !exiting
16783                          && !endingGame) { /* [HGM] crash: to not hang GameEnds() writing to deceased engines */
16784       if(!cps->initDone) return; // [HGM] should not generate fatal error during engine load
16785       snprintf(buf, MSG_SIZ, _("Error writing to %s chess program"), _(cps->which));
16786         if(gameInfo.resultDetails==NULL) { /* [HGM] crash: if game in progress, give reason for abort */
16787             if((signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
16788                 snprintf(buf, MSG_SIZ, _("%s program exits in draw position (%s)"), _(cps->which), cps->program);
16789                 if(matchMode && appData.tourneyFile[0]) { cps->pr = NoProc; GameEnds(GameIsDrawn, buf, GE_XBOARD); return; }
16790                 gameInfo.result = GameIsDrawn; /* [HGM] accept exit as draw claim */
16791             } else {
16792                 ChessMove res = cps->twoMachinesColor[0]=='w' ? BlackWins : WhiteWins;
16793                 if(matchMode && appData.tourneyFile[0]) { cps->pr = NoProc; GameEnds(res, buf, GE_XBOARD); return; }
16794                 gameInfo.result = res;
16795             }
16796             gameInfo.resultDetails = StrSave(buf);
16797         }
16798         if(matchMode && appData.tourneyFile[0]) { cps->pr = NoProc; return; }
16799         if(!cps->userError || !appData.popupExitMessage) DisplayFatalError(buf, error, 1); else errorExitStatus = 1;
16800     }
16801 }
16802
16803 void
16804 ReceiveFromProgram (InputSourceRef isr, VOIDSTAR closure, char *message, int count, int error)
16805 {
16806     char *end_str;
16807     char buf[MSG_SIZ];
16808     ChessProgramState *cps = (ChessProgramState *)closure;
16809
16810     if (isr != cps->isr) return; /* Killed intentionally */
16811     if (count <= 0) {
16812         if (count == 0) {
16813             RemoveInputSource(cps->isr);
16814             snprintf(buf, MSG_SIZ, _("Error: %s chess program (%s) exited unexpectedly"),
16815                     _(cps->which), cps->program);
16816             if(LoadError(cps->userError ? NULL : buf, cps)) return; // [HGM] should not generate fatal error during engine load
16817             if(gameInfo.resultDetails==NULL) { /* [HGM] crash: if game in progress, give reason for abort */
16818                 if((signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
16819                     snprintf(buf, MSG_SIZ, _("%s program exits in draw position (%s)"), _(cps->which), cps->program);
16820                     if(matchMode && appData.tourneyFile[0]) { cps->pr = NoProc; GameEnds(GameIsDrawn, buf, GE_XBOARD); return; }
16821                     gameInfo.result = GameIsDrawn; /* [HGM] accept exit as draw claim */
16822                 } else {
16823                     ChessMove res = cps->twoMachinesColor[0]=='w' ? BlackWins : WhiteWins;
16824                     if(matchMode && appData.tourneyFile[0]) { cps->pr = NoProc; GameEnds(res, buf, GE_XBOARD); return; }
16825                     gameInfo.result = res;
16826                 }
16827                 gameInfo.resultDetails = StrSave(buf);
16828             }
16829             if(matchMode && appData.tourneyFile[0]) { cps->pr = NoProc; return; }
16830             if(!cps->userError || !appData.popupExitMessage) DisplayFatalError(buf, 0, 1); else errorExitStatus = 1;
16831         } else {
16832             snprintf(buf, MSG_SIZ, _("Error reading from %s chess program (%s)"),
16833                     _(cps->which), cps->program);
16834             RemoveInputSource(cps->isr);
16835
16836             /* [AS] Program is misbehaving badly... kill it */
16837             if( count == -2 ) {
16838                 DestroyChildProcess( cps->pr, 9 );
16839                 cps->pr = NoProc;
16840             }
16841
16842             if(!cps->userError || !appData.popupExitMessage) DisplayFatalError(buf, error, 1); else errorExitStatus = 1;
16843         }
16844         return;
16845     }
16846
16847     if ((end_str = strchr(message, '\r')) != NULL)
16848       *end_str = NULLCHAR;
16849     if ((end_str = strchr(message, '\n')) != NULL)
16850       *end_str = NULLCHAR;
16851
16852     if (appData.debugMode) {
16853         TimeMark now; int print = 1;
16854         char *quote = ""; char c; int i;
16855
16856         if(appData.engineComments != 1) { /* [HGM] debug: decide if protocol-violating output is written */
16857                 char start = message[0];
16858                 if(start >='A' && start <= 'Z') start += 'a' - 'A'; // be tolerant to capitalizing
16859                 if(sscanf(message, "%d%c%d%d%d", &i, &c, &i, &i, &i) != 5 &&
16860                    sscanf(message, "move %c", &c)!=1  && sscanf(message, "offer%c", &c)!=1 &&
16861                    sscanf(message, "resign%c", &c)!=1 && sscanf(message, "feature %c", &c)!=1 &&
16862                    sscanf(message, "error %c", &c)!=1 && sscanf(message, "illegal %c", &c)!=1 &&
16863                    sscanf(message, "tell%c", &c)!=1   && sscanf(message, "0-1 %c", &c)!=1 &&
16864                    sscanf(message, "1-0 %c", &c)!=1   && sscanf(message, "1/2-1/2 %c", &c)!=1 &&
16865                    sscanf(message, "setboard %c", &c)!=1   && sscanf(message, "setup %c", &c)!=1 &&
16866                    sscanf(message, "hint: %c", &c)!=1 &&
16867                    sscanf(message, "pong %c", &c)!=1   && start != '#') {
16868                     quote = appData.engineComments == 2 ? "# " : "### NON-COMPLIANT! ### ";
16869                     print = (appData.engineComments >= 2);
16870                 }
16871                 message[0] = start; // restore original message
16872         }
16873         if(print) {
16874                 GetTimeMark(&now);
16875                 fprintf(debugFP, "%ld <%-6s: %s%s\n",
16876                         SubtractTimeMarks(&now, &programStartTime), cps->which,
16877                         quote,
16878                         message);
16879                 if(serverFP)
16880                     fprintf(serverFP, "%ld <%-6s: %s%s\n",
16881                         SubtractTimeMarks(&now, &programStartTime), cps->which,
16882                         quote,
16883                         message), fflush(serverFP);
16884         }
16885     }
16886
16887     /* [DM] if icsEngineAnalyze is active we block all whisper and kibitz output, because nobody want to see this */
16888     if (appData.icsEngineAnalyze) {
16889         if (strstr(message, "whisper") != NULL ||
16890              strstr(message, "kibitz") != NULL ||
16891             strstr(message, "tellics") != NULL) return;
16892     }
16893
16894     HandleMachineMove(message, cps);
16895 }
16896
16897
16898 void
16899 SendTimeControl (ChessProgramState *cps, int mps, long tc, int inc, int sd, int st)
16900 {
16901     char buf[MSG_SIZ];
16902     int seconds;
16903
16904     if( timeControl_2 > 0 ) {
16905         if( (gameMode == MachinePlaysBlack) || (gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b') ) {
16906             tc = timeControl_2;
16907         }
16908     }
16909     tc  /= cps->timeOdds; /* [HGM] time odds: apply before telling engine */
16910     inc /= cps->timeOdds;
16911     st  /= cps->timeOdds;
16912
16913     seconds = (tc / 1000) % 60; /* [HGM] displaced to after applying odds */
16914
16915     if (st > 0) {
16916       /* Set exact time per move, normally using st command */
16917       if (cps->stKludge) {
16918         /* GNU Chess 4 has no st command; uses level in a nonstandard way */
16919         seconds = st % 60;
16920         if (seconds == 0) {
16921           snprintf(buf, MSG_SIZ, "level 1 %d\n", st/60);
16922         } else {
16923           snprintf(buf, MSG_SIZ, "level 1 %d:%02d\n", st/60, seconds);
16924         }
16925       } else {
16926         snprintf(buf, MSG_SIZ, "st %d\n", st);
16927       }
16928     } else {
16929       /* Set conventional or incremental time control, using level command */
16930       if (seconds == 0) {
16931         /* Note old gnuchess bug -- minutes:seconds used to not work.
16932            Fixed in later versions, but still avoid :seconds
16933            when seconds is 0. */
16934         snprintf(buf, MSG_SIZ, "level %d %ld %g\n", mps, tc/60000, inc/1000.);
16935       } else {
16936         snprintf(buf, MSG_SIZ, "level %d %ld:%02d %g\n", mps, tc/60000,
16937                  seconds, inc/1000.);
16938       }
16939     }
16940     SendToProgram(buf, cps);
16941
16942     /* Orthoganally (except for GNU Chess 4), limit time to st seconds */
16943     /* Orthogonally, limit search to given depth */
16944     if (sd > 0) {
16945       if (cps->sdKludge) {
16946         snprintf(buf, MSG_SIZ, "depth\n%d\n", sd);
16947       } else {
16948         snprintf(buf, MSG_SIZ, "sd %d\n", sd);
16949       }
16950       SendToProgram(buf, cps);
16951     }
16952
16953     if(cps->nps >= 0) { /* [HGM] nps */
16954         if(cps->supportsNPS == FALSE)
16955           cps->nps = -1; // don't use if engine explicitly says not supported!
16956         else {
16957           snprintf(buf, MSG_SIZ, "nps %d\n", cps->nps);
16958           SendToProgram(buf, cps);
16959         }
16960     }
16961 }
16962
16963 ChessProgramState *
16964 WhitePlayer ()
16965 /* [HGM] return pointer to 'first' or 'second', depending on who plays white */
16966 {
16967     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b' ||
16968        gameMode == BeginningOfGame || gameMode == MachinePlaysBlack)
16969         return &second;
16970     return &first;
16971 }
16972
16973 void
16974 SendTimeRemaining (ChessProgramState *cps, int machineWhite)
16975 {
16976     char message[MSG_SIZ];
16977     long time, otime;
16978
16979     /* Note: this routine must be called when the clocks are stopped
16980        or when they have *just* been set or switched; otherwise
16981        it will be off by the time since the current tick started.
16982     */
16983     if (machineWhite) {
16984         time = whiteTimeRemaining / 10;
16985         otime = blackTimeRemaining / 10;
16986     } else {
16987         time = blackTimeRemaining / 10;
16988         otime = whiteTimeRemaining / 10;
16989     }
16990     /* [HGM] translate opponent's time by time-odds factor */
16991     otime = (otime * cps->other->timeOdds) / cps->timeOdds;
16992
16993     if (time <= 0) time = 1;
16994     if (otime <= 0) otime = 1;
16995
16996     snprintf(message, MSG_SIZ, "time %ld\n", time);
16997     SendToProgram(message, cps);
16998
16999     snprintf(message, MSG_SIZ, "otim %ld\n", otime);
17000     SendToProgram(message, cps);
17001 }
17002
17003 char *
17004 EngineDefinedVariant (ChessProgramState *cps, int n)
17005 {   // return name of n-th unknown variant that engine supports
17006     static char buf[MSG_SIZ];
17007     char *p, *s = cps->variants;
17008     if(!s) return NULL;
17009     do { // parse string from variants feature
17010       VariantClass v;
17011         p = strchr(s, ',');
17012         if(p) *p = NULLCHAR;
17013       v = StringToVariant(s);
17014       if(v == VariantNormal && strcmp(s, "normal") && !strstr(s, "_normal")) v = VariantUnknown; // garbage is recognized as normal
17015         if(v == VariantUnknown) { // non-standard variant in list of engine-supported variants
17016             if(!strcmp(s, "tenjiku") || !strcmp(s, "dai") || !strcmp(s, "dada") || // ignore Alien-Edition variants
17017                !strcmp(s, "maka") || !strcmp(s, "tai") || !strcmp(s, "kyoku") ||
17018                !strcmp(s, "checkers") || !strcmp(s, "go") || !strcmp(s, "reversi") ||
17019                !strcmp(s, "dark") || !strcmp(s, "alien") || !strcmp(s, "multi") || !strcmp(s, "amazons") ) n++;
17020             if(--n < 0) safeStrCpy(buf, s, MSG_SIZ);
17021         }
17022         if(p) *p++ = ',';
17023         if(n < 0) return buf;
17024     } while(s = p);
17025     return NULL;
17026 }
17027
17028 int
17029 BoolFeature (char **p, char *name, int *loc, ChessProgramState *cps)
17030 {
17031   char buf[MSG_SIZ];
17032   int len = strlen(name);
17033   int val;
17034
17035   if (strncmp((*p), name, len) == 0 && (*p)[len] == '=') {
17036     (*p) += len + 1;
17037     sscanf(*p, "%d", &val);
17038     *loc = (val != 0);
17039     while (**p && **p != ' ')
17040       (*p)++;
17041     snprintf(buf, MSG_SIZ, "accepted %s\n", name);
17042     SendToProgram(buf, cps);
17043     return TRUE;
17044   }
17045   return FALSE;
17046 }
17047
17048 int
17049 IntFeature (char **p, char *name, int *loc, ChessProgramState *cps)
17050 {
17051   char buf[MSG_SIZ];
17052   int len = strlen(name);
17053   if (strncmp((*p), name, len) == 0 && (*p)[len] == '=') {
17054     (*p) += len + 1;
17055     sscanf(*p, "%d", loc);
17056     while (**p && **p != ' ') (*p)++;
17057     snprintf(buf, MSG_SIZ, "accepted %s\n", name);
17058     SendToProgram(buf, cps);
17059     return TRUE;
17060   }
17061   return FALSE;
17062 }
17063
17064 int
17065 StringFeature (char **p, char *name, char **loc, ChessProgramState *cps)
17066 {
17067   char buf[MSG_SIZ];
17068   int len = strlen(name);
17069   if (strncmp((*p), name, len) == 0
17070       && (*p)[len] == '=' && (*p)[len+1] == '\"') {
17071     (*p) += len + 2;
17072     ASSIGN(*loc, *p); // kludge alert: assign rest of line just to be sure allocation is large enough so that sscanf below always fits
17073     sscanf(*p, "%[^\"]", *loc);
17074     while (**p && **p != '\"') (*p)++;
17075     if (**p == '\"') (*p)++;
17076     snprintf(buf, MSG_SIZ, "accepted %s\n", name);
17077     SendToProgram(buf, cps);
17078     return TRUE;
17079   }
17080   return FALSE;
17081 }
17082
17083 int
17084 ParseOption (Option *opt, ChessProgramState *cps)
17085 // [HGM] options: process the string that defines an engine option, and determine
17086 // name, type, default value, and allowed value range
17087 {
17088         char *p, *q, buf[MSG_SIZ];
17089         int n, min = (-1)<<31, max = 1<<31, def;
17090
17091         opt->target = &opt->value;   // OK for spin/slider and checkbox
17092         if(p = strstr(opt->name, " -spin ")) {
17093             if((n = sscanf(p, " -spin %d %d %d", &def, &min, &max)) < 3 ) return FALSE;
17094             if(max < min) max = min; // enforce consistency
17095             if(def < min) def = min;
17096             if(def > max) def = max;
17097             opt->value = def;
17098             opt->min = min;
17099             opt->max = max;
17100             opt->type = Spin;
17101         } else if((p = strstr(opt->name, " -slider "))) {
17102             // for now -slider is a synonym for -spin, to already provide compatibility with future polyglots
17103             if((n = sscanf(p, " -slider %d %d %d", &def, &min, &max)) < 3 ) return FALSE;
17104             if(max < min) max = min; // enforce consistency
17105             if(def < min) def = min;
17106             if(def > max) def = max;
17107             opt->value = def;
17108             opt->min = min;
17109             opt->max = max;
17110             opt->type = Spin; // Slider;
17111         } else if((p = strstr(opt->name, " -string "))) {
17112             opt->textValue = p+9;
17113             opt->type = TextBox;
17114             opt->target = &opt->textValue;
17115         } else if((p = strstr(opt->name, " -file "))) {
17116             // for now -file is a synonym for -string, to already provide compatibility with future polyglots
17117             opt->target = opt->textValue = p+7;
17118             opt->type = FileName; // FileName;
17119             opt->target = &opt->textValue;
17120         } else if((p = strstr(opt->name, " -path "))) {
17121             // for now -file is a synonym for -string, to already provide compatibility with future polyglots
17122             opt->target = opt->textValue = p+7;
17123             opt->type = PathName; // PathName;
17124             opt->target = &opt->textValue;
17125         } else if(p = strstr(opt->name, " -check ")) {
17126             if(sscanf(p, " -check %d", &def) < 1) return FALSE;
17127             opt->value = (def != 0);
17128             opt->type = CheckBox;
17129         } else if(p = strstr(opt->name, " -combo ")) {
17130             opt->textValue = (char*) (opt->choice = &cps->comboList[cps->comboCnt]); // cheat with pointer type
17131             cps->comboList[cps->comboCnt++] = q = p+8; // holds possible choices
17132             if(*q == '*') cps->comboList[cps->comboCnt-1]++;
17133             opt->value = n = 0;
17134             while(q = StrStr(q, " /// ")) {
17135                 n++; *q = 0;    // count choices, and null-terminate each of them
17136                 q += 5;
17137                 if(*q == '*') { // remember default, which is marked with * prefix
17138                     q++;
17139                     opt->value = n;
17140                 }
17141                 cps->comboList[cps->comboCnt++] = q;
17142             }
17143             cps->comboList[cps->comboCnt++] = NULL;
17144             opt->max = n + 1;
17145             opt->type = ComboBox;
17146         } else if(p = strstr(opt->name, " -button")) {
17147             opt->type = Button;
17148         } else if(p = strstr(opt->name, " -save")) {
17149             opt->type = SaveButton;
17150         } else return FALSE;
17151         *p = 0; // terminate option name
17152         // now look if the command-line options define a setting for this engine option.
17153         if(cps->optionSettings && cps->optionSettings[0])
17154             p = strstr(cps->optionSettings, opt->name); else p = NULL;
17155         if(p && (p == cps->optionSettings || p[-1] == ',')) {
17156           snprintf(buf, MSG_SIZ, "option %s", p);
17157                 if(p = strstr(buf, ",")) *p = 0;
17158                 if(q = strchr(buf, '=')) switch(opt->type) {
17159                     case ComboBox:
17160                         for(n=0; n<opt->max; n++)
17161                             if(!strcmp(((char**)opt->textValue)[n], q+1)) opt->value = n;
17162                         break;
17163                     case TextBox:
17164                         safeStrCpy(opt->textValue, q+1, MSG_SIZ - (opt->textValue - opt->name));
17165                         break;
17166                     case Spin:
17167                     case CheckBox:
17168                         opt->value = atoi(q+1);
17169                     default:
17170                         break;
17171                 }
17172                 strcat(buf, "\n");
17173                 SendToProgram(buf, cps);
17174         }
17175         return TRUE;
17176 }
17177
17178 void
17179 FeatureDone (ChessProgramState *cps, int val)
17180 {
17181   DelayedEventCallback cb = GetDelayedEvent();
17182   if ((cb == InitBackEnd3 && cps == &first) ||
17183       (cb == SettingsMenuIfReady && cps == &second) ||
17184       (cb == LoadEngine) ||
17185       (cb == TwoMachinesEventIfReady)) {
17186     CancelDelayedEvent();
17187     ScheduleDelayedEvent(cb, val ? 1 : 3600000);
17188   } else if(!val && !cps->reload) ClearOptions(cps); // let 'spurious' done=0 clear engine's option list
17189   cps->initDone = val;
17190   if(val) cps->reload = FALSE,  RefreshSettingsDialog(cps, val);
17191 }
17192
17193 /* Parse feature command from engine */
17194 void
17195 ParseFeatures (char *args, ChessProgramState *cps)
17196 {
17197   char *p = args;
17198   char *q = NULL;
17199   int val;
17200   char buf[MSG_SIZ];
17201
17202   for (;;) {
17203     while (*p == ' ') p++;
17204     if (*p == NULLCHAR) return;
17205
17206     if (BoolFeature(&p, "setboard", &cps->useSetboard, cps)) continue;
17207     if (BoolFeature(&p, "xedit", &cps->extendedEdit, cps)) continue;
17208     if (BoolFeature(&p, "time", &cps->sendTime, cps)) continue;
17209     if (BoolFeature(&p, "draw", &cps->sendDrawOffers, cps)) continue;
17210     if (BoolFeature(&p, "sigint", &cps->useSigint, cps)) continue;
17211     if (BoolFeature(&p, "sigterm", &cps->useSigterm, cps)) continue;
17212     if (BoolFeature(&p, "reuse", &val, cps)) {
17213       /* Engine can disable reuse, but can't enable it if user said no */
17214       if (!val) cps->reuse = FALSE;
17215       continue;
17216     }
17217     if (BoolFeature(&p, "analyze", &cps->analysisSupport, cps)) continue;
17218     if (StringFeature(&p, "myname", &cps->tidy, cps)) {
17219       if (gameMode == TwoMachinesPlay) {
17220         DisplayTwoMachinesTitle();
17221       } else {
17222         DisplayTitle("");
17223       }
17224       continue;
17225     }
17226     if (StringFeature(&p, "variants", &cps->variants, cps)) continue;
17227     if (BoolFeature(&p, "san", &cps->useSAN, cps)) continue;
17228     if (BoolFeature(&p, "ping", &cps->usePing, cps)) continue;
17229     if (BoolFeature(&p, "playother", &cps->usePlayother, cps)) continue;
17230     if (BoolFeature(&p, "colors", &cps->useColors, cps)) continue;
17231     if (BoolFeature(&p, "usermove", &cps->useUsermove, cps)) continue;
17232     if (BoolFeature(&p, "exclude", &cps->excludeMoves, cps)) continue;
17233     if (BoolFeature(&p, "ics", &cps->sendICS, cps)) continue;
17234     if (BoolFeature(&p, "name", &cps->sendName, cps)) continue;
17235     if (BoolFeature(&p, "pause", &cps->pause, cps)) continue; // [HGM] pause
17236     if (IntFeature(&p, "done", &val, cps)) {
17237       FeatureDone(cps, val);
17238       continue;
17239     }
17240     /* Added by Tord: */
17241     if (BoolFeature(&p, "fen960", &cps->useFEN960, cps)) continue;
17242     if (BoolFeature(&p, "oocastle", &cps->useOOCastle, cps)) continue;
17243     /* End of additions by Tord */
17244
17245     /* [HGM] added features: */
17246     if (BoolFeature(&p, "highlight", &cps->highlight, cps)) continue;
17247     if (BoolFeature(&p, "debug", &cps->debug, cps)) continue;
17248     if (BoolFeature(&p, "nps", &cps->supportsNPS, cps)) continue;
17249     if (IntFeature(&p, "level", &cps->maxNrOfSessions, cps)) continue;
17250     if (BoolFeature(&p, "memory", &cps->memSize, cps)) continue;
17251     if (BoolFeature(&p, "smp", &cps->maxCores, cps)) continue;
17252     if (StringFeature(&p, "egt", &cps->egtFormats, cps)) continue;
17253     if (StringFeature(&p, "option", &q, cps)) { // read to freshly allocated temp buffer first
17254         if(cps->reload) { FREE(q); q = NULL; continue; } // we are reloading because of xreuse
17255         FREE(cps->option[cps->nrOptions].name);
17256         cps->option[cps->nrOptions].name = q; q = NULL;
17257         if(!ParseOption(&(cps->option[cps->nrOptions++]), cps)) { // [HGM] options: add option feature
17258           snprintf(buf, MSG_SIZ, "rejected option %s\n", cps->option[--cps->nrOptions].name);
17259             SendToProgram(buf, cps);
17260             continue;
17261         }
17262         if(cps->nrOptions >= MAX_OPTIONS) {
17263             cps->nrOptions--;
17264             snprintf(buf, MSG_SIZ, _("%s engine has too many options\n"), _(cps->which));
17265             DisplayError(buf, 0);
17266         }
17267         continue;
17268     }
17269     /* End of additions by HGM */
17270
17271     /* unknown feature: complain and skip */
17272     q = p;
17273     while (*q && *q != '=') q++;
17274     snprintf(buf, MSG_SIZ,"rejected %.*s\n", (int)(q-p), p);
17275     SendToProgram(buf, cps);
17276     p = q;
17277     if (*p == '=') {
17278       p++;
17279       if (*p == '\"') {
17280         p++;
17281         while (*p && *p != '\"') p++;
17282         if (*p == '\"') p++;
17283       } else {
17284         while (*p && *p != ' ') p++;
17285       }
17286     }
17287   }
17288
17289 }
17290
17291 void
17292 PeriodicUpdatesEvent (int newState)
17293 {
17294     if (newState == appData.periodicUpdates)
17295       return;
17296
17297     appData.periodicUpdates=newState;
17298
17299     /* Display type changes, so update it now */
17300 //    DisplayAnalysis();
17301
17302     /* Get the ball rolling again... */
17303     if (newState) {
17304         AnalysisPeriodicEvent(1);
17305         StartAnalysisClock();
17306     }
17307 }
17308
17309 void
17310 PonderNextMoveEvent (int newState)
17311 {
17312     if (newState == appData.ponderNextMove) return;
17313     if (gameMode == EditPosition) EditPositionDone(TRUE);
17314     if (newState) {
17315         SendToProgram("hard\n", &first);
17316         if (gameMode == TwoMachinesPlay) {
17317             SendToProgram("hard\n", &second);
17318         }
17319     } else {
17320         SendToProgram("easy\n", &first);
17321         thinkOutput[0] = NULLCHAR;
17322         if (gameMode == TwoMachinesPlay) {
17323             SendToProgram("easy\n", &second);
17324         }
17325     }
17326     appData.ponderNextMove = newState;
17327 }
17328
17329 void
17330 NewSettingEvent (int option, int *feature, char *command, int value)
17331 {
17332     char buf[MSG_SIZ];
17333
17334     if (gameMode == EditPosition) EditPositionDone(TRUE);
17335     snprintf(buf, MSG_SIZ,"%s%s %d\n", (option ? "option ": ""), command, value);
17336     if(feature == NULL || *feature) SendToProgram(buf, &first);
17337     if (gameMode == TwoMachinesPlay) {
17338         if(feature == NULL || feature[(int*)&second - (int*)&first]) SendToProgram(buf, &second);
17339     }
17340 }
17341
17342 void
17343 ShowThinkingEvent ()
17344 // [HGM] thinking: this routine is now also called from "Options -> Engine..." popup
17345 {
17346     static int oldState = 2; // kludge alert! Neither true nor fals, so first time oldState is always updated
17347     int newState = appData.showThinking
17348         // [HGM] thinking: other features now need thinking output as well
17349         || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp();
17350
17351     if (oldState == newState) return;
17352     oldState = newState;
17353     if (gameMode == EditPosition) EditPositionDone(TRUE);
17354     if (oldState) {
17355         SendToProgram("post\n", &first);
17356         if (gameMode == TwoMachinesPlay) {
17357             SendToProgram("post\n", &second);
17358         }
17359     } else {
17360         SendToProgram("nopost\n", &first);
17361         thinkOutput[0] = NULLCHAR;
17362         if (gameMode == TwoMachinesPlay) {
17363             SendToProgram("nopost\n", &second);
17364         }
17365     }
17366 //    appData.showThinking = newState; // [HGM] thinking: responsible option should already have be changed when calling this routine!
17367 }
17368
17369 void
17370 AskQuestionEvent (char *title, char *question, char *replyPrefix, char *which)
17371 {
17372   ProcRef pr = (which[0] == '1') ? first.pr : second.pr;
17373   if (pr == NoProc) return;
17374   AskQuestion(title, question, replyPrefix, pr);
17375 }
17376
17377 void
17378 TypeInEvent (char firstChar)
17379 {
17380     if ((gameMode == BeginningOfGame && !appData.icsActive) ||
17381         gameMode == MachinePlaysWhite || gameMode == MachinePlaysBlack ||
17382         gameMode == AnalyzeMode || gameMode == EditGame ||
17383         gameMode == EditPosition || gameMode == IcsExamining ||
17384         gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack ||
17385         isdigit(firstChar) && // [HGM] movenum: allow typing in of move nr in 'passive' modes
17386                 ( gameMode == AnalyzeFile || gameMode == PlayFromGameFile ||
17387                   gameMode == IcsObserving || gameMode == TwoMachinesPlay    ) ||
17388         gameMode == Training) PopUpMoveDialog(firstChar);
17389 }
17390
17391 void
17392 TypeInDoneEvent (char *move)
17393 {
17394         Board board;
17395         int n, fromX, fromY, toX, toY;
17396         char promoChar;
17397         ChessMove moveType;
17398
17399         // [HGM] FENedit
17400         if(gameMode == EditPosition && ParseFEN(board, &n, move, TRUE) ) {
17401                 EditPositionPasteFEN(move);
17402                 return;
17403         }
17404         // [HGM] movenum: allow move number to be typed in any mode
17405         if(sscanf(move, "%d", &n) == 1 && n != 0 ) {
17406           ToNrEvent(2*n-1);
17407           return;
17408         }
17409         // undocumented kludge: allow command-line option to be typed in!
17410         // (potentially fatal, and does not implement the effect of the option.)
17411         // should only be used for options that are values on which future decisions will be made,
17412         // and definitely not on options that would be used during initialization.
17413         if(strstr(move, "!!! -") == move) {
17414             ParseArgsFromString(move+4);
17415             return;
17416         }
17417
17418       if (gameMode != EditGame && currentMove != forwardMostMove &&
17419         gameMode != Training) {
17420         DisplayMoveError(_("Displayed move is not current"));
17421       } else {
17422         int ok = ParseOneMove(move, gameMode == EditPosition ? blackPlaysFirst : currentMove,
17423           &moveType, &fromX, &fromY, &toX, &toY, &promoChar);
17424         if(!ok && move[0] >= 'a') { move[0] += 'A' - 'a'; ok = 2; } // [HGM] try also capitalized
17425         if (ok==1 || ok && ParseOneMove(move, gameMode == EditPosition ? blackPlaysFirst : currentMove,
17426           &moveType, &fromX, &fromY, &toX, &toY, &promoChar)) {
17427           UserMoveEvent(fromX, fromY, toX, toY, promoChar);
17428         } else {
17429           DisplayMoveError(_("Could not parse move"));
17430         }
17431       }
17432 }
17433
17434 void
17435 DisplayMove (int moveNumber)
17436 {
17437     char message[MSG_SIZ];
17438     char res[MSG_SIZ];
17439     char cpThinkOutput[MSG_SIZ];
17440
17441     if(appData.noGUI) return; // [HGM] fast: suppress display of moves
17442
17443     if (moveNumber == forwardMostMove - 1 ||
17444         gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
17445
17446         safeStrCpy(cpThinkOutput, thinkOutput, sizeof(cpThinkOutput)/sizeof(cpThinkOutput[0]));
17447
17448         if (strchr(cpThinkOutput, '\n')) {
17449             *strchr(cpThinkOutput, '\n') = NULLCHAR;
17450         }
17451     } else {
17452         *cpThinkOutput = NULLCHAR;
17453     }
17454
17455     /* [AS] Hide thinking from human user */
17456     if( appData.hideThinkingFromHuman && gameMode != TwoMachinesPlay ) {
17457         *cpThinkOutput = NULLCHAR;
17458         if( thinkOutput[0] != NULLCHAR ) {
17459             int i;
17460
17461             for( i=0; i<=hiddenThinkOutputState; i++ ) {
17462                 cpThinkOutput[i] = '.';
17463             }
17464             cpThinkOutput[i] = NULLCHAR;
17465             hiddenThinkOutputState = (hiddenThinkOutputState + 1) % 3;
17466         }
17467     }
17468
17469     if (moveNumber == forwardMostMove - 1 &&
17470         gameInfo.resultDetails != NULL) {
17471         if (gameInfo.resultDetails[0] == NULLCHAR) {
17472           snprintf(res, MSG_SIZ, " %s", PGNResult(gameInfo.result));
17473         } else {
17474           snprintf(res, MSG_SIZ, " {%s} %s",
17475                     T_(gameInfo.resultDetails), PGNResult(gameInfo.result));
17476         }
17477     } else {
17478         res[0] = NULLCHAR;
17479     }
17480
17481     if (moveNumber < 0 || parseList[moveNumber][0] == NULLCHAR) {
17482         DisplayMessage(res, cpThinkOutput);
17483     } else {
17484       snprintf(message, MSG_SIZ, "%d.%s%s%s", moveNumber / 2 + 1,
17485                 WhiteOnMove(moveNumber) ? " " : ".. ",
17486                 parseList[moveNumber], res);
17487         DisplayMessage(message, cpThinkOutput);
17488     }
17489 }
17490
17491 void
17492 DisplayComment (int moveNumber, char *text)
17493 {
17494     char title[MSG_SIZ];
17495
17496     if (moveNumber < 0 || parseList[moveNumber][0] == NULLCHAR) {
17497       safeStrCpy(title, "Comment", sizeof(title)/sizeof(title[0]));
17498     } else {
17499       snprintf(title,MSG_SIZ, "Comment on %d.%s%s", moveNumber / 2 + 1,
17500               WhiteOnMove(moveNumber) ? " " : ".. ",
17501               parseList[moveNumber]);
17502     }
17503     if (text != NULL && (appData.autoDisplayComment || commentUp))
17504         CommentPopUp(title, text);
17505 }
17506
17507 /* This routine sends a ^C interrupt to gnuchess, to awaken it if it
17508  * might be busy thinking or pondering.  It can be omitted if your
17509  * gnuchess is configured to stop thinking immediately on any user
17510  * input.  However, that gnuchess feature depends on the FIONREAD
17511  * ioctl, which does not work properly on some flavors of Unix.
17512  */
17513 void
17514 Attention (ChessProgramState *cps)
17515 {
17516 #if ATTENTION
17517     if (!cps->useSigint) return;
17518     if (appData.noChessProgram || (cps->pr == NoProc)) return;
17519     switch (gameMode) {
17520       case MachinePlaysWhite:
17521       case MachinePlaysBlack:
17522       case TwoMachinesPlay:
17523       case IcsPlayingWhite:
17524       case IcsPlayingBlack:
17525       case AnalyzeMode:
17526       case AnalyzeFile:
17527         /* Skip if we know it isn't thinking */
17528         if (!cps->maybeThinking) return;
17529         if (appData.debugMode)
17530           fprintf(debugFP, "Interrupting %s\n", cps->which);
17531         InterruptChildProcess(cps->pr);
17532         cps->maybeThinking = FALSE;
17533         break;
17534       default:
17535         break;
17536     }
17537 #endif /*ATTENTION*/
17538 }
17539
17540 int
17541 CheckFlags ()
17542 {
17543     if (whiteTimeRemaining <= 0) {
17544         if (!whiteFlag) {
17545             whiteFlag = TRUE;
17546             if (appData.icsActive) {
17547                 if (appData.autoCallFlag &&
17548                     gameMode == IcsPlayingBlack && !blackFlag) {
17549                   SendToICS(ics_prefix);
17550                   SendToICS("flag\n");
17551                 }
17552             } else {
17553                 if (blackFlag) {
17554                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Both flags fell"));
17555                 } else {
17556                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("White's flag fell"));
17557                     if (appData.autoCallFlag) {
17558                         GameEnds(BlackWins, "Black wins on time", GE_XBOARD);
17559                         return TRUE;
17560                     }
17561                 }
17562             }
17563         }
17564     }
17565     if (blackTimeRemaining <= 0) {
17566         if (!blackFlag) {
17567             blackFlag = TRUE;
17568             if (appData.icsActive) {
17569                 if (appData.autoCallFlag &&
17570                     gameMode == IcsPlayingWhite && !whiteFlag) {
17571                   SendToICS(ics_prefix);
17572                   SendToICS("flag\n");
17573                 }
17574             } else {
17575                 if (whiteFlag) {
17576                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Both flags fell"));
17577                 } else {
17578                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Black's flag fell"));
17579                     if (appData.autoCallFlag) {
17580                         GameEnds(WhiteWins, "White wins on time", GE_XBOARD);
17581                         return TRUE;
17582                     }
17583                 }
17584             }
17585         }
17586     }
17587     return FALSE;
17588 }
17589
17590 void
17591 CheckTimeControl ()
17592 {
17593     if (!appData.clockMode || appData.icsActive || searchTime || // [HGM] st: no inc in st mode
17594         gameMode == PlayFromGameFile || forwardMostMove == 0) return;
17595
17596     /*
17597      * add time to clocks when time control is achieved ([HGM] now also used for increment)
17598      */
17599     if ( !WhiteOnMove(forwardMostMove) ) {
17600         /* White made time control */
17601         lastWhite -= whiteTimeRemaining; // [HGM] contains start time, socalculate thinking time
17602         whiteTimeRemaining += GetTimeQuota((forwardMostMove-whiteStartMove-1)/2, lastWhite, whiteTC)
17603         /* [HGM] time odds: correct new time quota for time odds! */
17604                                             / WhitePlayer()->timeOdds;
17605         lastBlack = blackTimeRemaining; // [HGM] leave absolute time (after quota), so next switch we can us it to calculate thinking time
17606     } else {
17607         lastBlack -= blackTimeRemaining;
17608         /* Black made time control */
17609         blackTimeRemaining += GetTimeQuota((forwardMostMove-blackStartMove-1)/2, lastBlack, blackTC)
17610                                             / WhitePlayer()->other->timeOdds;
17611         lastWhite = whiteTimeRemaining;
17612     }
17613 }
17614
17615 void
17616 DisplayBothClocks ()
17617 {
17618     int wom = gameMode == EditPosition ?
17619       !blackPlaysFirst : WhiteOnMove(currentMove);
17620     DisplayWhiteClock(whiteTimeRemaining, wom);
17621     DisplayBlackClock(blackTimeRemaining, !wom);
17622 }
17623
17624
17625 /* Timekeeping seems to be a portability nightmare.  I think everyone
17626    has ftime(), but I'm really not sure, so I'm including some ifdefs
17627    to use other calls if you don't.  Clocks will be less accurate if
17628    you have neither ftime nor gettimeofday.
17629 */
17630
17631 /* VS 2008 requires the #include outside of the function */
17632 #if !HAVE_GETTIMEOFDAY && HAVE_FTIME
17633 #include <sys/timeb.h>
17634 #endif
17635
17636 /* Get the current time as a TimeMark */
17637 void
17638 GetTimeMark (TimeMark *tm)
17639 {
17640 #if HAVE_GETTIMEOFDAY
17641
17642     struct timeval timeVal;
17643     struct timezone timeZone;
17644
17645     gettimeofday(&timeVal, &timeZone);
17646     tm->sec = (long) timeVal.tv_sec;
17647     tm->ms = (int) (timeVal.tv_usec / 1000L);
17648
17649 #else /*!HAVE_GETTIMEOFDAY*/
17650 #if HAVE_FTIME
17651
17652 // include <sys/timeb.h> / moved to just above start of function
17653     struct timeb timeB;
17654
17655     ftime(&timeB);
17656     tm->sec = (long) timeB.time;
17657     tm->ms = (int) timeB.millitm;
17658
17659 #else /*!HAVE_FTIME && !HAVE_GETTIMEOFDAY*/
17660     tm->sec = (long) time(NULL);
17661     tm->ms = 0;
17662 #endif
17663 #endif
17664 }
17665
17666 /* Return the difference in milliseconds between two
17667    time marks.  We assume the difference will fit in a long!
17668 */
17669 long
17670 SubtractTimeMarks (TimeMark *tm2, TimeMark *tm1)
17671 {
17672     return 1000L*(tm2->sec - tm1->sec) +
17673            (long) (tm2->ms - tm1->ms);
17674 }
17675
17676
17677 /*
17678  * Code to manage the game clocks.
17679  *
17680  * In tournament play, black starts the clock and then white makes a move.
17681  * We give the human user a slight advantage if he is playing white---the
17682  * clocks don't run until he makes his first move, so it takes zero time.
17683  * Also, we don't account for network lag, so we could get out of sync
17684  * with GNU Chess's clock -- but then, referees are always right.
17685  */
17686
17687 static TimeMark tickStartTM;
17688 static long intendedTickLength;
17689
17690 long
17691 NextTickLength (long timeRemaining)
17692 {
17693     long nominalTickLength, nextTickLength;
17694
17695     if (timeRemaining > 0L && timeRemaining <= 10000L)
17696       nominalTickLength = 100L;
17697     else
17698       nominalTickLength = 1000L;
17699     nextTickLength = timeRemaining % nominalTickLength;
17700     if (nextTickLength <= 0) nextTickLength += nominalTickLength;
17701
17702     return nextTickLength;
17703 }
17704
17705 /* Adjust clock one minute up or down */
17706 void
17707 AdjustClock (Boolean which, int dir)
17708 {
17709     if(appData.autoCallFlag) { DisplayError(_("Clock adjustment not allowed in auto-flag mode"), 0); return; }
17710     if(which) blackTimeRemaining += 60000*dir;
17711     else      whiteTimeRemaining += 60000*dir;
17712     DisplayBothClocks();
17713     adjustedClock = TRUE;
17714 }
17715
17716 /* Stop clocks and reset to a fresh time control */
17717 void
17718 ResetClocks ()
17719 {
17720     (void) StopClockTimer();
17721     if (appData.icsActive) {
17722         whiteTimeRemaining = blackTimeRemaining = 0;
17723     } else if (searchTime) {
17724         whiteTimeRemaining = 1000*searchTime / WhitePlayer()->timeOdds;
17725         blackTimeRemaining = 1000*searchTime / WhitePlayer()->other->timeOdds;
17726     } else { /* [HGM] correct new time quote for time odds */
17727         whiteTC = blackTC = fullTimeControlString;
17728         whiteTimeRemaining = GetTimeQuota(-1, 0, whiteTC) / WhitePlayer()->timeOdds;
17729         blackTimeRemaining = GetTimeQuota(-1, 0, blackTC) / WhitePlayer()->other->timeOdds;
17730     }
17731     if (whiteFlag || blackFlag) {
17732         DisplayTitle("");
17733         whiteFlag = blackFlag = FALSE;
17734     }
17735     lastWhite = lastBlack = whiteStartMove = blackStartMove = 0;
17736     DisplayBothClocks();
17737     adjustedClock = FALSE;
17738 }
17739
17740 #define FUDGE 25 /* 25ms = 1/40 sec; should be plenty even for 50 Hz clocks */
17741
17742 /* Decrement running clock by amount of time that has passed */
17743 void
17744 DecrementClocks ()
17745 {
17746     long timeRemaining;
17747     long lastTickLength, fudge;
17748     TimeMark now;
17749
17750     if (!appData.clockMode) return;
17751     if (gameMode==AnalyzeMode || gameMode == AnalyzeFile) return;
17752
17753     GetTimeMark(&now);
17754
17755     lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
17756
17757     /* Fudge if we woke up a little too soon */
17758     fudge = intendedTickLength - lastTickLength;
17759     if (fudge < 0 || fudge > FUDGE) fudge = 0;
17760
17761     if (WhiteOnMove(forwardMostMove)) {
17762         if(whiteNPS >= 0) lastTickLength = 0;
17763         timeRemaining = whiteTimeRemaining -= lastTickLength;
17764         if(timeRemaining < 0 && !appData.icsActive) {
17765             GetTimeQuota((forwardMostMove-whiteStartMove-1)/2, 0, whiteTC); // sets suddenDeath & nextSession;
17766             if(suddenDeath) { // [HGM] if we run out of a non-last incremental session, go to the next
17767                 whiteStartMove = forwardMostMove; whiteTC = nextSession;
17768                 lastWhite= timeRemaining = whiteTimeRemaining += GetTimeQuota(-1, 0, whiteTC);
17769             }
17770         }
17771         DisplayWhiteClock(whiteTimeRemaining - fudge,
17772                           WhiteOnMove(currentMove < forwardMostMove ? currentMove : forwardMostMove));
17773     } else {
17774         if(blackNPS >= 0) lastTickLength = 0;
17775         timeRemaining = blackTimeRemaining -= lastTickLength;
17776         if(timeRemaining < 0 && !appData.icsActive) { // [HGM] if we run out of a non-last incremental session, go to the next
17777             GetTimeQuota((forwardMostMove-blackStartMove-1)/2, 0, blackTC);
17778             if(suddenDeath) {
17779                 blackStartMove = forwardMostMove;
17780                 lastBlack = timeRemaining = blackTimeRemaining += GetTimeQuota(-1, 0, blackTC=nextSession);
17781             }
17782         }
17783         DisplayBlackClock(blackTimeRemaining - fudge,
17784                           !WhiteOnMove(currentMove < forwardMostMove ? currentMove : forwardMostMove));
17785     }
17786     if (CheckFlags()) return;
17787
17788     if(twoBoards) { // count down secondary board's clocks as well
17789         activePartnerTime -= lastTickLength;
17790         partnerUp = 1;
17791         if(activePartner == 'W')
17792             DisplayWhiteClock(activePartnerTime, TRUE); // the counting clock is always the highlighted one!
17793         else
17794             DisplayBlackClock(activePartnerTime, TRUE);
17795         partnerUp = 0;
17796     }
17797
17798     tickStartTM = now;
17799     intendedTickLength = NextTickLength(timeRemaining - fudge) + fudge;
17800     StartClockTimer(intendedTickLength);
17801
17802     /* if the time remaining has fallen below the alarm threshold, sound the
17803      * alarm. if the alarm has sounded and (due to a takeback or time control
17804      * with increment) the time remaining has increased to a level above the
17805      * threshold, reset the alarm so it can sound again.
17806      */
17807
17808     if (appData.icsActive && appData.icsAlarm) {
17809
17810         /* make sure we are dealing with the user's clock */
17811         if (!( ((gameMode == IcsPlayingWhite) && WhiteOnMove(currentMove)) ||
17812                ((gameMode == IcsPlayingBlack) && !WhiteOnMove(currentMove))
17813            )) return;
17814
17815         if (alarmSounded && (timeRemaining > appData.icsAlarmTime)) {
17816             alarmSounded = FALSE;
17817         } else if (!alarmSounded && (timeRemaining <= appData.icsAlarmTime)) {
17818             PlayAlarmSound();
17819             alarmSounded = TRUE;
17820         }
17821     }
17822 }
17823
17824
17825 /* A player has just moved, so stop the previously running
17826    clock and (if in clock mode) start the other one.
17827    We redisplay both clocks in case we're in ICS mode, because
17828    ICS gives us an update to both clocks after every move.
17829    Note that this routine is called *after* forwardMostMove
17830    is updated, so the last fractional tick must be subtracted
17831    from the color that is *not* on move now.
17832 */
17833 void
17834 SwitchClocks (int newMoveNr)
17835 {
17836     long lastTickLength;
17837     TimeMark now;
17838     int flagged = FALSE;
17839
17840     GetTimeMark(&now);
17841
17842     if (StopClockTimer() && appData.clockMode) {
17843         lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
17844         if (!WhiteOnMove(forwardMostMove)) {
17845             if(blackNPS >= 0) lastTickLength = 0;
17846             blackTimeRemaining -= lastTickLength;
17847            /* [HGM] PGNtime: save time for PGN file if engine did not give it */
17848 //         if(pvInfoList[forwardMostMove].time == -1)
17849                  pvInfoList[forwardMostMove].time =               // use GUI time
17850                       (timeRemaining[1][forwardMostMove-1] - blackTimeRemaining)/10;
17851         } else {
17852            if(whiteNPS >= 0) lastTickLength = 0;
17853            whiteTimeRemaining -= lastTickLength;
17854            /* [HGM] PGNtime: save time for PGN file if engine did not give it */
17855 //         if(pvInfoList[forwardMostMove].time == -1)
17856                  pvInfoList[forwardMostMove].time =
17857                       (timeRemaining[0][forwardMostMove-1] - whiteTimeRemaining)/10;
17858         }
17859         flagged = CheckFlags();
17860     }
17861     forwardMostMove = newMoveNr; // [HGM] race: change stm when no timer interrupt scheduled
17862     CheckTimeControl();
17863
17864     if (flagged || !appData.clockMode) return;
17865
17866     switch (gameMode) {
17867       case MachinePlaysBlack:
17868       case MachinePlaysWhite:
17869       case BeginningOfGame:
17870         if (pausing) return;
17871         break;
17872
17873       case EditGame:
17874       case PlayFromGameFile:
17875       case IcsExamining:
17876         return;
17877
17878       default:
17879         break;
17880     }
17881
17882     if (searchTime) { // [HGM] st: set clock of player that has to move to max time
17883         if(WhiteOnMove(forwardMostMove))
17884              whiteTimeRemaining = 1000*searchTime / WhitePlayer()->timeOdds;
17885         else blackTimeRemaining = 1000*searchTime / WhitePlayer()->other->timeOdds;
17886     }
17887
17888     tickStartTM = now;
17889     intendedTickLength = NextTickLength(WhiteOnMove(forwardMostMove) ?
17890       whiteTimeRemaining : blackTimeRemaining);
17891     StartClockTimer(intendedTickLength);
17892 }
17893
17894
17895 /* Stop both clocks */
17896 void
17897 StopClocks ()
17898 {
17899     long lastTickLength;
17900     TimeMark now;
17901
17902     if (!StopClockTimer()) return;
17903     if (!appData.clockMode) return;
17904
17905     GetTimeMark(&now);
17906
17907     lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
17908     if (WhiteOnMove(forwardMostMove)) {
17909         if(whiteNPS >= 0) lastTickLength = 0;
17910         whiteTimeRemaining -= lastTickLength;
17911         DisplayWhiteClock(whiteTimeRemaining, WhiteOnMove(currentMove));
17912     } else {
17913         if(blackNPS >= 0) lastTickLength = 0;
17914         blackTimeRemaining -= lastTickLength;
17915         DisplayBlackClock(blackTimeRemaining, !WhiteOnMove(currentMove));
17916     }
17917     CheckFlags();
17918 }
17919
17920 /* Start clock of player on move.  Time may have been reset, so
17921    if clock is already running, stop and restart it. */
17922 void
17923 StartClocks ()
17924 {
17925     (void) StopClockTimer(); /* in case it was running already */
17926     DisplayBothClocks();
17927     if (CheckFlags()) return;
17928
17929     if (!appData.clockMode) return;
17930     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) return;
17931
17932     GetTimeMark(&tickStartTM);
17933     intendedTickLength = NextTickLength(WhiteOnMove(forwardMostMove) ?
17934       whiteTimeRemaining : blackTimeRemaining);
17935
17936    /* [HGM] nps: figure out nps factors, by determining which engine plays white and/or black once and for all */
17937     whiteNPS = blackNPS = -1;
17938     if(gameMode == MachinePlaysWhite || gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'w'
17939        || appData.zippyPlay && gameMode == IcsPlayingBlack) // first (perhaps only) engine has white
17940         whiteNPS = first.nps;
17941     if(gameMode == MachinePlaysBlack || gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b'
17942        || appData.zippyPlay && gameMode == IcsPlayingWhite) // first (perhaps only) engine has black
17943         blackNPS = first.nps;
17944     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b') // second only used in Two-Machines mode
17945         whiteNPS = second.nps;
17946     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'w')
17947         blackNPS = second.nps;
17948     if(appData.debugMode) fprintf(debugFP, "nps: w=%d, b=%d\n", whiteNPS, blackNPS);
17949
17950     StartClockTimer(intendedTickLength);
17951 }
17952
17953 char *
17954 TimeString (long ms)
17955 {
17956     long second, minute, hour, day;
17957     char *sign = "";
17958     static char buf[32];
17959
17960     if (ms > 0 && ms <= 9900) {
17961       /* convert milliseconds to tenths, rounding up */
17962       double tenths = floor( ((double)(ms + 99L)) / 100.00 );
17963
17964       snprintf(buf,sizeof(buf)/sizeof(buf[0]), " %03.1f ", tenths/10.0);
17965       return buf;
17966     }
17967
17968     /* convert milliseconds to seconds, rounding up */
17969     /* use floating point to avoid strangeness of integer division
17970        with negative dividends on many machines */
17971     second = (long) floor(((double) (ms + 999L)) / 1000.0);
17972
17973     if (second < 0) {
17974         sign = "-";
17975         second = -second;
17976     }
17977
17978     day = second / (60 * 60 * 24);
17979     second = second % (60 * 60 * 24);
17980     hour = second / (60 * 60);
17981     second = second % (60 * 60);
17982     minute = second / 60;
17983     second = second % 60;
17984
17985     if (day > 0)
17986       snprintf(buf, sizeof(buf)/sizeof(buf[0]), " %s%ld:%02ld:%02ld:%02ld ",
17987               sign, day, hour, minute, second);
17988     else if (hour > 0)
17989       snprintf(buf, sizeof(buf)/sizeof(buf[0]), " %s%ld:%02ld:%02ld ", sign, hour, minute, second);
17990     else
17991       snprintf(buf, sizeof(buf)/sizeof(buf[0]), " %s%2ld:%02ld ", sign, minute, second);
17992
17993     return buf;
17994 }
17995
17996
17997 /*
17998  * This is necessary because some C libraries aren't ANSI C compliant yet.
17999  */
18000 char *
18001 StrStr (char *string, char *match)
18002 {
18003     int i, length;
18004
18005     length = strlen(match);
18006
18007     for (i = strlen(string) - length; i >= 0; i--, string++)
18008       if (!strncmp(match, string, length))
18009         return string;
18010
18011     return NULL;
18012 }
18013
18014 char *
18015 StrCaseStr (char *string, char *match)
18016 {
18017     int i, j, length;
18018
18019     length = strlen(match);
18020
18021     for (i = strlen(string) - length; i >= 0; i--, string++) {
18022         for (j = 0; j < length; j++) {
18023             if (ToLower(match[j]) != ToLower(string[j]))
18024               break;
18025         }
18026         if (j == length) return string;
18027     }
18028
18029     return NULL;
18030 }
18031
18032 #ifndef _amigados
18033 int
18034 StrCaseCmp (char *s1, char *s2)
18035 {
18036     char c1, c2;
18037
18038     for (;;) {
18039         c1 = ToLower(*s1++);
18040         c2 = ToLower(*s2++);
18041         if (c1 > c2) return 1;
18042         if (c1 < c2) return -1;
18043         if (c1 == NULLCHAR) return 0;
18044     }
18045 }
18046
18047
18048 int
18049 ToLower (int c)
18050 {
18051     return isupper(c) ? tolower(c) : c;
18052 }
18053
18054
18055 int
18056 ToUpper (int c)
18057 {
18058     return islower(c) ? toupper(c) : c;
18059 }
18060 #endif /* !_amigados    */
18061
18062 char *
18063 StrSave (char *s)
18064 {
18065   char *ret;
18066
18067   if ((ret = (char *) malloc(strlen(s) + 1)))
18068     {
18069       safeStrCpy(ret, s, strlen(s)+1);
18070     }
18071   return ret;
18072 }
18073
18074 char *
18075 StrSavePtr (char *s, char **savePtr)
18076 {
18077     if (*savePtr) {
18078         free(*savePtr);
18079     }
18080     if ((*savePtr = (char *) malloc(strlen(s) + 1))) {
18081       safeStrCpy(*savePtr, s, strlen(s)+1);
18082     }
18083     return(*savePtr);
18084 }
18085
18086 char *
18087 PGNDate ()
18088 {
18089     time_t clock;
18090     struct tm *tm;
18091     char buf[MSG_SIZ];
18092
18093     clock = time((time_t *)NULL);
18094     tm = localtime(&clock);
18095     snprintf(buf, MSG_SIZ, "%04d.%02d.%02d",
18096             tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday);
18097     return StrSave(buf);
18098 }
18099
18100
18101 char *
18102 PositionToFEN (int move, char *overrideCastling, int moveCounts)
18103 {
18104     int i, j, fromX, fromY, toX, toY;
18105     int whiteToPlay, haveRights = nrCastlingRights;
18106     char buf[MSG_SIZ];
18107     char *p, *q;
18108     int emptycount;
18109     ChessSquare piece;
18110
18111     whiteToPlay = (gameMode == EditPosition) ?
18112       !blackPlaysFirst : (move % 2 == 0);
18113     p = buf;
18114
18115     /* Piece placement data */
18116     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
18117         if(MSG_SIZ - (p - buf) < BOARD_RGHT - BOARD_LEFT + 20) { *p = 0; return StrSave(buf); }
18118         emptycount = 0;
18119         for (j = BOARD_LEFT; j < BOARD_RGHT; j++) {
18120             if (boards[move][i][j] == EmptySquare) {
18121                 emptycount++;
18122             } else { ChessSquare piece = boards[move][i][j];
18123                 if (emptycount > 0) {
18124                     if(emptycount<10) /* [HGM] can be >= 10 */
18125                         *p++ = '0' + emptycount;
18126                     else { *p++ = '0' + emptycount/10; *p++ = '0' + emptycount%10; }
18127                     emptycount = 0;
18128                 }
18129                 if(PieceToChar(piece) == '+') {
18130                     /* [HGM] write promoted pieces as '+<unpromoted>' (Shogi) */
18131                     *p++ = '+';
18132                     piece = (ChessSquare)(CHUDEMOTED(piece));
18133                 }
18134                 *p++ = (piece == DarkSquare ? '*' : PieceToChar(piece));
18135                 if(*p = PieceSuffix(piece)) p++;
18136                 if(p[-1] == '~') {
18137                     /* [HGM] flag promoted pieces as '<promoted>~' (Crazyhouse) */
18138                     p[-1] = PieceToChar((ChessSquare)(CHUDEMOTED(piece)));
18139                     *p++ = '~';
18140                 }
18141             }
18142         }
18143         if (emptycount > 0) {
18144             if(emptycount<10) /* [HGM] can be >= 10 */
18145                 *p++ = '0' + emptycount;
18146             else { *p++ = '0' + emptycount/10; *p++ = '0' + emptycount%10; }
18147             emptycount = 0;
18148         }
18149         *p++ = '/';
18150     }
18151     *(p - 1) = ' ';
18152
18153     /* [HGM] print Crazyhouse or Shogi holdings */
18154     if( gameInfo.holdingsWidth ) {
18155         *(p-1) = '['; /* if we wanted to support BFEN, this could be '/' */
18156         q = p;
18157         for(i=0; i<gameInfo.holdingsSize; i++) { /* white holdings */
18158             piece = boards[move][i][BOARD_WIDTH-1];
18159             if( piece != EmptySquare )
18160               for(j=0; j<(int) boards[move][i][BOARD_WIDTH-2]; j++)
18161                   *p++ = PieceToChar(piece);
18162         }
18163         for(i=0; i<gameInfo.holdingsSize; i++) { /* black holdings */
18164             piece = boards[move][BOARD_HEIGHT-i-1][0];
18165             if( piece != EmptySquare )
18166               for(j=0; j<(int) boards[move][BOARD_HEIGHT-i-1][1]; j++)
18167                   *p++ = PieceToChar(piece);
18168         }
18169
18170         if( q == p ) *p++ = '-';
18171         *p++ = ']';
18172         *p++ = ' ';
18173     }
18174
18175     /* Active color */
18176     *p++ = whiteToPlay ? 'w' : 'b';
18177     *p++ = ' ';
18178
18179   if(pieceDesc[WhiteKing] && strchr(pieceDesc[WhiteKing], 'i') && !strchr(pieceDesc[WhiteKing], 'O')) { // redefined without castling
18180     haveRights = 0; q = p;
18181     for(i=BOARD_RGHT-1; i>=BOARD_LEFT; i--) {
18182       piece = boards[move][0][i];
18183       if(piece >= WhitePawn && piece <= WhiteKing && pieceDesc[piece] && strchr(pieceDesc[piece], 'i')) { // piece with initial move
18184         if(!(boards[move][TOUCHED_W] & 1<<i)) *p++ = 'A' + i; // print file ID if it has not moved
18185       }
18186     }
18187     for(i=BOARD_RGHT-1; i>=BOARD_LEFT; i--) {
18188       piece = boards[move][BOARD_HEIGHT-1][i];
18189       if(piece >= BlackPawn && piece <= BlackKing && pieceDesc[piece] && strchr(pieceDesc[piece], 'i')) { // piece with initial move
18190         if(!(boards[move][TOUCHED_B] & 1<<i)) *p++ = 'a' + i; // print file ID if it has not moved
18191       }
18192     }
18193     if(p == q) *p++ = '-';
18194     *p++ = ' ';
18195   }
18196
18197   if(q = overrideCastling) { // [HGM] FRC: override castling & e.p fields for non-compliant engines
18198     while(*p++ = *q++); if(q != overrideCastling+1) p[-1] = ' '; else --p;
18199   } else {
18200   if(haveRights) {
18201      int handW=0, handB=0;
18202      if(gameInfo.variant == VariantSChess) { // for S-Chess, all virgin backrank pieces must be listed
18203         for(i=0; i<BOARD_HEIGHT; i++) handW += boards[move][i][BOARD_RGHT]; // count white held pieces
18204         for(i=0; i<BOARD_HEIGHT; i++) handB += boards[move][i][BOARD_LEFT-1]; // count black held pieces
18205      }
18206      q = p;
18207      if(appData.fischerCastling) {
18208         if(handW) { // in shuffle S-Chess simply dump all virgin pieces
18209            for(i=BOARD_RGHT-1; i>=BOARD_LEFT; i--)
18210                if(boards[move][VIRGIN][i] & VIRGIN_W) *p++ = i + AAA + 'A' - 'a';
18211         } else {
18212        /* [HGM] write directly from rights */
18213            if(boards[move][CASTLING][2] != NoRights &&
18214               boards[move][CASTLING][0] != NoRights   )
18215                 *p++ = boards[move][CASTLING][0] + AAA + 'A' - 'a';
18216            if(boards[move][CASTLING][2] != NoRights &&
18217               boards[move][CASTLING][1] != NoRights   )
18218                 *p++ = boards[move][CASTLING][1] + AAA + 'A' - 'a';
18219         }
18220         if(handB) {
18221            for(i=BOARD_RGHT-1; i>=BOARD_LEFT; i--)
18222                if(boards[move][VIRGIN][i] & VIRGIN_B) *p++ = i + AAA;
18223         } else {
18224            if(boards[move][CASTLING][5] != NoRights &&
18225               boards[move][CASTLING][3] != NoRights   )
18226                 *p++ = boards[move][CASTLING][3] + AAA;
18227            if(boards[move][CASTLING][5] != NoRights &&
18228               boards[move][CASTLING][4] != NoRights   )
18229                 *p++ = boards[move][CASTLING][4] + AAA;
18230         }
18231      } else {
18232
18233         /* [HGM] write true castling rights */
18234         if( nrCastlingRights == 6 ) {
18235             int q, k=0;
18236             if(boards[move][CASTLING][0] != NoRights &&
18237                boards[move][CASTLING][2] != NoRights  ) k = 1, *p++ = 'K';
18238             q = (boards[move][CASTLING][1] != NoRights &&
18239                  boards[move][CASTLING][2] != NoRights  );
18240             if(handW) { // for S-Chess with pieces in hand, list virgin pieces between K and Q
18241                 for(i=BOARD_RGHT-1-k; i>=BOARD_LEFT+q; i--)
18242                     if((boards[move][0][i] != WhiteKing || k+q == 0) &&
18243                         boards[move][VIRGIN][i] & VIRGIN_W) *p++ = i + AAA + 'A' - 'a';
18244             }
18245             if(q) *p++ = 'Q';
18246             k = 0;
18247             if(boards[move][CASTLING][3] != NoRights &&
18248                boards[move][CASTLING][5] != NoRights  ) k = 1, *p++ = 'k';
18249             q = (boards[move][CASTLING][4] != NoRights &&
18250                  boards[move][CASTLING][5] != NoRights  );
18251             if(handB) {
18252                 for(i=BOARD_RGHT-1-k; i>=BOARD_LEFT+q; i--)
18253                     if((boards[move][BOARD_HEIGHT-1][i] != BlackKing || k+q == 0) &&
18254                         boards[move][VIRGIN][i] & VIRGIN_B) *p++ = i + AAA;
18255             }
18256             if(q) *p++ = 'q';
18257         }
18258      }
18259      if (q == p) *p++ = '-'; /* No castling rights */
18260      *p++ = ' ';
18261   }
18262
18263   if(gameInfo.variant != VariantShogi    && gameInfo.variant != VariantXiangqi &&
18264      gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier &&
18265      gameInfo.variant != VariantMakruk   && gameInfo.variant != VariantASEAN ) {
18266     /* En passant target square */
18267     if (move > backwardMostMove) {
18268         fromX = moveList[move - 1][0] - AAA;
18269         fromY = moveList[move - 1][1] - ONE;
18270         toX = moveList[move - 1][2] - AAA;
18271         toY = moveList[move - 1][3] - ONE;
18272         if (fromY == (whiteToPlay ? BOARD_HEIGHT-2 : 1) &&
18273             toY == (whiteToPlay ? BOARD_HEIGHT-4 : 3) &&
18274             boards[move][toY][toX] == (whiteToPlay ? BlackPawn : WhitePawn) &&
18275             fromX == toX) {
18276             /* 2-square pawn move just happened */
18277             *p++ = toX + AAA;
18278             *p++ = whiteToPlay ? '6'+BOARD_HEIGHT-8 : '3';
18279         } else {
18280             *p++ = '-';
18281         }
18282     } else if(move == backwardMostMove) {
18283         // [HGM] perhaps we should always do it like this, and forget the above?
18284         if((signed char)boards[move][EP_STATUS] >= 0) {
18285             *p++ = boards[move][EP_STATUS] + AAA;
18286             *p++ = whiteToPlay ? '6'+BOARD_HEIGHT-8 : '3';
18287         } else {
18288             *p++ = '-';
18289         }
18290     } else {
18291         *p++ = '-';
18292     }
18293     *p++ = ' ';
18294   }
18295   }
18296
18297     if(moveCounts)
18298     {   int i = 0, j=move;
18299
18300         /* [HGM] find reversible plies */
18301         if (appData.debugMode) { int k;
18302             fprintf(debugFP, "write FEN 50-move: %d %d %d\n", initialRulePlies, forwardMostMove, backwardMostMove);
18303             for(k=backwardMostMove; k<=forwardMostMove; k++)
18304                 fprintf(debugFP, "e%d. p=%d\n", k, (signed char)boards[k][EP_STATUS]);
18305
18306         }
18307
18308         while(j > backwardMostMove && (signed char)boards[j][EP_STATUS] <= EP_NONE) j--,i++;
18309         if( j == backwardMostMove ) i += initialRulePlies;
18310         sprintf(p, "%d ", i);
18311         p += i>=100 ? 4 : i >= 10 ? 3 : 2;
18312
18313         /* Fullmove number */
18314         sprintf(p, "%d", (move / 2) + 1);
18315     } else *--p = NULLCHAR;
18316
18317     return StrSave(buf);
18318 }
18319
18320 Boolean
18321 ParseFEN (Board board, int *blackPlaysFirst, char *fen, Boolean autoSize)
18322 {
18323     int i, j, k, w=0, subst=0, shuffle=0, wKingRank = -1, bKingRank = -1;
18324     char *p, c;
18325     int emptycount, virgin[BOARD_FILES];
18326     ChessSquare piece, king = (gameInfo.variant == VariantKnightmate ? WhiteUnicorn : WhiteKing);
18327
18328     p = fen;
18329
18330     /* Piece placement data */
18331     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
18332         j = 0;
18333         for (;;) {
18334             if (*p == '/' || *p == ' ' || *p == '[' ) {
18335                 if(j > w) w = j;
18336                 emptycount = gameInfo.boardWidth - j;
18337                 while (emptycount--)
18338                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
18339                 if (*p == '/') p++;
18340                 else if(autoSize && i != BOARD_HEIGHT-1) { // we stumbled unexpectedly into end of board
18341                     for(k=i; k<BOARD_HEIGHT; k++) { // too few ranks; shift towards bottom
18342                         for(j=0; j<BOARD_WIDTH; j++) board[k-i][j] = board[k][j];
18343                     }
18344                     appData.NrRanks = gameInfo.boardHeight - i; i=0;
18345                 }
18346                 break;
18347 #if(BOARD_FILES >= 10)*0
18348             } else if(*p=='x' || *p=='X') { /* [HGM] X means 10 */
18349                 p++; emptycount=10;
18350                 if (j + emptycount > gameInfo.boardWidth) return FALSE;
18351                 while (emptycount--)
18352                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
18353 #endif
18354             } else if (*p == '*') {
18355                 board[i][(j++)+gameInfo.holdingsWidth] = DarkSquare; p++;
18356             } else if (isdigit(*p)) {
18357                 emptycount = *p++ - '0';
18358                 while(isdigit(*p)) emptycount = 10*emptycount + *p++ - '0'; /* [HGM] allow > 9 */
18359                 if (j + emptycount > gameInfo.boardWidth) return FALSE;
18360                 while (emptycount--)
18361                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
18362             } else if (*p == '<') {
18363                 if(i == BOARD_HEIGHT-1) shuffle = 1;
18364                 else if (i != 0 || !shuffle) return FALSE;
18365                 p++;
18366             } else if (shuffle && *p == '>') {
18367                 p++; // for now ignore closing shuffle range, and assume rank-end
18368             } else if (*p == '?') {
18369                 if (j >= gameInfo.boardWidth) return FALSE;
18370                 if (i != 0  && i != BOARD_HEIGHT-1) return FALSE; // only on back-rank
18371                 board[i][(j++)+gameInfo.holdingsWidth] = ClearBoard; p++; subst++; // placeHolder
18372             } else if (*p == '+' || isalpha(*p)) {
18373                 char *q, *s = SUFFIXES;
18374                 if (j >= gameInfo.boardWidth) return FALSE;
18375                 if(*p=='+') {
18376                     char c = *++p;
18377                     if(q = strchr(s, p[1])) p++;
18378                     piece = CharToPiece(c + (q ? 64*(q - s + 1) : 0));
18379                     if(piece == EmptySquare) return FALSE; /* unknown piece */
18380                     piece = (ChessSquare) (CHUPROMOTED(piece)); p++;
18381                     if(PieceToChar(piece) != '+') return FALSE; /* unpromotable piece */
18382                 } else {
18383                     char c = *p++;
18384                     if(q = strchr(s, *p)) p++;
18385                     piece = CharToPiece(c + (q ? 64*(q - s + 1) : 0));
18386                 }
18387
18388                 if(piece==EmptySquare) return FALSE; /* unknown piece */
18389                 if(*p == '~') { /* [HGM] make it a promoted piece for Crazyhouse */
18390                     piece = (ChessSquare) (PROMOTED(piece));
18391                     if(PieceToChar(piece) != '~') return FALSE; /* cannot be a promoted piece */
18392                     p++;
18393                 }
18394                 board[i][(j++)+gameInfo.holdingsWidth] = piece;
18395                 if(piece == king) wKingRank = i;
18396                 if(piece == WHITE_TO_BLACK king) bKingRank = i;
18397             } else {
18398                 return FALSE;
18399             }
18400         }
18401     }
18402     while (*p == '/' || *p == ' ') p++;
18403
18404     if(autoSize && w != 0) appData.NrFiles = w, InitPosition(TRUE);
18405
18406     /* [HGM] by default clear Crazyhouse holdings, if present */
18407     if(gameInfo.holdingsWidth) {
18408        for(i=0; i<BOARD_HEIGHT; i++) {
18409            board[i][0]             = EmptySquare; /* black holdings */
18410            board[i][BOARD_WIDTH-1] = EmptySquare; /* white holdings */
18411            board[i][1]             = (ChessSquare) 0; /* black counts */
18412            board[i][BOARD_WIDTH-2] = (ChessSquare) 0; /* white counts */
18413        }
18414     }
18415
18416     /* [HGM] look for Crazyhouse holdings here */
18417     while(*p==' ') p++;
18418     if( gameInfo.holdingsWidth && p[-1] == '/' || *p == '[') {
18419         int swap=0, wcnt=0, bcnt=0;
18420         if(*p == '[') p++;
18421         if(*p == '<') swap++, p++;
18422         if(*p == '-' ) p++; /* empty holdings */ else {
18423             if( !gameInfo.holdingsWidth ) return FALSE; /* no room to put holdings! */
18424             /* if we would allow FEN reading to set board size, we would   */
18425             /* have to add holdings and shift the board read so far here   */
18426             while( (piece = CharToPiece(*p) ) != EmptySquare ) {
18427                 p++;
18428                 if((int) piece >= (int) BlackPawn ) {
18429                     i = (int)piece - (int)BlackPawn;
18430                     i = PieceToNumber((ChessSquare)i);
18431                     if( i >= gameInfo.holdingsSize ) return FALSE;
18432                     board[BOARD_HEIGHT-1-i][0] = piece; /* black holdings */
18433                     board[BOARD_HEIGHT-1-i][1]++;       /* black counts   */
18434                     bcnt++;
18435                 } else {
18436                     i = (int)piece - (int)WhitePawn;
18437                     i = PieceToNumber((ChessSquare)i);
18438                     if( i >= gameInfo.holdingsSize ) return FALSE;
18439                     board[i][BOARD_WIDTH-1] = piece;    /* white holdings */
18440                     board[i][BOARD_WIDTH-2]++;          /* black holdings */
18441                     wcnt++;
18442                 }
18443             }
18444             if(subst) { // substitute back-rank question marks by holdings pieces
18445                 for(j=BOARD_LEFT; j<BOARD_RGHT; j++) {
18446                     int k, m, n = bcnt + 1;
18447                     if(board[0][j] == ClearBoard) {
18448                         if(!wcnt) return FALSE;
18449                         n = rand() % wcnt;
18450                         for(k=0, m=n; k<gameInfo.holdingsSize; k++) if((m -= board[k][BOARD_WIDTH-2]) < 0) {
18451                             board[0][j] = board[k][BOARD_WIDTH-1]; wcnt--;
18452                             if(--board[k][BOARD_WIDTH-2] == 0) board[k][BOARD_WIDTH-1] = EmptySquare;
18453                             break;
18454                         }
18455                     }
18456                     if(board[BOARD_HEIGHT-1][j] == ClearBoard) {
18457                         if(!bcnt) return FALSE;
18458                         if(n >= bcnt) n = rand() % bcnt; // use same randomization for black and white if possible
18459                         for(k=0, m=n; k<gameInfo.holdingsSize; k++) if((n -= board[BOARD_HEIGHT-1-k][1]) < 0) {
18460                             board[BOARD_HEIGHT-1][j] = board[BOARD_HEIGHT-1-k][0]; bcnt--;
18461                             if(--board[BOARD_HEIGHT-1-k][1] == 0) board[BOARD_HEIGHT-1-k][0] = EmptySquare;
18462                             break;
18463                         }
18464                     }
18465                 }
18466                 subst = 0;
18467             }
18468         }
18469         if(*p == ']') p++;
18470     }
18471
18472     if(subst) return FALSE; // substitution requested, but no holdings
18473
18474     while(*p == ' ') p++;
18475
18476     /* Active color */
18477     c = *p++;
18478     if(appData.colorNickNames) {
18479       if( c == appData.colorNickNames[0] ) c = 'w'; else
18480       if( c == appData.colorNickNames[1] ) c = 'b';
18481     }
18482     switch (c) {
18483       case 'w':
18484         *blackPlaysFirst = FALSE;
18485         break;
18486       case 'b':
18487         *blackPlaysFirst = TRUE;
18488         break;
18489       default:
18490         return FALSE;
18491     }
18492
18493     /* [HGM] We NO LONGER ignore the rest of the FEN notation */
18494     /* return the extra info in global variiables             */
18495
18496     while(*p==' ') p++;
18497
18498     if(!isdigit(*p) && *p != '-') { // we seem to have castling rights. Make sure they are on the rank the King actually is.
18499         if(wKingRank >= 0) for(i=0; i<3; i++) castlingRank[i] = wKingRank;
18500         if(bKingRank >= 0) for(i=3; i<6; i++) castlingRank[i] = bKingRank;
18501     }
18502
18503     /* set defaults in case FEN is incomplete */
18504     board[EP_STATUS] = EP_UNKNOWN;
18505     board[TOUCHED_W] = board[TOUCHED_B] = 0;
18506     for(i=0; i<nrCastlingRights; i++ ) {
18507         board[CASTLING][i] =
18508             appData.fischerCastling ? NoRights : initialRights[i];
18509     }   /* assume possible unless obviously impossible */
18510     if(initialRights[0]!=NoRights && board[castlingRank[0]][initialRights[0]] != WhiteRook) board[CASTLING][0] = NoRights;
18511     if(initialRights[1]!=NoRights && board[castlingRank[1]][initialRights[1]] != WhiteRook) board[CASTLING][1] = NoRights;
18512     if(initialRights[2]!=NoRights && board[castlingRank[2]][initialRights[2]] != WhiteUnicorn
18513                                   && board[castlingRank[2]][initialRights[2]] != WhiteKing) board[CASTLING][2] = NoRights;
18514     if(initialRights[3]!=NoRights && board[castlingRank[3]][initialRights[3]] != BlackRook) board[CASTLING][3] = NoRights;
18515     if(initialRights[4]!=NoRights && board[castlingRank[4]][initialRights[4]] != BlackRook) board[CASTLING][4] = NoRights;
18516     if(initialRights[5]!=NoRights && board[castlingRank[5]][initialRights[5]] != BlackUnicorn
18517                                   && board[castlingRank[5]][initialRights[5]] != BlackKing) board[CASTLING][5] = NoRights;
18518     FENrulePlies = 0;
18519
18520     if(pieceDesc[WhiteKing] && strchr(pieceDesc[WhiteKing], 'i') && !strchr(pieceDesc[WhiteKing], 'O')) { // redefined without castling
18521       char *q = p;
18522       int w=0, b=0;
18523       while(isalpha(*p)) {
18524         if(isupper(*p)) w |= 1 << (*p++ - 'A');
18525         if(islower(*p)) b |= 1 << (*p++ - 'a');
18526       }
18527       if(*p == '-') p++;
18528       if(p != q) {
18529         board[TOUCHED_W] = ~w;
18530         board[TOUCHED_B] = ~b;
18531         while(*p == ' ') p++;
18532       }
18533     } else
18534
18535     if(nrCastlingRights) {
18536       int fischer = 0;
18537       if(gameInfo.variant == VariantSChess) for(i=0; i<BOARD_FILES; i++) virgin[i] = 0;
18538       if(*p >= 'A' && *p <= 'Z' || *p >= 'a' && *p <= 'z' || *p=='-') {
18539           /* castling indicator present, so default becomes no castlings */
18540           for(i=0; i<nrCastlingRights; i++ ) {
18541                  board[CASTLING][i] = NoRights;
18542           }
18543       }
18544       while(*p=='K' || *p=='Q' || *p=='k' || *p=='q' || *p=='-' ||
18545              (appData.fischerCastling || gameInfo.variant == VariantSChess) &&
18546              ( *p >= 'a' && *p < 'a' + gameInfo.boardWidth) ||
18547              ( *p >= 'A' && *p < 'A' + gameInfo.boardWidth)   ) {
18548         int c = *p++, whiteKingFile=NoRights, blackKingFile=NoRights;
18549
18550         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) {
18551             if(board[castlingRank[5]][i] == BlackKing) blackKingFile = i;
18552             if(board[castlingRank[2]][i] == WhiteKing) whiteKingFile = i;
18553         }
18554         if(gameInfo.variant == VariantTwoKings || gameInfo.variant == VariantKnightmate)
18555             whiteKingFile = blackKingFile = BOARD_WIDTH >> 1; // for these variant scanning fails
18556         if(whiteKingFile == NoRights || board[castlingRank[2]][whiteKingFile] != WhiteUnicorn
18557                                      && board[castlingRank[2]][whiteKingFile] != WhiteKing) whiteKingFile = NoRights;
18558         if(blackKingFile == NoRights || board[castlingRank[5]][blackKingFile] != BlackUnicorn
18559                                      && board[castlingRank[5]][blackKingFile] != BlackKing) blackKingFile = NoRights;
18560         switch(c) {
18561           case'K':
18562               for(i=BOARD_RGHT-1; board[castlingRank[2]][i]!=WhiteRook && i>whiteKingFile; i--);
18563               board[CASTLING][0] = i != whiteKingFile ? i : NoRights;
18564               board[CASTLING][2] = whiteKingFile;
18565               if(board[CASTLING][0] != NoRights) virgin[board[CASTLING][0]] |= VIRGIN_W;
18566               if(board[CASTLING][2] != NoRights) virgin[board[CASTLING][2]] |= VIRGIN_W;
18567               if(whiteKingFile != BOARD_WIDTH>>1|| i != BOARD_RGHT-1) fischer = 1;
18568               break;
18569           case'Q':
18570               for(i=BOARD_LEFT;  i<BOARD_RGHT && board[castlingRank[2]][i]!=WhiteRook && i<whiteKingFile; i++);
18571               board[CASTLING][1] = i != whiteKingFile ? i : NoRights;
18572               board[CASTLING][2] = whiteKingFile;
18573               if(board[CASTLING][1] != NoRights) virgin[board[CASTLING][1]] |= VIRGIN_W;
18574               if(board[CASTLING][2] != NoRights) virgin[board[CASTLING][2]] |= VIRGIN_W;
18575               if(whiteKingFile != BOARD_WIDTH>>1|| i != BOARD_LEFT) fischer = 1;
18576               break;
18577           case'k':
18578               for(i=BOARD_RGHT-1; board[castlingRank[5]][i]!=BlackRook && i>blackKingFile; i--);
18579               board[CASTLING][3] = i != blackKingFile ? i : NoRights;
18580               board[CASTLING][5] = blackKingFile;
18581               if(board[CASTLING][3] != NoRights) virgin[board[CASTLING][3]] |= VIRGIN_B;
18582               if(board[CASTLING][5] != NoRights) virgin[board[CASTLING][5]] |= VIRGIN_B;
18583               if(blackKingFile != BOARD_WIDTH>>1|| i != BOARD_RGHT-1) fischer = 1;
18584               break;
18585           case'q':
18586               for(i=BOARD_LEFT; i<BOARD_RGHT && board[castlingRank[5]][i]!=BlackRook && i<blackKingFile; i++);
18587               board[CASTLING][4] = i != blackKingFile ? i : NoRights;
18588               board[CASTLING][5] = blackKingFile;
18589               if(board[CASTLING][4] != NoRights) virgin[board[CASTLING][4]] |= VIRGIN_B;
18590               if(board[CASTLING][5] != NoRights) virgin[board[CASTLING][5]] |= VIRGIN_B;
18591               if(blackKingFile != BOARD_WIDTH>>1|| i != BOARD_LEFT) fischer = 1;
18592           case '-':
18593               break;
18594           default: /* FRC castlings */
18595               if(c >= 'a') { /* black rights */
18596                   if(gameInfo.variant == VariantSChess) { virgin[c-AAA] |= VIRGIN_B; break; } // in S-Chess castlings are always kq, so just virginity
18597                   for(i=BOARD_LEFT; i<BOARD_RGHT; i++)
18598                     if(board[BOARD_HEIGHT-1][i] == BlackKing) break;
18599                   if(i == BOARD_RGHT) break;
18600                   board[CASTLING][5] = i;
18601                   c -= AAA;
18602                   if(board[BOARD_HEIGHT-1][c] <  BlackPawn ||
18603                      board[BOARD_HEIGHT-1][c] >= BlackKing   ) break;
18604                   if(c > i)
18605                       board[CASTLING][3] = c;
18606                   else
18607                       board[CASTLING][4] = c;
18608               } else { /* white rights */
18609                   if(gameInfo.variant == VariantSChess) { virgin[c-AAA-'A'+'a'] |= VIRGIN_W; break; } // in S-Chess castlings are always KQ
18610                   for(i=BOARD_LEFT; i<BOARD_RGHT; i++)
18611                     if(board[0][i] == WhiteKing) break;
18612                   if(i == BOARD_RGHT) break;
18613                   board[CASTLING][2] = i;
18614                   c -= AAA - 'a' + 'A';
18615                   if(board[0][c] >= WhiteKing) break;
18616                   if(c > i)
18617                       board[CASTLING][0] = c;
18618                   else
18619                       board[CASTLING][1] = c;
18620               }
18621         }
18622       }
18623       for(i=0; i<nrCastlingRights; i++)
18624         if(board[CASTLING][i] != NoRights) initialRights[i] = board[CASTLING][i];
18625       if(gameInfo.variant == VariantSChess)
18626         for(i=0; i<BOARD_FILES; i++) board[VIRGIN][i] = shuffle ? VIRGIN_W | VIRGIN_B : virgin[i]; // when shuffling assume all virgin
18627       if(fischer && shuffle) appData.fischerCastling = TRUE;
18628     if (appData.debugMode) {
18629         fprintf(debugFP, "FEN castling rights:");
18630         for(i=0; i<nrCastlingRights; i++)
18631         fprintf(debugFP, " %d", board[CASTLING][i]);
18632         fprintf(debugFP, "\n");
18633     }
18634
18635       while(*p==' ') p++;
18636     }
18637
18638     if(shuffle) SetUpShuffle(board, appData.defaultFrcPosition);
18639
18640     /* read e.p. field in games that know e.p. capture */
18641     if(gameInfo.variant != VariantShogi    && gameInfo.variant != VariantXiangqi &&
18642        gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier &&
18643        gameInfo.variant != VariantMakruk && gameInfo.variant != VariantASEAN ) {
18644       if(*p=='-') {
18645         p++; board[EP_STATUS] = EP_NONE;
18646       } else {
18647          char c = *p++ - AAA;
18648
18649          if(c < BOARD_LEFT || c >= BOARD_RGHT) return TRUE;
18650          if(*p >= '0' && *p <='9') p++;
18651          board[EP_STATUS] = c;
18652       }
18653     }
18654
18655
18656     if(sscanf(p, "%d", &i) == 1) {
18657         FENrulePlies = i; /* 50-move ply counter */
18658         /* (The move number is still ignored)    */
18659     }
18660
18661     return TRUE;
18662 }
18663
18664 void
18665 EditPositionPasteFEN (char *fen)
18666 {
18667   if (fen != NULL) {
18668     Board initial_position;
18669
18670     if (!ParseFEN(initial_position, &blackPlaysFirst, fen, TRUE)) {
18671       DisplayError(_("Bad FEN position in clipboard"), 0);
18672       return ;
18673     } else {
18674       int savedBlackPlaysFirst = blackPlaysFirst;
18675       EditPositionEvent();
18676       blackPlaysFirst = savedBlackPlaysFirst;
18677       CopyBoard(boards[0], initial_position);
18678       initialRulePlies = FENrulePlies; /* [HGM] copy FEN attributes as well */
18679       EditPositionDone(FALSE); // [HGM] fake: do not fake rights if we had FEN
18680       DisplayBothClocks();
18681       DrawPosition(FALSE, boards[currentMove]);
18682     }
18683   }
18684 }
18685
18686 static char cseq[12] = "\\   ";
18687
18688 Boolean
18689 set_cont_sequence (char *new_seq)
18690 {
18691     int len;
18692     Boolean ret;
18693
18694     // handle bad attempts to set the sequence
18695         if (!new_seq)
18696                 return 0; // acceptable error - no debug
18697
18698     len = strlen(new_seq);
18699     ret = (len > 0) && (len < sizeof(cseq));
18700     if (ret)
18701       safeStrCpy(cseq, new_seq, sizeof(cseq)/sizeof(cseq[0]));
18702     else if (appData.debugMode)
18703       fprintf(debugFP, "Invalid continuation sequence \"%s\"  (maximum length is: %u)\n", new_seq, (unsigned) sizeof(cseq)-1);
18704     return ret;
18705 }
18706
18707 /*
18708     reformat a source message so words don't cross the width boundary.  internal
18709     newlines are not removed.  returns the wrapped size (no null character unless
18710     included in source message).  If dest is NULL, only calculate the size required
18711     for the dest buffer.  lp argument indicats line position upon entry, and it's
18712     passed back upon exit.
18713 */
18714 int
18715 wrap (char *dest, char *src, int count, int width, int *lp)
18716 {
18717     int len, i, ansi, cseq_len, line, old_line, old_i, old_len, clen;
18718
18719     cseq_len = strlen(cseq);
18720     old_line = line = *lp;
18721     ansi = len = clen = 0;
18722
18723     for (i=0; i < count; i++)
18724     {
18725         if (src[i] == '\033')
18726             ansi = 1;
18727
18728         // if we hit the width, back up
18729         if (!ansi && (line >= width) && src[i] != '\n' && src[i] != ' ')
18730         {
18731             // store i & len in case the word is too long
18732             old_i = i, old_len = len;
18733
18734             // find the end of the last word
18735             while (i && src[i] != ' ' && src[i] != '\n')
18736             {
18737                 i--;
18738                 len--;
18739             }
18740
18741             // word too long?  restore i & len before splitting it
18742             if ((old_i-i+clen) >= width)
18743             {
18744                 i = old_i;
18745                 len = old_len;
18746             }
18747
18748             // extra space?
18749             if (i && src[i-1] == ' ')
18750                 len--;
18751
18752             if (src[i] != ' ' && src[i] != '\n')
18753             {
18754                 i--;
18755                 if (len)
18756                     len--;
18757             }
18758
18759             // now append the newline and continuation sequence
18760             if (dest)
18761                 dest[len] = '\n';
18762             len++;
18763             if (dest)
18764                 strncpy(dest+len, cseq, cseq_len);
18765             len += cseq_len;
18766             line = cseq_len;
18767             clen = cseq_len;
18768             continue;
18769         }
18770
18771         if (dest)
18772             dest[len] = src[i];
18773         len++;
18774         if (!ansi)
18775             line++;
18776         if (src[i] == '\n')
18777             line = 0;
18778         if (src[i] == 'm')
18779             ansi = 0;
18780     }
18781     if (dest && appData.debugMode)
18782     {
18783         fprintf(debugFP, "wrap(count:%d,width:%d,line:%d,len:%d,*lp:%d,src: ",
18784             count, width, line, len, *lp);
18785         show_bytes(debugFP, src, count);
18786         fprintf(debugFP, "\ndest: ");
18787         show_bytes(debugFP, dest, len);
18788         fprintf(debugFP, "\n");
18789     }
18790     *lp = dest ? line : old_line;
18791
18792     return len;
18793 }
18794
18795 // [HGM] vari: routines for shelving variations
18796 Boolean modeRestore = FALSE;
18797
18798 void
18799 PushInner (int firstMove, int lastMove)
18800 {
18801         int i, j, nrMoves = lastMove - firstMove;
18802
18803         // push current tail of game on stack
18804         savedResult[storedGames] = gameInfo.result;
18805         savedDetails[storedGames] = gameInfo.resultDetails;
18806         gameInfo.resultDetails = NULL;
18807         savedFirst[storedGames] = firstMove;
18808         savedLast [storedGames] = lastMove;
18809         savedFramePtr[storedGames] = framePtr;
18810         framePtr -= nrMoves; // reserve space for the boards
18811         for(i=nrMoves; i>=1; i--) { // copy boards to stack, working downwards, in case of overlap
18812             CopyBoard(boards[framePtr+i], boards[firstMove+i]);
18813             for(j=0; j<MOVE_LEN; j++)
18814                 moveList[framePtr+i][j] = moveList[firstMove+i-1][j];
18815             for(j=0; j<2*MOVE_LEN; j++)
18816                 parseList[framePtr+i][j] = parseList[firstMove+i-1][j];
18817             timeRemaining[0][framePtr+i] = timeRemaining[0][firstMove+i];
18818             timeRemaining[1][framePtr+i] = timeRemaining[1][firstMove+i];
18819             pvInfoList[framePtr+i] = pvInfoList[firstMove+i-1];
18820             pvInfoList[firstMove+i-1].depth = 0;
18821             commentList[framePtr+i] = commentList[firstMove+i];
18822             commentList[firstMove+i] = NULL;
18823         }
18824
18825         storedGames++;
18826         forwardMostMove = firstMove; // truncate game so we can start variation
18827 }
18828
18829 void
18830 PushTail (int firstMove, int lastMove)
18831 {
18832         if(appData.icsActive) { // only in local mode
18833                 forwardMostMove = currentMove; // mimic old ICS behavior
18834                 return;
18835         }
18836         if(storedGames >= MAX_VARIATIONS-2) return; // leave one for PV-walk
18837
18838         PushInner(firstMove, lastMove);
18839         if(storedGames == 1) GreyRevert(FALSE);
18840         if(gameMode == PlayFromGameFile) gameMode = EditGame, modeRestore = TRUE;
18841 }
18842
18843 void
18844 PopInner (Boolean annotate)
18845 {
18846         int i, j, nrMoves;
18847         char buf[8000], moveBuf[20];
18848
18849         ToNrEvent(savedFirst[storedGames-1]); // sets currentMove
18850         storedGames--; // do this after ToNrEvent, to make sure HistorySet will refresh entire game after PopInner returns
18851         nrMoves = savedLast[storedGames] - currentMove;
18852         if(annotate) {
18853                 int cnt = 10;
18854                 if(!WhiteOnMove(currentMove))
18855                   snprintf(buf, sizeof(buf)/sizeof(buf[0]),"(%d...", (currentMove+2)>>1);
18856                 else safeStrCpy(buf, "(", sizeof(buf)/sizeof(buf[0]));
18857                 for(i=currentMove; i<forwardMostMove; i++) {
18858                         if(WhiteOnMove(i))
18859                           snprintf(moveBuf, sizeof(moveBuf)/sizeof(moveBuf[0]), " %d. %s", (i+2)>>1, SavePart(parseList[i]));
18860                         else snprintf(moveBuf, sizeof(moveBuf)/sizeof(moveBuf[0])," %s", SavePart(parseList[i]));
18861                         strcat(buf, moveBuf);
18862                         if(commentList[i]) { strcat(buf, " "); strcat(buf, commentList[i]); }
18863                         if(!--cnt) { strcat(buf, "\n"); cnt = 10; }
18864                 }
18865                 strcat(buf, ")");
18866         }
18867         for(i=1; i<=nrMoves; i++) { // copy last variation back
18868             CopyBoard(boards[currentMove+i], boards[framePtr+i]);
18869             for(j=0; j<MOVE_LEN; j++)
18870                 moveList[currentMove+i-1][j] = moveList[framePtr+i][j];
18871             for(j=0; j<2*MOVE_LEN; j++)
18872                 parseList[currentMove+i-1][j] = parseList[framePtr+i][j];
18873             timeRemaining[0][currentMove+i] = timeRemaining[0][framePtr+i];
18874             timeRemaining[1][currentMove+i] = timeRemaining[1][framePtr+i];
18875             pvInfoList[currentMove+i-1] = pvInfoList[framePtr+i];
18876             if(commentList[currentMove+i]) free(commentList[currentMove+i]);
18877             commentList[currentMove+i] = commentList[framePtr+i];
18878             commentList[framePtr+i] = NULL;
18879         }
18880         if(annotate) AppendComment(currentMove+1, buf, FALSE);
18881         framePtr = savedFramePtr[storedGames];
18882         gameInfo.result = savedResult[storedGames];
18883         if(gameInfo.resultDetails != NULL) {
18884             free(gameInfo.resultDetails);
18885       }
18886         gameInfo.resultDetails = savedDetails[storedGames];
18887         forwardMostMove = currentMove + nrMoves;
18888 }
18889
18890 Boolean
18891 PopTail (Boolean annotate)
18892 {
18893         if(appData.icsActive) return FALSE; // only in local mode
18894         if(!storedGames) return FALSE; // sanity
18895         CommentPopDown(); // make sure no stale variation comments to the destroyed line can remain open
18896
18897         PopInner(annotate);
18898         if(currentMove < forwardMostMove) ForwardEvent(); else
18899         HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
18900
18901         if(storedGames == 0) { GreyRevert(TRUE); if(modeRestore) modeRestore = FALSE, gameMode = PlayFromGameFile; }
18902         return TRUE;
18903 }
18904
18905 void
18906 CleanupTail ()
18907 {       // remove all shelved variations
18908         int i;
18909         for(i=0; i<storedGames; i++) {
18910             if(savedDetails[i])
18911                 free(savedDetails[i]);
18912             savedDetails[i] = NULL;
18913         }
18914         for(i=framePtr; i<MAX_MOVES; i++) {
18915                 if(commentList[i]) free(commentList[i]);
18916                 commentList[i] = NULL;
18917         }
18918         framePtr = MAX_MOVES-1;
18919         storedGames = 0;
18920 }
18921
18922 void
18923 LoadVariation (int index, char *text)
18924 {       // [HGM] vari: shelve previous line and load new variation, parsed from text around text[index]
18925         char *p = text, *start = NULL, *end = NULL, wait = NULLCHAR;
18926         int level = 0, move;
18927
18928         if(gameMode != EditGame && gameMode != AnalyzeMode && gameMode != PlayFromGameFile) return;
18929         // first find outermost bracketing variation
18930         while(*p) { // hope I got this right... Non-nesting {} and [] can screen each other and nesting ()
18931             if(!wait) { // while inside [] pr {}, ignore everyting except matching closing ]}
18932                 if(*p == '{') wait = '}'; else
18933                 if(*p == '[') wait = ']'; else
18934                 if(*p == '(' && level++ == 0 && p-text < index) start = p+1;
18935                 if(*p == ')' && level > 0 && --level == 0 && p-text > index && end == NULL) end = p-1;
18936             }
18937             if(*p == wait) wait = NULLCHAR; // closing ]} found
18938             p++;
18939         }
18940         if(!start || !end) return; // no variation found, or syntax error in PGN: ignore click
18941         if(appData.debugMode) fprintf(debugFP, "at move %d load variation '%s'\n", currentMove, start);
18942         end[1] = NULLCHAR; // clip off comment beyond variation
18943         ToNrEvent(currentMove-1);
18944         PushTail(currentMove, forwardMostMove); // shelve main variation. This truncates game
18945         // kludge: use ParsePV() to append variation to game
18946         move = currentMove;
18947         ParsePV(start, TRUE, TRUE);
18948         forwardMostMove = endPV; endPV = -1; currentMove = move; // cleanup what ParsePV did
18949         ClearPremoveHighlights();
18950         CommentPopDown();
18951         ToNrEvent(currentMove+1);
18952 }
18953
18954 void
18955 LoadTheme ()
18956 {
18957     char *p, *q, buf[MSG_SIZ];
18958     if(engineLine && engineLine[0]) { // a theme was selected from the listbox
18959         snprintf(buf, MSG_SIZ, "-theme %s", engineLine);
18960         ParseArgsFromString(buf);
18961         ActivateTheme(TRUE); // also redo colors
18962         return;
18963     }
18964     p = nickName;
18965     if(*p && !strchr(p, '"')) // theme name specified and well-formed; add settings to theme list
18966     {
18967         int len;
18968         q = appData.themeNames;
18969         snprintf(buf, MSG_SIZ, "\"%s\"", nickName);
18970       if(appData.useBitmaps) {
18971         snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), " -ubt true -lbtf \"%s\" -dbtf \"%s\" -lbtm %d -dbtm %d",
18972                 appData.liteBackTextureFile, appData.darkBackTextureFile,
18973                 appData.liteBackTextureMode,
18974                 appData.darkBackTextureMode );
18975       } else {
18976         snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), " -ubt false -lsc %s -dsc %s",
18977                 Col2Text(2),   // lightSquareColor
18978                 Col2Text(3) ); // darkSquareColor
18979       }
18980       if(appData.useBorder) {
18981         snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), " -ub true -border \"%s\"",
18982                 appData.border);
18983       } else {
18984         snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), " -ub false");
18985       }
18986       if(appData.useFont) {
18987         snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), " -upf true -pf \"%s\" -fptc \"%s\" -fpfcw %s -fpbcb %s",
18988                 appData.renderPiecesWithFont,
18989                 appData.fontToPieceTable,
18990                 Col2Text(9),    // appData.fontBackColorWhite
18991                 Col2Text(10) ); // appData.fontForeColorBlack
18992       } else {
18993         snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), " -upf false -pid \"%s\"",
18994                 appData.pieceDirectory);
18995         if(!appData.pieceDirectory[0])
18996           snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), " -wpc %s -bpc %s",
18997                 Col2Text(0),   // whitePieceColor
18998                 Col2Text(1) ); // blackPieceColor
18999       }
19000       snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), " -hsc %s -phc %s\n",
19001                 Col2Text(4),   // highlightSquareColor
19002                 Col2Text(5) ); // premoveHighlightColor
19003         appData.themeNames = malloc(len = strlen(q) + strlen(buf) + 1);
19004         if(insert != q) insert[-1] = NULLCHAR;
19005         snprintf(appData.themeNames, len, "%s\n%s%s", q, buf, insert);
19006         if(q)   free(q);
19007     }
19008     ActivateTheme(FALSE);
19009 }