backend.c

   1 /*
   2  * backend.c -- Common back end for X and Windows NT versions of
   3  *
   4  * Copyright 1991 by Digital Equipment Corporation, Maynard,
   5  * Massachusetts.
   6  *
   7  * Enhancements Copyright 1992-2001, 2002, 2003, 2004, 2005, 2006,
   8  * 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015 Free Software Foundation, Inc.
   9  *
  10  * Enhancements Copyright 2005 Alessandro Scotti
  11  *
  12  * The following terms apply to Digital Equipment Corporation's copyright
  13  * interest in XBoard:
  14  * ------------------------------------------------------------------------
  15  * All Rights Reserved
  16  *
  17  * Permission to use, copy, modify, and distribute this software and its
  18  * documentation for any purpose and without fee is hereby granted,
  19  * provided that the above copyright notice appear in all copies and that
  20  * both that copyright notice and this permission notice appear in
  21  * supporting documentation, and that the name of Digital not be
  22  * used in advertising or publicity pertaining to distribution of the
  23  * software without specific, written prior permission.
  24  *
  25  * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  26  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  27  * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  28  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  29  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  30  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  31  * SOFTWARE.
  32  * ------------------------------------------------------------------------
  33  *
  34  * The following terms apply to the enhanced version of XBoard
  35  * distributed by the Free Software Foundation:
  36  * ------------------------------------------------------------------------
  37  *
  38  * GNU XBoard is free software: you can redistribute it and/or modify
  39  * it under the terms of the GNU General Public License as published by
  40  * the Free Software Foundation, either version 3 of the License, or (at
  41  * your option) any later version.
  42  *
  43  * GNU XBoard is distributed in the hope that it will be useful, but
  44  * WITHOUT ANY WARRANTY; without even the implied warranty of
  45  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  46  * General Public License for more details.
  47  *
  48  * You should have received a copy of the GNU General Public License
  49  * along with this program. If not, see http://www.gnu.org/licenses/.  *
  50  *
  51  *------------------------------------------------------------------------
  52  ** See the file ChangeLog for a revision history.  */
  53
  54 /* [AS] Also useful here for debugging */
  55 #ifdef WIN32
  56 #include <windows.h>
  57
  58     int flock(int f, int code);
  59 #   define LOCK_EX 2
  60 #   define SLASH '\\'
  61
  62 #   ifdef ARC_64BIT
  63 #       define EGBB_NAME "egbbdll64.dll"
  64 #   else
  65 #       define EGBB_NAME "egbbdll.dll"
  66 #   endif
  67
  68 #else
  69
  70 #   include <sys/file.h>
  71 #   define SLASH '/'
  72
  73 #   include <dlfcn.h>
  74 #   ifdef ARC_64BIT
  75 #       define EGBB_NAME "egbbso64.so"
  76 #   else
  77 #       define EGBB_NAME "egbbso.so"
  78 #   endif
  79     // kludge to allow Windows code in back-end by converting it to corresponding Linux code
  80 #   define CDECL
  81 #   define HMODULE void *
  82 #   define LoadLibrary(x) dlopen(x, RTLD_LAZY)
  83 #   define GetProcAddress dlsym
  84
  85 #endif
  86
  87 #include "config.h"
  88
  89 #include <assert.h>
  90 #include <stdio.h>
  91 #include <ctype.h>
  92 #include <errno.h>
  93 #include <sys/types.h>
  94 #include <sys/stat.h>
  95 #include <math.h>
  96 #include <ctype.h>
  97
  98 #if STDC_HEADERS
  99 # include <stdlib.h>
 100 # include <string.h>
 101 # include <stdarg.h>
 102 #else /* not STDC_HEADERS */
 103 # if HAVE_STRING_H
 104 #  include <string.h>
 105 # else /* not HAVE_STRING_H */
 106 #  include <strings.h>
 107 # endif /* not HAVE_STRING_H */
 108 #endif /* not STDC_HEADERS */
 109
 110 #if HAVE_SYS_FCNTL_H
 111 # include <sys/fcntl.h>
 112 #else /* not HAVE_SYS_FCNTL_H */
 113 # if HAVE_FCNTL_H
 114 #  include <fcntl.h>
 115 # endif /* HAVE_FCNTL_H */
 116 #endif /* not HAVE_SYS_FCNTL_H */
 117
 118 #if TIME_WITH_SYS_TIME
 119 # include <sys/time.h>
 120 # include <time.h>
 121 #else
 122 # if HAVE_SYS_TIME_H
 123 #  include <sys/time.h>
 124 # else
 125 #  include <time.h>
 126 # endif
 127 #endif
 128
 129 #if defined(_amigados) && !defined(__GNUC__)
 130 struct timezone {
 131     int tz_minuteswest;
 132     int tz_dsttime;
 133 };
 134 extern int gettimeofday(struct timeval *, struct timezone *);
 135 #endif
 136
 137 #if HAVE_UNISTD_H
 138 # include <unistd.h>
 139 #endif
 140
 141 #include "common.h"
 142 #include "frontend.h"
 143 #include "backend.h"
 144 #include "parser.h"
 145 #include "moves.h"
 146 #if ZIPPY
 147 # include "zippy.h"
 148 #endif
 149 #include "backendz.h"
 150 #include "evalgraph.h"
 151 #include "engineoutput.h"
 152 #include "gettext.h"
 153
 154 #ifdef ENABLE_NLS
 155 # define _(s) gettext (s)
 156 # define N_(s) gettext_noop (s)
 157 # define T_(s) gettext(s)
 158 #else
 159 # ifdef WIN32
 160 #   define _(s) T_(s)
 161 #   define N_(s) s
 162 # else
 163 #   define _(s) (s)
 164 #   define N_(s) s
 165 #   define T_(s) s
 166 # endif
 167 #endif
 168
 169
 170 int establish P((void));
 171 void read_from_player P((InputSourceRef isr, VOIDSTAR closure,
 172                          char *buf, int count, int error));
 173 void read_from_ics P((InputSourceRef isr, VOIDSTAR closure,
 174                       char *buf, int count, int error));
 175 void SendToICS P((char *s));
 176 void SendToICSDelayed P((char *s, long msdelay));
 177 void SendMoveToICS P((ChessMove moveType, int fromX, int fromY, int toX, int toY, char promoChar));
 178 void HandleMachineMove P((char *message, ChessProgramState *cps));
 179 int AutoPlayOneMove P((void));
 180 int LoadGameOneMove P((ChessMove readAhead));
 181 int LoadGameFromFile P((char *filename, int n, char *title, int useList));
 182 int LoadPositionFromFile P((char *filename, int n, char *title));
 183 int SavePositionToFile P((char *filename));
 184 void MakeMove P((int fromX, int fromY, int toX, int toY, int promoChar));
 185 void ShowMove P((int fromX, int fromY, int toX, int toY));
 186 int FinishMove P((ChessMove moveType, int fromX, int fromY, int toX, int toY,
 187                    /*char*/int promoChar));
 188 void BackwardInner P((int target));
 189 void ForwardInner P((int target));
 190 int Adjudicate P((ChessProgramState *cps));
 191 void GameEnds P((ChessMove result, char *resultDetails, int whosays));
 192 void EditPositionDone P((Boolean fakeRights));
 193 void PrintOpponents P((FILE *fp));
 194 void PrintPosition P((FILE *fp, int move));
 195 void StartChessProgram P((ChessProgramState *cps));
 196 void SendToProgram P((char *message, ChessProgramState *cps));
 197 void SendMoveToProgram P((int moveNum, ChessProgramState *cps));
 198 void ReceiveFromProgram P((InputSourceRef isr, VOIDSTAR closure,
 199                            char *buf, int count, int error));
 200 void SendTimeControl P((ChessProgramState *cps,
 201                         int mps, long tc, int inc, int sd, int st));
 202 char *TimeControlTagValue P((void));
 203 void Attention P((ChessProgramState *cps));
 204 void FeedMovesToProgram P((ChessProgramState *cps, int upto));
 205 int ResurrectChessProgram P((void));
 206 void DisplayComment P((int moveNumber, char *text));
 207 void DisplayMove P((int moveNumber));
 208
 209 void ParseGameHistory P((char *game));
 210 void ParseBoard12 P((char *string));
 211 void KeepAlive P((void));
 212 void StartClocks P((void));
 213 void SwitchClocks P((int nr));
 214 void StopClocks P((void));
 215 void ResetClocks P((void));
 216 char *PGNDate P((void));
 217 void SetGameInfo P((void));
 218 int RegisterMove P((void));
 219 void MakeRegisteredMove P((void));
 220 void TruncateGame P((void));
 221 int looking_at P((char *, int *, char *));
 222 void CopyPlayerNameIntoFileName P((char **, char *));
 223 char *SavePart P((char *));
 224 int SaveGameOldStyle P((FILE *));
 225 int SaveGamePGN P((FILE *));
 226 int CheckFlags P((void));
 227 long NextTickLength P((long));
 228 void CheckTimeControl P((void));
 229 void show_bytes P((FILE *, char *, int));
 230 int string_to_rating P((char *str));
 231 void ParseFeatures P((char* args, ChessProgramState *cps));
 232 void InitBackEnd3 P((void));
 233 void FeatureDone P((ChessProgramState* cps, int val));
 234 void InitChessProgram P((ChessProgramState *cps, int setup));
 235 void OutputKibitz(int window, char *text);
 236 int PerpetualChase(int first, int last);
 237 int EngineOutputIsUp();
 238 void InitDrawingSizes(int x, int y);
 239 void NextMatchGame P((void));
 240 int NextTourneyGame P((int nr, int *swap));
 241 int Pairing P((int nr, int nPlayers, int *w, int *b, int *sync));
 242 FILE *WriteTourneyFile P((char *results, FILE *f));
 243 void DisplayTwoMachinesTitle P(());
 244 static void ExcludeClick P((int index));
 245 void ToggleSecond P((void));
 246 void PauseEngine P((ChessProgramState *cps));
 247 static int NonStandardBoardSize P((VariantClass v, int w, int h, int s));
 248
 249 #ifdef WIN32
 250        extern void ConsoleCreate();
 251 #endif
 252
 253 ChessProgramState *WhitePlayer();
 254 int VerifyDisplayMode P(());
 255
 256 char *GetInfoFromComment( int, char * ); // [HGM] PV time: returns stripped comment
 257 void InitEngineUCI( const char * iniDir, ChessProgramState * cps ); // [HGM] moved here from winboard.c
 258 char *ProbeBook P((int moveNr, char *book)); // [HGM] book: returns a book move
 259 char *SendMoveToBookUser P((int nr, ChessProgramState *cps, int initial)); // [HGM] book
 260 void ics_update_width P((int new_width));
 261 extern char installDir[MSG_SIZ];
 262 VariantClass startVariant; /* [HGM] nicks: initial variant */
 263 Boolean abortMatch;
 264
 265 extern int tinyLayout, smallLayout;
 266 ChessProgramStats programStats;
 267 char lastPV[2][2*MSG_SIZ]; /* [HGM] pv: last PV in thinking output of each engine */
 268 int endPV = -1;
 269 static int exiting = 0; /* [HGM] moved to top */
 270 static int setboardSpoiledMachineBlack = 0 /*, errorExitFlag = 0*/;
 271 int startedFromPositionFile = FALSE; Board filePosition;       /* [HGM] loadPos */
 272 Board partnerBoard;     /* [HGM] bughouse: for peeking at partner game          */
 273 int partnerHighlight[2];
 274 Boolean partnerBoardValid = 0;
 275 char partnerStatus[MSG_SIZ];
 276 Boolean partnerUp;
 277 Boolean originalFlip;
 278 Boolean twoBoards = 0;
 279 char endingGame = 0;    /* [HGM] crash: flag to prevent recursion of GameEnds() */
 280 int whiteNPS, blackNPS; /* [HGM] nps: for easily making clocks aware of NPS     */
 281 VariantClass currentlyInitializedVariant; /* [HGM] variantswitch */
 282 int lastIndex = 0;      /* [HGM] autoinc: last game/position used in match mode */
 283 Boolean connectionAlive;/* [HGM] alive: ICS connection status from probing      */
 284 int opponentKibitzes;
 285 int lastSavedGame; /* [HGM] save: ID of game */
 286 char chatPartner[MAX_CHAT][MSG_SIZ]; /* [HGM] chat: list of chatting partners */
 287 extern int chatCount;
 288 int chattingPartner;
 289 char marker[BOARD_RANKS][BOARD_FILES]; /* [HGM] marks for target squares */
 290 char legal[BOARD_RANKS][BOARD_FILES];  /* [HGM] legal target squares */
 291 char lastMsg[MSG_SIZ];
 292 char lastTalker[MSG_SIZ];
 293 ChessSquare pieceSweep = EmptySquare;
 294 ChessSquare promoSweep = EmptySquare, defaultPromoChoice;
 295 int promoDefaultAltered;
 296 int keepInfo = 0; /* [HGM] to protect PGN tags in auto-step game analysis */
 297 static int initPing = -1;
 298 int border;       /* [HGM] width of board rim, needed to size seek graph  */
 299 char bestMove[MSG_SIZ];
 300 int solvingTime, totalTime;
 301
 302 /* States for ics_getting_history */
 303 #define H_FALSE 0
 304 #define H_REQUESTED 1
 305 #define H_GOT_REQ_HEADER 2
 306 #define H_GOT_UNREQ_HEADER 3
 307 #define H_GETTING_MOVES 4
 308 #define H_GOT_UNWANTED_HEADER 5
 309
 310 /* whosays values for GameEnds */
 311 #define GE_ICS 0
 312 #define GE_ENGINE 1
 313 #define GE_PLAYER 2
 314 #define GE_FILE 3
 315 #define GE_XBOARD 4
 316 #define GE_ENGINE1 5
 317 #define GE_ENGINE2 6
 318
 319 /* Maximum number of games in a cmail message */
 320 #define CMAIL_MAX_GAMES 20
 321
 322 /* Different types of move when calling RegisterMove */
 323 #define CMAIL_MOVE   0
 324 #define CMAIL_RESIGN 1
 325 #define CMAIL_DRAW   2
 326 #define CMAIL_ACCEPT 3
 327
 328 /* Different types of result to remember for each game */
 329 #define CMAIL_NOT_RESULT 0
 330 #define CMAIL_OLD_RESULT 1
 331 #define CMAIL_NEW_RESULT 2
 332
 333 /* Telnet protocol constants */
 334 #define TN_WILL 0373
 335 #define TN_WONT 0374
 336 #define TN_DO   0375
 337 #define TN_DONT 0376
 338 #define TN_IAC  0377
 339 #define TN_ECHO 0001
 340 #define TN_SGA  0003
 341 #define TN_PORT 23
 342
 343 char*
 344 safeStrCpy (char *dst, const char *src, size_t count)
 345 { // [HGM] made safe
 346   int i;
 347   assert( dst != NULL );
 348   assert( src != NULL );
 349   assert( count > 0 );
 350
 351   for(i=0; i<count; i++) if((dst[i] = src[i]) == NULLCHAR) break;
 352   if(  i == count && dst[count-1] != NULLCHAR)
 353     {
 354       dst[ count-1 ] = '\0'; // make sure incomplete copy still null-terminated
 355       if(appData.debugMode)
 356         fprintf(debugFP, "safeStrCpy: copying %s into %s didn't work, not enough space %d\n",src,dst, (int)count);
 357     }
 358
 359   return dst;
 360 }
 361
 362 /* Some compiler can't cast u64 to double
 363  * This function do the job for us:
 364
 365  * We use the highest bit for cast, this only
 366  * works if the highest bit is not
 367  * in use (This should not happen)
 368  *
 369  * We used this for all compiler
 370  */
 371 double
 372 u64ToDouble (u64 value)
 373 {
 374   double r;
 375   u64 tmp = value & u64Const(0x7fffffffffffffff);
 376   r = (double)(s64)tmp;
 377   if (value & u64Const(0x8000000000000000))
 378        r +=  9.2233720368547758080e18; /* 2^63 */
 379  return r;
 380 }
 381
 382 /* Fake up flags for now, as we aren't keeping track of castling
 383    availability yet. [HGM] Change of logic: the flag now only
 384    indicates the type of castlings allowed by the rule of the game.
 385    The actual rights themselves are maintained in the array
 386    castlingRights, as part of the game history, and are not probed
 387    by this function.
 388  */
 389 int
 390 PosFlags (index)
 391 {
 392   int flags = F_ALL_CASTLE_OK;
 393   if ((index % 2) == 0) flags |= F_WHITE_ON_MOVE;
 394   switch (gameInfo.variant) {
 395   case VariantSuicide:
 396     flags &= ~F_ALL_CASTLE_OK;
 397   case VariantGiveaway:         // [HGM] moved this case label one down: seems Giveaway does have castling on ICC!
 398     flags |= F_IGNORE_CHECK;
 399   case VariantLosers:
 400     flags |= F_MANDATORY_CAPTURE; //[HGM] losers: sets flag so TestLegality rejects non-capts if capts exist
 401     break;
 402   case VariantAtomic:
 403     flags |= F_IGNORE_CHECK | F_ATOMIC_CAPTURE;
 404     break;
 405   case VariantKriegspiel:
 406     flags |= F_KRIEGSPIEL_CAPTURE;
 407     break;
 408   case VariantCapaRandom:
 409   case VariantFischeRandom:
 410     flags |= F_FRC_TYPE_CASTLING; /* [HGM] enable this through flag */
 411   case VariantNoCastle:
 412   case VariantShatranj:
 413   case VariantCourier:
 414   case VariantMakruk:
 415   case VariantASEAN:
 416   case VariantGrand:
 417     flags &= ~F_ALL_CASTLE_OK;
 418     break;
 419   case VariantChu:
 420   case VariantChuChess:
 421   case VariantLion:
 422     flags |= F_NULL_MOVE;
 423     break;
 424   default:
 425     break;
 426   }
 427   if(appData.fischerCastling) flags |= F_FRC_TYPE_CASTLING, flags &= ~F_ALL_CASTLE_OK; // [HGM] fischer
 428   return flags;
 429 }
 430
 431 FILE *gameFileFP, *debugFP, *serverFP;
 432 char *currentDebugFile; // [HGM] debug split: to remember name
 433
 434 /*
 435     [AS] Note: sometimes, the sscanf() function is used to parse the input
 436     into a fixed-size buffer. Because of this, we must be prepared to
 437     receive strings as long as the size of the input buffer, which is currently
 438     set to 4K for Windows and 8K for the rest.
 439     So, we must either allocate sufficiently large buffers here, or
 440     reduce the size of the input buffer in the input reading part.
 441 */
 442
 443 char cmailMove[CMAIL_MAX_GAMES][MOVE_LEN], cmailMsg[MSG_SIZ];
 444 char bookOutput[MSG_SIZ*10], thinkOutput[MSG_SIZ*10], lastHint[MSG_SIZ];
 445 char thinkOutput1[MSG_SIZ*10];
 446
 447 ChessProgramState first, second, pairing;
 448
 449 /* premove variables */
 450 int premoveToX = 0;
 451 int premoveToY = 0;
 452 int premoveFromX = 0;
 453 int premoveFromY = 0;
 454 int premovePromoChar = 0;
 455 int gotPremove = 0;
 456 Boolean alarmSounded;
 457 /* end premove variables */
 458
 459 char *ics_prefix = "$";
 460 enum ICS_TYPE ics_type = ICS_GENERIC;
 461
 462 int currentMove = 0, forwardMostMove = 0, backwardMostMove = 0;
 463 int pauseExamForwardMostMove = 0;
 464 int nCmailGames = 0, nCmailResults = 0, nCmailMovesRegistered = 0;
 465 int cmailMoveRegistered[CMAIL_MAX_GAMES], cmailResult[CMAIL_MAX_GAMES];
 466 int cmailMsgLoaded = FALSE, cmailMailedMove = FALSE;
 467 int cmailOldMove = -1, firstMove = TRUE, flipView = FALSE;
 468 int blackPlaysFirst = FALSE, startedFromSetupPosition = FALSE;
 469 int searchTime = 0, pausing = FALSE, pauseExamInvalid = FALSE;
 470 int whiteFlag = FALSE, blackFlag = FALSE;
 471 int userOfferedDraw = FALSE;
 472 int ics_user_moved = 0, ics_gamenum = -1, ics_getting_history = H_FALSE;
 473 int matchMode = FALSE, hintRequested = FALSE, bookRequested = FALSE;
 474 int cmailMoveType[CMAIL_MAX_GAMES];
 475 long ics_clock_paused = 0;
 476 ProcRef icsPR = NoProc, cmailPR = NoProc;
 477 InputSourceRef telnetISR = NULL, fromUserISR = NULL, cmailISR = NULL;
 478 GameMode gameMode = BeginningOfGame;
 479 char moveList[MAX_MOVES][MOVE_LEN], parseList[MAX_MOVES][MOVE_LEN * 2];
 480 char *commentList[MAX_MOVES], *cmailCommentList[CMAIL_MAX_GAMES];
 481 ChessProgramStats_Move pvInfoList[MAX_MOVES]; /* [AS] Info about engine thinking */
 482 int hiddenThinkOutputState = 0; /* [AS] */
 483 int adjudicateLossThreshold = 0; /* [AS] Automatic adjudication */
 484 int adjudicateLossPlies = 6;
 485 char white_holding[64], black_holding[64];
 486 TimeMark lastNodeCountTime;
 487 long lastNodeCount=0;
 488 int shiftKey, controlKey; // [HGM] set by mouse handler
 489
 490 int have_sent_ICS_logon = 0;
 491 int movesPerSession;
 492 int suddenDeath, whiteStartMove, blackStartMove; /* [HGM] for implementation of 'any per time' sessions, as in first part of byoyomi TC */
 493 long whiteTimeRemaining, blackTimeRemaining, timeControl, timeIncrement, lastWhite, lastBlack, activePartnerTime;
 494 Boolean adjustedClock;
 495 long timeControl_2; /* [AS] Allow separate time controls */
 496 char *fullTimeControlString = NULL, *nextSession, *whiteTC, *blackTC, activePartner; /* [HGM] secondary TC: merge of MPS, TC and inc */
 497 long timeRemaining[2][MAX_MOVES];
 498 int matchGame = 0, nextGame = 0, roundNr = 0;
 499 Boolean waitingForGame = FALSE, startingEngine = FALSE;
 500 TimeMark programStartTime, pauseStart;
 501 char ics_handle[MSG_SIZ];
 502 int have_set_title = 0;
 503
 504 /* animateTraining preserves the state of appData.animate
 505  * when Training mode is activated. This allows the
 506  * response to be animated when appData.animate == TRUE and
 507  * appData.animateDragging == TRUE.
 508  */
 509 Boolean animateTraining;
 510
 511 GameInfo gameInfo;
 512
 513 AppData appData;
 514
 515 Board boards[MAX_MOVES];
 516 /* [HGM] Following 7 needed for accurate legality tests: */
 517 signed char  castlingRank[BOARD_FILES]; // and corresponding ranks
 518 signed char  initialRights[BOARD_FILES];
 519 int   nrCastlingRights; // For TwoKings, or to implement castling-unknown status
 520 int   initialRulePlies, FENrulePlies;
 521 FILE  *serverMoves = NULL; // next two for broadcasting (/serverMoves option)
 522 int loadFlag = 0;
 523 Boolean shuffleOpenings;
 524 int mute; // mute all sounds
 525
 526 // [HGM] vari: next 12 to save and restore variations
 527 #define MAX_VARIATIONS 10
 528 int framePtr = MAX_MOVES-1; // points to free stack entry
 529 int storedGames = 0;
 530 int savedFirst[MAX_VARIATIONS];
 531 int savedLast[MAX_VARIATIONS];
 532 int savedFramePtr[MAX_VARIATIONS];
 533 char *savedDetails[MAX_VARIATIONS];
 534 ChessMove savedResult[MAX_VARIATIONS];
 535
 536 void PushTail P((int firstMove, int lastMove));
 537 Boolean PopTail P((Boolean annotate));
 538 void PushInner P((int firstMove, int lastMove));
 539 void PopInner P((Boolean annotate));
 540 void CleanupTail P((void));
 541
 542 ChessSquare  FIDEArray[2][BOARD_FILES] = {
 543     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 544         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 545     { BlackRook, BlackKnight, BlackBishop, BlackQueen,
 546         BlackKing, BlackBishop, BlackKnight, BlackRook }
 547 };
 548
 549 ChessSquare twoKingsArray[2][BOARD_FILES] = {
 550     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 551         WhiteKing, WhiteKing, WhiteKnight, WhiteRook },
 552     { BlackRook, BlackKnight, BlackBishop, BlackQueen,
 553         BlackKing, BlackKing, BlackKnight, BlackRook }
 554 };
 555
 556 ChessSquare  KnightmateArray[2][BOARD_FILES] = {
 557     { WhiteRook, WhiteMan, WhiteBishop, WhiteQueen,
 558         WhiteUnicorn, WhiteBishop, WhiteMan, WhiteRook },
 559     { BlackRook, BlackMan, BlackBishop, BlackQueen,
 560         BlackUnicorn, BlackBishop, BlackMan, BlackRook }
 561 };
 562
 563 ChessSquare SpartanArray[2][BOARD_FILES] = {
 564     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 565         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 566     { BlackAlfil, BlackMarshall, BlackKing, BlackDragon,
 567         BlackDragon, BlackKing, BlackAngel, BlackAlfil }
 568 };
 569
 570 ChessSquare fairyArray[2][BOARD_FILES] = { /* [HGM] Queen side differs from King side */
 571     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 572         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 573     { BlackCardinal, BlackAlfil, BlackMarshall, BlackAngel,
 574         BlackKing, BlackMarshall, BlackAlfil, BlackCardinal }
 575 };
 576
 577 ChessSquare ShatranjArray[2][BOARD_FILES] = { /* [HGM] (movGen knows about Shatranj Q and P) */
 578     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteKing,
 579         WhiteFerz, WhiteAlfil, WhiteKnight, WhiteRook },
 580     { BlackRook, BlackKnight, BlackAlfil, BlackKing,
 581         BlackFerz, BlackAlfil, BlackKnight, BlackRook }
 582 };
 583
 584 ChessSquare makrukArray[2][BOARD_FILES] = { /* [HGM] (movGen knows about Shatranj Q and P) */
 585     { WhiteRook, WhiteKnight, WhiteMan, WhiteKing,
 586         WhiteFerz, WhiteMan, WhiteKnight, WhiteRook },
 587     { BlackRook, BlackKnight, BlackMan, BlackFerz,
 588         BlackKing, BlackMan, BlackKnight, BlackRook }
 589 };
 590
 591 ChessSquare aseanArray[2][BOARD_FILES] = { /* [HGM] (movGen knows about Shatranj Q and P) */
 592     { WhiteRook, WhiteKnight, WhiteMan, WhiteFerz,
 593         WhiteKing, WhiteMan, WhiteKnight, WhiteRook },
 594     { BlackRook, BlackKnight, BlackMan, BlackFerz,
 595         BlackKing, BlackMan, BlackKnight, BlackRook }
 596 };
 597
 598 ChessSquare  lionArray[2][BOARD_FILES] = {
 599     { WhiteRook, WhiteLion, WhiteBishop, WhiteQueen,
 600         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 601     { BlackRook, BlackLion, BlackBishop, BlackQueen,
 602         BlackKing, BlackBishop, BlackKnight, BlackRook }
 603 };
 604
 605
 606 #if (BOARD_FILES>=10)
 607 ChessSquare ShogiArray[2][BOARD_FILES] = {
 608     { WhiteQueen, WhiteKnight, WhiteFerz, WhiteWazir,
 609         WhiteKing, WhiteWazir, WhiteFerz, WhiteKnight, WhiteQueen },
 610     { BlackQueen, BlackKnight, BlackFerz, BlackWazir,
 611         BlackKing, BlackWazir, BlackFerz, BlackKnight, BlackQueen }
 612 };
 613
 614 ChessSquare XiangqiArray[2][BOARD_FILES] = {
 615     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteFerz,
 616         WhiteWazir, WhiteFerz, WhiteAlfil, WhiteKnight, WhiteRook },
 617     { BlackRook, BlackKnight, BlackAlfil, BlackFerz,
 618         BlackWazir, BlackFerz, BlackAlfil, BlackKnight, BlackRook }
 619 };
 620
 621 ChessSquare CapablancaArray[2][BOARD_FILES] = {
 622     { WhiteRook, WhiteKnight, WhiteAngel, WhiteBishop, WhiteQueen,
 623         WhiteKing, WhiteBishop, WhiteMarshall, WhiteKnight, WhiteRook },
 624     { BlackRook, BlackKnight, BlackAngel, BlackBishop, BlackQueen,
 625         BlackKing, BlackBishop, BlackMarshall, BlackKnight, BlackRook }
 626 };
 627
 628 ChessSquare GreatArray[2][BOARD_FILES] = {
 629     { WhiteDragon, WhiteKnight, WhiteAlfil, WhiteGrasshopper, WhiteKing,
 630         WhiteSilver, WhiteCardinal, WhiteAlfil, WhiteKnight, WhiteDragon },
 631     { BlackDragon, BlackKnight, BlackAlfil, BlackGrasshopper, BlackKing,
 632         BlackSilver, BlackCardinal, BlackAlfil, BlackKnight, BlackDragon },
 633 };
 634
 635 ChessSquare JanusArray[2][BOARD_FILES] = {
 636     { WhiteRook, WhiteAngel, WhiteKnight, WhiteBishop, WhiteKing,
 637         WhiteQueen, WhiteBishop, WhiteKnight, WhiteAngel, WhiteRook },
 638     { BlackRook, BlackAngel, BlackKnight, BlackBishop, BlackKing,
 639         BlackQueen, BlackBishop, BlackKnight, BlackAngel, BlackRook }
 640 };
 641
 642 ChessSquare GrandArray[2][BOARD_FILES] = {
 643     { EmptySquare, WhiteKnight, WhiteBishop, WhiteQueen, WhiteKing,
 644         WhiteMarshall, WhiteAngel, WhiteBishop, WhiteKnight, EmptySquare },
 645     { EmptySquare, BlackKnight, BlackBishop, BlackQueen, BlackKing,
 646         BlackMarshall, BlackAngel, BlackBishop, BlackKnight, EmptySquare }
 647 };
 648
 649 ChessSquare ChuChessArray[2][BOARD_FILES] = {
 650     { WhiteMan, WhiteKnight, WhiteBishop, WhiteCardinal, WhiteLion,
 651         WhiteQueen, WhiteDragon, WhiteBishop, WhiteKnight, WhiteMan },
 652     { BlackMan, BlackKnight, BlackBishop, BlackDragon, BlackQueen,
 653         BlackLion, BlackCardinal, BlackBishop, BlackKnight, BlackMan }
 654 };
 655
 656 #ifdef GOTHIC
 657 ChessSquare GothicArray[2][BOARD_FILES] = {
 658     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen, WhiteMarshall,
 659         WhiteKing, WhiteAngel, WhiteBishop, WhiteKnight, WhiteRook },
 660     { BlackRook, BlackKnight, BlackBishop, BlackQueen, BlackMarshall,
 661         BlackKing, BlackAngel, BlackBishop, BlackKnight, BlackRook }
 662 };
 663 #else // !GOTHIC
 664 #define GothicArray CapablancaArray
 665 #endif // !GOTHIC
 666
 667 #ifdef FALCON
 668 ChessSquare FalconArray[2][BOARD_FILES] = {
 669     { WhiteRook, WhiteKnight, WhiteBishop, WhiteFalcon, WhiteQueen,
 670         WhiteKing, WhiteFalcon, WhiteBishop, WhiteKnight, WhiteRook },
 671     { BlackRook, BlackKnight, BlackBishop, BlackFalcon, BlackQueen,
 672         BlackKing, BlackFalcon, BlackBishop, BlackKnight, BlackRook }
 673 };
 674 #else // !FALCON
 675 #define FalconArray CapablancaArray
 676 #endif // !FALCON
 677
 678 #else // !(BOARD_FILES>=10)
 679 #define XiangqiPosition FIDEArray
 680 #define CapablancaArray FIDEArray
 681 #define GothicArray FIDEArray
 682 #define GreatArray FIDEArray
 683 #endif // !(BOARD_FILES>=10)
 684
 685 #if (BOARD_FILES>=12)
 686 ChessSquare CourierArray[2][BOARD_FILES] = {
 687     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteBishop, WhiteMan, WhiteKing,
 688         WhiteFerz, WhiteWazir, WhiteBishop, WhiteAlfil, WhiteKnight, WhiteRook },
 689     { BlackRook, BlackKnight, BlackAlfil, BlackBishop, BlackMan, BlackKing,
 690         BlackFerz, BlackWazir, BlackBishop, BlackAlfil, BlackKnight, BlackRook }
 691 };
 692 ChessSquare ChuArray[6][BOARD_FILES] = {
 693     { WhiteLance, WhiteUnicorn, WhiteMan, WhiteFerz, WhiteWazir, WhiteKing,
 694       WhiteAlfil, WhiteWazir, WhiteFerz, WhiteMan, WhiteUnicorn, WhiteLance },
 695     { BlackLance, BlackUnicorn, BlackMan, BlackFerz, BlackWazir, BlackAlfil,
 696       BlackKing, BlackWazir, BlackFerz, BlackMan, BlackUnicorn, BlackLance },
 697     { WhiteCannon, EmptySquare, WhiteBishop, EmptySquare, WhiteNightrider, WhiteMarshall,
 698       WhiteAngel, WhiteNightrider, EmptySquare, WhiteBishop, EmptySquare, WhiteCannon },
 699     { BlackCannon, EmptySquare, BlackBishop, EmptySquare, BlackNightrider, BlackAngel,
 700       BlackMarshall, BlackNightrider, EmptySquare, BlackBishop, EmptySquare, BlackCannon },
 701     { WhiteFalcon, WhiteSilver, WhiteRook, WhiteCardinal, WhiteDragon, WhiteLion,
 702       WhiteQueen, WhiteDragon, WhiteCardinal, WhiteRook, WhiteSilver, WhiteFalcon },
 703     { BlackFalcon, BlackSilver, BlackRook, BlackCardinal, BlackDragon, BlackQueen,
 704       BlackLion, BlackDragon, BlackCardinal, BlackRook, BlackSilver, BlackFalcon }
 705 };
 706 #else // !(BOARD_FILES>=12)
 707 #define CourierArray CapablancaArray
 708 #define ChuArray CapablancaArray
 709 #endif // !(BOARD_FILES>=12)
 710
 711
 712 Board initialPosition;
 713
 714
 715 /* Convert str to a rating. Checks for special cases of "----",
 716
 717    "++++", etc. Also strips ()'s */
 718 int
 719 string_to_rating (char *str)
 720 {
 721   while(*str && !isdigit(*str)) ++str;
 722   if (!*str)
 723     return 0;   /* One of the special "no rating" cases */
 724   else
 725     return atoi(str);
 726 }
 727
 728 void
 729 ClearProgramStats ()
 730 {
 731     /* Init programStats */
 732     programStats.movelist[0] = 0;
 733     programStats.depth = 0;
 734     programStats.nr_moves = 0;
 735     programStats.moves_left = 0;
 736     programStats.nodes = 0;
 737     programStats.time = -1;        // [HGM] PGNtime: make invalid to recognize engine output
 738     programStats.score = 0;
 739     programStats.got_only_move = 0;
 740     programStats.got_fail = 0;
 741     programStats.line_is_book = 0;
 742 }
 743
 744 void
 745 CommonEngineInit ()
 746 {   // [HGM] moved some code here from InitBackend1 that has to be done after both engines have contributed their settings
 747     if (appData.firstPlaysBlack) {
 748         first.twoMachinesColor = "black\n";
 749         second.twoMachinesColor = "white\n";
 750     } else {
 751         first.twoMachinesColor = "white\n";
 752         second.twoMachinesColor = "black\n";
 753     }
 754
 755     first.other = &second;
 756     second.other = &first;
 757
 758     { float norm = 1;
 759         if(appData.timeOddsMode) {
 760             norm = appData.timeOdds[0];
 761             if(norm > appData.timeOdds[1]) norm = appData.timeOdds[1];
 762         }
 763         first.timeOdds  = appData.timeOdds[0]/norm;
 764         second.timeOdds = appData.timeOdds[1]/norm;
 765     }
 766
 767     if(programVersion) free(programVersion);
 768     if (appData.noChessProgram) {
 769         programVersion = (char*) malloc(5 + strlen(PACKAGE_STRING));
 770         sprintf(programVersion, "%s", PACKAGE_STRING);
 771     } else {
 772       /* [HGM] tidy: use tidy name, in stead of full pathname (which was probably a bug due to / vs \ ) */
 773       programVersion = (char*) malloc(8 + strlen(PACKAGE_STRING) + strlen(first.tidy));
 774       sprintf(programVersion, "%s + %s", PACKAGE_STRING, first.tidy);
 775     }
 776 }
 777
 778 void
 779 UnloadEngine (ChessProgramState *cps)
 780 {
 781         /* Kill off first chess program */
 782         if (cps->isr != NULL)
 783           RemoveInputSource(cps->isr);
 784         cps->isr = NULL;
 785
 786         if (cps->pr != NoProc) {
 787             ExitAnalyzeMode();
 788             DoSleep( appData.delayBeforeQuit );
 789             SendToProgram("quit\n", cps);
 790             DestroyChildProcess(cps->pr, 4 + cps->useSigterm);
 791         }
 792         cps->pr = NoProc;
 793         if(appData.debugMode) fprintf(debugFP, "Unload %s\n", cps->which);
 794 }
 795
 796 void
 797 ClearOptions (ChessProgramState *cps)
 798 {
 799     int i;
 800     cps->nrOptions = cps->comboCnt = 0;
 801     for(i=0; i<MAX_OPTIONS; i++) {
 802         cps->option[i].min = cps->option[i].max = cps->option[i].value = 0;
 803         cps->option[i].textValue = 0;
 804     }
 805 }
 806
 807 char *engineNames[] = {
 808   /* TRANSLATORS: "first" is the first of possible two chess engines. It is inserted into strings
 809      such as "%s engine" / "%s chess program" / "%s machine" - all meaning the same thing */
 810 N_("first"),
 811   /* TRANSLATORS: "second" is the second of possible two chess engines. It is inserted into strings
 812      such as "%s engine" / "%s chess program" / "%s machine" - all meaning the same thing */
 813 N_("second")
 814 };
 815
 816 void
 817 InitEngine (ChessProgramState *cps, int n)
 818 {   // [HGM] all engine initialiation put in a function that does one engine
 819
 820     ClearOptions(cps);
 821
 822     cps->which = engineNames[n];
 823     cps->maybeThinking = FALSE;
 824     cps->pr = NoProc;
 825     cps->isr = NULL;
 826     cps->sendTime = 2;
 827     cps->sendDrawOffers = 1;
 828
 829     cps->program = appData.chessProgram[n];
 830     cps->host = appData.host[n];
 831     cps->dir = appData.directory[n];
 832     cps->initString = appData.engInitString[n];
 833     cps->computerString = appData.computerString[n];
 834     cps->useSigint  = TRUE;
 835     cps->useSigterm = TRUE;
 836     cps->reuse = appData.reuse[n];
 837     cps->nps = appData.NPS[n];   // [HGM] nps: copy nodes per second
 838     cps->useSetboard = FALSE;
 839     cps->useSAN = FALSE;
 840     cps->usePing = FALSE;
 841     cps->lastPing = 0;
 842     cps->lastPong = 0;
 843     cps->usePlayother = FALSE;
 844     cps->useColors = TRUE;
 845     cps->useUsermove = FALSE;
 846     cps->sendICS = FALSE;
 847     cps->sendName = appData.icsActive;
 848     cps->sdKludge = FALSE;
 849     cps->stKludge = FALSE;
 850     if(cps->tidy == NULL) cps->tidy = (char*) malloc(MSG_SIZ);
 851     TidyProgramName(cps->program, cps->host, cps->tidy);
 852     cps->matchWins = 0;
 853     ASSIGN(cps->variants, appData.noChessProgram ? "" : appData.variant);
 854     cps->analysisSupport = 2; /* detect */
 855     cps->analyzing = FALSE;
 856     cps->initDone = FALSE;
 857     cps->reload = FALSE;
 858     cps->pseudo = appData.pseudo[n];
 859
 860     /* New features added by Tord: */
 861     cps->useFEN960 = FALSE;
 862     cps->useOOCastle = TRUE;
 863     /* End of new features added by Tord. */
 864     cps->fenOverride  = appData.fenOverride[n];
 865
 866     /* [HGM] time odds: set factor for each machine */
 867     cps->timeOdds  = appData.timeOdds[n];
 868
 869     /* [HGM] secondary TC: how to handle sessions that do not fit in 'level'*/
 870     cps->accumulateTC = appData.accumulateTC[n];
 871     cps->maxNrOfSessions = 1;
 872
 873     /* [HGM] debug */
 874     cps->debug = FALSE;
 875
 876     cps->drawDepth = appData.drawDepth[n];
 877     cps->supportsNPS = UNKNOWN;
 878     cps->memSize = FALSE;
 879     cps->maxCores = FALSE;
 880     ASSIGN(cps->egtFormats, "");
 881
 882     /* [HGM] options */
 883     cps->optionSettings  = appData.engOptions[n];
 884
 885     cps->scoreIsAbsolute = appData.scoreIsAbsolute[n]; /* [AS] */
 886     cps->isUCI = appData.isUCI[n]; /* [AS] */
 887     cps->hasOwnBookUCI = appData.hasOwnBookUCI[n]; /* [AS] */
 888     cps->highlight = 0;
 889
 890     if (appData.protocolVersion[n] > PROTOVER
 891         || appData.protocolVersion[n] < 1)
 892       {
 893         char buf[MSG_SIZ];
 894         int len;
 895
 896         len = snprintf(buf, MSG_SIZ, _("protocol version %d not supported"),
 897                        appData.protocolVersion[n]);
 898         if( (len >= MSG_SIZ) && appData.debugMode )
 899           fprintf(debugFP, "InitBackEnd1: buffer truncated.\n");
 900
 901         DisplayFatalError(buf, 0, 2);
 902       }
 903     else
 904       {
 905         cps->protocolVersion = appData.protocolVersion[n];
 906       }
 907
 908     InitEngineUCI( installDir, cps );  // [HGM] moved here from winboard.c, to make available in xboard
 909     ParseFeatures(appData.featureDefaults, cps);
 910 }
 911
 912 ChessProgramState *savCps;
 913
 914 GameMode oldMode;
 915
 916 void
 917 LoadEngine ()
 918 {
 919     int i;
 920     if(WaitForEngine(savCps, LoadEngine)) return;
 921     CommonEngineInit(); // recalculate time odds
 922     if(gameInfo.variant != StringToVariant(appData.variant)) {
 923         // we changed variant when loading the engine; this forces us to reset
 924         Reset(TRUE, savCps != &first);
 925         oldMode = BeginningOfGame; // to prevent restoring old mode
 926     }
 927     InitChessProgram(savCps, FALSE);
 928     if(gameMode == EditGame) SendToProgram("force\n", savCps); // in EditGame mode engine must be in force mode
 929     DisplayMessage("", "");
 930     if (startedFromSetupPosition) SendBoard(savCps, backwardMostMove);
 931     for (i = backwardMostMove; i < currentMove; i++) SendMoveToProgram(i, savCps);
 932     ThawUI();
 933     SetGNUMode();
 934     if(oldMode == AnalyzeMode) AnalyzeModeEvent();
 935 }
 936
 937 void
 938 ReplaceEngine (ChessProgramState *cps, int n)
 939 {
 940     oldMode = gameMode; // remember mode, so it can be restored after loading sequence is complete
 941     keepInfo = 1;
 942     if(oldMode != BeginningOfGame) EditGameEvent();
 943     keepInfo = 0;
 944     UnloadEngine(cps);
 945     appData.noChessProgram = FALSE;
 946     appData.clockMode = TRUE;
 947     InitEngine(cps, n);
 948     UpdateLogos(TRUE);
 949     if(n) return; // only startup first engine immediately; second can wait
 950     savCps = cps; // parameter to LoadEngine passed as globals, to allow scheduled calling :-(
 951     LoadEngine();
 952 }
 953
 954 extern char *engineName, *engineDir, *engineChoice, *engineLine, *nickName, *params;
 955 extern Boolean isUCI, hasBook, storeVariant, v1, addToList, useNick;
 956
 957 static char resetOptions[] =
 958         "-reuse -firstIsUCI false -firstHasOwnBookUCI true -firstTimeOdds 1 "
 959         "-firstInitString \"" INIT_STRING "\" -firstComputerString \"" COMPUTER_STRING "\" "
 960         "-firstFeatures \"\" -firstLogo \"\" -firstAccumulateTC 1 -fd \".\" "
 961         "-firstOptions \"\" -firstNPS -1 -fn \"\" -firstScoreAbs false";
 962
 963 void
 964 FloatToFront(char **list, char *engineLine)
 965 {
 966     char buf[MSG_SIZ], tidy[MSG_SIZ], *p = buf, *q, *r = buf;
 967     int i=0;
 968     if(appData.recentEngines <= 0) return;
 969     TidyProgramName(engineLine, "localhost", tidy+1);
 970     tidy[0] = buf[0] = '\n'; strcat(tidy, "\n");
 971     strncpy(buf+1, *list, MSG_SIZ-50);
 972     if(p = strstr(buf, tidy)) { // tidy name appears in list
 973         q = strchr(++p, '\n'); if(q == NULL) return; // malformed, don't touch
 974         while(*p++ = *++q); // squeeze out
 975     }
 976     strcat(tidy, buf+1); // put list behind tidy name
 977     p = tidy + 1; while(q = strchr(p, '\n')) i++, r = p, p = q + 1; // count entries in new list
 978     if(i > appData.recentEngines) *r = NULLCHAR; // if maximum rached, strip off last
 979     ASSIGN(*list, tidy+1);
 980 }
 981
 982 char *insert, *wbOptions; // point in ChessProgramNames were we should insert new engine
 983
 984 void
 985 Load (ChessProgramState *cps, int i)
 986 {
 987     char *p, *q, buf[MSG_SIZ], command[MSG_SIZ], buf2[MSG_SIZ], buf3[MSG_SIZ], jar;
 988     if(engineLine && engineLine[0]) { // an engine was selected from the combo box
 989         snprintf(buf, MSG_SIZ, "-fcp %s", engineLine);
 990         SwapEngines(i); // kludge to parse -f* / -first* like it is -s* / -second*
 991         ParseArgsFromString(resetOptions); appData.pvSAN[0] = FALSE;
 992         FREE(appData.fenOverride[0]); appData.fenOverride[0] = NULL;
 993         appData.firstProtocolVersion = PROTOVER;
 994         ParseArgsFromString(buf);
 995         SwapEngines(i);
 996         ReplaceEngine(cps, i);
 997         FloatToFront(&appData.recentEngineList, engineLine);
 998         return;
 999     }
1000     p = engineName;
1001     while(q = strchr(p, SLASH)) p = q+1;
1002     if(*p== NULLCHAR) { DisplayError(_("You did not specify the engine executable"), 0); return; }
1003     if(engineDir[0] != NULLCHAR) {
1004         ASSIGN(appData.directory[i], engineDir); p = engineName;
1005     } else if(p != engineName) { // derive directory from engine path, when not given
1006         p[-1] = 0;
1007         ASSIGN(appData.directory[i], engineName);
1008         p[-1] = SLASH;
1009         if(SLASH == '/' && p - engineName > 1) *(p -= 2) = '.'; // for XBoard use ./exeName as command after split!
1010     } else { ASSIGN(appData.directory[i], "."); }
1011     jar = (strstr(p, ".jar") == p + strlen(p) - 4);
1012     if(params[0]) {
1013         if(strchr(p, ' ') && !strchr(p, '"')) snprintf(buf2, MSG_SIZ, "\"%s\"", p), p = buf2; // quote if it contains spaces
1014         snprintf(command, MSG_SIZ, "%s %s", p, params);
1015         p = command;
1016     }
1017     if(jar) { snprintf(buf3, MSG_SIZ, "java -jar %s", p); p = buf3; }
1018     ASSIGN(appData.chessProgram[i], p);
1019     appData.isUCI[i] = isUCI;
1020     appData.protocolVersion[i] = v1 ? 1 : PROTOVER;
1021     appData.hasOwnBookUCI[i] = hasBook;
1022     if(!nickName[0]) useNick = FALSE;
1023     if(useNick) ASSIGN(appData.pgnName[i], nickName);
1024     if(addToList) {
1025         int len;
1026         char quote;
1027         q = firstChessProgramNames;
1028         if(nickName[0]) snprintf(buf, MSG_SIZ, "\"%s\" -fcp ", nickName); else buf[0] = NULLCHAR;
1029         quote = strchr(p, '"') ? '\'' : '"'; // use single quotes around engine command if it contains double quotes
1030         snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), "%c%s%c -fd \"%s\"%s%s%s%s%s%s%s%s\n",
1031                         quote, p, quote, appData.directory[i],
1032                         useNick ? " -fn \"" : "",
1033                         useNick ? nickName : "",
1034                         useNick ? "\"" : "",
1035                         v1 ? " -firstProtocolVersion 1" : "",
1036                         hasBook ? "" : " -fNoOwnBookUCI",
1037                         isUCI ? (isUCI == TRUE ? " -fUCI" : gameInfo.variant == VariantShogi ? " -fUSI" : " -fUCCI") : "",
1038                         storeVariant ? " -variant " : "",
1039                         storeVariant ? VariantName(gameInfo.variant) : "");
1040         if(wbOptions && wbOptions[0]) snprintf(buf+strlen(buf)-1, MSG_SIZ-strlen(buf), " %s\n", wbOptions);
1041         firstChessProgramNames = malloc(len = strlen(q) + strlen(buf) + 1);
1042         if(insert != q) insert[-1] = NULLCHAR;
1043         snprintf(firstChessProgramNames, len, "%s\n%s%s", q, buf, insert);
1044         if(q)   free(q);
1045         FloatToFront(&appData.recentEngineList, buf);
1046     }
1047     ReplaceEngine(cps, i);
1048 }
1049
1050 void
1051 InitTimeControls ()
1052 {
1053     int matched, min, sec;
1054     /*
1055      * Parse timeControl resource
1056      */
1057     if (!ParseTimeControl(appData.timeControl, appData.timeIncrement,
1058                           appData.movesPerSession)) {
1059         char buf[MSG_SIZ];
1060         snprintf(buf, sizeof(buf), _("bad timeControl option %s"), appData.timeControl);
1061         DisplayFatalError(buf, 0, 2);
1062     }
1063
1064     /*
1065      * Parse searchTime resource
1066      */
1067     if (*appData.searchTime != NULLCHAR) {
1068         matched = sscanf(appData.searchTime, "%d:%d", &min, &sec);
1069         if (matched == 1) {
1070             searchTime = min * 60;
1071         } else if (matched == 2) {
1072             searchTime = min * 60 + sec;
1073         } else {
1074             char buf[MSG_SIZ];
1075             snprintf(buf, sizeof(buf), _("bad searchTime option %s"), appData.searchTime);
1076             DisplayFatalError(buf, 0, 2);
1077         }
1078     }
1079 }
1080
1081 void
1082 InitBackEnd1 ()
1083 {
1084
1085     ShowThinkingEvent(); // [HGM] thinking: make sure post/nopost state is set according to options
1086     startVariant = StringToVariant(appData.variant); // [HGM] nicks: remember original variant
1087
1088     GetTimeMark(&programStartTime);
1089     srandom((programStartTime.ms + 1000*programStartTime.sec)*0x1001001); // [HGM] book: makes sure random is unpredictabe to msec level
1090     appData.seedBase = random() + (random()<<15);
1091     pauseStart = programStartTime; pauseStart.sec -= 100; // [HGM] matchpause: fake a pause that has long since ended
1092
1093     ClearProgramStats();
1094     programStats.ok_to_send = 1;
1095     programStats.seen_stat = 0;
1096
1097     /*
1098      * Initialize game list
1099      */
1100     ListNew(&gameList);
1101
1102
1103     /*
1104      * Internet chess server status
1105      */
1106     if (appData.icsActive) {
1107         appData.matchMode = FALSE;
1108         appData.matchGames = 0;
1109 #if ZIPPY
1110         appData.noChessProgram = !appData.zippyPlay;
1111 #else
1112         appData.zippyPlay = FALSE;
1113         appData.zippyTalk = FALSE;
1114         appData.noChessProgram = TRUE;
1115 #endif
1116         if (*appData.icsHelper != NULLCHAR) {
1117             appData.useTelnet = TRUE;
1118             appData.telnetProgram = appData.icsHelper;
1119         }
1120     } else {
1121         appData.zippyTalk = appData.zippyPlay = FALSE;
1122     }
1123
1124     /* [AS] Initialize pv info list [HGM] and game state */
1125     {
1126         int i, j;
1127
1128         for( i=0; i<=framePtr; i++ ) {
1129             pvInfoList[i].depth = -1;
1130             boards[i][EP_STATUS] = EP_NONE;
1131             for( j=0; j<BOARD_FILES-2; j++ ) boards[i][CASTLING][j] = NoRights;
1132         }
1133     }
1134
1135     InitTimeControls();
1136
1137     /* [AS] Adjudication threshold */
1138     adjudicateLossThreshold = appData.adjudicateLossThreshold;
1139
1140     InitEngine(&first, 0);
1141     InitEngine(&second, 1);
1142     CommonEngineInit();
1143
1144     pairing.which = "pairing"; // pairing engine
1145     pairing.pr = NoProc;
1146     pairing.isr = NULL;
1147     pairing.program = appData.pairingEngine;
1148     pairing.host = "localhost";
1149     pairing.dir = ".";
1150
1151     if (appData.icsActive) {
1152         appData.clockMode = TRUE;  /* changes dynamically in ICS mode */
1153     } else if (appData.noChessProgram) { // [HGM] st: searchTime mode now also is clockMode
1154         appData.clockMode = FALSE;
1155         first.sendTime = second.sendTime = 0;
1156     }
1157
1158 #if ZIPPY
1159     /* Override some settings from environment variables, for backward
1160        compatibility.  Unfortunately it's not feasible to have the env
1161        vars just set defaults, at least in xboard.  Ugh.
1162     */
1163     if (appData.icsActive && (appData.zippyPlay || appData.zippyTalk)) {
1164       ZippyInit();
1165     }
1166 #endif
1167
1168     if (!appData.icsActive) {
1169       char buf[MSG_SIZ];
1170       int len;
1171
1172       /* Check for variants that are supported only in ICS mode,
1173          or not at all.  Some that are accepted here nevertheless
1174          have bugs; see comments below.
1175       */
1176       VariantClass variant = StringToVariant(appData.variant);
1177       switch (variant) {
1178       case VariantBughouse:     /* need four players and two boards */
1179       case VariantKriegspiel:   /* need to hide pieces and move details */
1180         /* case VariantFischeRandom: (Fabien: moved below) */
1181         len = snprintf(buf,MSG_SIZ, _("Variant %s supported only in ICS mode"), appData.variant);
1182         if( (len >= MSG_SIZ) && appData.debugMode )
1183           fprintf(debugFP, "InitBackEnd1: buffer truncated.\n");
1184
1185         DisplayFatalError(buf, 0, 2);
1186         return;
1187
1188       case VariantUnknown:
1189       case VariantLoadable:
1190       case Variant29:
1191       case Variant30:
1192       case Variant31:
1193       case Variant32:
1194       case Variant33:
1195       case Variant34:
1196       case Variant35:
1197       case Variant36:
1198       default:
1199         len = snprintf(buf, MSG_SIZ, _("Unknown variant name %s"), appData.variant);
1200         if( (len >= MSG_SIZ) && appData.debugMode )
1201           fprintf(debugFP, "InitBackEnd1: buffer truncated.\n");
1202
1203         DisplayFatalError(buf, 0, 2);
1204         return;
1205
1206       case VariantNormal:     /* definitely works! */
1207         if(strcmp(appData.variant, "normal") && !appData.noChessProgram) { // [HGM] hope this is an engine-defined variant
1208           safeStrCpy(engineVariant, appData.variant, MSG_SIZ);
1209           return;
1210         }
1211       case VariantXiangqi:    /* [HGM] repetition rules not implemented */
1212       case VariantFairy:      /* [HGM] TestLegality definitely off! */
1213       case VariantGothic:     /* [HGM] should work */
1214       case VariantCapablanca: /* [HGM] should work */
1215       case VariantCourier:    /* [HGM] initial forced moves not implemented */
1216       case VariantShogi:      /* [HGM] could still mate with pawn drop */
1217       case VariantChu:        /* [HGM] experimental */
1218       case VariantKnightmate: /* [HGM] should work */
1219       case VariantCylinder:   /* [HGM] untested */
1220       case VariantFalcon:     /* [HGM] untested */
1221       case VariantCrazyhouse: /* holdings not shown, ([HGM] fixed that!)
1222                                  offboard interposition not understood */
1223       case VariantWildCastle: /* pieces not automatically shuffled */
1224       case VariantNoCastle:   /* pieces not automatically shuffled */
1225       case VariantFischeRandom: /* [HGM] works and shuffles pieces */
1226       case VariantLosers:     /* should work except for win condition,
1227                                  and doesn't know captures are mandatory */
1228       case VariantSuicide:    /* should work except for win condition,
1229                                  and doesn't know captures are mandatory */
1230       case VariantGiveaway:   /* should work except for win condition,
1231                                  and doesn't know captures are mandatory */
1232       case VariantTwoKings:   /* should work */
1233       case VariantAtomic:     /* should work except for win condition */
1234       case Variant3Check:     /* should work except for win condition */
1235       case VariantShatranj:   /* should work except for all win conditions */
1236       case VariantMakruk:     /* should work except for draw countdown */
1237       case VariantASEAN :     /* should work except for draw countdown */
1238       case VariantBerolina:   /* might work if TestLegality is off */
1239       case VariantCapaRandom: /* should work */
1240       case VariantJanus:      /* should work */
1241       case VariantSuper:      /* experimental */
1242       case VariantGreat:      /* experimental, requires legality testing to be off */
1243       case VariantSChess:     /* S-Chess, should work */
1244       case VariantGrand:      /* should work */
1245       case VariantSpartan:    /* should work */
1246       case VariantLion:       /* should work */
1247       case VariantChuChess:   /* should work */
1248         break;
1249       }
1250     }
1251
1252 }
1253
1254 int
1255 NextIntegerFromString (char ** str, long * value)
1256 {
1257     int result = -1;
1258     char * s = *str;
1259
1260     while( *s == ' ' || *s == '\t' ) {
1261         s++;
1262     }
1263
1264     *value = 0;
1265
1266     if( *s >= '0' && *s <= '9' ) {
1267         while( *s >= '0' && *s <= '9' ) {
1268             *value = *value * 10 + (*s - '0');
1269             s++;
1270         }
1271
1272         result = 0;
1273     }
1274
1275     *str = s;
1276
1277     return result;
1278 }
1279
1280 int
1281 NextTimeControlFromString (char ** str, long * value)
1282 {
1283     long temp;
1284     int result = NextIntegerFromString( str, &temp );
1285
1286     if( result == 0 ) {
1287         *value = temp * 60; /* Minutes */
1288         if( **str == ':' ) {
1289             (*str)++;
1290             result = NextIntegerFromString( str, &temp );
1291             *value += temp; /* Seconds */
1292         }
1293     }
1294
1295     return result;
1296 }
1297
1298 int
1299 NextSessionFromString (char ** str, int *moves, long * tc, long *inc, int *incType)
1300 {   /* [HGM] routine added to read '+moves/time' for secondary time control. */
1301     int result = -1, type = 0; long temp, temp2;
1302
1303     if(**str != ':') return -1; // old params remain in force!
1304     (*str)++;
1305     if(**str == '*') type = *(*str)++, temp = 0; // sandclock TC
1306     if( NextIntegerFromString( str, &temp ) ) return -1;
1307     if(type) { *moves = 0; *tc = temp * 500; *inc = temp * 1000; *incType = '*'; return 0; }
1308
1309     if(**str != '/') {
1310         /* time only: incremental or sudden-death time control */
1311         if(**str == '+') { /* increment follows; read it */
1312             (*str)++;
1313             if(**str == '!') type = *(*str)++; // Bronstein TC
1314             if(result = NextIntegerFromString( str, &temp2)) return -1;
1315             *inc = temp2 * 1000;
1316             if(**str == '.') { // read fraction of increment
1317                 char *start = ++(*str);
1318                 if(result = NextIntegerFromString( str, &temp2)) return -1;
1319                 temp2 *= 1000;
1320                 while(start++ < *str) temp2 /= 10;
1321                 *inc += temp2;
1322             }
1323         } else *inc = 0;
1324         *moves = 0; *tc = temp * 1000; *incType = type;
1325         return 0;
1326     }
1327
1328     (*str)++; /* classical time control */
1329     result = NextIntegerFromString( str, &temp2); // NOTE: already converted to seconds by ParseTimeControl()
1330
1331     if(result == 0) {
1332         *moves = temp;
1333         *tc    = temp2 * 1000;
1334         *inc   = 0;
1335         *incType = type;
1336     }
1337     return result;
1338 }
1339
1340 int
1341 GetTimeQuota (int movenr, int lastUsed, char *tcString)
1342 {   /* [HGM] get time to add from the multi-session time-control string */
1343     int incType, moves=1; /* kludge to force reading of first session */
1344     long time, increment;
1345     char *s = tcString;
1346
1347     if(!s || !*s) return 0; // empty TC string means we ran out of the last sudden-death version
1348     do {
1349         if(moves) NextSessionFromString(&s, &moves, &time, &increment, &incType);
1350         nextSession = s; suddenDeath = moves == 0 && increment == 0;
1351         if(movenr == -1) return time;    /* last move before new session     */
1352         if(incType == '*') increment = 0; else // for sandclock, time is added while not thinking
1353         if(incType == '!' && lastUsed < increment) increment = lastUsed;
1354         if(!moves) return increment;     /* current session is incremental   */
1355         if(movenr >= 0) movenr -= moves; /* we already finished this session */
1356     } while(movenr >= -1);               /* try again for next session       */
1357
1358     return 0; // no new time quota on this move
1359 }
1360
1361 int
1362 ParseTimeControl (char *tc, float ti, int mps)
1363 {
1364   long tc1;
1365   long tc2;
1366   char buf[MSG_SIZ], buf2[MSG_SIZ], *mytc = tc;
1367   int min, sec=0;
1368
1369   if(ti >= 0 && !strchr(tc, '+') && !strchr(tc, '/') ) mps = 0;
1370   if(!strchr(tc, '+') && !strchr(tc, '/') && sscanf(tc, "%d:%d", &min, &sec) >= 1)
1371       sprintf(mytc=buf2, "%d", 60*min+sec); // convert 'classical' min:sec tc string to seconds
1372   if(ti > 0) {
1373
1374     if(mps)
1375       snprintf(buf, MSG_SIZ, ":%d/%s+%g", mps, mytc, ti);
1376     else
1377       snprintf(buf, MSG_SIZ, ":%s+%g", mytc, ti);
1378   } else {
1379     if(mps)
1380       snprintf(buf, MSG_SIZ, ":%d/%s", mps, mytc);
1381     else
1382       snprintf(buf, MSG_SIZ, ":%s", mytc);
1383   }
1384   fullTimeControlString = StrSave(buf); // this should now be in PGN format
1385
1386   if( NextTimeControlFromString( &tc, &tc1 ) != 0 ) {
1387     return FALSE;
1388   }
1389
1390   if( *tc == '/' ) {
1391     /* Parse second time control */
1392     tc++;
1393
1394     if( NextTimeControlFromString( &tc, &tc2 ) != 0 ) {
1395       return FALSE;
1396     }
1397
1398     if( tc2 == 0 ) {
1399       return FALSE;
1400     }
1401
1402     timeControl_2 = tc2 * 1000;
1403   }
1404   else {
1405     timeControl_2 = 0;
1406   }
1407
1408   if( tc1 == 0 ) {
1409     return FALSE;
1410   }
1411
1412   timeControl = tc1 * 1000;
1413
1414   if (ti >= 0) {
1415     timeIncrement = ti * 1000;  /* convert to ms */
1416     movesPerSession = 0;
1417   } else {
1418     timeIncrement = 0;
1419     movesPerSession = mps;
1420   }
1421   return TRUE;
1422 }
1423
1424 void
1425 InitBackEnd2 ()
1426 {
1427     if (appData.debugMode) {
1428 #    ifdef __GIT_VERSION
1429       fprintf(debugFP, "Version: %s (%s)\n", programVersion, __GIT_VERSION);
1430 #    else
1431       fprintf(debugFP, "Version: %s\n", programVersion);
1432 #    endif
1433     }
1434     ASSIGN(currentDebugFile, appData.nameOfDebugFile); // [HGM] debug split: remember initial name in use
1435
1436     set_cont_sequence(appData.wrapContSeq);
1437     if (appData.matchGames > 0) {
1438         appData.matchMode = TRUE;
1439     } else if (appData.matchMode) {
1440         appData.matchGames = 1;
1441     }
1442     if(appData.matchMode && appData.sameColorGames > 0) /* [HGM] alternate: overrule matchGames */
1443         appData.matchGames = appData.sameColorGames;
1444     if(appData.rewindIndex > 1) { /* [HGM] autoinc: rewind implies auto-increment and overrules given index */
1445         if(appData.loadPositionIndex >= 0) appData.loadPositionIndex = -1;
1446         if(appData.loadGameIndex >= 0) appData.loadGameIndex = -1;
1447     }
1448     Reset(TRUE, FALSE);
1449     if (appData.noChessProgram || first.protocolVersion == 1) {
1450       InitBackEnd3();
1451     } else {
1452       /* kludge: allow timeout for initial "feature" commands */
1453       FreezeUI();
1454       DisplayMessage("", _("Starting chess program"));
1455       ScheduleDelayedEvent(InitBackEnd3, FEATURE_TIMEOUT);
1456     }
1457 }
1458
1459 int
1460 CalculateIndex (int index, int gameNr)
1461 {   // [HGM] autoinc: absolute way to determine load index from game number (taking auto-inc and rewind into account)
1462     int res;
1463     if(index > 0) return index; // fixed nmber
1464     if(index == 0) return 1;
1465     res = (index == -1 ? gameNr : (gameNr-1)/2 + 1); // autoinc
1466     if(appData.rewindIndex > 0) res = (res-1) % appData.rewindIndex + 1; // rewind
1467     return res;
1468 }
1469
1470 int
1471 LoadGameOrPosition (int gameNr)
1472 {   // [HGM] taken out of MatchEvent and NextMatchGame (to combine it)
1473     if (*appData.loadGameFile != NULLCHAR) {
1474         if (!LoadGameFromFile(appData.loadGameFile,
1475                 CalculateIndex(appData.loadGameIndex, gameNr),
1476                               appData.loadGameFile, FALSE)) {
1477             DisplayFatalError(_("Bad game file"), 0, 1);
1478             return 0;
1479         }
1480     } else if (*appData.loadPositionFile != NULLCHAR) {
1481         if (!LoadPositionFromFile(appData.loadPositionFile,
1482                 CalculateIndex(appData.loadPositionIndex, gameNr),
1483                                   appData.loadPositionFile)) {
1484             DisplayFatalError(_("Bad position file"), 0, 1);
1485             return 0;
1486         }
1487     }
1488     return 1;
1489 }
1490
1491 void
1492 ReserveGame (int gameNr, char resChar)
1493 {
1494     FILE *tf = fopen(appData.tourneyFile, "r+");
1495     char *p, *q, c, buf[MSG_SIZ];
1496     if(tf == NULL) { nextGame = appData.matchGames + 1; return; } // kludge to terminate match
1497     safeStrCpy(buf, lastMsg, MSG_SIZ);
1498     DisplayMessage(_("Pick new game"), "");
1499     flock(fileno(tf), LOCK_EX); // lock the tourney file while we are messing with it
1500     ParseArgsFromFile(tf);
1501     p = q = appData.results;
1502     if(appData.debugMode) {
1503       char *r = appData.participants;
1504       fprintf(debugFP, "results = '%s'\n", p);
1505       while(*r) fprintf(debugFP, *r >= ' ' ? "%c" : "\\%03o", *r), r++;
1506       fprintf(debugFP, "\n");
1507     }
1508     while(*q && *q != ' ') q++; // get first un-played game (could be beyond end!)
1509     nextGame = q - p;
1510     q = malloc(strlen(p) + 2); // could be arbitrary long, but allow to extend by one!
1511     safeStrCpy(q, p, strlen(p) + 2);
1512     if(gameNr >= 0) q[gameNr] = resChar; // replace '*' with result
1513     if(appData.debugMode) fprintf(debugFP, "pick next game from '%s': %d\n", q, nextGame);
1514     if(nextGame <= appData.matchGames && resChar != ' ' && !abortMatch) { // reserve next game if tourney not yet done
1515         if(q[nextGame] == NULLCHAR) q[nextGame+1] = NULLCHAR; // append one char
1516         q[nextGame] = '*';
1517     }
1518     fseek(tf, -(strlen(p)+4), SEEK_END);
1519     c = fgetc(tf);
1520     if(c != '"') // depending on DOS or Unix line endings we can be one off
1521          fseek(tf, -(strlen(p)+2), SEEK_END);
1522     else fseek(tf, -(strlen(p)+3), SEEK_END);
1523     fprintf(tf, "%s\"\n", q); fclose(tf); // update, and flush by closing
1524     DisplayMessage(buf, "");
1525     free(p); appData.results = q;
1526     if(nextGame <= appData.matchGames && resChar != ' ' && !abortMatch &&
1527        (gameNr < 0 || nextGame / appData.defaultMatchGames != gameNr / appData.defaultMatchGames)) {
1528       int round = appData.defaultMatchGames * appData.tourneyType;
1529       if(gameNr < 0 || appData.tourneyType < 1 ||  // gauntlet engine can always stay loaded as first engine
1530          appData.tourneyType > 1 && nextGame/round != gameNr/round) // in multi-gauntlet change only after round
1531         UnloadEngine(&first);  // next game belongs to other pairing;
1532         UnloadEngine(&second); // already unload the engines, so TwoMachinesEvent will load new ones.
1533     }
1534     if(appData.debugMode) fprintf(debugFP, "Reserved, next=%d, nr=%d\n", nextGame, gameNr);
1535 }
1536
1537 void
1538 MatchEvent (int mode)
1539 {       // [HGM] moved out of InitBackend3, to make it callable when match starts through menu
1540         int dummy;
1541         if(matchMode) { // already in match mode: switch it off
1542             abortMatch = TRUE;
1543             if(!appData.tourneyFile[0]) appData.matchGames = matchGame; // kludge to let match terminate after next game.
1544             return;
1545         }
1546 //      if(gameMode != BeginningOfGame) {
1547 //          DisplayError(_("You can only start a match from the initial position."), 0);
1548 //          return;
1549 //      }
1550         abortMatch = FALSE;
1551         if(mode == 2) appData.matchGames = appData.defaultMatchGames;
1552         /* Set up machine vs. machine match */
1553         nextGame = 0;
1554         NextTourneyGame(-1, &dummy); // sets appData.matchGames if this is tourney, to make sure ReserveGame knows it
1555         if(appData.tourneyFile[0]) {
1556             ReserveGame(-1, 0);
1557             if(nextGame > appData.matchGames) {
1558                 char buf[MSG_SIZ];
1559                 if(strchr(appData.results, '*') == NULL) {
1560                     FILE *f;
1561                     appData.tourneyCycles++;
1562                     if(f = WriteTourneyFile(appData.results, NULL)) { // make a tourney file with increased number of cycles
1563                         fclose(f);
1564                         NextTourneyGame(-1, &dummy);
1565                         ReserveGame(-1, 0);
1566                         if(nextGame <= appData.matchGames) {
1567                             DisplayNote(_("You restarted an already completed tourney.\nOne more cycle will now be added to it.\nGames commence in 10 sec."));
1568                             matchMode = mode;
1569                             ScheduleDelayedEvent(NextMatchGame, 10000);
1570                             return;
1571                         }
1572                     }
1573                 }
1574                 snprintf(buf, MSG_SIZ, _("All games in tourney '%s' are already played or playing"), appData.tourneyFile);
1575                 DisplayError(buf, 0);
1576                 appData.tourneyFile[0] = 0;
1577                 return;
1578             }
1579         } else
1580         if (appData.noChessProgram) {  // [HGM] in tourney engines are loaded automatically
1581             DisplayFatalError(_("Can't have a match with no chess programs"),
1582                               0, 2);
1583             return;
1584         }
1585         matchMode = mode;
1586         matchGame = roundNr = 1;
1587         first.matchWins = second.matchWins = 0; // [HGM] match: needed in later matches
1588         NextMatchGame();
1589 }
1590
1591 char *comboLine = NULL; // [HGM] recent: WinBoard's first-engine combobox line
1592
1593 void
1594 InitBackEnd3 P((void))
1595 {
1596     GameMode initialMode;
1597     char buf[MSG_SIZ];
1598     int err, len;
1599
1600     if(!appData.icsActive && !appData.noChessProgram && !appData.matchMode &&                         // mode involves only first engine
1601        !strcmp(appData.variant, "normal") &&                                                          // no explicit variant request
1602         appData.NrRanks == -1 && appData.NrFiles == -1 && appData.holdingsSize == -1 &&               // no size overrides requested
1603        !SupportedVariant(first.variants, VariantNormal, 8, 8, 0, first.protocolVersion, "") &&        // but 'normal' won't work with engine
1604        !SupportedVariant(first.variants, VariantFischeRandom, 8, 8, 0, first.protocolVersion, "") ) { // nor will Chess960
1605         char c, *q = first.variants, *p = strchr(q, ',');
1606         if(p) *p = NULLCHAR;
1607         if(StringToVariant(q) != VariantUnknown) { // the engine can play a recognized variant, however
1608             int w, h, s;
1609             if(sscanf(q, "%dx%d+%d_%c", &w, &h, &s, &c) == 4) // get size overrides the engine needs with it (if any)
1610                 appData.NrFiles = w, appData.NrRanks = h, appData.holdingsSize = s, q = strchr(q, '_') + 1;
1611             ASSIGN(appData.variant, q); // fake user requested the first variant played by the engine
1612             Reset(TRUE, FALSE);         // and re-initialize
1613         }
1614         if(p) *p = ',';
1615     }
1616
1617     InitChessProgram(&first, startedFromSetupPosition);
1618
1619     if(!appData.noChessProgram) {  /* [HGM] tidy: redo program version to use name from myname feature */
1620         free(programVersion);
1621         programVersion = (char*) malloc(8 + strlen(PACKAGE_STRING) + strlen(first.tidy));
1622         sprintf(programVersion, "%s + %s", PACKAGE_STRING, first.tidy);
1623         FloatToFront(&appData.recentEngineList, comboLine ? comboLine : appData.firstChessProgram);
1624     }
1625
1626     if (appData.icsActive) {
1627 #ifdef WIN32
1628         /* [DM] Make a console window if needed [HGM] merged ifs */
1629         ConsoleCreate();
1630 #endif
1631         err = establish();
1632         if (err != 0)
1633           {
1634             if (*appData.icsCommPort != NULLCHAR)
1635               len = snprintf(buf, MSG_SIZ, _("Could not open comm port %s"),
1636                              appData.icsCommPort);
1637             else
1638               len = snprintf(buf, MSG_SIZ, _("Could not connect to host %s, port %s"),
1639                         appData.icsHost, appData.icsPort);
1640
1641             if( (len >= MSG_SIZ) && appData.debugMode )
1642               fprintf(debugFP, "InitBackEnd3: buffer truncated.\n");
1643
1644             DisplayFatalError(buf, err, 1);
1645             return;
1646         }
1647         SetICSMode();
1648         telnetISR =
1649           AddInputSource(icsPR, FALSE, read_from_ics, &telnetISR);
1650         fromUserISR =
1651           AddInputSource(NoProc, FALSE, read_from_player, &fromUserISR);
1652         if(appData.keepAlive) // [HGM] alive: schedule sending of dummy 'date' command
1653             ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
1654     } else if (appData.noChessProgram) {
1655         SetNCPMode();
1656     } else {
1657         SetGNUMode();
1658     }
1659
1660     if (*appData.cmailGameName != NULLCHAR) {
1661         SetCmailMode();
1662         OpenLoopback(&cmailPR);
1663         cmailISR =
1664           AddInputSource(cmailPR, FALSE, CmailSigHandlerCallBack, &cmailISR);
1665     }
1666
1667     ThawUI();
1668     DisplayMessage("", "");
1669     if (StrCaseCmp(appData.initialMode, "") == 0) {
1670       initialMode = BeginningOfGame;
1671       if(!appData.icsActive && appData.noChessProgram) { // [HGM] could be fall-back
1672         gameMode = MachinePlaysBlack; // "Machine Black" might have been implicitly highlighted
1673         ModeHighlight(); // make sure XBoard knows it is highlighted, so it will un-highlight it
1674         gameMode = BeginningOfGame; // in case BeginningOfGame now means "Edit Position"
1675         ModeHighlight();
1676       }
1677     } else if (StrCaseCmp(appData.initialMode, "TwoMachines") == 0) {
1678       initialMode = TwoMachinesPlay;
1679     } else if (StrCaseCmp(appData.initialMode, "AnalyzeFile") == 0) {
1680       initialMode = AnalyzeFile;
1681     } else if (StrCaseCmp(appData.initialMode, "Analysis") == 0) {
1682       initialMode = AnalyzeMode;
1683     } else if (StrCaseCmp(appData.initialMode, "MachineWhite") == 0) {
1684       initialMode = MachinePlaysWhite;
1685     } else if (StrCaseCmp(appData.initialMode, "MachineBlack") == 0) {
1686       initialMode = MachinePlaysBlack;
1687     } else if (StrCaseCmp(appData.initialMode, "EditGame") == 0) {
1688       initialMode = EditGame;
1689     } else if (StrCaseCmp(appData.initialMode, "EditPosition") == 0) {
1690       initialMode = EditPosition;
1691     } else if (StrCaseCmp(appData.initialMode, "Training") == 0) {
1692       initialMode = Training;
1693     } else {
1694       len = snprintf(buf, MSG_SIZ, _("Unknown initialMode %s"), appData.initialMode);
1695       if( (len >= MSG_SIZ) && appData.debugMode )
1696         fprintf(debugFP, "InitBackEnd3: buffer truncated.\n");
1697
1698       DisplayFatalError(buf, 0, 2);
1699       return;
1700     }
1701
1702     if (appData.matchMode) {
1703         if(appData.tourneyFile[0]) { // start tourney from command line
1704             FILE *f;
1705             if(f = fopen(appData.tourneyFile, "r")) {
1706                 ParseArgsFromFile(f); // make sure tourney parmeters re known
1707                 fclose(f);
1708                 appData.clockMode = TRUE;
1709                 SetGNUMode();
1710             } else appData.tourneyFile[0] = NULLCHAR; // for now ignore bad tourney file
1711         }
1712         MatchEvent(TRUE);
1713     } else if (*appData.cmailGameName != NULLCHAR) {
1714         /* Set up cmail mode */
1715         ReloadCmailMsgEvent(TRUE);
1716     } else {
1717         /* Set up other modes */
1718         if (initialMode == AnalyzeFile) {
1719           if (*appData.loadGameFile == NULLCHAR) {
1720             DisplayFatalError(_("AnalyzeFile mode requires a game file"), 0, 1);
1721             return;
1722           }
1723         }
1724         if (*appData.loadGameFile != NULLCHAR) {
1725             (void) LoadGameFromFile(appData.loadGameFile,
1726                                     appData.loadGameIndex,
1727                                     appData.loadGameFile, TRUE);
1728         } else if (*appData.loadPositionFile != NULLCHAR) {
1729             (void) LoadPositionFromFile(appData.loadPositionFile,
1730                                         appData.loadPositionIndex,
1731                                         appData.loadPositionFile);
1732             /* [HGM] try to make self-starting even after FEN load */
1733             /* to allow automatic setup of fairy variants with wtm */
1734             if(initialMode == BeginningOfGame && !blackPlaysFirst) {
1735                 gameMode = BeginningOfGame;
1736                 setboardSpoiledMachineBlack = 1;
1737             }
1738             /* [HGM] loadPos: make that every new game uses the setup */
1739             /* from file as long as we do not switch variant          */
1740             if(!blackPlaysFirst) {
1741                 startedFromPositionFile = TRUE;
1742                 CopyBoard(filePosition, boards[0]);
1743             }
1744         }
1745         if (initialMode == AnalyzeMode) {
1746           if (appData.noChessProgram) {
1747             DisplayFatalError(_("Analysis mode requires a chess engine"), 0, 2);
1748             return;
1749           }
1750           if (appData.icsActive) {
1751             DisplayFatalError(_("Analysis mode does not work with ICS mode"),0,2);
1752             return;
1753           }
1754           AnalyzeModeEvent();
1755         } else if (initialMode == AnalyzeFile) {
1756           appData.showThinking = TRUE; // [HGM] thinking: moved out of ShowThinkingEvent
1757           ShowThinkingEvent();
1758           AnalyzeFileEvent();
1759           AnalysisPeriodicEvent(1);
1760         } else if (initialMode == MachinePlaysWhite) {
1761           if (appData.noChessProgram) {
1762             DisplayFatalError(_("MachineWhite mode requires a chess engine"),
1763                               0, 2);
1764             return;
1765           }
1766           if (appData.icsActive) {
1767             DisplayFatalError(_("MachineWhite mode does not work with ICS mode"),
1768                               0, 2);
1769             return;
1770           }
1771           MachineWhiteEvent();
1772         } else if (initialMode == MachinePlaysBlack) {
1773           if (appData.noChessProgram) {
1774             DisplayFatalError(_("MachineBlack mode requires a chess engine"),
1775                               0, 2);
1776             return;
1777           }
1778           if (appData.icsActive) {
1779             DisplayFatalError(_("MachineBlack mode does not work with ICS mode"),
1780                               0, 2);
1781             return;
1782           }
1783           MachineBlackEvent();
1784         } else if (initialMode == TwoMachinesPlay) {
1785           if (appData.noChessProgram) {
1786             DisplayFatalError(_("TwoMachines mode requires a chess engine"),
1787                               0, 2);
1788             return;
1789           }
1790           if (appData.icsActive) {
1791             DisplayFatalError(_("TwoMachines mode does not work with ICS mode"),
1792                               0, 2);
1793             return;
1794           }
1795           TwoMachinesEvent();
1796         } else if (initialMode == EditGame) {
1797           EditGameEvent();
1798         } else if (initialMode == EditPosition) {
1799           EditPositionEvent();
1800         } else if (initialMode == Training) {
1801           if (*appData.loadGameFile == NULLCHAR) {
1802             DisplayFatalError(_("Training mode requires a game file"), 0, 2);
1803             return;
1804           }
1805           TrainingEvent();
1806         }
1807     }
1808 }
1809
1810 void
1811 HistorySet (char movelist[][2*MOVE_LEN], int first, int last, int current)
1812 {
1813     DisplayBook(current+1);
1814
1815     MoveHistorySet( movelist, first, last, current, pvInfoList );
1816
1817     EvalGraphSet( first, last, current, pvInfoList );
1818
1819     MakeEngineOutputTitle();
1820 }
1821
1822 /*
1823  * Establish will establish a contact to a remote host.port.
1824  * Sets icsPR to a ProcRef for a process (or pseudo-process)
1825  *  used to talk to the host.
1826  * Returns 0 if okay, error code if not.
1827  */
1828 int
1829 establish ()
1830 {
1831     char buf[MSG_SIZ];
1832
1833     if (*appData.icsCommPort != NULLCHAR) {
1834         /* Talk to the host through a serial comm port */
1835         return OpenCommPort(appData.icsCommPort, &icsPR);
1836
1837     } else if (*appData.gateway != NULLCHAR) {
1838         if (*appData.remoteShell == NULLCHAR) {
1839             /* Use the rcmd protocol to run telnet program on a gateway host */
1840             snprintf(buf, sizeof(buf), "%s %s %s",
1841                     appData.telnetProgram, appData.icsHost, appData.icsPort);
1842             return OpenRcmd(appData.gateway, appData.remoteUser, buf, &icsPR);
1843
1844         } else {
1845             /* Use the rsh program to run telnet program on a gateway host */
1846             if (*appData.remoteUser == NULLCHAR) {
1847                 snprintf(buf, sizeof(buf), "%s %s %s %s %s", appData.remoteShell,
1848                         appData.gateway, appData.telnetProgram,
1849                         appData.icsHost, appData.icsPort);
1850             } else {
1851                 snprintf(buf, sizeof(buf), "%s %s -l %s %s %s %s",
1852                         appData.remoteShell, appData.gateway,
1853                         appData.remoteUser, appData.telnetProgram,
1854                         appData.icsHost, appData.icsPort);
1855             }
1856             return StartChildProcess(buf, "", &icsPR);
1857
1858         }
1859     } else if (appData.useTelnet) {
1860         return OpenTelnet(appData.icsHost, appData.icsPort, &icsPR);
1861
1862     } else {
1863         /* TCP socket interface differs somewhat between
1864            Unix and NT; handle details in the front end.
1865            */
1866         return OpenTCP(appData.icsHost, appData.icsPort, &icsPR);
1867     }
1868 }
1869
1870 void
1871 EscapeExpand (char *p, char *q)
1872 {       // [HGM] initstring: routine to shape up string arguments
1873         while(*p++ = *q++) if(p[-1] == '\\')
1874             switch(*q++) {
1875                 case 'n': p[-1] = '\n'; break;
1876                 case 'r': p[-1] = '\r'; break;
1877                 case 't': p[-1] = '\t'; break;
1878                 case '\\': p[-1] = '\\'; break;
1879                 case 0: *p = 0; return;
1880                 default: p[-1] = q[-1]; break;
1881             }
1882 }
1883
1884 void
1885 show_bytes (FILE *fp, char *buf, int count)
1886 {
1887     while (count--) {
1888         if (*buf < 040 || *(unsigned char *) buf > 0177) {
1889             fprintf(fp, "\\%03o", *buf & 0xff);
1890         } else {
1891             putc(*buf, fp);
1892         }
1893         buf++;
1894     }
1895     fflush(fp);
1896 }
1897
1898 /* Returns an errno value */
1899 int
1900 OutputMaybeTelnet (ProcRef pr, char *message, int count, int *outError)
1901 {
1902     char buf[8192], *p, *q, *buflim;
1903     int left, newcount, outcount;
1904
1905     if (*appData.icsCommPort != NULLCHAR || appData.useTelnet ||
1906         *appData.gateway != NULLCHAR) {
1907         if (appData.debugMode) {
1908             fprintf(debugFP, ">ICS: ");
1909             show_bytes(debugFP, message, count);
1910             fprintf(debugFP, "\n");
1911         }
1912         return OutputToProcess(pr, message, count, outError);
1913     }
1914
1915     buflim = &buf[sizeof(buf)-1]; /* allow 1 byte for expanding last char */
1916     p = message;
1917     q = buf;
1918     left = count;
1919     newcount = 0;
1920     while (left) {
1921         if (q >= buflim) {
1922             if (appData.debugMode) {
1923                 fprintf(debugFP, ">ICS: ");
1924                 show_bytes(debugFP, buf, newcount);
1925                 fprintf(debugFP, "\n");
1926             }
1927             outcount = OutputToProcess(pr, buf, newcount, outError);
1928             if (outcount < newcount) return -1; /* to be sure */
1929             q = buf;
1930             newcount = 0;
1931         }
1932         if (*p == '\n') {
1933             *q++ = '\r';
1934             newcount++;
1935         } else if (((unsigned char) *p) == TN_IAC) {
1936             *q++ = (char) TN_IAC;
1937             newcount ++;
1938         }
1939         *q++ = *p++;
1940         newcount++;
1941         left--;
1942     }
1943     if (appData.debugMode) {
1944         fprintf(debugFP, ">ICS: ");
1945         show_bytes(debugFP, buf, newcount);
1946         fprintf(debugFP, "\n");
1947     }
1948     outcount = OutputToProcess(pr, buf, newcount, outError);
1949     if (outcount < newcount) return -1; /* to be sure */
1950     return count;
1951 }
1952
1953 void
1954 read_from_player (InputSourceRef isr, VOIDSTAR closure, char *message, int count, int error)
1955 {
1956     int outError, outCount;
1957     static int gotEof = 0;
1958     static FILE *ini;
1959
1960     /* Pass data read from player on to ICS */
1961     if (count > 0) {
1962         gotEof = 0;
1963         outCount = OutputMaybeTelnet(icsPR, message, count, &outError);
1964         if (outCount < count) {
1965             DisplayFatalError(_("Error writing to ICS"), outError, 1);
1966         }
1967         if(have_sent_ICS_logon == 2) {
1968           if(ini = fopen(appData.icsLogon, "w")) { // save first two lines (presumably username & password) on init script file
1969             fprintf(ini, "%s", message);
1970             have_sent_ICS_logon = 3;
1971           } else
1972             have_sent_ICS_logon = 1;
1973         } else if(have_sent_ICS_logon == 3) {
1974             fprintf(ini, "%s", message);
1975             fclose(ini);
1976           have_sent_ICS_logon = 1;
1977         }
1978     } else if (count < 0) {
1979         RemoveInputSource(isr);
1980         DisplayFatalError(_("Error reading from keyboard"), error, 1);
1981     } else if (gotEof++ > 0) {
1982         RemoveInputSource(isr);
1983         DisplayFatalError(_("Got end of file from keyboard"), 0, 0);
1984     }
1985 }
1986
1987 void
1988 KeepAlive ()
1989 {   // [HGM] alive: periodically send dummy (date) command to ICS to prevent time-out
1990     if(!connectionAlive) DisplayFatalError("No response from ICS", 0, 1);
1991     connectionAlive = FALSE; // only sticks if no response to 'date' command.
1992     SendToICS("date\n");
1993     if(appData.keepAlive) ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
1994 }
1995
1996 /* added routine for printf style output to ics */
1997 void
1998 ics_printf (char *format, ...)
1999 {
2000     char buffer[MSG_SIZ];
2001     va_list args;
2002
2003     va_start(args, format);
2004     vsnprintf(buffer, sizeof(buffer), format, args);
2005     buffer[sizeof(buffer)-1] = '\0';
2006     SendToICS(buffer);
2007     va_end(args);
2008 }
2009
2010 void
2011 SendToICS (char *s)
2012 {
2013     int count, outCount, outError;
2014
2015     if (icsPR == NoProc) return;
2016
2017     count = strlen(s);
2018     outCount = OutputMaybeTelnet(icsPR, s, count, &outError);
2019     if (outCount < count) {
2020         DisplayFatalError(_("Error writing to ICS"), outError, 1);
2021     }
2022 }
2023
2024 /* This is used for sending logon scripts to the ICS. Sending
2025    without a delay causes problems when using timestamp on ICC
2026    (at least on my machine). */
2027 void
2028 SendToICSDelayed (char *s, long msdelay)
2029 {
2030     int count, outCount, outError;
2031
2032     if (icsPR == NoProc) return;
2033
2034     count = strlen(s);
2035     if (appData.debugMode) {
2036         fprintf(debugFP, ">ICS: ");
2037         show_bytes(debugFP, s, count);
2038         fprintf(debugFP, "\n");
2039     }
2040     outCount = OutputToProcessDelayed(icsPR, s, count, &outError,
2041                                       msdelay);
2042     if (outCount < count) {
2043         DisplayFatalError(_("Error writing to ICS"), outError, 1);
2044     }
2045 }
2046
2047
2048 /* Remove all highlighting escape sequences in s
2049    Also deletes any suffix starting with '('
2050    */
2051 char *
2052 StripHighlightAndTitle (char *s)
2053 {
2054     static char retbuf[MSG_SIZ];
2055     char *p = retbuf;
2056
2057     while (*s != NULLCHAR) {
2058         while (*s == '\033') {
2059             while (*s != NULLCHAR && !isalpha(*s)) s++;
2060             if (*s != NULLCHAR) s++;
2061         }
2062         while (*s != NULLCHAR && *s != '\033') {
2063             if (*s == '(' || *s == '[') {
2064                 *p = NULLCHAR;
2065                 return retbuf;
2066             }
2067             *p++ = *s++;
2068         }
2069     }
2070     *p = NULLCHAR;
2071     return retbuf;
2072 }
2073
2074 /* Remove all highlighting escape sequences in s */
2075 char *
2076 StripHighlight (char *s)
2077 {
2078     static char retbuf[MSG_SIZ];
2079     char *p = retbuf;
2080
2081     while (*s != NULLCHAR) {
2082         while (*s == '\033') {
2083             while (*s != NULLCHAR && !isalpha(*s)) s++;
2084             if (*s != NULLCHAR) s++;
2085         }
2086         while (*s != NULLCHAR && *s != '\033') {
2087             *p++ = *s++;
2088         }
2089     }
2090     *p = NULLCHAR;
2091     return retbuf;
2092 }
2093
2094 char engineVariant[MSG_SIZ];
2095 char *variantNames[] = VARIANT_NAMES;
2096 char *
2097 VariantName (VariantClass v)
2098 {
2099     if(v == VariantUnknown || *engineVariant) return engineVariant;
2100     return variantNames[v];
2101 }
2102
2103
2104 /* Identify a variant from the strings the chess servers use or the
2105    PGN Variant tag names we use. */
2106 VariantClass
2107 StringToVariant (char *e)
2108 {
2109     char *p;
2110     int wnum = -1;
2111     VariantClass v = VariantNormal;
2112     int i, found = FALSE;
2113     char buf[MSG_SIZ], c;
2114     int len;
2115
2116     if (!e) return v;
2117
2118     /* [HGM] skip over optional board-size prefixes */
2119     if( sscanf(e, "%dx%d_%c", &i, &i, &c) == 3 ||
2120         sscanf(e, "%dx%d+%d_%c", &i, &i, &i, &c) == 4 ) {
2121         while( *e++ != '_');
2122     }
2123
2124     if(StrCaseStr(e, "misc/")) { // [HGM] on FICS, misc/shogi is not shogi
2125         v = VariantNormal;
2126         found = TRUE;
2127     } else
2128     for (i=0; i<sizeof(variantNames)/sizeof(char*); i++) {
2129       if (p = StrCaseStr(e, variantNames[i])) {
2130         if(p && i >= VariantShogi && (p != e || isalpha(p[strlen(variantNames[i])]))) continue;
2131         v = (VariantClass) i;
2132         found = TRUE;
2133         break;
2134       }
2135     }
2136
2137     if (!found) {
2138       if ((StrCaseStr(e, "fischer") && StrCaseStr(e, "random"))
2139           || StrCaseStr(e, "wild/fr")
2140           || StrCaseStr(e, "frc") || StrCaseStr(e, "960")) {
2141         v = VariantFischeRandom;
2142       } else if ((i = 4, p = StrCaseStr(e, "wild")) ||
2143                  (i = 1, p = StrCaseStr(e, "w"))) {
2144         p += i;
2145         while (*p && (isspace(*p) || *p == '(' || *p == '/')) p++;
2146         if (isdigit(*p)) {
2147           wnum = atoi(p);
2148         } else {
2149           wnum = -1;
2150         }
2151         switch (wnum) {
2152         case 0: /* FICS only, actually */
2153         case 1:
2154           /* Castling legal even if K starts on d-file */
2155           v = VariantWildCastle;
2156           break;
2157         case 2:
2158         case 3:
2159         case 4:
2160           /* Castling illegal even if K & R happen to start in
2161              normal positions. */
2162           v = VariantNoCastle;
2163           break;
2164         case 5:
2165         case 7:
2166         case 8:
2167         case 10:
2168         case 11:
2169         case 12:
2170         case 13:
2171         case 14:
2172         case 15:
2173         case 18:
2174         case 19:
2175           /* Castling legal iff K & R start in normal positions */
2176           v = VariantNormal;
2177           break;
2178         case 6:
2179         case 20:
2180         case 21:
2181           /* Special wilds for position setup; unclear what to do here */
2182           v = VariantLoadable;
2183           break;
2184         case 9:
2185           /* Bizarre ICC game */
2186           v = VariantTwoKings;
2187           break;
2188         case 16:
2189           v = VariantKriegspiel;
2190           break;
2191         case 17:
2192           v = VariantLosers;
2193           break;
2194         case 22:
2195           v = VariantFischeRandom;
2196           break;
2197         case 23:
2198           v = VariantCrazyhouse;
2199           break;
2200         case 24:
2201           v = VariantBughouse;
2202           break;
2203         case 25:
2204           v = Variant3Check;
2205           break;
2206         case 26:
2207           /* Not quite the same as FICS suicide! */
2208           v = VariantGiveaway;
2209           break;
2210         case 27:
2211           v = VariantAtomic;
2212           break;
2213         case 28:
2214           v = VariantShatranj;
2215           break;
2216
2217         /* Temporary names for future ICC types.  The name *will* change in
2218            the next xboard/WinBoard release after ICC defines it. */
2219         case 29:
2220           v = Variant29;
2221           break;
2222         case 30:
2223           v = Variant30;
2224           break;
2225         case 31:
2226           v = Variant31;
2227           break;
2228         case 32:
2229           v = Variant32;
2230           break;
2231         case 33:
2232           v = Variant33;
2233           break;
2234         case 34:
2235           v = Variant34;
2236           break;
2237         case 35:
2238           v = Variant35;
2239           break;
2240         case 36:
2241           v = Variant36;
2242           break;
2243         case 37:
2244           v = VariantShogi;
2245           break;
2246         case 38:
2247           v = VariantXiangqi;
2248           break;
2249         case 39:
2250           v = VariantCourier;
2251           break;
2252         case 40:
2253           v = VariantGothic;
2254           break;
2255         case 41:
2256           v = VariantCapablanca;
2257           break;
2258         case 42:
2259           v = VariantKnightmate;
2260           break;
2261         case 43:
2262           v = VariantFairy;
2263           break;
2264         case 44:
2265           v = VariantCylinder;
2266           break;
2267         case 45:
2268           v = VariantFalcon;
2269           break;
2270         case 46:
2271           v = VariantCapaRandom;
2272           break;
2273         case 47:
2274           v = VariantBerolina;
2275           break;
2276         case 48:
2277           v = VariantJanus;
2278           break;
2279         case 49:
2280           v = VariantSuper;
2281           break;
2282         case 50:
2283           v = VariantGreat;
2284           break;
2285         case -1:
2286           /* Found "wild" or "w" in the string but no number;
2287              must assume it's normal chess. */
2288           v = VariantNormal;
2289           break;
2290         default:
2291           len = snprintf(buf, MSG_SIZ, _("Unknown wild type %d"), wnum);
2292           if( (len >= MSG_SIZ) && appData.debugMode )
2293             fprintf(debugFP, "StringToVariant: buffer truncated.\n");
2294
2295           DisplayError(buf, 0);
2296           v = VariantUnknown;
2297           break;
2298         }
2299       }
2300     }
2301     if (appData.debugMode) {
2302       fprintf(debugFP, "recognized '%s' (%d) as variant %s\n",
2303               e, wnum, VariantName(v));
2304     }
2305     return v;
2306 }
2307
2308 static int leftover_start = 0, leftover_len = 0;
2309 char star_match[STAR_MATCH_N][MSG_SIZ];
2310
2311 /* Test whether pattern is present at &buf[*index]; if so, return TRUE,
2312    advance *index beyond it, and set leftover_start to the new value of
2313    *index; else return FALSE.  If pattern contains the character '*', it
2314    matches any sequence of characters not containing '\r', '\n', or the
2315    character following the '*' (if any), and the matched sequence(s) are
2316    copied into star_match.
2317    */
2318 int
2319 looking_at ( char *buf, int *index, char *pattern)
2320 {
2321     char *bufp = &buf[*index], *patternp = pattern;
2322     int star_count = 0;
2323     char *matchp = star_match[0];
2324
2325     for (;;) {
2326         if (*patternp == NULLCHAR) {
2327             *index = leftover_start = bufp - buf;
2328             *matchp = NULLCHAR;
2329             return TRUE;
2330         }
2331         if (*bufp == NULLCHAR) return FALSE;
2332         if (*patternp == '*') {
2333             if (*bufp == *(patternp + 1)) {
2334                 *matchp = NULLCHAR;
2335                 matchp = star_match[++star_count];
2336                 patternp += 2;
2337                 bufp++;
2338                 continue;
2339             } else if (*bufp == '\n' || *bufp == '\r') {
2340                 patternp++;
2341                 if (*patternp == NULLCHAR)
2342                   continue;
2343                 else
2344                   return FALSE;
2345             } else {
2346                 *matchp++ = *bufp++;
2347                 continue;
2348             }
2349         }
2350         if (*patternp != *bufp) return FALSE;
2351         patternp++;
2352         bufp++;
2353     }
2354 }
2355
2356 void
2357 SendToPlayer (char *data, int length)
2358 {
2359     int error, outCount;
2360     outCount = OutputToProcess(NoProc, data, length, &error);
2361     if (outCount < length) {
2362         DisplayFatalError(_("Error writing to display"), error, 1);
2363     }
2364 }
2365
2366 void
2367 PackHolding (char packed[], char *holding)
2368 {
2369     char *p = holding;
2370     char *q = packed;
2371     int runlength = 0;
2372     int curr = 9999;
2373     do {
2374         if (*p == curr) {
2375             runlength++;
2376         } else {
2377             switch (runlength) {
2378               case 0:
2379                 break;
2380               case 1:
2381                 *q++ = curr;
2382                 break;
2383               case 2:
2384                 *q++ = curr;
2385                 *q++ = curr;
2386                 break;
2387               default:
2388                 sprintf(q, "%d", runlength);
2389                 while (*q) q++;
2390                 *q++ = curr;
2391                 break;
2392             }
2393             runlength = 1;
2394             curr = *p;
2395         }
2396     } while (*p++);
2397     *q = NULLCHAR;
2398 }
2399
2400 /* Telnet protocol requests from the front end */
2401 void
2402 TelnetRequest (unsigned char ddww, unsigned char option)
2403 {
2404     unsigned char msg[3];
2405     int outCount, outError;
2406
2407     if (*appData.icsCommPort != NULLCHAR || appData.useTelnet) return;
2408
2409     if (appData.debugMode) {
2410         char buf1[8], buf2[8], *ddwwStr, *optionStr;
2411         switch (ddww) {
2412           case TN_DO:
2413             ddwwStr = "DO";
2414             break;
2415           case TN_DONT:
2416             ddwwStr = "DONT";
2417             break;
2418           case TN_WILL:
2419             ddwwStr = "WILL";
2420             break;
2421           case TN_WONT:
2422             ddwwStr = "WONT";
2423             break;
2424           default:
2425             ddwwStr = buf1;
2426             snprintf(buf1,sizeof(buf1)/sizeof(buf1[0]), "%d", ddww);
2427             break;
2428         }
2429         switch (option) {
2430           case TN_ECHO:
2431             optionStr = "ECHO";
2432             break;
2433           default:
2434             optionStr = buf2;
2435             snprintf(buf2,sizeof(buf2)/sizeof(buf2[0]), "%d", option);
2436             break;
2437         }
2438         fprintf(debugFP, ">%s %s ", ddwwStr, optionStr);
2439     }
2440     msg[0] = TN_IAC;
2441     msg[1] = ddww;
2442     msg[2] = option;
2443     outCount = OutputToProcess(icsPR, (char *)msg, 3, &outError);
2444     if (outCount < 3) {
2445         DisplayFatalError(_("Error writing to ICS"), outError, 1);
2446     }
2447 }
2448
2449 void
2450 DoEcho ()
2451 {
2452     if (!appData.icsActive) return;
2453     TelnetRequest(TN_DO, TN_ECHO);
2454 }
2455
2456 void
2457 DontEcho ()
2458 {
2459     if (!appData.icsActive) return;
2460     TelnetRequest(TN_DONT, TN_ECHO);
2461 }
2462
2463 void
2464 CopyHoldings (Board board, char *holdings, ChessSquare lowestPiece)
2465 {
2466     /* put the holdings sent to us by the server on the board holdings area */
2467     int i, j, holdingsColumn, holdingsStartRow, direction, countsColumn;
2468     char p;
2469     ChessSquare piece;
2470
2471     if(gameInfo.holdingsWidth < 2)  return;
2472     if(gameInfo.variant != VariantBughouse && board[HOLDINGS_SET])
2473         return; // prevent overwriting by pre-board holdings
2474
2475     if( (int)lowestPiece >= BlackPawn ) {
2476         holdingsColumn = 0;
2477         countsColumn = 1;
2478         holdingsStartRow = BOARD_HEIGHT-1;
2479         direction = -1;
2480     } else {
2481         holdingsColumn = BOARD_WIDTH-1;
2482         countsColumn = BOARD_WIDTH-2;
2483         holdingsStartRow = 0;
2484         direction = 1;
2485     }
2486
2487     for(i=0; i<BOARD_HEIGHT; i++) { /* clear holdings */
2488         board[i][holdingsColumn] = EmptySquare;
2489         board[i][countsColumn]   = (ChessSquare) 0;
2490     }
2491     while( (p=*holdings++) != NULLCHAR ) {
2492         piece = CharToPiece( ToUpper(p) );
2493         if(piece == EmptySquare) continue;
2494         /*j = (int) piece - (int) WhitePawn;*/
2495         j = PieceToNumber(piece);
2496         if(j >= gameInfo.holdingsSize) continue; /* ignore pieces that do not fit */
2497         if(j < 0) continue;               /* should not happen */
2498         piece = (ChessSquare) ( (int)piece + (int)lowestPiece );
2499         board[holdingsStartRow+j*direction][holdingsColumn] = piece;
2500         board[holdingsStartRow+j*direction][countsColumn]++;
2501     }
2502 }
2503
2504
2505 void
2506 VariantSwitch (Board board, VariantClass newVariant)
2507 {
2508    int newHoldingsWidth, newWidth = 8, newHeight = 8, i, j;
2509    static Board oldBoard;
2510
2511    startedFromPositionFile = FALSE;
2512    if(gameInfo.variant == newVariant) return;
2513
2514    /* [HGM] This routine is called each time an assignment is made to
2515     * gameInfo.variant during a game, to make sure the board sizes
2516     * are set to match the new variant. If that means adding or deleting
2517     * holdings, we shift the playing board accordingly
2518     * This kludge is needed because in ICS observe mode, we get boards
2519     * of an ongoing game without knowing the variant, and learn about the
2520     * latter only later. This can be because of the move list we requested,
2521     * in which case the game history is refilled from the beginning anyway,
2522     * but also when receiving holdings of a crazyhouse game. In the latter
2523     * case we want to add those holdings to the already received position.
2524     */
2525
2526
2527    if (appData.debugMode) {
2528      fprintf(debugFP, "Switch board from %s to %s\n",
2529              VariantName(gameInfo.variant), VariantName(newVariant));
2530      setbuf(debugFP, NULL);
2531    }
2532    shuffleOpenings = 0;       /* [HGM] shuffle */
2533    gameInfo.holdingsSize = 5; /* [HGM] prepare holdings */
2534    switch(newVariant)
2535      {
2536      case VariantShogi:
2537        newWidth = 9;  newHeight = 9;
2538        gameInfo.holdingsSize = 7;
2539      case VariantBughouse:
2540      case VariantCrazyhouse:
2541        newHoldingsWidth = 2; break;
2542      case VariantGreat:
2543        newWidth = 10;
2544      case VariantSuper:
2545        newHoldingsWidth = 2;
2546        gameInfo.holdingsSize = 8;
2547        break;
2548      case VariantGothic:
2549      case VariantCapablanca:
2550      case VariantCapaRandom:
2551        newWidth = 10;
2552      default:
2553        newHoldingsWidth = gameInfo.holdingsSize = 0;
2554      };
2555
2556    if(newWidth  != gameInfo.boardWidth  ||
2557       newHeight != gameInfo.boardHeight ||
2558       newHoldingsWidth != gameInfo.holdingsWidth ) {
2559
2560      /* shift position to new playing area, if needed */
2561      if(newHoldingsWidth > gameInfo.holdingsWidth) {
2562        for(i=0; i<BOARD_HEIGHT; i++)
2563          for(j=BOARD_RGHT-1; j>=BOARD_LEFT; j--)
2564            board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
2565              board[i][j];
2566        for(i=0; i<newHeight; i++) {
2567          board[i][0] = board[i][newWidth+2*newHoldingsWidth-1] = EmptySquare;
2568          board[i][1] = board[i][newWidth+2*newHoldingsWidth-2] = (ChessSquare) 0;
2569        }
2570      } else if(newHoldingsWidth < gameInfo.holdingsWidth) {
2571        for(i=0; i<BOARD_HEIGHT; i++)
2572          for(j=BOARD_LEFT; j<BOARD_RGHT; j++)
2573            board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
2574              board[i][j];
2575      }
2576      board[HOLDINGS_SET] = 0;
2577      gameInfo.boardWidth  = newWidth;
2578      gameInfo.boardHeight = newHeight;
2579      gameInfo.holdingsWidth = newHoldingsWidth;
2580      gameInfo.variant = newVariant;
2581      InitDrawingSizes(-2, 0);
2582    } else gameInfo.variant = newVariant;
2583    CopyBoard(oldBoard, board);   // remember correctly formatted board
2584      InitPosition(FALSE);          /* this sets up board[0], but also other stuff        */
2585    DrawPosition(TRUE, currentMove ? boards[currentMove] : oldBoard);
2586 }
2587
2588 static int loggedOn = FALSE;
2589
2590 /*-- Game start info cache: --*/
2591 int gs_gamenum;
2592 char gs_kind[MSG_SIZ];
2593 static char player1Name[128] = "";
2594 static char player2Name[128] = "";
2595 static char cont_seq[] = "\n\\   ";
2596 static int player1Rating = -1;
2597 static int player2Rating = -1;
2598 /*----------------------------*/
2599
2600 ColorClass curColor = ColorNormal;
2601 int suppressKibitz = 0;
2602
2603 // [HGM] seekgraph
2604 Boolean soughtPending = FALSE;
2605 Boolean seekGraphUp;
2606 #define MAX_SEEK_ADS 200
2607 #define SQUARE 0x80
2608 char *seekAdList[MAX_SEEK_ADS];
2609 int ratingList[MAX_SEEK_ADS], xList[MAX_SEEK_ADS], yList[MAX_SEEK_ADS], seekNrList[MAX_SEEK_ADS], zList[MAX_SEEK_ADS];
2610 float tcList[MAX_SEEK_ADS];
2611 char colorList[MAX_SEEK_ADS];
2612 int nrOfSeekAds = 0;
2613 int minRating = 1010, maxRating = 2800;
2614 int hMargin = 10, vMargin = 20, h, w;
2615 extern int squareSize, lineGap;
2616
2617 void
2618 PlotSeekAd (int i)
2619 {
2620         int x, y, color = 0, r = ratingList[i]; float tc = tcList[i];
2621         xList[i] = yList[i] = -100; // outside graph, so cannot be clicked
2622         if(r < minRating+100 && r >=0 ) r = minRating+100;
2623         if(r > maxRating) r = maxRating;
2624         if(tc < 1.f) tc = 1.f;
2625         if(tc > 95.f) tc = 95.f;
2626         x = (w-hMargin-squareSize/8-7)* log(tc)/log(95.) + hMargin;
2627         y = ((double)r - minRating)/(maxRating - minRating)
2628             * (h-vMargin-squareSize/8-1) + vMargin;
2629         if(ratingList[i] < 0) y = vMargin + squareSize/4;
2630         if(strstr(seekAdList[i], " u ")) color = 1;
2631         if(!strstr(seekAdList[i], "lightning") && // for now all wilds same color
2632            !strstr(seekAdList[i], "bullet") &&
2633            !strstr(seekAdList[i], "blitz") &&
2634            !strstr(seekAdList[i], "standard") ) color = 2;
2635         if(strstr(seekAdList[i], "(C) ")) color |= SQUARE; // plot computer seeks as squares
2636         DrawSeekDot(xList[i]=x+3*(color&~SQUARE), yList[i]=h-1-y, colorList[i]=color);
2637 }
2638
2639 void
2640 PlotSingleSeekAd (int i)
2641 {
2642         PlotSeekAd(i);
2643 }
2644
2645 void
2646 AddAd (char *handle, char *rating, int base, int inc,  char rated, char *type, int nr, Boolean plot)
2647 {
2648         char buf[MSG_SIZ], *ext = "";
2649         VariantClass v = StringToVariant(type);
2650         if(strstr(type, "wild")) {
2651             ext = type + 4; // append wild number
2652             if(v == VariantFischeRandom) type = "chess960"; else
2653             if(v == VariantLoadable) type = "setup"; else
2654             type = VariantName(v);
2655         }
2656         snprintf(buf, MSG_SIZ, "%s (%s) %d %d %c %s%s", handle, rating, base, inc, rated, type, ext);
2657         if(nrOfSeekAds < MAX_SEEK_ADS-1) {
2658             if(seekAdList[nrOfSeekAds]) free(seekAdList[nrOfSeekAds]);
2659             ratingList[nrOfSeekAds] = -1; // for if seeker has no rating
2660             sscanf(rating, "%d", &ratingList[nrOfSeekAds]);
2661             tcList[nrOfSeekAds] = base + (2./3.)*inc;
2662             seekNrList[nrOfSeekAds] = nr;
2663             zList[nrOfSeekAds] = 0;
2664             seekAdList[nrOfSeekAds++] = StrSave(buf);
2665             if(plot) PlotSingleSeekAd(nrOfSeekAds-1);
2666         }
2667 }
2668
2669 void
2670 EraseSeekDot (int i)
2671 {
2672     int x = xList[i], y = yList[i], d=squareSize/4, k;
2673     DrawSeekBackground(x-squareSize/8, y-squareSize/8, x+squareSize/8+1, y+squareSize/8+1);
2674     if(x < hMargin+d) DrawSeekAxis(hMargin, y-squareSize/8, hMargin, y+squareSize/8+1);
2675     // now replot every dot that overlapped
2676     for(k=0; k<nrOfSeekAds; k++) if(k != i) {
2677         int xx = xList[k], yy = yList[k];
2678         if(xx <= x+d && xx > x-d && yy <= y+d && yy > y-d)
2679             DrawSeekDot(xx, yy, colorList[k]);
2680     }
2681 }
2682
2683 void
2684 RemoveSeekAd (int nr)
2685 {
2686         int i;
2687         for(i=0; i<nrOfSeekAds; i++) if(seekNrList[i] == nr) {
2688             EraseSeekDot(i);
2689             if(seekAdList[i]) free(seekAdList[i]);
2690             seekAdList[i] = seekAdList[--nrOfSeekAds];
2691             seekNrList[i] = seekNrList[nrOfSeekAds];
2692             ratingList[i] = ratingList[nrOfSeekAds];
2693             colorList[i]  = colorList[nrOfSeekAds];
2694             tcList[i] = tcList[nrOfSeekAds];
2695             xList[i]  = xList[nrOfSeekAds];
2696             yList[i]  = yList[nrOfSeekAds];
2697             zList[i]  = zList[nrOfSeekAds];
2698             seekAdList[nrOfSeekAds] = NULL;
2699             break;
2700         }
2701 }
2702
2703 Boolean
2704 MatchSoughtLine (char *line)
2705 {
2706     char handle[MSG_SIZ], rating[MSG_SIZ], type[MSG_SIZ];
2707     int nr, base, inc, u=0; char dummy;
2708
2709     if(sscanf(line, "%d %s %s %d %d rated %s", &nr, rating, handle, &base, &inc, type) == 6 ||
2710        sscanf(line, "%d %s %s %s %d %d rated %c", &nr, rating, handle, type, &base, &inc, &dummy) == 7 ||
2711        (u=1) &&
2712        (sscanf(line, "%d %s %s %d %d unrated %s", &nr, rating, handle, &base, &inc, type) == 6 ||
2713         sscanf(line, "%d %s %s %s %d %d unrated %c", &nr, rating, handle, type, &base, &inc, &dummy) == 7)  ) {
2714         // match: compact and save the line
2715         AddAd(handle, rating, base, inc, u ? 'u' : 'r', type, nr, FALSE);
2716         return TRUE;
2717     }
2718     return FALSE;
2719 }
2720
2721 int
2722 DrawSeekGraph ()
2723 {
2724     int i;
2725     if(!seekGraphUp) return FALSE;
2726     h = BOARD_HEIGHT * (squareSize + lineGap) + lineGap + 2*border;
2727     w = BOARD_WIDTH  * (squareSize + lineGap) + lineGap + 2*border;
2728
2729     DrawSeekBackground(0, 0, w, h);
2730     DrawSeekAxis(hMargin, h-1-vMargin, w-5, h-1-vMargin);
2731     DrawSeekAxis(hMargin, h-1-vMargin, hMargin, 5);
2732     for(i=0; i<4000; i+= 100) if(i>=minRating && i<maxRating) {
2733         int yy =((double)i - minRating)/(maxRating - minRating)*(h-vMargin-squareSize/8-1) + vMargin;
2734         yy = h-1-yy;
2735         DrawSeekAxis(hMargin-5, yy, hMargin+5*(i%500==0), yy); // rating ticks
2736         if(i%500 == 0) {
2737             char buf[MSG_SIZ];
2738             snprintf(buf, MSG_SIZ, "%d", i);
2739             DrawSeekText(buf, hMargin+squareSize/8+7, yy);
2740         }
2741     }
2742     DrawSeekText("unrated", hMargin+squareSize/8+7, h-1-vMargin-squareSize/4);
2743     for(i=1; i<100; i+=(i<10?1:5)) {
2744         int xx = (w-hMargin-squareSize/8-7)* log((double)i)/log(95.) + hMargin;
2745         DrawSeekAxis(xx, h-1-vMargin, xx, h-6-vMargin-3*(i%10==0)); // TC ticks
2746         if(i<=5 || (i>40 ? i%20 : i%10) == 0) {
2747             char buf[MSG_SIZ];
2748             snprintf(buf, MSG_SIZ, "%d", i);
2749             DrawSeekText(buf, xx-2-3*(i>9), h-1-vMargin/2);
2750         }
2751     }
2752     for(i=0; i<nrOfSeekAds; i++) PlotSeekAd(i);
2753     return TRUE;
2754 }
2755
2756 int
2757 SeekGraphClick (ClickType click, int x, int y, int moving)
2758 {
2759     static int lastDown = 0, displayed = 0, lastSecond;
2760     if(y < 0) return FALSE;
2761     if(!(appData.seekGraph && appData.icsActive && loggedOn &&
2762         (gameMode == BeginningOfGame || gameMode == IcsIdle))) {
2763         if(!seekGraphUp) return FALSE;
2764         seekGraphUp = FALSE; // seek graph is up when it shouldn't be: take it down
2765         DrawPosition(TRUE, NULL);
2766         return TRUE;
2767     }
2768     if(!seekGraphUp) { // initiate cration of seek graph by requesting seek-ad list
2769         if(click == Release || moving) return FALSE;
2770         nrOfSeekAds = 0;
2771         soughtPending = TRUE;
2772         SendToICS(ics_prefix);
2773         SendToICS("sought\n"); // should this be "sought all"?
2774     } else { // issue challenge based on clicked ad
2775         int dist = 10000; int i, closest = 0, second = 0;
2776         for(i=0; i<nrOfSeekAds; i++) {
2777             int d = (x-xList[i])*(x-xList[i]) +  (y-yList[i])*(y-yList[i]) + zList[i];
2778             if(d < dist) { dist = d; closest = i; }
2779             second += (d - zList[i] < 120); // count in-range ads
2780             if(click == Press && moving != 1 && zList[i]>0) zList[i] *= 0.8; // age priority
2781         }
2782         if(dist < 120) {
2783             char buf[MSG_SIZ];
2784             second = (second > 1);
2785             if(displayed != closest || second != lastSecond) {
2786                 DisplayMessage(second ? "!" : "", seekAdList[closest]);
2787                 lastSecond = second; displayed = closest;
2788             }
2789             if(click == Press) {
2790                 if(moving == 2) zList[closest] = 100; // right-click; push to back on press
2791                 lastDown = closest;
2792                 return TRUE;
2793             } // on press 'hit', only show info
2794             if(moving == 2) return TRUE; // ignore right up-clicks on dot
2795             snprintf(buf, MSG_SIZ, "play %d\n", seekNrList[closest]);
2796             SendToICS(ics_prefix);
2797             SendToICS(buf);
2798             return TRUE; // let incoming board of started game pop down the graph
2799         } else if(click == Release) { // release 'miss' is ignored
2800             zList[lastDown] = 100; // make future selection of the rejected ad more difficult
2801             if(moving == 2) { // right up-click
2802                 nrOfSeekAds = 0; // refresh graph
2803                 soughtPending = TRUE;
2804                 SendToICS(ics_prefix);
2805                 SendToICS("sought\n"); // should this be "sought all"?
2806             }
2807             return TRUE;
2808         } else if(moving) { if(displayed >= 0) DisplayMessage("", ""); displayed = -1; return TRUE; }
2809         // press miss or release hit 'pop down' seek graph
2810         seekGraphUp = FALSE;
2811         DrawPosition(TRUE, NULL);
2812     }
2813     return TRUE;
2814 }
2815
2816 void
2817 read_from_ics (InputSourceRef isr, VOIDSTAR closure, char *data, int count, int error)
2818 {
2819 #define BUF_SIZE (16*1024) /* overflowed at 8K with "inchannel 1" on FICS? */
2820 #define STARTED_NONE 0
2821 #define STARTED_MOVES 1
2822 #define STARTED_BOARD 2
2823 #define STARTED_OBSERVE 3
2824 #define STARTED_HOLDINGS 4
2825 #define STARTED_CHATTER 5
2826 #define STARTED_COMMENT 6
2827 #define STARTED_MOVES_NOHIDE 7
2828
2829     static int started = STARTED_NONE;
2830     static char parse[20000];
2831     static int parse_pos = 0;
2832     static char buf[BUF_SIZE + 1];
2833     static int firstTime = TRUE, intfSet = FALSE;
2834     static ColorClass prevColor = ColorNormal;
2835     static int savingComment = FALSE;
2836     static int cmatch = 0; // continuation sequence match
2837     char *bp;
2838     char str[MSG_SIZ];
2839     int i, oldi;
2840     int buf_len;
2841     int next_out;
2842     int tkind;
2843     int backup;    /* [DM] For zippy color lines */
2844     char *p;
2845     char talker[MSG_SIZ]; // [HGM] chat
2846     int channel, collective=0;
2847
2848     connectionAlive = TRUE; // [HGM] alive: I think, therefore I am...
2849
2850     if (appData.debugMode) {
2851       if (!error) {
2852         fprintf(debugFP, "<ICS: ");
2853         show_bytes(debugFP, data, count);
2854         fprintf(debugFP, "\n");
2855       }
2856     }
2857
2858     if (appData.debugMode) { int f = forwardMostMove;
2859         fprintf(debugFP, "ics input %d, castling = %d %d %d %d %d %d\n", f,
2860                 boards[f][CASTLING][0],boards[f][CASTLING][1],boards[f][CASTLING][2],
2861                 boards[f][CASTLING][3],boards[f][CASTLING][4],boards[f][CASTLING][5]);
2862     }
2863     if (count > 0) {
2864         /* If last read ended with a partial line that we couldn't parse,
2865            prepend it to the new read and try again. */
2866         if (leftover_len > 0) {
2867             for (i=0; i<leftover_len; i++)
2868               buf[i] = buf[leftover_start + i];
2869         }
2870
2871     /* copy new characters into the buffer */
2872     bp = buf + leftover_len;
2873     buf_len=leftover_len;
2874     for (i=0; i<count; i++)
2875     {
2876         // ignore these
2877         if (data[i] == '\r')
2878             continue;
2879
2880         // join lines split by ICS?
2881         if (!appData.noJoin)
2882         {
2883             /*
2884                 Joining just consists of finding matches against the
2885                 continuation sequence, and discarding that sequence
2886                 if found instead of copying it.  So, until a match
2887                 fails, there's nothing to do since it might be the
2888                 complete sequence, and thus, something we don't want
2889                 copied.
2890             */
2891             if (data[i] == cont_seq[cmatch])
2892             {
2893                 cmatch++;
2894                 if (cmatch == strlen(cont_seq))
2895                 {
2896                     cmatch = 0; // complete match.  just reset the counter
2897
2898                     /*
2899                         it's possible for the ICS to not include the space
2900                         at the end of the last word, making our [correct]
2901                         join operation fuse two separate words.  the server
2902                         does this when the space occurs at the width setting.
2903                     */
2904                     if (!buf_len || buf[buf_len-1] != ' ')
2905                     {
2906                         *bp++ = ' ';
2907                         buf_len++;
2908                     }
2909                 }
2910                 continue;
2911             }
2912             else if (cmatch)
2913             {
2914                 /*
2915                     match failed, so we have to copy what matched before
2916                     falling through and copying this character.  In reality,
2917                     this will only ever be just the newline character, but
2918                     it doesn't hurt to be precise.
2919                 */
2920                 strncpy(bp, cont_seq, cmatch);
2921                 bp += cmatch;
2922                 buf_len += cmatch;
2923                 cmatch = 0;
2924             }
2925         }
2926
2927         // copy this char
2928         *bp++ = data[i];
2929         buf_len++;
2930     }
2931
2932         buf[buf_len] = NULLCHAR;
2933 //      next_out = leftover_len; // [HGM] should we set this to 0, and not print it in advance?
2934         next_out = 0;
2935         leftover_start = 0;
2936
2937         i = 0;
2938         while (i < buf_len) {
2939             /* Deal with part of the TELNET option negotiation
2940                protocol.  We refuse to do anything beyond the
2941                defaults, except that we allow the WILL ECHO option,
2942                which ICS uses to turn off password echoing when we are
2943                directly connected to it.  We reject this option
2944                if localLineEditing mode is on (always on in xboard)
2945                and we are talking to port 23, which might be a real
2946                telnet server that will try to keep WILL ECHO on permanently.
2947              */
2948             if (buf_len - i >= 3 && (unsigned char) buf[i] == TN_IAC) {
2949                 static int remoteEchoOption = FALSE; /* telnet ECHO option */
2950                 unsigned char option;
2951                 oldi = i;
2952                 switch ((unsigned char) buf[++i]) {
2953                   case TN_WILL:
2954                     if (appData.debugMode)
2955                       fprintf(debugFP, "\n<WILL ");
2956                     switch (option = (unsigned char) buf[++i]) {
2957                       case TN_ECHO:
2958                         if (appData.debugMode)
2959                           fprintf(debugFP, "ECHO ");
2960                         /* Reply only if this is a change, according
2961                            to the protocol rules. */
2962                         if (remoteEchoOption) break;
2963                         if (appData.localLineEditing &&
2964                             atoi(appData.icsPort) == TN_PORT) {
2965                             TelnetRequest(TN_DONT, TN_ECHO);
2966                         } else {
2967                             EchoOff();
2968                             TelnetRequest(TN_DO, TN_ECHO);
2969                             remoteEchoOption = TRUE;
2970                         }
2971                         break;
2972                       default:
2973                         if (appData.debugMode)
2974                           fprintf(debugFP, "%d ", option);
2975                         /* Whatever this is, we don't want it. */
2976                         TelnetRequest(TN_DONT, option);
2977                         break;
2978                     }
2979                     break;
2980                   case TN_WONT:
2981                     if (appData.debugMode)
2982                       fprintf(debugFP, "\n<WONT ");
2983                     switch (option = (unsigned char) buf[++i]) {
2984                       case TN_ECHO:
2985                         if (appData.debugMode)
2986                           fprintf(debugFP, "ECHO ");
2987                         /* Reply only if this is a change, according
2988                            to the protocol rules. */
2989                         if (!remoteEchoOption) break;
2990                         EchoOn();
2991                         TelnetRequest(TN_DONT, TN_ECHO);
2992                         remoteEchoOption = FALSE;
2993                         break;
2994                       default:
2995                         if (appData.debugMode)
2996                           fprintf(debugFP, "%d ", (unsigned char) option);
2997                         /* Whatever this is, it must already be turned
2998                            off, because we never agree to turn on
2999                            anything non-default, so according to the
3000                            protocol rules, we don't reply. */
3001                         break;
3002                     }
3003                     break;
3004                   case TN_DO:
3005                     if (appData.debugMode)
3006                       fprintf(debugFP, "\n<DO ");
3007                     switch (option = (unsigned char) buf[++i]) {
3008                       default:
3009                         /* Whatever this is, we refuse to do it. */
3010                         if (appData.debugMode)
3011                           fprintf(debugFP, "%d ", option);
3012                         TelnetRequest(TN_WONT, option);
3013                         break;
3014                     }
3015                     break;
3016                   case TN_DONT:
3017                     if (appData.debugMode)
3018                       fprintf(debugFP, "\n<DONT ");
3019                     switch (option = (unsigned char) buf[++i]) {
3020                       default:
3021                         if (appData.debugMode)
3022                           fprintf(debugFP, "%d ", option);
3023                         /* Whatever this is, we are already not doing
3024                            it, because we never agree to do anything
3025                            non-default, so according to the protocol
3026                            rules, we don't reply. */
3027                         break;
3028                     }
3029                     break;
3030                   case TN_IAC:
3031                     if (appData.debugMode)
3032                       fprintf(debugFP, "\n<IAC ");
3033                     /* Doubled IAC; pass it through */
3034                     i--;
3035                     break;
3036                   default:
3037                     if (appData.debugMode)
3038                       fprintf(debugFP, "\n<%d ", (unsigned char) buf[i]);
3039                     /* Drop all other telnet commands on the floor */
3040                     break;
3041                 }
3042                 if (oldi > next_out)
3043                   SendToPlayer(&buf[next_out], oldi - next_out);
3044                 if (++i > next_out)
3045                   next_out = i;
3046                 continue;
3047             }
3048
3049             /* OK, this at least will *usually* work */
3050             if (!loggedOn && looking_at(buf, &i, "ics%")) {
3051                 loggedOn = TRUE;
3052             }
3053
3054             if (loggedOn && !intfSet) {
3055                 if (ics_type == ICS_ICC) {
3056                   snprintf(str, MSG_SIZ,
3057                           "/set-quietly interface %s\n/set-quietly style 12\n",
3058                           programVersion);
3059                   if(appData.seekGraph && appData.autoRefresh) // [HGM] seekgraph
3060                       strcat(str, "/set-2 51 1\n/set seek 1\n");
3061                 } else if (ics_type == ICS_CHESSNET) {
3062                   snprintf(str, MSG_SIZ, "/style 12\n");
3063                 } else {
3064                   safeStrCpy(str, "alias $ @\n$set interface ", sizeof(str)/sizeof(str[0]));
3065                   strcat(str, programVersion);
3066                   strcat(str, "\n$iset startpos 1\n$iset ms 1\n");
3067                   if(appData.seekGraph && appData.autoRefresh) // [HGM] seekgraph
3068                       strcat(str, "$iset seekremove 1\n$set seek 1\n");
3069 #ifdef WIN32
3070                   strcat(str, "$iset nohighlight 1\n");
3071 #endif
3072                   strcat(str, "$iset lock 1\n$style 12\n");
3073                 }
3074                 SendToICS(str);
3075                 NotifyFrontendLogin();
3076                 intfSet = TRUE;
3077             }
3078
3079             if (started == STARTED_COMMENT) {
3080                 /* Accumulate characters in comment */
3081                 parse[parse_pos++] = buf[i];
3082                 if (buf[i] == '\n') {
3083                     parse[parse_pos] = NULLCHAR;
3084                     if(chattingPartner>=0) {
3085                         char mess[MSG_SIZ];
3086                         snprintf(mess, MSG_SIZ, "%s%s", talker, parse);
3087                         OutputChatMessage(chattingPartner, mess);
3088                         if(collective == 1) { // broadcasted talk also goes to private chatbox of talker
3089                             int p;
3090                             talker[strlen(talker+1)-1] = NULLCHAR; // strip closing delimiter
3091                             for(p=0; p<MAX_CHAT; p++) if(!StrCaseCmp(talker+1, chatPartner[p])) {
3092                                 snprintf(mess, MSG_SIZ, "%s: %s", chatPartner[chattingPartner], parse);
3093                                 OutputChatMessage(p, mess);
3094                                 break;
3095                             }
3096                         }
3097                         chattingPartner = -1;
3098                         if(collective != 3) next_out = i+1; // [HGM] suppress printing in ICS window
3099                         collective = 0;
3100                     } else
3101                     if(!suppressKibitz) // [HGM] kibitz
3102                         AppendComment(forwardMostMove, StripHighlight(parse), TRUE);
3103                     else { // [HGM kibitz: divert memorized engine kibitz to engine-output window
3104                         int nrDigit = 0, nrAlph = 0, j;
3105                         if(parse_pos > MSG_SIZ - 30) // defuse unreasonably long input
3106                         { parse_pos = MSG_SIZ-30; parse[parse_pos - 1] = '\n'; }
3107                         parse[parse_pos] = NULLCHAR;
3108                         // try to be smart: if it does not look like search info, it should go to
3109                         // ICS interaction window after all, not to engine-output window.
3110                         for(j=0; j<parse_pos; j++) { // count letters and digits
3111                             nrDigit += (parse[j] >= '0' && parse[j] <= '9');
3112                             nrAlph  += (parse[j] >= 'a' && parse[j] <= 'z');
3113                             nrAlph  += (parse[j] >= 'A' && parse[j] <= 'Z');
3114                         }
3115                         if(nrAlph < 9*nrDigit) { // if more than 10% digit we assume search info
3116                             int depth=0; float score;
3117                             if(sscanf(parse, "!!! %f/%d", &score, &depth) == 2 && depth>0) {
3118                                 // [HGM] kibitz: save kibitzed opponent info for PGN and eval graph
3119                                 pvInfoList[forwardMostMove-1].depth = depth;
3120                                 pvInfoList[forwardMostMove-1].score = 100*score;
3121                             }
3122                             OutputKibitz(suppressKibitz, parse);
3123                         } else {
3124                             char tmp[MSG_SIZ];
3125                             if(gameMode == IcsObserving) // restore original ICS messages
3126                               /* TRANSLATORS: to 'kibitz' is to send a message to all players and the game observers */
3127                               snprintf(tmp, MSG_SIZ, "%s kibitzes: %s", star_match[0], parse);
3128                             else
3129                             /* TRANSLATORS: to 'kibitz' is to send a message to all players and the game observers */
3130                             snprintf(tmp, MSG_SIZ, _("your opponent kibitzes: %s"), parse);
3131                             SendToPlayer(tmp, strlen(tmp));
3132                         }
3133                         next_out = i+1; // [HGM] suppress printing in ICS window
3134                     }
3135                     started = STARTED_NONE;
3136                 } else {
3137                     /* Don't match patterns against characters in comment */
3138                     i++;
3139                     continue;
3140                 }
3141             }
3142             if (started == STARTED_CHATTER) {
3143                 if (buf[i] != '\n') {
3144                     /* Don't match patterns against characters in chatter */
3145                     i++;
3146                     continue;
3147                 }
3148                 started = STARTED_NONE;
3149                 if(suppressKibitz) next_out = i+1;
3150             }
3151
3152             /* Kludge to deal with rcmd protocol */
3153             if (firstTime && looking_at(buf, &i, "\001*")) {
3154                 DisplayFatalError(&buf[1], 0, 1);
3155                 continue;
3156             } else {
3157                 firstTime = FALSE;
3158             }
3159
3160             if (!loggedOn && looking_at(buf, &i, "chessclub.com")) {
3161                 ics_type = ICS_ICC;
3162                 ics_prefix = "/";
3163                 if (appData.debugMode)
3164                   fprintf(debugFP, "ics_type %d\n", ics_type);
3165                 continue;
3166             }
3167             if (!loggedOn && looking_at(buf, &i, "freechess.org")) {
3168                 ics_type = ICS_FICS;
3169                 ics_prefix = "$";
3170                 if (appData.debugMode)
3171                   fprintf(debugFP, "ics_type %d\n", ics_type);
3172                 continue;
3173             }
3174             if (!loggedOn && looking_at(buf, &i, "chess.net")) {
3175                 ics_type = ICS_CHESSNET;
3176                 ics_prefix = "/";
3177                 if (appData.debugMode)
3178                   fprintf(debugFP, "ics_type %d\n", ics_type);
3179                 continue;
3180             }
3181
3182             if (!loggedOn &&
3183                 (looking_at(buf, &i, "\"*\" is *a registered name") ||
3184                  looking_at(buf, &i, "Logging you in as \"*\"") ||
3185                  looking_at(buf, &i, "will be \"*\""))) {
3186               safeStrCpy(ics_handle, star_match[0], sizeof(ics_handle)/sizeof(ics_handle[0]));
3187               continue;
3188             }
3189
3190             if (loggedOn && !have_set_title && ics_handle[0] != NULLCHAR) {
3191               char buf[MSG_SIZ];
3192               snprintf(buf, sizeof(buf), "%s@%s", ics_handle, appData.icsHost);
3193               DisplayIcsInteractionTitle(buf);
3194               have_set_title = TRUE;
3195             }
3196
3197             /* skip finger notes */
3198             if (started == STARTED_NONE &&
3199                 ((buf[i] == ' ' && isdigit(buf[i+1])) ||
3200                  (buf[i] == '1' && buf[i+1] == '0')) &&
3201                 buf[i+2] == ':' && buf[i+3] == ' ') {
3202               started = STARTED_CHATTER;
3203               i += 3;
3204               continue;
3205             }
3206
3207             oldi = i;
3208             // [HGM] seekgraph: recognize sought lines and end-of-sought message
3209             if(appData.seekGraph) {
3210                 if(soughtPending && MatchSoughtLine(buf+i)) {
3211                     i = strstr(buf+i, "rated") - buf;
3212                     if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
3213                     next_out = leftover_start = i;
3214                     started = STARTED_CHATTER;
3215                     suppressKibitz = TRUE;
3216                     continue;
3217                 }
3218                 if((gameMode == IcsIdle || gameMode == BeginningOfGame)
3219                         && looking_at(buf, &i, "* ads displayed")) {
3220                     soughtPending = FALSE;
3221                     seekGraphUp = TRUE;
3222                     DrawSeekGraph();
3223                     continue;
3224                 }
3225                 if(appData.autoRefresh) {
3226                     if(looking_at(buf, &i, "* (*) seeking * * * * *\"play *\" to respond)\n")) {
3227                         int s = (ics_type == ICS_ICC); // ICC format differs
3228                         if(seekGraphUp)
3229                         AddAd(star_match[0], star_match[1], atoi(star_match[2+s]), atoi(star_match[3+s]),
3230                               star_match[4+s][0], star_match[5-3*s], atoi(star_match[7]), TRUE);
3231                         looking_at(buf, &i, "*% "); // eat prompt
3232                         if(oldi > 0 && buf[oldi-1] == '\n') oldi--; // suppress preceding LF, if any
3233                         if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
3234                         next_out = i; // suppress
3235                         continue;
3236                     }
3237                     if(looking_at(buf, &i, "\nAds removed: *\n") || looking_at(buf, &i, "\031(51 * *\031)")) {
3238                         char *p = star_match[0];
3239                         while(*p) {
3240                             if(seekGraphUp) RemoveSeekAd(atoi(p));
3241                             while(*p && *p++ != ' '); // next
3242                         }
3243                         looking_at(buf, &i, "*% "); // eat prompt
3244                         if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
3245                         next_out = i;
3246                         continue;
3247                     }
3248                 }
3249             }
3250
3251             /* skip formula vars */
3252             if (started == STARTED_NONE &&
3253                 buf[i] == 'f' && isdigit(buf[i+1]) && buf[i+2] == ':') {
3254               started = STARTED_CHATTER;
3255               i += 3;
3256               continue;
3257             }
3258
3259             // [HGM] kibitz: try to recognize opponent engine-score kibitzes, to divert them to engine-output window
3260             if (appData.autoKibitz && started == STARTED_NONE &&
3261                 !appData.icsEngineAnalyze &&                     // [HGM] [DM] ICS analyze
3262                 (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack || gameMode == IcsObserving)) {
3263                 if((looking_at(buf, &i, "\n* kibitzes: ") || looking_at(buf, &i, "\n* whispers: ") ||
3264                     looking_at(buf, &i, "* kibitzes: ") || looking_at(buf, &i, "* whispers: ")) &&
3265                    (StrStr(star_match[0], gameInfo.white) == star_match[0] ||
3266                     StrStr(star_match[0], gameInfo.black) == star_match[0]   )) { // kibitz of self or opponent
3267                         suppressKibitz = TRUE;
3268                         if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
3269                         next_out = i;
3270                         if((StrStr(star_match[0], gameInfo.white) == star_match[0]
3271                                 && (gameMode == IcsPlayingWhite)) ||
3272                            (StrStr(star_match[0], gameInfo.black) == star_match[0]
3273                                 && (gameMode == IcsPlayingBlack))   ) // opponent kibitz
3274                             started = STARTED_CHATTER; // own kibitz we simply discard
3275                         else {
3276                             started = STARTED_COMMENT; // make sure it will be collected in parse[]
3277                             parse_pos = 0; parse[0] = NULLCHAR;
3278                             savingComment = TRUE;
3279                             suppressKibitz = gameMode != IcsObserving ? 2 :
3280                                 (StrStr(star_match[0], gameInfo.white) == NULL) + 1;
3281                         }
3282                         continue;
3283                 } else
3284                 if((looking_at(buf, &i, "\nkibitzed to *\n") || looking_at(buf, &i, "kibitzed to *\n") ||
3285                     looking_at(buf, &i, "\n(kibitzed to *\n") || looking_at(buf, &i, "(kibitzed to *\n"))
3286                          && atoi(star_match[0])) {
3287                     // suppress the acknowledgements of our own autoKibitz
3288                     char *p;
3289                     if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
3290                     if(p = strchr(star_match[0], ' ')) p[1] = NULLCHAR; // clip off "players)" on FICS
3291                     SendToPlayer(star_match[0], strlen(star_match[0]));
3292                     if(looking_at(buf, &i, "*% ")) // eat prompt
3293                         suppressKibitz = FALSE;
3294                     next_out = i;
3295                     continue;
3296                 }
3297             } // [HGM] kibitz: end of patch
3298
3299             if(looking_at(buf, &i, "* rating adjustment: * --> *\n")) continue;
3300
3301             // [HGM] chat: intercept tells by users for which we have an open chat window
3302             channel = -1;
3303             if(started == STARTED_NONE && (looking_at(buf, &i, "* tells you:") || looking_at(buf, &i, "* says:") ||
3304                                            looking_at(buf, &i, "* whispers:") ||
3305                                            looking_at(buf, &i, "* kibitzes:") ||
3306                                            looking_at(buf, &i, "* shouts:") ||
3307                                            looking_at(buf, &i, "* c-shouts:") ||
3308                                            looking_at(buf, &i, "--> * ") ||
3309                                            looking_at(buf, &i, "*(*):") && (sscanf(star_match[1], "%d", &channel),1) ||
3310                                            looking_at(buf, &i, "*(*)(*):") && (sscanf(star_match[2], "%d", &channel),1) ||
3311                                            looking_at(buf, &i, "*(*)(*)(*):") && (sscanf(star_match[3], "%d", &channel),1) ||
3312                                            looking_at(buf, &i, "*(*)(*)(*)(*):") && sscanf(star_match[4], "%d", &channel) == 1 )) {
3313                 int p;
3314                 sscanf(star_match[0], "%[^(]", talker+1); // strip (C) or (U) off ICS handle
3315                 chattingPartner = -1; collective = 0;
3316
3317                 if(channel >= 0) // channel broadcast; look if there is a chatbox for this channel
3318                 for(p=0; p<MAX_CHAT; p++) {
3319                     collective = 1;
3320                     if(chatPartner[p][0] >= '0' && chatPartner[p][0] <= '9' && channel == atoi(chatPartner[p])) {
3321                     talker[0] = '['; strcat(talker, "] ");
3322                     Colorize((channel == 1 ? ColorChannel1 : ColorChannel), FALSE);
3323                     chattingPartner = p; break;
3324                     }
3325                 } else
3326                 if(buf[i-3] == 'e') // kibitz; look if there is a KIBITZ chatbox
3327                 for(p=0; p<MAX_CHAT; p++) {
3328                     collective = 1;
3329                     if(!strcmp("kibitzes", chatPartner[p])) {
3330                         talker[0] = '['; strcat(talker, "] ");
3331                         chattingPartner = p; break;
3332                     }
3333                 } else
3334                 if(buf[i-3] == 'r') // whisper; look if there is a WHISPER chatbox
3335                 for(p=0; p<MAX_CHAT; p++) {
3336                     collective = 1;
3337                     if(!strcmp("whispers", chatPartner[p])) {
3338                         talker[0] = '['; strcat(talker, "] ");
3339                         chattingPartner = p; break;
3340                     }
3341                 } else
3342                 if(buf[i-3] == 't' || buf[oldi+2] == '>') {// shout, c-shout or it; look if there is a 'shouts' chatbox
3343                   if(buf[i-8] == '-' && buf[i-3] == 't')
3344                   for(p=0; p<MAX_CHAT; p++) { // c-shout; check if dedicatesd c-shout box exists
3345                     collective = 1;
3346                     if(!strcmp("c-shouts", chatPartner[p])) {
3347                         talker[0] = '('; strcat(talker, ") "); Colorize(ColorSShout, FALSE);
3348                         chattingPartner = p; break;
3349                     }
3350                   }
3351                   if(chattingPartner < 0)
3352                   for(p=0; p<MAX_CHAT; p++) {
3353                     collective = 1;
3354                     if(!strcmp("shouts", chatPartner[p])) {
3355                         if(buf[oldi+2] == '>') { talker[0] = '<'; strcat(talker, "> "); Colorize(ColorShout, FALSE); }
3356                         else if(buf[i-8] == '-') { talker[0] = '('; strcat(talker, ") "); Colorize(ColorSShout, FALSE); }
3357                         else { talker[0] = '['; strcat(talker, "] "); Colorize(ColorShout, FALSE); }
3358                         chattingPartner = p; break;
3359                     }
3360                   }
3361                 }
3362                 if(chattingPartner<0) // if not, look if there is a chatbox for this indivdual
3363                 for(p=0; p<MAX_CHAT; p++) if(!StrCaseCmp(talker+1, chatPartner[p])) {
3364                     talker[0] = 0;
3365                     Colorize(ColorTell, FALSE);
3366                     if(collective) safeStrCpy(talker, "broadcasts: ", MSG_SIZ);
3367                     collective |= 2;
3368                     chattingPartner = p; break;
3369                 }
3370                 if(chattingPartner<0) i = oldi, safeStrCpy(lastTalker, talker+1, MSG_SIZ); else {
3371                     Colorize(curColor, TRUE); // undo the bogus colorations we just made to trigger the souds
3372                     started = STARTED_COMMENT;
3373                     parse_pos = 0; parse[0] = NULLCHAR;
3374                     savingComment = 3 + chattingPartner; // counts as TRUE
3375                     if(collective == 3) i = oldi; else {
3376                         suppressKibitz = TRUE;
3377                         if(oldi > 0 && buf[oldi-1] == '\n') oldi--;
3378                         if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
3379                         continue;
3380                     }
3381                 }
3382             } // [HGM] chat: end of patch
3383
3384           backup = i;
3385             if (appData.zippyTalk || appData.zippyPlay) {
3386                 /* [DM] Backup address for color zippy lines */
3387 #if ZIPPY
3388                if (loggedOn == TRUE)
3389                        if (ZippyControl(buf, &backup) || ZippyConverse(buf, &backup) ||
3390                           (appData.zippyPlay && ZippyMatch(buf, &backup)));
3391 #endif
3392             } // [DM] 'else { ' deleted
3393                 if (
3394                     /* Regular tells and says */
3395                     (tkind = 1, looking_at(buf, &i, "* tells you: ")) ||
3396                     looking_at(buf, &i, "* (your partner) tells you: ") ||
3397                     looking_at(buf, &i, "* says: ") ||
3398                     /* Don't color "message" or "messages" output */
3399                     (tkind = 5, looking_at(buf, &i, "*. * (*:*): ")) ||
3400                     looking_at(buf, &i, "*. * at *:*: ") ||
3401                     looking_at(buf, &i, "--* (*:*): ") ||
3402                     /* Message notifications (same color as tells) */
3403                     looking_at(buf, &i, "* has left a message ") ||
3404                     looking_at(buf, &i, "* just sent you a message:\n") ||
3405                     /* Whispers and kibitzes */
3406                     (tkind = 2, looking_at(buf, &i, "* whispers: ")) ||
3407                     looking_at(buf, &i, "* kibitzes: ") ||
3408                     /* Channel tells */
3409                     (tkind = 3, looking_at(buf, &i, "*(*: "))) {
3410
3411                   if (tkind == 1 && strchr(star_match[0], ':')) {
3412                       /* Avoid "tells you:" spoofs in channels */
3413                      tkind = 3;
3414                   }
3415                   if (star_match[0][0] == NULLCHAR ||
3416                       strchr(star_match[0], ' ') ||
3417                       (tkind == 3 && strchr(star_match[1], ' '))) {
3418                     /* Reject bogus matches */
3419                     i = oldi;
3420                   } else {
3421                     if (appData.colorize) {
3422                       if (oldi > next_out) {
3423                         SendToPlayer(&buf[next_out], oldi - next_out);
3424                         next_out = oldi;
3425                       }
3426                       switch (tkind) {
3427                       case 1:
3428                         Colorize(ColorTell, FALSE);
3429                         curColor = ColorTell;
3430                         break;
3431                       case 2:
3432                         Colorize(ColorKibitz, FALSE);
3433                         curColor = ColorKibitz;
3434                         break;
3435                       case 3:
3436                         p = strrchr(star_match[1], '(');
3437                         if (p == NULL) {
3438                           p = star_match[1];
3439                         } else {
3440                           p++;
3441                         }
3442                         if (atoi(p) == 1) {
3443                           Colorize(ColorChannel1, FALSE);
3444                           curColor = ColorChannel1;
3445                         } else {
3446                           Colorize(ColorChannel, FALSE);
3447                           curColor = ColorChannel;
3448                         }
3449                         break;
3450                       case 5:
3451                         curColor = ColorNormal;
3452                         break;
3453                       }
3454                     }
3455                     if (started == STARTED_NONE && appData.autoComment &&
3456                         (gameMode == IcsObserving ||
3457                          gameMode == IcsPlayingWhite ||
3458                          gameMode == IcsPlayingBlack)) {
3459                       parse_pos = i - oldi;
3460                       memcpy(parse, &buf[oldi], parse_pos);
3461                       parse[parse_pos] = NULLCHAR;
3462                       started = STARTED_COMMENT;
3463                       savingComment = TRUE;
3464                     } else if(collective != 3) {
3465                       started = STARTED_CHATTER;
3466                       savingComment = FALSE;
3467                     }
3468                     loggedOn = TRUE;
3469                     continue;
3470                   }
3471                 }
3472
3473                 if (looking_at(buf, &i, "* s-shouts: ") ||
3474                     looking_at(buf, &i, "* c-shouts: ")) {
3475                     if (appData.colorize) {
3476                         if (oldi > next_out) {
3477                             SendToPlayer(&buf[next_out], oldi - next_out);
3478                             next_out = oldi;
3479                         }
3480                         Colorize(ColorSShout, FALSE);
3481                         curColor = ColorSShout;
3482                     }
3483                     loggedOn = TRUE;
3484                     started = STARTED_CHATTER;
3485                     continue;
3486                 }
3487
3488                 if (looking_at(buf, &i, "--->")) {
3489                     loggedOn = TRUE;
3490                     continue;
3491                 }
3492
3493                 if (looking_at(buf, &i, "* shouts: ") ||
3494                     looking_at(buf, &i, "--> ")) {
3495                     if (appData.colorize) {
3496                         if (oldi > next_out) {
3497                             SendToPlayer(&buf[next_out], oldi - next_out);
3498                             next_out = oldi;
3499                         }
3500                         Colorize(ColorShout, FALSE);
3501                         curColor = ColorShout;
3502                     }
3503                     loggedOn = TRUE;
3504                     started = STARTED_CHATTER;
3505                     continue;
3506                 }
3507
3508                 if (looking_at( buf, &i, "Challenge:")) {
3509                     if (appData.colorize) {
3510                         if (oldi > next_out) {
3511                             SendToPlayer(&buf[next_out], oldi - next_out);
3512                             next_out = oldi;
3513                         }
3514                         Colorize(ColorChallenge, FALSE);
3515                         curColor = ColorChallenge;
3516                     }
3517                     loggedOn = TRUE;
3518                     continue;
3519                 }
3520
3521                 if (looking_at(buf, &i, "* offers you") ||
3522                     looking_at(buf, &i, "* offers to be") ||
3523                     looking_at(buf, &i, "* would like to") ||
3524                     looking_at(buf, &i, "* requests to") ||
3525                     looking_at(buf, &i, "Your opponent offers") ||
3526                     looking_at(buf, &i, "Your opponent requests")) {
3527
3528                     if (appData.colorize) {
3529                         if (oldi > next_out) {
3530                             SendToPlayer(&buf[next_out], oldi - next_out);
3531                             next_out = oldi;
3532                         }
3533                         Colorize(ColorRequest, FALSE);
3534                         curColor = ColorRequest;
3535                     }
3536                     continue;
3537                 }
3538
3539                 if (looking_at(buf, &i, "* (*) seeking")) {
3540                     if (appData.colorize) {
3541                         if (oldi > next_out) {
3542                             SendToPlayer(&buf[next_out], oldi - next_out);
3543                             next_out = oldi;
3544                         }
3545                         Colorize(ColorSeek, FALSE);
3546                         curColor = ColorSeek;
3547                     }
3548                     continue;
3549             }
3550
3551           if(i < backup) { i = backup; continue; } // [HGM] for if ZippyControl matches, but the colorie code doesn't
3552
3553             if (looking_at(buf, &i, "\\   ")) {
3554                 if (prevColor != ColorNormal) {
3555                     if (oldi > next_out) {
3556                         SendToPlayer(&buf[next_out], oldi - next_out);
3557                         next_out = oldi;
3558                     }
3559                     Colorize(prevColor, TRUE);
3560                     curColor = prevColor;
3561                 }
3562                 if (savingComment) {
3563                     parse_pos = i - oldi;
3564                     memcpy(parse, &buf[oldi], parse_pos);
3565                     parse[parse_pos] = NULLCHAR;
3566                     started = STARTED_COMMENT;
3567                     if(savingComment >= 3) // [HGM] chat: continuation of line for chat box
3568                         chattingPartner = savingComment - 3; // kludge to remember the box
3569                 } else {
3570                     started = STARTED_CHATTER;
3571                 }
3572                 continue;
3573             }
3574
3575             if (looking_at(buf, &i, "Black Strength :") ||
3576                 looking_at(buf, &i, "<<< style 10 board >>>") ||
3577                 looking_at(buf, &i, "<10>") ||
3578                 looking_at(buf, &i, "#@#")) {
3579                 /* Wrong board style */
3580                 loggedOn = TRUE;
3581                 SendToICS(ics_prefix);
3582                 SendToICS("set style 12\n");
3583                 SendToICS(ics_prefix);
3584                 SendToICS("refresh\n");
3585                 continue;
3586             }
3587
3588             if (looking_at(buf, &i, "login:")) {
3589               if (!have_sent_ICS_logon) {
3590                 if(ICSInitScript())
3591                   have_sent_ICS_logon = 1;
3592                 else // no init script was found
3593                   have_sent_ICS_logon = (appData.autoCreateLogon ? 2 : 1); // flag that we should capture username + password
3594               } else { // we have sent (or created) the InitScript, but apparently the ICS rejected it
3595                   have_sent_ICS_logon = (appData.autoCreateLogon ? 2 : 1); // request creation of a new script
3596               }
3597                 continue;
3598             }
3599
3600             if (ics_getting_history != H_GETTING_MOVES /*smpos kludge*/ &&
3601                 (looking_at(buf, &i, "\n<12> ") ||
3602                  looking_at(buf, &i, "<12> "))) {
3603                 loggedOn = TRUE;
3604                 if (oldi > next_out) {
3605                     SendToPlayer(&buf[next_out], oldi - next_out);
3606                 }
3607                 next_out = i;
3608                 started = STARTED_BOARD;
3609                 parse_pos = 0;
3610                 continue;
3611             }
3612
3613             if ((started == STARTED_NONE && looking_at(buf, &i, "\n<b1> ")) ||
3614                 looking_at(buf, &i, "<b1> ")) {
3615                 if (oldi > next_out) {
3616                     SendToPlayer(&buf[next_out], oldi - next_out);
3617                 }
3618                 next_out = i;
3619                 started = STARTED_HOLDINGS;
3620                 parse_pos = 0;
3621                 continue;
3622             }
3623
3624             if (looking_at(buf, &i, "* *vs. * *--- *")) {
3625                 loggedOn = TRUE;
3626                 /* Header for a move list -- first line */
3627
3628                 switch (ics_getting_history) {
3629                   case H_FALSE:
3630                     switch (gameMode) {
3631                       case IcsIdle:
3632                       case BeginningOfGame:
3633                         /* User typed "moves" or "oldmoves" while we
3634                            were idle.  Pretend we asked for these
3635                            moves and soak them up so user can step
3636                            through them and/or save them.
3637                            */
3638                         Reset(FALSE, TRUE);
3639                         gameMode = IcsObserving;
3640                         ModeHighlight();
3641                         ics_gamenum = -1;
3642                         ics_getting_history = H_GOT_UNREQ_HEADER;
3643                         break;
3644                       case EditGame: /*?*/
3645                       case EditPosition: /*?*/
3646                         /* Should above feature work in these modes too? */
3647                         /* For now it doesn't */
3648                         ics_getting_history = H_GOT_UNWANTED_HEADER;
3649                         break;
3650                       default:
3651                         ics_getting_history = H_GOT_UNWANTED_HEADER;
3652                         break;
3653                     }
3654                     break;
3655                   case H_REQUESTED:
3656                     /* Is this the right one? */
3657                     if (gameInfo.white && gameInfo.black &&
3658                         strcmp(gameInfo.white, star_match[0]) == 0 &&
3659                         strcmp(gameInfo.black, star_match[2]) == 0) {
3660                         /* All is well */
3661                         ics_getting_history = H_GOT_REQ_HEADER;
3662                     }
3663                     break;
3664                   case H_GOT_REQ_HEADER:
3665                   case H_GOT_UNREQ_HEADER:
3666                   case H_GOT_UNWANTED_HEADER:
3667                   case H_GETTING_MOVES:
3668                     /* Should not happen */
3669                     DisplayError(_("Error gathering move list: two headers"), 0);
3670                     ics_getting_history = H_FALSE;
3671                     break;
3672                 }
3673
3674                 /* Save player ratings into gameInfo if needed */
3675                 if ((ics_getting_history == H_GOT_REQ_HEADER ||
3676                      ics_getting_history == H_GOT_UNREQ_HEADER) &&
3677                     (gameInfo.whiteRating == -1 ||
3678                      gameInfo.blackRating == -1)) {
3679
3680                     gameInfo.whiteRating = string_to_rating(star_match[1]);
3681                     gameInfo.blackRating = string_to_rating(star_match[3]);
3682                     if (appData.debugMode)
3683                       fprintf(debugFP, "Ratings from header: W %d, B %d\n",
3684                               gameInfo.whiteRating, gameInfo.blackRating);
3685                 }
3686                 continue;
3687             }
3688
3689             if (looking_at(buf, &i,
3690               "* * match, initial time: * minute*, increment: * second")) {
3691                 /* Header for a move list -- second line */
3692                 /* Initial board will follow if this is a wild game */
3693                 if (gameInfo.event != NULL) free(gameInfo.event);
3694                 snprintf(str, MSG_SIZ, "ICS %s %s match", star_match[0], star_match[1]);
3695                 gameInfo.event = StrSave(str);
3696                 /* [HGM] we switched variant. Translate boards if needed. */
3697                 VariantSwitch(boards[currentMove], StringToVariant(gameInfo.event));
3698                 continue;
3699             }
3700
3701             if (looking_at(buf, &i, "Move  ")) {
3702                 /* Beginning of a move list */
3703                 switch (ics_getting_history) {
3704                   case H_FALSE:
3705                     /* Normally should not happen */
3706                     /* Maybe user hit reset while we were parsing */
3707                     break;
3708                   case H_REQUESTED:
3709                     /* Happens if we are ignoring a move list that is not
3710                      * the one we just requested.  Common if the user
3711                      * tries to observe two games without turning off
3712                      * getMoveList */
3713                     break;
3714                   case H_GETTING_MOVES:
3715                     /* Should not happen */
3716                     DisplayError(_("Error gathering move list: nested"), 0);
3717                     ics_getting_history = H_FALSE;
3718                     break;
3719                   case H_GOT_REQ_HEADER:
3720                     ics_getting_history = H_GETTING_MOVES;
3721                     started = STARTED_MOVES;
3722                     parse_pos = 0;
3723                     if (oldi > next_out) {
3724                         SendToPlayer(&buf[next_out], oldi - next_out);
3725                     }
3726                     break;
3727                   case H_GOT_UNREQ_HEADER:
3728                     ics_getting_history = H_GETTING_MOVES;
3729                     started = STARTED_MOVES_NOHIDE;
3730                     parse_pos = 0;
3731                     break;
3732                   case H_GOT_UNWANTED_HEADER:
3733                     ics_getting_history = H_FALSE;
3734                     break;
3735                 }
3736                 continue;
3737             }
3738
3739             if (looking_at(buf, &i, "% ") ||
3740                 ((started == STARTED_MOVES || started == STARTED_MOVES_NOHIDE)
3741                  && looking_at(buf, &i, "}*"))) { char *bookHit = NULL; // [HGM] book
3742                 if(soughtPending && nrOfSeekAds) { // [HGM] seekgraph: on ICC sought-list has no termination line
3743                     soughtPending = FALSE;
3744                     seekGraphUp = TRUE;
3745                     DrawSeekGraph();
3746                 }
3747                 if(suppressKibitz) next_out = i;
3748                 savingComment = FALSE;
3749                 suppressKibitz = 0;
3750                 switch (started) {
3751                   case STARTED_MOVES:
3752                   case STARTED_MOVES_NOHIDE:
3753                     memcpy(&parse[parse_pos], &buf[oldi], i - oldi);
3754                     parse[parse_pos + i - oldi] = NULLCHAR;
3755                     ParseGameHistory(parse);
3756 #if ZIPPY
3757                     if (appData.zippyPlay && first.initDone) {
3758                         FeedMovesToProgram(&first, forwardMostMove);
3759                         if (gameMode == IcsPlayingWhite) {
3760                             if (WhiteOnMove(forwardMostMove)) {
3761                                 if (first.sendTime) {
3762                                   if (first.useColors) {
3763                                     SendToProgram("black\n", &first);
3764                                   }
3765                                   SendTimeRemaining(&first, TRUE);
3766                                 }
3767                                 if (first.useColors) {
3768                                   SendToProgram("white\n", &first); // [HGM] book: made sending of "go\n" book dependent
3769                                 }
3770                                 bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: probe book for initial pos
3771                                 first.maybeThinking = TRUE;
3772                             } else {
3773                                 if (first.usePlayother) {
3774                                   if (first.sendTime) {
3775                                     SendTimeRemaining(&first, TRUE);
3776                                   }
3777                                   SendToProgram("playother\n", &first);
3778                                   firstMove = FALSE;
3779                                 } else {
3780                                   firstMove = TRUE;
3781                                 }
3782                             }
3783                         } else if (gameMode == IcsPlayingBlack) {
3784                             if (!WhiteOnMove(forwardMostMove)) {
3785                                 if (first.sendTime) {
3786                                   if (first.useColors) {
3787                                     SendToProgram("white\n", &first);
3788                                   }
3789                                   SendTimeRemaining(&first, FALSE);
3790                                 }
3791                                 if (first.useColors) {
3792                                   SendToProgram("black\n", &first);
3793                                 }
3794                                 bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE);
3795                                 first.maybeThinking = TRUE;
3796                             } else {
3797                                 if (first.usePlayother) {
3798                                   if (first.sendTime) {
3799                                     SendTimeRemaining(&first, FALSE);
3800                                   }
3801                                   SendToProgram("playother\n", &first);
3802                                   firstMove = FALSE;
3803                                 } else {
3804                                   firstMove = TRUE;
3805                                 }
3806                             }
3807                         }
3808                     }
3809 #endif
3810                     if (gameMode == IcsObserving && ics_gamenum == -1) {
3811                         /* Moves came from oldmoves or moves command
3812                            while we weren't doing anything else.
3813                            */
3814                         currentMove = forwardMostMove;
3815                         ClearHighlights();/*!!could figure this out*/
3816                         flipView = appData.flipView;
3817                         DrawPosition(TRUE, boards[currentMove]);
3818                         DisplayBothClocks();
3819                         snprintf(str, MSG_SIZ, "%s %s %s",
3820                                 gameInfo.white, _("vs."),  gameInfo.black);
3821                         DisplayTitle(str);
3822                         gameMode = IcsIdle;
3823                     } else {
3824                         /* Moves were history of an active game */
3825                         if (gameInfo.resultDetails != NULL) {
3826                             free(gameInfo.resultDetails);
3827                             gameInfo.resultDetails = NULL;
3828                         }
3829                     }
3830                     HistorySet(parseList, backwardMostMove,
3831                                forwardMostMove, currentMove-1);
3832                     DisplayMove(currentMove - 1);
3833                     if (started == STARTED_MOVES) next_out = i;
3834                     started = STARTED_NONE;
3835                     ics_getting_history = H_FALSE;
3836                     break;
3837
3838                   case STARTED_OBSERVE:
3839                     started = STARTED_NONE;
3840                     SendToICS(ics_prefix);
3841                     SendToICS("refresh\n");
3842                     break;
3843
3844                   default:
3845                     break;
3846                 }
3847                 if(bookHit) { // [HGM] book: simulate book reply
3848                     static char bookMove[MSG_SIZ]; // a bit generous?
3849
3850                     programStats.nodes = programStats.depth = programStats.time =
3851                     programStats.score = programStats.got_only_move = 0;
3852                     sprintf(programStats.movelist, "%s (xbook)", bookHit);
3853
3854                     safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
3855                     strcat(bookMove, bookHit);
3856                     HandleMachineMove(bookMove, &first);
3857                 }
3858                 continue;
3859             }
3860
3861             if ((started == STARTED_MOVES || started == STARTED_BOARD ||
3862                  started == STARTED_HOLDINGS ||
3863                  started == STARTED_MOVES_NOHIDE) && i >= leftover_len) {
3864                 /* Accumulate characters in move list or board */
3865                 parse[parse_pos++] = buf[i];
3866             }
3867
3868             /* Start of game messages.  Mostly we detect start of game
3869                when the first board image arrives.  On some versions
3870                of the ICS, though, we need to do a "refresh" after starting
3871                to observe in order to get the current board right away. */
3872             if (looking_at(buf, &i, "Adding game * to observation list")) {
3873                 started = STARTED_OBSERVE;
3874                 continue;
3875             }
3876
3877             /* Handle auto-observe */
3878             if (appData.autoObserve &&
3879                 (gameMode == IcsIdle || gameMode == BeginningOfGame) &&
3880                 looking_at(buf, &i, "Game notification: * (*) vs. * (*)")) {
3881                 char *player;
3882                 /* Choose the player that was highlighted, if any. */
3883                 if (star_match[0][0] == '\033' ||
3884                     star_match[1][0] != '\033') {
3885                     player = star_match[0];
3886                 } else {
3887                     player = star_match[2];
3888                 }
3889                 snprintf(str, MSG_SIZ, "%sobserve %s\n",
3890                         ics_prefix, StripHighlightAndTitle(player));
3891                 SendToICS(str);
3892
3893                 /* Save ratings from notify string */
3894                 safeStrCpy(player1Name, star_match[0], sizeof(player1Name)/sizeof(player1Name[0]));
3895                 player1Rating = string_to_rating(star_match[1]);
3896                 safeStrCpy(player2Name, star_match[2], sizeof(player2Name)/sizeof(player2Name[0]));
3897                 player2Rating = string_to_rating(star_match[3]);
3898
3899                 if (appData.debugMode)
3900                   fprintf(debugFP,
3901                           "Ratings from 'Game notification:' %s %d, %s %d\n",
3902                           player1Name, player1Rating,
3903                           player2Name, player2Rating);
3904
3905                 continue;
3906             }
3907
3908             /* Deal with automatic examine mode after a game,
3909                and with IcsObserving -> IcsExamining transition */
3910             if (looking_at(buf, &i, "Entering examine mode for game *") ||
3911                 looking_at(buf, &i, "has made you an examiner of game *")) {
3912
3913                 int gamenum = atoi(star_match[0]);
3914                 if ((gameMode == IcsIdle || gameMode == IcsObserving) &&
3915                     gamenum == ics_gamenum) {
3916                     /* We were already playing or observing this game;
3917                        no need to refetch history */
3918                     gameMode = IcsExamining;
3919                     if (pausing) {
3920                         pauseExamForwardMostMove = forwardMostMove;
3921                     } else if (currentMove < forwardMostMove) {
3922                         ForwardInner(forwardMostMove);
3923                     }
3924                 } else {
3925                     /* I don't think this case really can happen */
3926                     SendToICS(ics_prefix);
3927                     SendToICS("refresh\n");
3928                 }
3929                 continue;
3930             }
3931
3932             /* Error messages */
3933 //          if (ics_user_moved) {
3934             if (1) { // [HGM] old way ignored error after move type in; ics_user_moved is not set then!
3935                 if (looking_at(buf, &i, "Illegal move") ||
3936                     looking_at(buf, &i, "Not a legal move") ||
3937                     looking_at(buf, &i, "Your king is in check") ||
3938                     looking_at(buf, &i, "It isn't your turn") ||
3939                     looking_at(buf, &i, "It is not your move")) {
3940                     /* Illegal move */
3941                     if (ics_user_moved && forwardMostMove > backwardMostMove) { // only backup if we already moved
3942                         currentMove = forwardMostMove-1;
3943                         DisplayMove(currentMove - 1); /* before DMError */
3944                         DrawPosition(FALSE, boards[currentMove]);
3945                         SwitchClocks(forwardMostMove-1); // [HGM] race
3946                         DisplayBothClocks();
3947                     }
3948                     DisplayMoveError(_("Illegal move (rejected by ICS)")); // [HGM] but always relay error msg
3949                     ics_user_moved = 0;
3950                     continue;
3951                 }
3952             }
3953
3954             if (looking_at(buf, &i, "still have time") ||
3955                 looking_at(buf, &i, "not out of time") ||
3956                 looking_at(buf, &i, "either player is out of time") ||
3957                 looking_at(buf, &i, "has timeseal; checking")) {
3958                 /* We must have called his flag a little too soon */
3959                 whiteFlag = blackFlag = FALSE;
3960                 continue;
3961             }
3962
3963             if (looking_at(buf, &i, "added * seconds to") ||
3964                 looking_at(buf, &i, "seconds were added to")) {
3965                 /* Update the clocks */
3966                 SendToICS(ics_prefix);
3967                 SendToICS("refresh\n");
3968                 continue;
3969             }
3970
3971             if (!ics_clock_paused && looking_at(buf, &i, "clock paused")) {
3972                 ics_clock_paused = TRUE;
3973                 StopClocks();
3974                 continue;
3975             }
3976
3977             if (ics_clock_paused && looking_at(buf, &i, "clock resumed")) {
3978                 ics_clock_paused = FALSE;
3979                 StartClocks();
3980                 continue;
3981             }
3982
3983             /* Grab player ratings from the Creating: message.
3984                Note we have to check for the special case when
3985                the ICS inserts things like [white] or [black]. */
3986             if (looking_at(buf, &i, "Creating: * (*)* * (*)") ||
3987                 looking_at(buf, &i, "Creating: * (*) [*] * (*)")) {
3988                 /* star_matches:
3989                    0    player 1 name (not necessarily white)
3990                    1    player 1 rating
3991                    2    empty, white, or black (IGNORED)
3992                    3    player 2 name (not necessarily black)
3993                    4    player 2 rating
3994
3995                    The names/ratings are sorted out when the game
3996                    actually starts (below).
3997                 */
3998                 safeStrCpy(player1Name, StripHighlightAndTitle(star_match[0]), sizeof(player1Name)/sizeof(player1Name[0]));
3999                 player1Rating = string_to_rating(star_match[1]);
4000                 safeStrCpy(player2Name, StripHighlightAndTitle(star_match[3]), sizeof(player2Name)/sizeof(player2Name[0]));
4001                 player2Rating = string_to_rating(star_match[4]);
4002
4003                 if (appData.debugMode)
4004                   fprintf(debugFP,
4005                           "Ratings from 'Creating:' %s %d, %s %d\n",
4006                           player1Name, player1Rating,
4007                           player2Name, player2Rating);
4008
4009                 continue;
4010             }
4011
4012             /* Improved generic start/end-of-game messages */
4013             if ((tkind=0, looking_at(buf, &i, "{Game * (* vs. *) *}*")) ||
4014                 (tkind=1, looking_at(buf, &i, "{Game * (*(*) vs. *(*)) *}*"))){
4015                 /* If tkind == 0: */
4016                 /* star_match[0] is the game number */
4017                 /*           [1] is the white player's name */
4018                 /*           [2] is the black player's name */
4019                 /* For end-of-game: */
4020                 /*           [3] is the reason for the game end */
4021                 /*           [4] is a PGN end game-token, preceded by " " */
4022                 /* For start-of-game: */
4023                 /*           [3] begins with "Creating" or "Continuing" */
4024                 /*           [4] is " *" or empty (don't care). */
4025                 int gamenum = atoi(star_match[0]);
4026                 char *whitename, *blackname, *why, *endtoken;
4027                 ChessMove endtype = EndOfFile;
4028
4029                 if (tkind == 0) {
4030                   whitename = star_match[1];
4031                   blackname = star_match[2];
4032                   why = star_match[3];
4033                   endtoken = star_match[4];
4034                 } else {
4035                   whitename = star_match[1];
4036                   blackname = star_match[3];
4037                   why = star_match[5];
4038                   endtoken = star_match[6];
4039                 }
4040
4041                 /* Game start messages */
4042                 if (strncmp(why, "Creating ", 9) == 0 ||
4043                     strncmp(why, "Continuing ", 11) == 0) {
4044                     gs_gamenum = gamenum;
4045                     safeStrCpy(gs_kind, strchr(why, ' ') + 1,sizeof(gs_kind)/sizeof(gs_kind[0]));
4046                     if(ics_gamenum == -1) // [HGM] only if we are not already involved in a game (because gin=1 sends us such messages)
4047                     VariantSwitch(boards[currentMove], StringToVariant(gs_kind)); // [HGM] variantswitch: even before we get first board
4048 #if ZIPPY
4049                     if (appData.zippyPlay) {
4050                         ZippyGameStart(whitename, blackname);
4051                     }
4052 #endif /*ZIPPY*/
4053                     partnerBoardValid = FALSE; // [HGM] bughouse
4054                     continue;
4055                 }
4056
4057                 /* Game end messages */
4058                 if (gameMode == IcsIdle || gameMode == BeginningOfGame ||
4059                     ics_gamenum != gamenum) {
4060                     continue;
4061                 }
4062                 while (endtoken[0] == ' ') endtoken++;
4063                 switch (endtoken[0]) {
4064                   case '*':
4065                   default:
4066                     endtype = GameUnfinished;
4067                     break;
4068                   case '0':
4069                     endtype = BlackWins;
4070                     break;
4071                   case '1':
4072                     if (endtoken[1] == '/')
4073                       endtype = GameIsDrawn;
4074                     else
4075                       endtype = WhiteWins;
4076                     break;
4077                 }
4078                 GameEnds(endtype, why, GE_ICS);
4079 #if ZIPPY
4080                 if (appData.zippyPlay && first.initDone) {
4081                     ZippyGameEnd(endtype, why);
4082                     if (first.pr == NoProc) {
4083                       /* Start the next process early so that we'll
4084                          be ready for the next challenge */
4085                       StartChessProgram(&first);
4086                     }
4087                     /* Send "new" early, in case this command takes
4088                        a long time to finish, so that we'll be ready
4089                        for the next challenge. */
4090                     gameInfo.variant = VariantNormal; // [HGM] variantswitch: suppress sending of 'variant'
4091                     Reset(TRUE, TRUE);
4092                 }
4093 #endif /*ZIPPY*/
4094                 if(appData.bgObserve && partnerBoardValid) DrawPosition(TRUE, partnerBoard);
4095                 continue;
4096             }
4097
4098             if (looking_at(buf, &i, "Removing game * from observation") ||
4099                 looking_at(buf, &i, "no longer observing game *") ||
4100                 looking_at(buf, &i, "Game * (*) has no examiners")) {
4101                 if (gameMode == IcsObserving &&
4102                     atoi(star_match[0]) == ics_gamenum)
4103                   {
4104                       /* icsEngineAnalyze */
4105                       if (appData.icsEngineAnalyze) {
4106                             ExitAnalyzeMode();
4107                             ModeHighlight();
4108                       }
4109                       StopClocks();
4110                       gameMode = IcsIdle;
4111                       ics_gamenum = -1;
4112                       ics_user_moved = FALSE;
4113                   }
4114                 continue;
4115             }
4116
4117             if (looking_at(buf, &i, "no longer examining game *")) {
4118                 if (gameMode == IcsExamining &&
4119                     atoi(star_match[0]) == ics_gamenum)
4120                   {
4121                       gameMode = IcsIdle;
4122                       ics_gamenum = -1;
4123                       ics_user_moved = FALSE;
4124                   }
4125                 continue;
4126             }
4127
4128             /* Advance leftover_start past any newlines we find,
4129                so only partial lines can get reparsed */
4130             if (looking_at(buf, &i, "\n")) {
4131                 prevColor = curColor;
4132                 if (curColor != ColorNormal) {
4133                     if (oldi > next_out) {
4134                         SendToPlayer(&buf[next_out], oldi - next_out);
4135                         next_out = oldi;
4136                     }
4137                     Colorize(ColorNormal, FALSE);
4138                     curColor = ColorNormal;
4139                 }
4140                 if (started == STARTED_BOARD) {
4141                     started = STARTED_NONE;
4142                     parse[parse_pos] = NULLCHAR;
4143                     ParseBoard12(parse);
4144                     ics_user_moved = 0;
4145
4146                     /* Send premove here */
4147                     if (appData.premove) {
4148                       char str[MSG_SIZ];
4149                       if (currentMove == 0 &&
4150                           gameMode == IcsPlayingWhite &&
4151                           appData.premoveWhite) {
4152                         snprintf(str, MSG_SIZ, "%s\n", appData.premoveWhiteText);
4153                         if (appData.debugMode)
4154                           fprintf(debugFP, "Sending premove:\n");
4155                         SendToICS(str);
4156                       } else if (currentMove == 1 &&
4157                                  gameMode == IcsPlayingBlack &&
4158                                  appData.premoveBlack) {
4159                         snprintf(str, MSG_SIZ, "%s\n", appData.premoveBlackText);
4160                         if (appData.debugMode)
4161                           fprintf(debugFP, "Sending premove:\n");
4162                         SendToICS(str);
4163                       } else if (gotPremove) {
4164                         gotPremove = 0;
4165                         ClearPremoveHighlights();
4166                         if (appData.debugMode)
4167                           fprintf(debugFP, "Sending premove:\n");
4168                           UserMoveEvent(premoveFromX, premoveFromY,
4169                                         premoveToX, premoveToY,
4170                                         premovePromoChar);
4171                       }
4172                     }
4173
4174                     /* Usually suppress following prompt */
4175                     if (!(forwardMostMove == 0 && gameMode == IcsExamining)) {
4176                         while(looking_at(buf, &i, "\n")); // [HGM] skip empty lines
4177                         if (looking_at(buf, &i, "*% ")) {
4178                             savingComment = FALSE;
4179                             suppressKibitz = 0;
4180                         }
4181                     }
4182                     next_out = i;
4183                 } else if (started == STARTED_HOLDINGS) {
4184                     int gamenum;
4185                     char new_piece[MSG_SIZ];
4186                     started = STARTED_NONE;
4187                     parse[parse_pos] = NULLCHAR;
4188                     if (appData.debugMode)
4189                       fprintf(debugFP, "Parsing holdings: %s, currentMove = %d\n",
4190                                                         parse, currentMove);
4191                     if (sscanf(parse, " game %d", &gamenum) == 1) {
4192                       if(gamenum == ics_gamenum) { // [HGM] bughouse: old code if part of foreground game
4193                         if (gameInfo.variant == VariantNormal) {
4194                           /* [HGM] We seem to switch variant during a game!
4195                            * Presumably no holdings were displayed, so we have
4196                            * to move the position two files to the right to
4197                            * create room for them!
4198                            */
4199                           VariantClass newVariant;
4200                           switch(gameInfo.boardWidth) { // base guess on board width
4201                                 case 9:  newVariant = VariantShogi; break;
4202                                 case 10: newVariant = VariantGreat; break;
4203                                 default: newVariant = VariantCrazyhouse; break;
4204                           }
4205                           VariantSwitch(boards[currentMove], newVariant); /* temp guess */
4206                           /* Get a move list just to see the header, which
4207                              will tell us whether this is really bug or zh */
4208                           if (ics_getting_history == H_FALSE) {
4209                             ics_getting_history = H_REQUESTED;
4210                             snprintf(str, MSG_SIZ, "%smoves %d\n", ics_prefix, gamenum);
4211                             SendToICS(str);
4212                           }
4213                         }
4214                         new_piece[0] = NULLCHAR;
4215                         sscanf(parse, "game %d white [%s black [%s <- %s",
4216                                &gamenum, white_holding, black_holding,
4217                                new_piece);
4218                         white_holding[strlen(white_holding)-1] = NULLCHAR;
4219                         black_holding[strlen(black_holding)-1] = NULLCHAR;
4220                         /* [HGM] copy holdings to board holdings area */
4221                         CopyHoldings(boards[forwardMostMove], white_holding, WhitePawn);
4222                         CopyHoldings(boards[forwardMostMove], black_holding, BlackPawn);
4223                         boards[forwardMostMove][HOLDINGS_SET] = 1; // flag holdings as set
4224 #if ZIPPY
4225                         if (appData.zippyPlay && first.initDone) {
4226                             ZippyHoldings(white_holding, black_holding,
4227                                           new_piece);
4228                         }
4229 #endif /*ZIPPY*/
4230                         if (tinyLayout || smallLayout) {
4231                             char wh[16], bh[16];
4232                             PackHolding(wh, white_holding);
4233                             PackHolding(bh, black_holding);
4234                             snprintf(str, MSG_SIZ, "[%s-%s] %s-%s", wh, bh,
4235                                     gameInfo.white, gameInfo.black);
4236                         } else {
4237                           snprintf(str, MSG_SIZ, "%s [%s] %s %s [%s]",
4238                                     gameInfo.white, white_holding, _("vs."),
4239                                     gameInfo.black, black_holding);
4240                         }
4241                         if(!partnerUp) // [HGM] bughouse: when peeking at partner game we already know what he captured...
4242                         DrawPosition(FALSE, boards[currentMove]);
4243                         DisplayTitle(str);
4244                       } else if(appData.bgObserve) { // [HGM] bughouse: holdings of other game => background
4245                         sscanf(parse, "game %d white [%s black [%s <- %s",
4246                                &gamenum, white_holding, black_holding,
4247                                new_piece);
4248                         white_holding[strlen(white_holding)-1] = NULLCHAR;
4249                         black_holding[strlen(black_holding)-1] = NULLCHAR;
4250                         /* [HGM] copy holdings to partner-board holdings area */
4251                         CopyHoldings(partnerBoard, white_holding, WhitePawn);
4252                         CopyHoldings(partnerBoard, black_holding, BlackPawn);
4253                         if(twoBoards) { partnerUp = 1; flipView = !flipView; } // [HGM] dual: always draw
4254                         if(partnerUp) DrawPosition(FALSE, partnerBoard);
4255                         if(twoBoards) { partnerUp = 0; flipView = !flipView; }
4256                       }
4257                     }
4258                     /* Suppress following prompt */
4259                     if (looking_at(buf, &i, "*% ")) {
4260                         if(strchr(star_match[0], 7)) SendToPlayer("\007", 1); // Bell(); // FICS fuses bell for next board with prompt in zh captures
4261                         savingComment = FALSE;
4262                         suppressKibitz = 0;
4263                     }
4264                     next_out = i;
4265                 }
4266                 continue;
4267             }
4268
4269             i++;                /* skip unparsed character and loop back */
4270         }
4271
4272         if (started != STARTED_MOVES && started != STARTED_BOARD && !suppressKibitz && // [HGM] kibitz
4273 //          started != STARTED_HOLDINGS && i > next_out) { // [HGM] should we compare to leftover_start in stead of i?
4274 //          SendToPlayer(&buf[next_out], i - next_out);
4275             started != STARTED_HOLDINGS && leftover_start > next_out) {
4276             SendToPlayer(&buf[next_out], leftover_start - next_out);
4277             next_out = i;
4278         }
4279
4280         leftover_len = buf_len - leftover_start;
4281         /* if buffer ends with something we couldn't parse,
4282            reparse it after appending the next read */
4283
4284     } else if (count == 0) {
4285         RemoveInputSource(isr);
4286         DisplayFatalError(_("Connection closed by ICS"), 0, 0);
4287     } else {
4288         DisplayFatalError(_("Error reading from ICS"), error, 1);
4289     }
4290 }
4291
4292
4293 /* Board style 12 looks like this:
4294
4295    <12> r-b---k- pp----pp ---bP--- ---p---- q------- ------P- P--Q--BP -----R-K W -1 0 0 0 0 0 0 paf MaxII 0 2 12 21 25 234 174 24 Q/d7-a4 (0:06) Qxa4 0 0
4296
4297  * The "<12> " is stripped before it gets to this routine.  The two
4298  * trailing 0's (flip state and clock ticking) are later addition, and
4299  * some chess servers may not have them, or may have only the first.
4300  * Additional trailing fields may be added in the future.
4301  */
4302
4303 #define PATTERN "%c%d%d%d%d%d%d%d%s%s%d%d%d%d%d%d%d%d%s%s%s%d%d"
4304
4305 #define RELATION_OBSERVING_PLAYED    0
4306 #define RELATION_OBSERVING_STATIC   -2   /* examined, oldmoves, or smoves */
4307 #define RELATION_PLAYING_MYMOVE      1
4308 #define RELATION_PLAYING_NOTMYMOVE  -1
4309 #define RELATION_EXAMINING           2
4310 #define RELATION_ISOLATED_BOARD     -3
4311 #define RELATION_STARTING_POSITION  -4   /* FICS only */
4312
4313 void
4314 ParseBoard12 (char *string)
4315 {
4316 #if ZIPPY
4317     int i, takeback;
4318     char *bookHit = NULL; // [HGM] book
4319 #endif
4320     GameMode newGameMode;
4321     int gamenum, newGame, newMove, relation, basetime, increment, ics_flip = 0;
4322     int j, k, n, moveNum, white_stren, black_stren, white_time, black_time;
4323     int double_push, castle_ws, castle_wl, castle_bs, castle_bl, irrev_count;
4324     char to_play, board_chars[200];
4325     char move_str[MSG_SIZ], str[MSG_SIZ], elapsed_time[MSG_SIZ];
4326     char black[32], white[32];
4327     Board board;
4328     int prevMove = currentMove;
4329     int ticking = 2;
4330     ChessMove moveType;
4331     int fromX, fromY, toX, toY;
4332     char promoChar;
4333     int ranks=1, files=0; /* [HGM] ICS80: allow variable board size */
4334     Boolean weird = FALSE, reqFlag = FALSE;
4335
4336     fromX = fromY = toX = toY = -1;
4337
4338     newGame = FALSE;
4339
4340     if (appData.debugMode)
4341       fprintf(debugFP, "Parsing board: %s\n", string);
4342
4343     move_str[0] = NULLCHAR;
4344     elapsed_time[0] = NULLCHAR;
4345     {   /* [HGM] figure out how many ranks and files the board has, for ICS extension used by Capablanca server */
4346         int  i = 0, j;
4347         while(i < 199 && (string[i] != ' ' || string[i+2] != ' ')) {
4348             if(string[i] == ' ') { ranks++; files = 0; }
4349             else files++;
4350             if(!strchr(" -pnbrqkPNBRQK" , string[i])) weird = TRUE; // test for fairies
4351             i++;
4352         }
4353         for(j = 0; j <i; j++) board_chars[j] = string[j];
4354         board_chars[i] = '\0';
4355         string += i + 1;
4356     }
4357     n = sscanf(string, PATTERN, &to_play, &double_push,
4358                &castle_ws, &castle_wl, &castle_bs, &castle_bl, &irrev_count,
4359                &gamenum, white, black, &relation, &basetime, &increment,
4360                &white_stren, &black_stren, &white_time, &black_time,
4361                &moveNum, str, elapsed_time, move_str, &ics_flip,
4362                &ticking);
4363
4364     if (n < 21) {
4365         snprintf(str, MSG_SIZ, _("Failed to parse board string:\n\"%s\""), string);
4366         DisplayError(str, 0);
4367         return;
4368     }
4369
4370     /* Convert the move number to internal form */
4371     moveNum = (moveNum - 1) * 2;
4372     if (to_play == 'B') moveNum++;
4373     if (moveNum > framePtr) { // [HGM] vari: do not run into saved variations
4374       DisplayFatalError(_("Game too long; increase MAX_MOVES and recompile"),
4375                         0, 1);
4376       return;
4377     }
4378
4379     switch (relation) {
4380       case RELATION_OBSERVING_PLAYED:
4381       case RELATION_OBSERVING_STATIC:
4382         if (gamenum == -1) {
4383             /* Old ICC buglet */
4384             relation = RELATION_OBSERVING_STATIC;
4385         }
4386         newGameMode = IcsObserving;
4387         break;
4388       case RELATION_PLAYING_MYMOVE:
4389       case RELATION_PLAYING_NOTMYMOVE:
4390         newGameMode =
4391           ((relation == RELATION_PLAYING_MYMOVE) == (to_play == 'W')) ?
4392             IcsPlayingWhite : IcsPlayingBlack;
4393         soughtPending =FALSE; // [HGM] seekgraph: solve race condition
4394         break;
4395       case RELATION_EXAMINING:
4396         newGameMode = IcsExamining;
4397         break;
4398       case RELATION_ISOLATED_BOARD:
4399       default:
4400         /* Just display this board.  If user was doing something else,
4401            we will forget about it until the next board comes. */
4402         newGameMode = IcsIdle;
4403         break;
4404       case RELATION_STARTING_POSITION:
4405         newGameMode = gameMode;
4406         break;
4407     }
4408
4409     if((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack ||
4410         gameMode == IcsObserving && appData.dualBoard) // also allow use of second board for observing two games
4411          && newGameMode == IcsObserving && gamenum != ics_gamenum && appData.bgObserve) {
4412       // [HGM] bughouse: don't act on alien boards while we play. Just parse the board and save it */
4413       int fac = strchr(elapsed_time, '.') ? 1 : 1000;
4414       static int lastBgGame = -1;
4415       char *toSqr;
4416       for (k = 0; k < ranks; k++) {
4417         for (j = 0; j < files; j++)
4418           board[k][j+gameInfo.holdingsWidth] = CharToPiece(board_chars[(ranks-1-k)*(files+1) + j]);
4419         if(gameInfo.holdingsWidth > 1) {
4420              board[k][0] = board[k][BOARD_WIDTH-1] = EmptySquare;
4421              board[k][1] = board[k][BOARD_WIDTH-2] = (ChessSquare) 0;;
4422         }
4423       }
4424       CopyBoard(partnerBoard, board);
4425       if(toSqr = strchr(str, '/')) { // extract highlights from long move
4426         partnerBoard[EP_STATUS-3] = toSqr[1] - AAA; // kludge: hide highlighting info in board
4427         partnerBoard[EP_STATUS-4] = toSqr[2] - ONE;
4428       } else partnerBoard[EP_STATUS-4] = partnerBoard[EP_STATUS-3] = -1;
4429       if(toSqr = strchr(str, '-')) {
4430         partnerBoard[EP_STATUS-1] = toSqr[1] - AAA;
4431         partnerBoard[EP_STATUS-2] = toSqr[2] - ONE;
4432       } else partnerBoard[EP_STATUS-1] = partnerBoard[EP_STATUS-2] = -1;
4433       if(appData.dualBoard && !twoBoards) { twoBoards = 1; InitDrawingSizes(-2,0); }
4434       if(twoBoards) { partnerUp = 1; flipView = !flipView; } // [HGM] dual
4435       if(partnerUp) DrawPosition(FALSE, partnerBoard);
4436       if(twoBoards) {
4437           DisplayWhiteClock(white_time*fac, to_play == 'W');
4438           DisplayBlackClock(black_time*fac, to_play != 'W');
4439           activePartner = to_play;
4440           if(gamenum != lastBgGame) {
4441               char buf[MSG_SIZ];
4442               snprintf(buf, MSG_SIZ, "%s %s %s", white, _("vs."), black);
4443               DisplayTitle(buf);
4444           }
4445           lastBgGame = gamenum;
4446           activePartnerTime = to_play == 'W' ? white_time*fac : black_time*fac;
4447                       partnerUp = 0; flipView = !flipView; } // [HGM] dual
4448       snprintf(partnerStatus, MSG_SIZ,"W: %d:%02d B: %d:%02d (%d-%d) %c", white_time*fac/60000, (white_time*fac%60000)/1000,
4449                  (black_time*fac/60000), (black_time*fac%60000)/1000, white_stren, black_stren, to_play);
4450       if(!twoBoards) DisplayMessage(partnerStatus, "");
4451         partnerBoardValid = TRUE;
4452       return;
4453     }
4454
4455     if(appData.dualBoard && appData.bgObserve) {
4456         if((newGameMode == IcsPlayingWhite || newGameMode == IcsPlayingBlack) && moveNum == 1)
4457             SendToICS(ics_prefix), SendToICS("pobserve\n");
4458         else if(newGameMode == IcsObserving && (gameMode == BeginningOfGame || gameMode == IcsIdle)) {
4459             char buf[MSG_SIZ];
4460             snprintf(buf, MSG_SIZ, "%spobserve %s\n", ics_prefix, white);
4461             SendToICS(buf);
4462         }
4463     }
4464
4465     /* Modify behavior for initial board display on move listing
4466        of wild games.
4467        */
4468     switch (ics_getting_history) {
4469       case H_FALSE:
4470       case H_REQUESTED:
4471         break;
4472       case H_GOT_REQ_HEADER:
4473       case H_GOT_UNREQ_HEADER:
4474         /* This is the initial position of the current game */
4475         gamenum = ics_gamenum;
4476         moveNum = 0;            /* old ICS bug workaround */
4477         if (to_play == 'B') {
4478           startedFromSetupPosition = TRUE;
4479           blackPlaysFirst = TRUE;
4480           moveNum = 1;
4481           if (forwardMostMove == 0) forwardMostMove = 1;
4482           if (backwardMostMove == 0) backwardMostMove = 1;
4483           if (currentMove == 0) currentMove = 1;
4484         }
4485         newGameMode = gameMode;
4486         relation = RELATION_STARTING_POSITION; /* ICC needs this */
4487         break;
4488       case H_GOT_UNWANTED_HEADER:
4489         /* This is an initial board that we don't want */
4490         return;
4491       case H_GETTING_MOVES:
4492         /* Should not happen */
4493         DisplayError(_("Error gathering move list: extra board"), 0);
4494         ics_getting_history = H_FALSE;
4495         return;
4496     }
4497
4498    if (gameInfo.boardHeight != ranks || gameInfo.boardWidth != files ||
4499                                         move_str[1] == '@' && !gameInfo.holdingsWidth ||
4500                                         weird && (int)gameInfo.variant < (int)VariantShogi) {
4501      /* [HGM] We seem to have switched variant unexpectedly
4502       * Try to guess new variant from board size
4503       */
4504           VariantClass newVariant = VariantFairy; // if 8x8, but fairies present
4505           if(ranks == 8 && files == 10) newVariant = VariantCapablanca; else
4506           if(ranks == 10 && files == 9) newVariant = VariantXiangqi; else
4507           if(ranks == 8 && files == 12) newVariant = VariantCourier; else
4508           if(ranks == 9 && files == 9)  newVariant = VariantShogi; else
4509           if(ranks == 10 && files == 10) newVariant = VariantGrand; else
4510           if(!weird) newVariant = move_str[1] == '@' ? VariantCrazyhouse : VariantNormal;
4511           VariantSwitch(boards[currentMove], newVariant); /* temp guess */
4512           /* Get a move list just to see the header, which
4513              will tell us whether this is really bug or zh */
4514           if (ics_getting_history == H_FALSE) {
4515             ics_getting_history = H_REQUESTED; reqFlag = TRUE;
4516             snprintf(str, MSG_SIZ, "%smoves %d\n", ics_prefix, gamenum);
4517             SendToICS(str);
4518           }
4519     }
4520
4521     /* Take action if this is the first board of a new game, or of a
4522        different game than is currently being displayed.  */
4523     if (gamenum != ics_gamenum || newGameMode != gameMode ||
4524         relation == RELATION_ISOLATED_BOARD) {
4525
4526         /* Forget the old game and get the history (if any) of the new one */
4527         if (gameMode != BeginningOfGame) {
4528           Reset(TRUE, TRUE);
4529         }
4530         newGame = TRUE;
4531         if (appData.autoRaiseBoard) BoardToTop();
4532         prevMove = -3;
4533         if (gamenum == -1) {
4534             newGameMode = IcsIdle;
4535         } else if ((moveNum > 0 || newGameMode == IcsObserving) && newGameMode != IcsIdle &&
4536                    appData.getMoveList && !reqFlag) {
4537             /* Need to get game history */
4538             ics_getting_history = H_REQUESTED;
4539             snprintf(str, MSG_SIZ, "%smoves %d\n", ics_prefix, gamenum);
4540             SendToICS(str);
4541         }
4542
4543         /* Initially flip the board to have black on the bottom if playing
4544            black or if the ICS flip flag is set, but let the user change
4545            it with the Flip View button. */
4546         flipView = appData.autoFlipView ?
4547           (newGameMode == IcsPlayingBlack) || ics_flip :
4548           appData.flipView;
4549
4550         /* Done with values from previous mode; copy in new ones */
4551         gameMode = newGameMode;
4552         ModeHighlight();
4553         ics_gamenum = gamenum;
4554         if (gamenum == gs_gamenum) {
4555             int klen = strlen(gs_kind);
4556             if (gs_kind[klen - 1] == '.') gs_kind[klen - 1] = NULLCHAR;
4557             snprintf(str, MSG_SIZ, "ICS %s", gs_kind);
4558             gameInfo.event = StrSave(str);
4559         } else {
4560             gameInfo.event = StrSave("ICS game");
4561         }
4562         gameInfo.site = StrSave(appData.icsHost);
4563         gameInfo.date = PGNDate();
4564         gameInfo.round = StrSave("-");
4565         gameInfo.white = StrSave(white);
4566         gameInfo.black = StrSave(black);
4567         timeControl = basetime * 60 * 1000;
4568         timeControl_2 = 0;
4569         timeIncrement = increment * 1000;
4570         movesPerSession = 0;
4571         gameInfo.timeControl = TimeControlTagValue();
4572         VariantSwitch(boards[currentMove], StringToVariant(gameInfo.event) );
4573   if (appData.debugMode) {
4574     fprintf(debugFP, "ParseBoard says variant = '%s'\n", gameInfo.event);
4575     fprintf(debugFP, "recognized as %s\n", VariantName(gameInfo.variant));
4576     setbuf(debugFP, NULL);
4577   }
4578
4579         gameInfo.outOfBook = NULL;
4580
4581         /* Do we have the ratings? */
4582         if (strcmp(player1Name, white) == 0 &&
4583             strcmp(player2Name, black) == 0) {
4584             if (appData.debugMode)
4585               fprintf(debugFP, "Remembered ratings: W %d, B %d\n",
4586                       player1Rating, player2Rating);
4587             gameInfo.whiteRating = player1Rating;
4588             gameInfo.blackRating = player2Rating;
4589         } else if (strcmp(player2Name, white) == 0 &&
4590                    strcmp(player1Name, black) == 0) {
4591             if (appData.debugMode)
4592               fprintf(debugFP, "Remembered ratings: W %d, B %d\n",
4593                       player2Rating, player1Rating);
4594             gameInfo.whiteRating = player2Rating;
4595             gameInfo.blackRating = player1Rating;
4596         }
4597         player1Name[0] = player2Name[0] = NULLCHAR;
4598
4599         /* Silence shouts if requested */
4600         if (appData.quietPlay &&
4601             (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack)) {
4602             SendToICS(ics_prefix);
4603             SendToICS("set shout 0\n");
4604         }
4605     }
4606
4607     /* Deal with midgame name changes */
4608     if (!newGame) {
4609         if (!gameInfo.white || strcmp(gameInfo.white, white) != 0) {
4610             if (gameInfo.white) free(gameInfo.white);
4611             gameInfo.white = StrSave(white);
4612         }
4613         if (!gameInfo.black || strcmp(gameInfo.black, black) != 0) {
4614             if (gameInfo.black) free(gameInfo.black);
4615             gameInfo.black = StrSave(black);
4616         }
4617     }
4618
4619     /* Throw away game result if anything actually changes in examine mode */
4620     if (gameMode == IcsExamining && !newGame) {
4621         gameInfo.result = GameUnfinished;
4622         if (gameInfo.resultDetails != NULL) {
4623             free(gameInfo.resultDetails);
4624             gameInfo.resultDetails = NULL;
4625         }
4626     }
4627
4628     /* In pausing && IcsExamining mode, we ignore boards coming
4629        in if they are in a different variation than we are. */
4630     if (pauseExamInvalid) return;
4631     if (pausing && gameMode == IcsExamining) {
4632         if (moveNum <= pauseExamForwardMostMove) {
4633             pauseExamInvalid = TRUE;
4634             forwardMostMove = pauseExamForwardMostMove;
4635             return;
4636         }
4637     }
4638
4639   if (appData.debugMode) {
4640     fprintf(debugFP, "load %dx%d board\n", files, ranks);
4641   }
4642     /* Parse the board */
4643     for (k = 0; k < ranks; k++) {
4644       for (j = 0; j < files; j++)
4645         board[k][j+gameInfo.holdingsWidth] = CharToPiece(board_chars[(ranks-1-k)*(files+1) + j]);
4646       if(gameInfo.holdingsWidth > 1) {
4647            board[k][0] = board[k][BOARD_WIDTH-1] = EmptySquare;
4648            board[k][1] = board[k][BOARD_WIDTH-2] = (ChessSquare) 0;;
4649       }
4650     }
4651     if(moveNum==0 && gameInfo.variant == VariantSChess) {
4652       board[5][BOARD_RGHT+1] = WhiteAngel;
4653       board[6][BOARD_RGHT+1] = WhiteMarshall;
4654       board[1][0] = BlackMarshall;
4655       board[2][0] = BlackAngel;
4656       board[1][1] = board[2][1] = board[5][BOARD_RGHT] = board[6][BOARD_RGHT] = 1;
4657     }
4658     CopyBoard(boards[moveNum], board);
4659     boards[moveNum][HOLDINGS_SET] = 0; // [HGM] indicate holdings not set
4660     if (moveNum == 0) {
4661         startedFromSetupPosition =
4662           !CompareBoards(board, initialPosition);
4663         if(startedFromSetupPosition)
4664             initialRulePlies = irrev_count; /* [HGM] 50-move counter offset */
4665     }
4666
4667     /* [HGM] Set castling rights. Take the outermost Rooks,
4668        to make it also work for FRC opening positions. Note that board12
4669        is really defective for later FRC positions, as it has no way to
4670        indicate which Rook can castle if they are on the same side of King.
4671        For the initial position we grant rights to the outermost Rooks,
4672        and remember thos rights, and we then copy them on positions
4673        later in an FRC game. This means WB might not recognize castlings with
4674        Rooks that have moved back to their original position as illegal,
4675        but in ICS mode that is not its job anyway.
4676     */
4677     if(moveNum == 0 || gameInfo.variant != VariantFischeRandom)
4678     { int i, j; ChessSquare wKing = WhiteKing, bKing = BlackKing;
4679
4680         for(i=BOARD_LEFT, j=NoRights; i<BOARD_RGHT; i++)
4681             if(board[0][i] == WhiteRook) j = i;
4682         initialRights[0] = boards[moveNum][CASTLING][0] = (castle_ws == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
4683         for(i=BOARD_RGHT-1, j=NoRights; i>=BOARD_LEFT; i--)
4684             if(board[0][i] == WhiteRook) j = i;
4685         initialRights[1] = boards[moveNum][CASTLING][1] = (castle_wl == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
4686         for(i=BOARD_LEFT, j=NoRights; i<BOARD_RGHT; i++)
4687             if(board[BOARD_HEIGHT-1][i] == BlackRook) j = i;
4688         initialRights[3] = boards[moveNum][CASTLING][3] = (castle_bs == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
4689         for(i=BOARD_RGHT-1, j=NoRights; i>=BOARD_LEFT; i--)
4690             if(board[BOARD_HEIGHT-1][i] == BlackRook) j = i;
4691         initialRights[4] = boards[moveNum][CASTLING][4] = (castle_bl == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
4692
4693         boards[moveNum][CASTLING][2] = boards[moveNum][CASTLING][5] = NoRights;
4694         if(gameInfo.variant == VariantKnightmate) { wKing = WhiteUnicorn; bKing = BlackUnicorn; }
4695         for(k=BOARD_LEFT; k<BOARD_RGHT; k++)
4696             if(board[0][k] == wKing) initialRights[2] = boards[moveNum][CASTLING][2] = k;
4697         for(k=BOARD_LEFT; k<BOARD_RGHT; k++)
4698             if(board[BOARD_HEIGHT-1][k] == bKing)
4699                 initialRights[5] = boards[moveNum][CASTLING][5] = k;
4700         if(gameInfo.variant == VariantTwoKings) {
4701             // In TwoKings looking for a King does not work, so always give castling rights to a King on e1/e8
4702             if(board[0][4] == wKing) initialRights[2] = boards[moveNum][CASTLING][2] = 4;
4703             if(board[BOARD_HEIGHT-1][4] == bKing) initialRights[5] = boards[moveNum][CASTLING][5] = 4;
4704         }
4705     } else { int r;
4706         r = boards[moveNum][CASTLING][0] = initialRights[0];
4707         if(board[0][r] != WhiteRook) boards[moveNum][CASTLING][0] = NoRights;
4708         r = boards[moveNum][CASTLING][1] = initialRights[1];
4709         if(board[0][r] != WhiteRook) boards[moveNum][CASTLING][1] = NoRights;
4710         r = boards[moveNum][CASTLING][3] = initialRights[3];
4711         if(board[BOARD_HEIGHT-1][r] != BlackRook) boards[moveNum][CASTLING][3] = NoRights;
4712         r = boards[moveNum][CASTLING][4] = initialRights[4];
4713         if(board[BOARD_HEIGHT-1][r] != BlackRook) boards[moveNum][CASTLING][4] = NoRights;
4714         /* wildcastle kludge: always assume King has rights */
4715         r = boards[moveNum][CASTLING][2] = initialRights[2];
4716         r = boards[moveNum][CASTLING][5] = initialRights[5];
4717     }
4718     /* [HGM] e.p. rights. Assume that ICS sends file number here? */
4719     boards[moveNum][EP_STATUS] = EP_NONE;
4720     if(str[0] == 'P') boards[moveNum][EP_STATUS] = EP_PAWN_MOVE;
4721     if(strchr(move_str, 'x')) boards[moveNum][EP_STATUS] = EP_CAPTURE;
4722     if(double_push !=  -1) boards[moveNum][EP_STATUS] = double_push + BOARD_LEFT;
4723
4724
4725     if (ics_getting_history == H_GOT_REQ_HEADER ||
4726         ics_getting_history == H_GOT_UNREQ_HEADER) {
4727         /* This was an initial position from a move list, not
4728            the current position */
4729         return;
4730     }
4731
4732     /* Update currentMove and known move number limits */
4733     newMove = newGame || moveNum > forwardMostMove;
4734
4735     if (newGame) {
4736         forwardMostMove = backwardMostMove = currentMove = moveNum;
4737         if (gameMode == IcsExamining && moveNum == 0) {
4738           /* Workaround for ICS limitation: we are not told the wild
4739              type when starting to examine a game.  But if we ask for
4740              the move list, the move list header will tell us */
4741             ics_getting_history = H_REQUESTED;
4742             snprintf(str, MSG_SIZ, "%smoves %d\n", ics_prefix, gamenum);
4743             SendToICS(str);
4744         }
4745     } else if (moveNum == forwardMostMove + 1 || moveNum == forwardMostMove
4746                || (moveNum < forwardMostMove && moveNum >= backwardMostMove)) {
4747 #if ZIPPY
4748         /* [DM] If we found takebacks during icsEngineAnalyze try send to engine */
4749         /* [HGM] applied this also to an engine that is silently watching        */
4750         if (appData.zippyPlay && moveNum < forwardMostMove && first.initDone &&
4751             (gameMode == IcsObserving || gameMode == IcsExamining) &&
4752             gameInfo.variant == currentlyInitializedVariant) {
4753           takeback = forwardMostMove - moveNum;
4754           for (i = 0; i < takeback; i++) {
4755             if (appData.debugMode) fprintf(debugFP, "take back move\n");
4756             SendToProgram("undo\n", &first);
4757           }
4758         }
4759 #endif
4760
4761         forwardMostMove = moveNum;
4762         if (!pausing || currentMove > forwardMostMove)
4763           currentMove = forwardMostMove;
4764     } else {
4765         /* New part of history that is not contiguous with old part */
4766         if (pausing && gameMode == IcsExamining) {
4767             pauseExamInvalid = TRUE;
4768             forwardMostMove = pauseExamForwardMostMove;
4769             return;
4770         }
4771         if (gameMode == IcsExamining && moveNum > 0 && appData.getMoveList) {
4772 #if ZIPPY
4773             if(appData.zippyPlay && forwardMostMove > 0 && first.initDone) {
4774                 // [HGM] when we will receive the move list we now request, it will be
4775                 // fed to the engine from the first move on. So if the engine is not
4776                 // in the initial position now, bring it there.
4777                 InitChessProgram(&first, 0);
4778             }
4779 #endif
4780             ics_getting_history = H_REQUESTED;
4781             snprintf(str, MSG_SIZ, "%smoves %d\n", ics_prefix, gamenum);
4782             SendToICS(str);
4783         }
4784         forwardMostMove = backwardMostMove = currentMove = moveNum;
4785     }
4786
4787     /* Update the clocks */
4788     if (strchr(elapsed_time, '.')) {
4789       /* Time is in ms */
4790       timeRemaining[0][moveNum] = whiteTimeRemaining = white_time;
4791       timeRemaining[1][moveNum] = blackTimeRemaining = black_time;
4792     } else {
4793       /* Time is in seconds */
4794       timeRemaining[0][moveNum] = whiteTimeRemaining = white_time * 1000;
4795       timeRemaining[1][moveNum] = blackTimeRemaining = black_time * 1000;
4796     }
4797
4798
4799 #if ZIPPY
4800     if (appData.zippyPlay && newGame &&
4801         gameMode != IcsObserving && gameMode != IcsIdle &&
4802         gameMode != IcsExamining)
4803       ZippyFirstBoard(moveNum, basetime, increment);
4804 #endif
4805
4806     /* Put the move on the move list, first converting
4807        to canonical algebraic form. */
4808     if (moveNum > 0) {
4809   if (appData.debugMode) {
4810     int f = forwardMostMove;
4811     fprintf(debugFP, "parseboard %d, castling = %d %d %d %d %d %d\n", f,
4812             boards[f][CASTLING][0],boards[f][CASTLING][1],boards[f][CASTLING][2],
4813             boards[f][CASTLING][3],boards[f][CASTLING][4],boards[f][CASTLING][5]);
4814     fprintf(debugFP, "accepted move %s from ICS, parse it.\n", move_str);
4815     fprintf(debugFP, "moveNum = %d\n", moveNum);
4816     fprintf(debugFP, "board = %d-%d x %d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT);
4817     setbuf(debugFP, NULL);
4818   }
4819         if (moveNum <= backwardMostMove) {
4820             /* We don't know what the board looked like before
4821                this move.  Punt. */
4822           safeStrCpy(parseList[moveNum - 1], move_str, sizeof(parseList[moveNum - 1])/sizeof(parseList[moveNum - 1][0]));
4823             strcat(parseList[moveNum - 1], " ");
4824             strcat(parseList[moveNum - 1], elapsed_time);
4825             moveList[moveNum - 1][0] = NULLCHAR;
4826         } else if (strcmp(move_str, "none") == 0) {
4827             // [HGM] long SAN: swapped order; test for 'none' before parsing move
4828             /* Again, we don't know what the board looked like;
4829                this is really the start of the game. */
4830             parseList[moveNum - 1][0] = NULLCHAR;
4831             moveList[moveNum - 1][0] = NULLCHAR;
4832             backwardMostMove = moveNum;
4833             startedFromSetupPosition = TRUE;
4834             fromX = fromY = toX = toY = -1;
4835         } else {
4836           // [HGM] long SAN: if legality-testing is off, disambiguation might not work or give wrong move.
4837           //                 So we parse the long-algebraic move string in stead of the SAN move
4838           int valid; char buf[MSG_SIZ], *prom;
4839
4840           if(gameInfo.variant == VariantShogi && !strchr(move_str, '=') && !strchr(move_str, '@'))
4841                 strcat(move_str, "="); // if ICS does not say 'promote' on non-drop, we defer.
4842           // str looks something like "Q/a1-a2"; kill the slash
4843           if(str[1] == '/')
4844             snprintf(buf, MSG_SIZ,"%c%s", str[0], str+2);
4845           else  safeStrCpy(buf, str, sizeof(buf)/sizeof(buf[0])); // might be castling
4846           if((prom = strstr(move_str, "=")) && !strstr(buf, "="))
4847                 strcat(buf, prom); // long move lacks promo specification!
4848           if(!appData.testLegality && move_str[1] != '@') { // drops never ambiguous (parser chokes on long form!)
4849                 if(appData.debugMode)
4850                         fprintf(debugFP, "replaced ICS move '%s' by '%s'\n", move_str, buf);
4851                 safeStrCpy(move_str, buf, MSG_SIZ);
4852           }
4853           valid = ParseOneMove(move_str, moveNum - 1, &moveType,
4854                                 &fromX, &fromY, &toX, &toY, &promoChar)
4855                || ParseOneMove(buf, moveNum - 1, &moveType,
4856                                 &fromX, &fromY, &toX, &toY, &promoChar);
4857           // end of long SAN patch
4858           if (valid) {
4859             (void) CoordsToAlgebraic(boards[moveNum - 1],
4860                                      PosFlags(moveNum - 1),
4861                                      fromY, fromX, toY, toX, promoChar,
4862                                      parseList[moveNum-1]);
4863             switch (MateTest(boards[moveNum], PosFlags(moveNum)) ) {
4864               case MT_NONE:
4865               case MT_STALEMATE:
4866               default:
4867                 break;
4868               case MT_CHECK:
4869                 if(!IS_SHOGI(gameInfo.variant))
4870                     strcat(parseList[moveNum - 1], "+");
4871                 break;
4872               case MT_CHECKMATE:
4873               case MT_STAINMATE: // [HGM] xq: for notation stalemate that wins counts as checkmate
4874                 strcat(parseList[moveNum - 1], "#");
4875                 break;
4876             }
4877             strcat(parseList[moveNum - 1], " ");
4878             strcat(parseList[moveNum - 1], elapsed_time);
4879             /* currentMoveString is set as a side-effect of ParseOneMove */
4880             if(gameInfo.variant == VariantShogi && currentMoveString[4]) currentMoveString[4] = '^';
4881             safeStrCpy(moveList[moveNum - 1], currentMoveString, sizeof(moveList[moveNum - 1])/sizeof(moveList[moveNum - 1][0]));
4882             strcat(moveList[moveNum - 1], "\n");
4883
4884             if(gameInfo.holdingsWidth && !appData.disguise && gameInfo.variant != VariantSuper && gameInfo.variant != VariantGreat
4885                && gameInfo.variant != VariantGrand&& gameInfo.variant != VariantSChess) // inherit info that ICS does not give from previous board
4886               for(k=0; k<ranks; k++) for(j=BOARD_LEFT; j<BOARD_RGHT; j++) {
4887                 ChessSquare old, new = boards[moveNum][k][j];
4888                   if(fromY == DROP_RANK && k==toY && j==toX) continue; // dropped pieces always stand for themselves
4889                   old = (k==toY && j==toX) ? boards[moveNum-1][fromY][fromX] : boards[moveNum-1][k][j]; // trace back mover
4890                   if(old == new) continue;
4891                   if(old == PROMOTED new) boards[moveNum][k][j] = old; // prevent promoted pieces to revert to primordial ones
4892                   else if(new == WhiteWazir || new == BlackWazir) {
4893                       if(old < WhiteCannon || old >= BlackPawn && old < BlackCannon)
4894                            boards[moveNum][k][j] = PROMOTED old; // choose correct type of Gold in promotion
4895                       else boards[moveNum][k][j] = old; // preserve type of Gold
4896                   } else if((old == WhitePawn || old == BlackPawn) && new != EmptySquare) // Pawn promotions (but not e.p.capture!)
4897                       boards[moveNum][k][j] = PROMOTED new; // use non-primordial representation of chosen piece
4898               }
4899           } else {
4900             /* Move from ICS was illegal!?  Punt. */
4901             if (appData.debugMode) {
4902               fprintf(debugFP, "Illegal move from ICS '%s'\n", move_str);
4903               fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
4904             }
4905             safeStrCpy(parseList[moveNum - 1], move_str, sizeof(parseList[moveNum - 1])/sizeof(parseList[moveNum - 1][0]));
4906             strcat(parseList[moveNum - 1], " ");
4907             strcat(parseList[moveNum - 1], elapsed_time);
4908             moveList[moveNum - 1][0] = NULLCHAR;
4909             fromX = fromY = toX = toY = -1;
4910           }
4911         }
4912   if (appData.debugMode) {
4913     fprintf(debugFP, "Move parsed to '%s'\n", parseList[moveNum - 1]);
4914     setbuf(debugFP, NULL);
4915   }
4916
4917 #if ZIPPY
4918         /* Send move to chess program (BEFORE animating it). */
4919         if (appData.zippyPlay && !newGame && newMove &&
4920            (!appData.getMoveList || backwardMostMove == 0) && first.initDone) {
4921
4922             if ((gameMode == IcsPlayingWhite && WhiteOnMove(moveNum)) ||
4923                 (gameMode == IcsPlayingBlack && !WhiteOnMove(moveNum))) {
4924                 if (moveList[moveNum - 1][0] == NULLCHAR) {
4925                   snprintf(str, MSG_SIZ, _("Couldn't parse move \"%s\" from ICS"),
4926                             move_str);
4927                     DisplayError(str, 0);
4928                 } else {
4929                     if (first.sendTime) {
4930                         SendTimeRemaining(&first, gameMode == IcsPlayingWhite);
4931                     }
4932                     bookHit = SendMoveToBookUser(moveNum - 1, &first, FALSE); // [HGM] book
4933                     if (firstMove && !bookHit) {
4934                         firstMove = FALSE;
4935                         if (first.useColors) {
4936                           SendToProgram(gameMode == IcsPlayingWhite ?
4937                                         "white\ngo\n" :
4938                                         "black\ngo\n", &first);
4939                         } else {
4940                           SendToProgram("go\n", &first);
4941                         }
4942                         first.maybeThinking = TRUE;
4943                     }
4944                 }
4945             } else if (gameMode == IcsObserving || gameMode == IcsExamining) {
4946               if (moveList[moveNum - 1][0] == NULLCHAR) {
4947                 snprintf(str, MSG_SIZ, _("Couldn't parse move \"%s\" from ICS"), move_str);
4948                 DisplayError(str, 0);
4949               } else {
4950                 if(gameInfo.variant == currentlyInitializedVariant) // [HGM] refrain sending moves engine can't understand!
4951                 SendMoveToProgram(moveNum - 1, &first);
4952               }
4953             }
4954         }
4955 #endif
4956     }
4957
4958     if (moveNum > 0 && !gotPremove && !appData.noGUI) {
4959         /* If move comes from a remote source, animate it.  If it
4960            isn't remote, it will have already been animated. */
4961         if (!pausing && !ics_user_moved && prevMove == moveNum - 1) {
4962             AnimateMove(boards[moveNum - 1], fromX, fromY, toX, toY);
4963         }
4964         if (!pausing && appData.highlightLastMove) {
4965             SetHighlights(fromX, fromY, toX, toY);
4966         }
4967     }
4968
4969     /* Start the clocks */
4970     whiteFlag = blackFlag = FALSE;
4971     appData.clockMode = !(basetime == 0 && increment == 0);
4972     if (ticking == 0) {
4973       ics_clock_paused = TRUE;
4974       StopClocks();
4975     } else if (ticking == 1) {
4976       ics_clock_paused = FALSE;
4977     }
4978     if (gameMode == IcsIdle ||
4979         relation == RELATION_OBSERVING_STATIC ||
4980         relation == RELATION_EXAMINING ||
4981         ics_clock_paused)
4982       DisplayBothClocks();
4983     else
4984       StartClocks();
4985
4986     /* Display opponents and material strengths */
4987     if (gameInfo.variant != VariantBughouse &&
4988         gameInfo.variant != VariantCrazyhouse && !appData.noGUI) {
4989         if (tinyLayout || smallLayout) {
4990             if(gameInfo.variant == VariantNormal)
4991               snprintf(str, MSG_SIZ, "%s(%d) %s(%d) {%d %d}",
4992                     gameInfo.white, white_stren, gameInfo.black, black_stren,
4993                     basetime, increment);
4994             else
4995               snprintf(str, MSG_SIZ, "%s(%d) %s(%d) {%d %d w%d}",
4996                     gameInfo.white, white_stren, gameInfo.black, black_stren,
4997                     basetime, increment, (int) gameInfo.variant);
4998         } else {
4999             if(gameInfo.variant == VariantNormal)
5000               snprintf(str, MSG_SIZ, "%s (%d) %s %s (%d) {%d %d}",
5001                     gameInfo.white, white_stren, _("vs."), gameInfo.black, black_stren,
5002                     basetime, increment);
5003             else
5004               snprintf(str, MSG_SIZ, "%s (%d) %s %s (%d) {%d %d %s}",
5005                     gameInfo.white, white_stren, _("vs."), gameInfo.black, black_stren,
5006                     basetime, increment, VariantName(gameInfo.variant));
5007         }
5008         DisplayTitle(str);
5009   if (appData.debugMode) {
5010     fprintf(debugFP, "Display title '%s, gameInfo.variant = %d'\n", str, gameInfo.variant);
5011   }
5012     }
5013
5014
5015     /* Display the board */
5016     if (!pausing && !appData.noGUI) {
5017
5018       if (appData.premove)
5019           if (!gotPremove ||
5020              ((gameMode == IcsPlayingWhite) && (WhiteOnMove(currentMove))) ||
5021              ((gameMode == IcsPlayingBlack) && (!WhiteOnMove(currentMove))))
5022               ClearPremoveHighlights();
5023
5024       j = seekGraphUp; seekGraphUp = FALSE; // [HGM] seekgraph: when we draw a board, it overwrites the seek graph
5025         if(partnerUp) { flipView = originalFlip; partnerUp = FALSE; j = TRUE; } // [HGM] bughouse: restore view
5026       DrawPosition(j, boards[currentMove]);
5027
5028       DisplayMove(moveNum - 1);
5029       if (appData.ringBellAfterMoves && /*!ics_user_moved*/ // [HGM] use absolute method to recognize own move
5030             !((gameMode == IcsPlayingWhite) && (!WhiteOnMove(moveNum)) ||
5031               (gameMode == IcsPlayingBlack) &&  (WhiteOnMove(moveNum))   ) ) {
5032         if(newMove) RingBell(); else PlayIcsUnfinishedSound();
5033       }
5034     }
5035
5036     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
5037 #if ZIPPY
5038     if(bookHit) { // [HGM] book: simulate book reply
5039         static char bookMove[MSG_SIZ]; // a bit generous?
5040
5041         programStats.nodes = programStats.depth = programStats.time =
5042         programStats.score = programStats.got_only_move = 0;
5043         sprintf(programStats.movelist, "%s (xbook)", bookHit);
5044
5045         safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
5046         strcat(bookMove, bookHit);
5047         HandleMachineMove(bookMove, &first);
5048     }
5049 #endif
5050 }
5051
5052 void
5053 GetMoveListEvent ()
5054 {
5055     char buf[MSG_SIZ];
5056     if (appData.icsActive && gameMode != IcsIdle && ics_gamenum > 0) {
5057         ics_getting_history = H_REQUESTED;
5058         snprintf(buf, MSG_SIZ, "%smoves %d\n", ics_prefix, ics_gamenum);
5059         SendToICS(buf);
5060     }
5061 }
5062
5063 void
5064 SendToBoth (char *msg)
5065 {   // to make it easy to keep two engines in step in dual analysis
5066     SendToProgram(msg, &first);
5067     if(second.analyzing) SendToProgram(msg, &second);
5068 }
5069
5070 void
5071 AnalysisPeriodicEvent (int force)
5072 {
5073     if (((programStats.ok_to_send == 0 || programStats.line_is_book)
5074          && !force) || !appData.periodicUpdates)
5075       return;
5076
5077     /* Send . command to Crafty to collect stats */
5078     SendToBoth(".\n");
5079
5080     /* Don't send another until we get a response (this makes
5081        us stop sending to old Crafty's which don't understand
5082        the "." command (sending illegal cmds resets node count & time,
5083        which looks bad)) */
5084     programStats.ok_to_send = 0;
5085 }
5086
5087 void
5088 ics_update_width (int new_width)
5089 {
5090         ics_printf("set width %d\n", new_width);
5091 }
5092
5093 void
5094 SendMoveToProgram (int moveNum, ChessProgramState *cps)
5095 {
5096     char buf[MSG_SIZ];
5097
5098     if(moveList[moveNum][1] == '@' && moveList[moveNum][0] == '@') {
5099         if(gameInfo.variant == VariantLion || gameInfo.variant == VariantChuChess || gameInfo.variant == VariantChu) {
5100             sprintf(buf, "%s@@@@\n", cps->useUsermove ? "usermove " : "");
5101             SendToProgram(buf, cps);
5102             return;
5103         }
5104         // null move in variant where engine does not understand it (for analysis purposes)
5105         SendBoard(cps, moveNum + 1); // send position after move in stead.
5106         return;
5107     }
5108     if (cps->useUsermove) {
5109       SendToProgram("usermove ", cps);
5110     }
5111     if (cps->useSAN) {
5112       char *space;
5113       if ((space = strchr(parseList[moveNum], ' ')) != NULL) {
5114         int len = space - parseList[moveNum];
5115         memcpy(buf, parseList[moveNum], len);
5116         buf[len++] = '\n';
5117         buf[len] = NULLCHAR;
5118       } else {
5119         snprintf(buf, MSG_SIZ,"%s\n", parseList[moveNum]);
5120       }
5121       SendToProgram(buf, cps);
5122     } else {
5123       if(cps->alphaRank) { /* [HGM] shogi: temporarily convert to shogi coordinates before sending */
5124         AlphaRank(moveList[moveNum], 4);
5125         SendToProgram(moveList[moveNum], cps);
5126         AlphaRank(moveList[moveNum], 4); // and back
5127       } else
5128       /* Added by Tord: Send castle moves in "O-O" in FRC games if required by
5129        * the engine. It would be nice to have a better way to identify castle
5130        * moves here. */
5131       if(appData.fischerCastling && cps->useOOCastle) {
5132         int fromX = moveList[moveNum][0] - AAA;
5133         int fromY = moveList[moveNum][1] - ONE;
5134         int toX = moveList[moveNum][2] - AAA;
5135         int toY = moveList[moveNum][3] - ONE;
5136         if((boards[moveNum][fromY][fromX] == WhiteKing
5137             && boards[moveNum][toY][toX] == WhiteRook)
5138            || (boards[moveNum][fromY][fromX] == BlackKing
5139                && boards[moveNum][toY][toX] == BlackRook)) {
5140           if(toX > fromX) SendToProgram("O-O\n", cps);
5141           else SendToProgram("O-O-O\n", cps);
5142         }
5143         else SendToProgram(moveList[moveNum], cps);
5144       } else
5145       if(moveList[moveNum][4] == ';') { // [HGM] lion: move is double-step over intermediate square
5146         char *m = moveList[moveNum];
5147         if((boards[moveNum][m[6]-ONE][m[5]-AAA] < BlackPawn) == (boards[moveNum][m[1]-ONE][m[0]-AAA] < BlackPawn)) // move is kludge to indicate castling
5148           snprintf(buf, MSG_SIZ, "%c%d%c%d,%c%d%c%d\n", m[0], m[1] - '0', // convert to two moves
5149                                                m[2], m[3] - '0',
5150                                                m[5], m[6] - '0',
5151                                                m[2] + (m[0] > m[5] ? 1 : -1), m[3] - '0');
5152         else
5153           snprintf(buf, MSG_SIZ, "%c%d%c%d,%c%d%c%d\n", m[0], m[1] - '0', // convert to two moves
5154                                                m[5], m[6] - '0',
5155                                                m[5], m[6] - '0',
5156                                                m[2], m[3] - '0');
5157           SendToProgram(buf, cps);
5158       } else
5159       if(BOARD_HEIGHT > 10) { // [HGM] big: convert ranks to double-digit where needed
5160         if(moveList[moveNum][1] == '@' && (BOARD_HEIGHT < 16 || moveList[moveNum][0] <= 'Z')) { // drop move
5161           if(moveList[moveNum][0]== '@') snprintf(buf, MSG_SIZ, "@@@@\n"); else
5162           snprintf(buf, MSG_SIZ, "%c@%c%d%s", moveList[moveNum][0],
5163                                               moveList[moveNum][2], moveList[moveNum][3] - '0', moveList[moveNum]+4);
5164         } else
5165           snprintf(buf, MSG_SIZ, "%c%d%c%d%s", moveList[moveNum][0], moveList[moveNum][1] - '0',
5166                                                moveList[moveNum][2], moveList[moveNum][3] - '0', moveList[moveNum]+4);
5167         SendToProgram(buf, cps);
5168       }
5169       else SendToProgram(moveList[moveNum], cps);
5170       /* End of additions by Tord */
5171     }
5172
5173     /* [HGM] setting up the opening has brought engine in force mode! */
5174     /*       Send 'go' if we are in a mode where machine should play. */
5175     if( (moveNum == 0 && setboardSpoiledMachineBlack && cps == &first) &&
5176         (gameMode == TwoMachinesPlay   ||
5177 #if ZIPPY
5178          gameMode == IcsPlayingBlack     || gameMode == IcsPlayingWhite ||
5179 #endif
5180          gameMode == MachinePlaysBlack || gameMode == MachinePlaysWhite) ) {
5181         SendToProgram("go\n", cps);
5182   if (appData.debugMode) {
5183     fprintf(debugFP, "(extra)\n");
5184   }
5185     }
5186     setboardSpoiledMachineBlack = 0;
5187 }
5188
5189 void
5190 SendMoveToICS (ChessMove moveType, int fromX, int fromY, int toX, int toY, char promoChar)
5191 {
5192     char user_move[MSG_SIZ];
5193     char suffix[4];
5194
5195     if(gameInfo.variant == VariantSChess && promoChar) {
5196         snprintf(suffix, 4, "=%c", toX == BOARD_WIDTH<<1 ? ToUpper(promoChar) : ToLower(promoChar));
5197         if(moveType == NormalMove) moveType = WhitePromotion; // kludge to do gating
5198     } else suffix[0] = NULLCHAR;
5199
5200     switch (moveType) {
5201       default:
5202         snprintf(user_move, MSG_SIZ, _("say Internal error; bad moveType %d (%d,%d-%d,%d)"),
5203                 (int)moveType, fromX, fromY, toX, toY);
5204         DisplayError(user_move + strlen("say "), 0);
5205         break;
5206       case WhiteKingSideCastle:
5207       case BlackKingSideCastle:
5208       case WhiteQueenSideCastleWild:
5209       case BlackQueenSideCastleWild:
5210       /* PUSH Fabien */
5211       case WhiteHSideCastleFR:
5212       case BlackHSideCastleFR:
5213       /* POP Fabien */
5214         snprintf(user_move, MSG_SIZ, "o-o%s\n", suffix);
5215         break;
5216       case WhiteQueenSideCastle:
5217       case BlackQueenSideCastle:
5218       case WhiteKingSideCastleWild:
5219       case BlackKingSideCastleWild:
5220       /* PUSH Fabien */
5221       case WhiteASideCastleFR:
5222       case BlackASideCastleFR:
5223       /* POP Fabien */
5224         snprintf(user_move, MSG_SIZ, "o-o-o%s\n",suffix);
5225         break;
5226       case WhiteNonPromotion:
5227       case BlackNonPromotion:
5228         sprintf(user_move, "%c%c%c%c==\n", AAA + fromX, ONE + fromY, AAA + toX, ONE + toY);
5229         break;
5230       case WhitePromotion:
5231       case BlackPromotion:
5232         if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier ||
5233            gameInfo.variant == VariantMakruk)
5234           snprintf(user_move, MSG_SIZ, "%c%c%c%c=%c\n",
5235                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
5236                 PieceToChar(WhiteFerz));
5237         else if(gameInfo.variant == VariantGreat)
5238           snprintf(user_move, MSG_SIZ,"%c%c%c%c=%c\n",
5239                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
5240                 PieceToChar(WhiteMan));
5241         else
5242           snprintf(user_move, MSG_SIZ, "%c%c%c%c=%c\n",
5243                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
5244                 promoChar);
5245         break;
5246       case WhiteDrop:
5247       case BlackDrop:
5248       drop:
5249         snprintf(user_move, MSG_SIZ, "%c@%c%c\n",
5250                  ToUpper(PieceToChar((ChessSquare) fromX)),
5251                  AAA + toX, ONE + toY);
5252         break;
5253       case IllegalMove:  /* could be a variant we don't quite understand */
5254         if(fromY == DROP_RANK) goto drop; // We need 'IllegalDrop' move type?
5255       case NormalMove:
5256       case WhiteCapturesEnPassant:
5257       case BlackCapturesEnPassant:
5258         snprintf(user_move, MSG_SIZ,"%c%c%c%c\n",
5259                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY);
5260         break;
5261     }
5262     SendToICS(user_move);
5263     if(appData.keepAlive) // [HGM] alive: schedule sending of dummy 'date' command
5264         ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
5265 }
5266
5267 void
5268 UploadGameEvent ()
5269 {   // [HGM] upload: send entire stored game to ICS as long-algebraic moves.
5270     int i, last = forwardMostMove; // make sure ICS reply cannot pre-empt us by clearing fmm
5271     static char *castlingStrings[4] = { "none", "kside", "qside", "both" };
5272     if(gameMode == IcsObserving || gameMode == IcsPlayingBlack || gameMode == IcsPlayingWhite) {
5273       DisplayError(_("You cannot do this while you are playing or observing"), 0);
5274       return;
5275     }
5276     if(gameMode != IcsExamining) { // is this ever not the case?
5277         char buf[MSG_SIZ], *p, *fen, command[MSG_SIZ], bsetup = 0;
5278
5279         if(ics_type == ICS_ICC) { // on ICC match ourselves in applicable variant
5280           snprintf(command,MSG_SIZ, "match %s", ics_handle);
5281         } else { // on FICS we must first go to general examine mode
5282           safeStrCpy(command, "examine\nbsetup", sizeof(command)/sizeof(command[0])); // and specify variant within it with bsetups
5283         }
5284         if(gameInfo.variant != VariantNormal) {
5285             // try figure out wild number, as xboard names are not always valid on ICS
5286             for(i=1; i<=36; i++) {
5287               snprintf(buf, MSG_SIZ, "wild/%d", i);
5288                 if(StringToVariant(buf) == gameInfo.variant) break;
5289             }
5290             if(i<=36 && ics_type == ICS_ICC) snprintf(buf, MSG_SIZ,"%s w%d\n", command, i);
5291             else if(i == 22) snprintf(buf,MSG_SIZ, "%s fr\n", command);
5292             else snprintf(buf, MSG_SIZ,"%s %s\n", command, VariantName(gameInfo.variant));
5293         } else snprintf(buf, MSG_SIZ,"%s\n", ics_type == ICS_ICC ? command : "examine\n"); // match yourself or examine
5294         SendToICS(ics_prefix);
5295         SendToICS(buf);
5296         if(startedFromSetupPosition || backwardMostMove != 0) {
5297           fen = PositionToFEN(backwardMostMove, NULL, 1);
5298           if(ics_type == ICS_ICC) { // on ICC we can simply send a complete FEN to set everything
5299             snprintf(buf, MSG_SIZ,"loadfen %s\n", fen);
5300             SendToICS(buf);
5301           } else { // FICS: everything has to set by separate bsetup commands
5302             p = strchr(fen, ' '); p[0] = NULLCHAR; // cut after board
5303             snprintf(buf, MSG_SIZ,"bsetup fen %s\n", fen);
5304             SendToICS(buf);
5305             if(!WhiteOnMove(backwardMostMove)) {
5306                 SendToICS("bsetup tomove black\n");
5307             }
5308             i = (strchr(p+3, 'K') != NULL) + 2*(strchr(p+3, 'Q') != NULL);
5309             snprintf(buf, MSG_SIZ,"bsetup wcastle %s\n", castlingStrings[i]);
5310             SendToICS(buf);
5311             i = (strchr(p+3, 'k') != NULL) + 2*(strchr(p+3, 'q') != NULL);
5312             snprintf(buf, MSG_SIZ, "bsetup bcastle %s\n", castlingStrings[i]);
5313             SendToICS(buf);
5314             i = boards[backwardMostMove][EP_STATUS];
5315             if(i >= 0) { // set e.p.
5316               snprintf(buf, MSG_SIZ,"bsetup eppos %c\n", i+AAA);
5317                 SendToICS(buf);
5318             }
5319             bsetup++;
5320           }
5321         }
5322       if(bsetup || ics_type != ICS_ICC && gameInfo.variant != VariantNormal)
5323             SendToICS("bsetup done\n"); // switch to normal examining.
5324     }
5325     for(i = backwardMostMove; i<last; i++) {
5326         char buf[20];
5327         snprintf(buf, sizeof(buf)/sizeof(buf[0]),"%s\n", parseList[i]);
5328         if((*buf == 'b' || *buf == 'B') && buf[1] == 'x') { // work-around for stupid FICS bug, which thinks bxc3 can be a Bishop move
5329             int len = strlen(moveList[i]);
5330             snprintf(buf, sizeof(buf)/sizeof(buf[0]),"%s", moveList[i]); // use long algebraic
5331             if(!isdigit(buf[len-2])) snprintf(buf+len-2, 20-len, "=%c\n", ToUpper(buf[len-2])); // promotion must have '=' in ICS format
5332         }
5333         SendToICS(buf);
5334     }
5335     SendToICS(ics_prefix);
5336     SendToICS(ics_type == ICS_ICC ? "tag result Game in progress\n" : "commit\n");
5337 }
5338
5339 int killX = -1, killY = -1, kill2X = -1, kill2Y = -1; // [HGM] lion: used for passing e.p. capture square to MakeMove
5340 int legNr = 1;
5341
5342 void
5343 CoordsToComputerAlgebraic (int rf, int ff, int rt, int ft, char promoChar, char move[9])
5344 {
5345     if (rf == DROP_RANK) {
5346       if(ff == EmptySquare) sprintf(move, "@@@@\n"); else // [HGM] pass
5347       sprintf(move, "%c@%c%c\n",
5348                 ToUpper(PieceToChar((ChessSquare) ff)), AAA + ft, ONE + rt);
5349     } else {
5350         if (promoChar == 'x' || promoChar == NULLCHAR) {
5351           sprintf(move, "%c%c%c%c\n",
5352                     AAA + ff, ONE + rf, AAA + ft, ONE + rt);
5353           if(killX >= 0 && killY >= 0) {
5354             sprintf(move+4, ";%c%c\n", AAA + killX, ONE + killY);
5355             if(kill2X >= 0 && kill2Y >= 0) sprintf(move+7, "%c%c\n", AAA + killX, ONE + killY);
5356           }
5357         } else {
5358             sprintf(move, "%c%c%c%c%c\n",
5359                     AAA + ff, ONE + rf, AAA + ft, ONE + rt, promoChar);
5360         }
5361     }
5362 }
5363
5364 void
5365 ProcessICSInitScript (FILE *f)
5366 {
5367     char buf[MSG_SIZ];
5368
5369     while (fgets(buf, MSG_SIZ, f)) {
5370         SendToICSDelayed(buf,(long)appData.msLoginDelay);
5371     }
5372
5373     fclose(f);
5374 }
5375
5376
5377 static int lastX, lastY, lastLeftX, lastLeftY, selectFlag;
5378 int dragging;
5379 static ClickType lastClickType;
5380
5381 int
5382 Partner (ChessSquare *p)
5383 { // change piece into promotion partner if one shogi-promotes to the other
5384   int stride = gameInfo.variant == VariantChu ? 22 : 11;
5385   ChessSquare partner;
5386   partner = (*p/stride & 1 ? *p - stride : *p + stride);
5387   if(PieceToChar(*p) != '+' && PieceToChar(partner) != '+') return 0;
5388   *p = partner;
5389   return 1;
5390 }
5391
5392 void
5393 Sweep (int step)
5394 {
5395     ChessSquare king = WhiteKing, pawn = WhitePawn, last = promoSweep;
5396     static int toggleFlag;
5397     if(gameInfo.variant == VariantKnightmate) king = WhiteUnicorn;
5398     if(gameInfo.variant == VariantSuicide || gameInfo.variant == VariantGiveaway) king = EmptySquare;
5399     if(promoSweep >= BlackPawn) king = WHITE_TO_BLACK king, pawn = WHITE_TO_BLACK pawn;
5400     if(gameInfo.variant == VariantSpartan && pawn == BlackPawn) pawn = BlackLance, king = EmptySquare;
5401     if(fromY != BOARD_HEIGHT-2 && fromY != 1 && gameInfo.variant != VariantChuChess) pawn = EmptySquare;
5402     if(!step) toggleFlag = Partner(&last); // piece has shogi-promotion
5403     do {
5404         if(step && !(toggleFlag && Partner(&promoSweep))) promoSweep -= step;
5405         if(promoSweep == EmptySquare) promoSweep = BlackPawn; // wrap
5406         else if((int)promoSweep == -1) promoSweep = WhiteKing;
5407         else if(promoSweep == BlackPawn && step < 0 && !toggleFlag) promoSweep = WhitePawn;
5408         else if(promoSweep == WhiteKing && step > 0 && !toggleFlag) promoSweep = BlackKing;
5409         if(!step) step = -1;
5410     } while(PieceToChar(promoSweep) == '.' || PieceToChar(promoSweep) == '~' || promoSweep == pawn ||
5411             !toggleFlag && PieceToChar(promoSweep) == '+' || // skip promoted versions of other
5412             appData.testLegality && (promoSweep == king || gameInfo.variant != VariantChuChess &&
5413             (promoSweep == WhiteLion || promoSweep == BlackLion)));
5414     if(toX >= 0) {
5415         int victim = boards[currentMove][toY][toX];
5416         boards[currentMove][toY][toX] = promoSweep;
5417         DrawPosition(FALSE, boards[currentMove]);
5418         boards[currentMove][toY][toX] = victim;
5419     } else
5420     ChangeDragPiece(promoSweep);
5421 }
5422
5423 int
5424 PromoScroll (int x, int y)
5425 {
5426   int step = 0;
5427
5428   if(promoSweep == EmptySquare || !appData.sweepSelect) return FALSE;
5429   if(abs(x - lastX) < 25 && abs(y - lastY) < 25) return FALSE;
5430   if( y > lastY + 2 ) step = -1; else if(y < lastY - 2) step = 1;
5431   if(!step) return FALSE;
5432   lastX = x; lastY = y;
5433   if((promoSweep < BlackPawn) == flipView) step = -step;
5434   if(step > 0) selectFlag = 1;
5435   if(!selectFlag) Sweep(step);
5436   return FALSE;
5437 }
5438
5439 void
5440 NextPiece (int step)
5441 {
5442     ChessSquare piece = boards[currentMove][toY][toX];
5443     do {
5444         pieceSweep -= step;
5445         if(pieceSweep == EmptySquare) pieceSweep = WhitePawn; // wrap
5446         if((int)pieceSweep == -1) pieceSweep = BlackKing;
5447         if(!step) step = -1;
5448     } while(PieceToChar(pieceSweep) == '.');
5449     boards[currentMove][toY][toX] = pieceSweep;
5450     DrawPosition(FALSE, boards[currentMove]);
5451     boards[currentMove][toY][toX] = piece;
5452 }
5453 /* [HGM] Shogi move preprocessor: swap digits for letters, vice versa */
5454 void
5455 AlphaRank (char *move, int n)
5456 {
5457 //    char *p = move, c; int x, y;
5458
5459     if (appData.debugMode) {
5460         fprintf(debugFP, "alphaRank(%s,%d)\n", move, n);
5461     }
5462
5463     if(move[1]=='*' &&
5464        move[2]>='0' && move[2]<='9' &&
5465        move[3]>='a' && move[3]<='x'    ) {
5466         move[1] = '@';
5467         move[2] = BOARD_RGHT  -1 - (move[2]-'1') + AAA;
5468         move[3] = BOARD_HEIGHT-1 - (move[3]-'a') + ONE;
5469     } else
5470     if(move[0]>='0' && move[0]<='9' &&
5471        move[1]>='a' && move[1]<='x' &&
5472        move[2]>='0' && move[2]<='9' &&
5473        move[3]>='a' && move[3]<='x'    ) {
5474         /* input move, Shogi -> normal */
5475         move[0] = BOARD_RGHT  -1 - (move[0]-'1') + AAA;
5476         move[1] = BOARD_HEIGHT-1 - (move[1]-'a') + ONE;
5477         move[2] = BOARD_RGHT  -1 - (move[2]-'1') + AAA;
5478         move[3] = BOARD_HEIGHT-1 - (move[3]-'a') + ONE;
5479     } else
5480     if(move[1]=='@' &&
5481        move[3]>='0' && move[3]<='9' &&
5482        move[2]>='a' && move[2]<='x'    ) {
5483         move[1] = '*';
5484         move[2] = BOARD_RGHT - 1 - (move[2]-AAA) + '1';
5485         move[3] = BOARD_HEIGHT-1 - (move[3]-ONE) + 'a';
5486     } else
5487     if(
5488        move[0]>='a' && move[0]<='x' &&
5489        move[3]>='0' && move[3]<='9' &&
5490        move[2]>='a' && move[2]<='x'    ) {
5491          /* output move, normal -> Shogi */
5492         move[0] = BOARD_RGHT - 1 - (move[0]-AAA) + '1';
5493         move[1] = BOARD_HEIGHT-1 - (move[1]-ONE) + 'a';
5494         move[2] = BOARD_RGHT - 1 - (move[2]-AAA) + '1';
5495         move[3] = BOARD_HEIGHT-1 - (move[3]-ONE) + 'a';
5496         if(move[4] == PieceToChar(BlackQueen)) move[4] = '+';
5497     }
5498     if (appData.debugMode) {
5499         fprintf(debugFP, "   out = '%s'\n", move);
5500     }
5501 }
5502
5503 char yy_textstr[8000];
5504
5505 /* Parser for moves from gnuchess, ICS, or user typein box */
5506 Boolean
5507 ParseOneMove (char *move, int moveNum, ChessMove *moveType, int *fromX, int *fromY, int *toX, int *toY, char *promoChar)
5508 {
5509     *moveType = yylexstr(moveNum, move, yy_textstr, sizeof yy_textstr);
5510
5511     switch (*moveType) {
5512       case WhitePromotion:
5513       case BlackPromotion:
5514       case WhiteNonPromotion:
5515       case BlackNonPromotion:
5516       case NormalMove:
5517       case FirstLeg:
5518       case WhiteCapturesEnPassant:
5519       case BlackCapturesEnPassant:
5520       case WhiteKingSideCastle:
5521       case WhiteQueenSideCastle:
5522       case BlackKingSideCastle:
5523       case BlackQueenSideCastle:
5524       case WhiteKingSideCastleWild:
5525       case WhiteQueenSideCastleWild:
5526       case BlackKingSideCastleWild:
5527       case BlackQueenSideCastleWild:
5528       /* Code added by Tord: */
5529       case WhiteHSideCastleFR:
5530       case WhiteASideCastleFR:
5531       case BlackHSideCastleFR:
5532       case BlackASideCastleFR:
5533       /* End of code added by Tord */
5534       case IllegalMove:         /* bug or odd chess variant */
5535         if(currentMoveString[1] == '@') { // illegal drop
5536           *fromX = WhiteOnMove(moveNum) ?
5537             (int) CharToPiece(ToUpper(currentMoveString[0])) :
5538             (int) CharToPiece(ToLower(currentMoveString[0]));
5539           goto drop;
5540         }
5541         *fromX = currentMoveString[0] - AAA;
5542         *fromY = currentMoveString[1] - ONE;
5543         *toX = currentMoveString[2] - AAA;
5544         *toY = currentMoveString[3] - ONE;
5545         *promoChar = currentMoveString[4];
5546         if (*fromX < BOARD_LEFT || *fromX >= BOARD_RGHT || *fromY < 0 || *fromY >= BOARD_HEIGHT ||
5547             *toX < BOARD_LEFT || *toX >= BOARD_RGHT || *toY < 0 || *toY >= BOARD_HEIGHT) {
5548     if (appData.debugMode) {
5549         fprintf(debugFP, "Off-board move (%d,%d)-(%d,%d)%c, type = %d\n", *fromX, *fromY, *toX, *toY, *promoChar, *moveType);
5550     }
5551             *fromX = *fromY = *toX = *toY = 0;
5552             return FALSE;
5553         }
5554         if (appData.testLegality) {
5555           return (*moveType != IllegalMove);
5556         } else {
5557           return !(*fromX == *toX && *fromY == *toY && killX < 0) && boards[moveNum][*fromY][*fromX] != EmptySquare &&
5558                          // [HGM] lion: if this is a double move we are less critical
5559                         WhiteOnMove(moveNum) == (boards[moveNum][*fromY][*fromX] < BlackPawn);
5560         }
5561
5562       case WhiteDrop:
5563       case BlackDrop:
5564         *fromX = *moveType == WhiteDrop ?
5565           (int) CharToPiece(ToUpper(currentMoveString[0])) :
5566           (int) CharToPiece(ToLower(currentMoveString[0]));
5567       drop:
5568         *fromY = DROP_RANK;
5569         *toX = currentMoveString[2] - AAA;
5570         *toY = currentMoveString[3] - ONE;
5571         *promoChar = NULLCHAR;
5572         return TRUE;
5573
5574       case AmbiguousMove:
5575       case ImpossibleMove:
5576       case EndOfFile:
5577       case ElapsedTime:
5578       case Comment:
5579       case PGNTag:
5580       case NAG:
5581       case WhiteWins:
5582       case BlackWins:
5583       case GameIsDrawn:
5584       default:
5585     if (appData.debugMode) {
5586         fprintf(debugFP, "Impossible move %s, type = %d\n", currentMoveString, *moveType);
5587     }
5588         /* bug? */
5589         *fromX = *fromY = *toX = *toY = 0;
5590         *promoChar = NULLCHAR;
5591         return FALSE;
5592     }
5593 }
5594
5595 Boolean pushed = FALSE;
5596 char *lastParseAttempt;
5597
5598 void
5599 ParsePV (char *pv, Boolean storeComments, Boolean atEnd)
5600 { // Parse a string of PV moves, and append to current game, behind forwardMostMove
5601   int fromX, fromY, toX, toY; char promoChar;
5602   ChessMove moveType;
5603   Boolean valid;
5604   int nr = 0;
5605
5606   lastParseAttempt = pv; if(!*pv) return;    // turns out we crash when we parse an empty PV
5607   if ((gameMode == AnalyzeMode || gameMode == AnalyzeFile) && currentMove < forwardMostMove) {
5608     PushInner(currentMove, forwardMostMove); // [HGM] engine might not be thinking on forwardMost position!
5609     pushed = TRUE;
5610   }
5611   endPV = forwardMostMove;
5612   do {
5613     while(*pv == ' ' || *pv == '\n' || *pv == '\t') pv++; // must still read away whitespace
5614     if(nr == 0 && !storeComments && *pv == '(') pv++; // first (ponder) move can be in parentheses
5615     lastParseAttempt = pv;
5616     valid = ParseOneMove(pv, endPV, &moveType, &fromX, &fromY, &toX, &toY, &promoChar);
5617     if(!valid && nr == 0 &&
5618        ParseOneMove(pv, endPV-1, &moveType, &fromX, &fromY, &toX, &toY, &promoChar)){
5619         nr++; moveType = Comment; // First move has been played; kludge to make sure we continue
5620         // Hande case where played move is different from leading PV move
5621         CopyBoard(boards[endPV+1], boards[endPV-1]); // tentatively unplay last game move
5622         CopyBoard(boards[endPV+2], boards[endPV-1]); // and play first move of PV
5623         ApplyMove(fromX, fromY, toX, toY, promoChar, boards[endPV+2]);
5624         if(!CompareBoards(boards[endPV], boards[endPV+2])) {
5625           endPV += 2; // if position different, keep this
5626           moveList[endPV-1][0] = fromX + AAA;
5627           moveList[endPV-1][1] = fromY + ONE;
5628           moveList[endPV-1][2] = toX + AAA;
5629           moveList[endPV-1][3] = toY + ONE;
5630           parseList[endPV-1][0] = NULLCHAR;
5631           safeStrCpy(moveList[endPV-2], "_0_0", sizeof(moveList[endPV-2])/sizeof(moveList[endPV-2][0])); // suppress premove highlight on takeback move
5632         }
5633       }
5634     pv = strstr(pv, yy_textstr) + strlen(yy_textstr); // skip what we parsed
5635     if(nr == 0 && !storeComments && *pv == ')') pv++; // closing parenthesis of ponder move;
5636     if(moveType == Comment && storeComments) AppendComment(endPV, yy_textstr, FALSE);
5637     if(moveType == Comment || moveType == NAG || moveType == ElapsedTime) {
5638         valid++; // allow comments in PV
5639         continue;
5640     }
5641     nr++;
5642     if(endPV+1 > framePtr) break; // no space, truncate
5643     if(!valid) break;
5644     endPV++;
5645     CopyBoard(boards[endPV], boards[endPV-1]);
5646     ApplyMove(fromX, fromY, toX, toY, promoChar, boards[endPV]);
5647     CoordsToComputerAlgebraic(fromY, fromX, toY, toX, promoChar, moveList[endPV - 1]);
5648     strncat(moveList[endPV-1], "\n", MOVE_LEN);
5649     CoordsToAlgebraic(boards[endPV - 1],
5650                              PosFlags(endPV - 1),
5651                              fromY, fromX, toY, toX, promoChar,
5652                              parseList[endPV - 1]);
5653   } while(valid);
5654   if(atEnd == 2) return; // used hidden, for PV conversion
5655   currentMove = (atEnd || endPV == forwardMostMove) ? endPV : forwardMostMove + 1;
5656   if(currentMove == forwardMostMove) ClearPremoveHighlights(); else
5657   SetPremoveHighlights(moveList[currentMove-1][0]-AAA, moveList[currentMove-1][1]-ONE,
5658                        moveList[currentMove-1][2]-AAA, moveList[currentMove-1][3]-ONE);
5659   DrawPosition(TRUE, boards[currentMove]);
5660 }
5661
5662 int
5663 MultiPV (ChessProgramState *cps)
5664 {       // check if engine supports MultiPV, and if so, return the number of the option that sets it
5665         int i;
5666         for(i=0; i<cps->nrOptions; i++)
5667             if(!strcmp(cps->option[i].name, "MultiPV") && cps->option[i].type == Spin)
5668                 return i;
5669         return -1;
5670 }
5671
5672 Boolean extendGame; // signals to UnLoadPV() if walked part of PV has to be appended to game
5673
5674 Boolean
5675 LoadMultiPV (int x, int y, char *buf, int index, int *start, int *end, int pane)
5676 {
5677         int startPV, multi, lineStart, origIndex = index;
5678         char *p, buf2[MSG_SIZ];
5679         ChessProgramState *cps = (pane ? &second : &first);
5680
5681         if(index < 0 || index >= strlen(buf)) return FALSE; // sanity
5682         lastX = x; lastY = y;
5683         while(index > 0 && buf[index-1] != '\n') index--; // beginning of line
5684         lineStart = startPV = index;
5685         while(buf[index] != '\n') if(buf[index++] == '\t') startPV = index;
5686         if(index == startPV && (p = StrCaseStr(buf+index, "PV="))) startPV = p - buf + 3;
5687         index = startPV;
5688         do{ while(buf[index] && buf[index] != '\n') index++;
5689         } while(buf[index] == '\n' && buf[index+1] == '\\' && buf[index+2] == ' ' && index++); // join kibitzed PV continuation line
5690         buf[index] = 0;
5691         if(lineStart == 0 && gameMode == AnalyzeMode && (multi = MultiPV(cps)) >= 0) {
5692                 int n = cps->option[multi].value;
5693                 if(origIndex > 17 && origIndex < 24) { if(n>1) n--; } else if(origIndex > index - 6) n++;
5694                 snprintf(buf2, MSG_SIZ, "option MultiPV=%d\n", n);
5695                 if(cps->option[multi].value != n) SendToProgram(buf2, cps);
5696                 cps->option[multi].value = n;
5697                 *start = *end = 0;
5698                 return FALSE;
5699         } else if(strstr(buf+lineStart, "exclude:") == buf+lineStart) { // exclude moves clicked
5700                 ExcludeClick(origIndex - lineStart);
5701                 return FALSE;
5702         } else if(!strncmp(buf+lineStart, "dep\t", 4)) {                // column headers clicked
5703                 Collapse(origIndex - lineStart);
5704                 return FALSE;
5705         }
5706         ParsePV(buf+startPV, FALSE, gameMode != AnalyzeMode);
5707         *start = startPV; *end = index-1;
5708         extendGame = (gameMode == AnalyzeMode && appData.autoExtend && origIndex - startPV < 5);
5709         return TRUE;
5710 }
5711
5712 char *
5713 PvToSAN (char *pv)
5714 {
5715         static char buf[10*MSG_SIZ];
5716         int i, k=0, savedEnd=endPV, saveFMM = forwardMostMove;
5717         *buf = NULLCHAR;
5718         if(forwardMostMove < endPV) PushInner(forwardMostMove, endPV); // shelve PV of PV-walk
5719         ParsePV(pv, FALSE, 2); // this appends PV to game, suppressing any display of it
5720         for(i = forwardMostMove; i<endPV; i++){
5721             if(i&1) snprintf(buf+k, 10*MSG_SIZ-k, "%s ", parseList[i]);
5722             else    snprintf(buf+k, 10*MSG_SIZ-k, "%d. %s ", i/2 + 1, parseList[i]);
5723             k += strlen(buf+k);
5724         }
5725         snprintf(buf+k, 10*MSG_SIZ-k, "%s", lastParseAttempt); // if we ran into stuff that could not be parsed, print it verbatim
5726         if(pushed) { PopInner(0); pushed = FALSE; } // restore game continuation shelved by ParsePV
5727         if(forwardMostMove < savedEnd) { PopInner(0); forwardMostMove = saveFMM; } // PopInner would set fmm to endPV!
5728         endPV = savedEnd;
5729         return buf;
5730 }
5731
5732 Boolean
5733 LoadPV (int x, int y)
5734 { // called on right mouse click to load PV
5735   int which = gameMode == TwoMachinesPlay && (WhiteOnMove(forwardMostMove) == (second.twoMachinesColor[0] == 'w'));
5736   lastX = x; lastY = y;
5737   ParsePV(lastPV[which], FALSE, TRUE); // load the PV of the thinking engine in the boards array.
5738   extendGame = FALSE;
5739   return TRUE;
5740 }
5741
5742 void
5743 UnLoadPV ()
5744 {
5745   int oldFMM = forwardMostMove; // N.B.: this was currentMove before PV was loaded!
5746   if(endPV < 0) return;
5747   if(appData.autoCopyPV) CopyFENToClipboard();
5748   endPV = -1;
5749   if(extendGame && currentMove > forwardMostMove) {
5750         Boolean saveAnimate = appData.animate;
5751         if(pushed) {
5752             if(shiftKey && storedGames < MAX_VARIATIONS-2) { // wants to start variation, and there is space
5753                 if(storedGames == 1) GreyRevert(FALSE);      // we already pushed the tail, so just make it official
5754             } else storedGames--; // abandon shelved tail of original game
5755         }
5756         pushed = FALSE;
5757         forwardMostMove = currentMove;
5758         currentMove = oldFMM;
5759         appData.animate = FALSE;
5760         ToNrEvent(forwardMostMove);
5761         appData.animate = saveAnimate;
5762   }
5763   currentMove = forwardMostMove;
5764   if(pushed) { PopInner(0); pushed = FALSE; } // restore shelved game continuation
5765   ClearPremoveHighlights();
5766   DrawPosition(TRUE, boards[currentMove]);
5767 }
5768
5769 void
5770 MovePV (int x, int y, int h)
5771 { // step through PV based on mouse coordinates (called on mouse move)
5772   int margin = h>>3, step = 0, threshold = (pieceSweep == EmptySquare ? 10 : 15);
5773
5774   // we must somehow check if right button is still down (might be released off board!)
5775   if(endPV < 0 && pieceSweep == EmptySquare) return; // needed in XBoard because lastX/Y is shared :-(
5776   if(abs(x - lastX) < threshold && abs(y - lastY) < threshold) return;
5777   if( y > lastY + 2 ) step = -1; else if(y < lastY - 2) step = 1;
5778   if(!step) return;
5779   lastX = x; lastY = y;
5780
5781   if(pieceSweep != EmptySquare) { NextPiece(step); return; }
5782   if(endPV < 0) return;
5783   if(y < margin) step = 1; else
5784   if(y > h - margin) step = -1;
5785   if(currentMove + step > endPV || currentMove + step < forwardMostMove) step = 0;
5786   currentMove += step;
5787   if(currentMove == forwardMostMove) ClearPremoveHighlights(); else
5788   SetPremoveHighlights(moveList[currentMove-1][0]-AAA, moveList[currentMove-1][1]-ONE,
5789                        moveList[currentMove-1][2]-AAA, moveList[currentMove-1][3]-ONE);
5790   DrawPosition(FALSE, boards[currentMove]);
5791 }
5792
5793
5794 // [HGM] shuffle: a general way to suffle opening setups, applicable to arbitrary variants.
5795 // All positions will have equal probability, but the current method will not provide a unique
5796 // numbering scheme for arrays that contain 3 or more pieces of the same kind.
5797 #define DARK 1
5798 #define LITE 2
5799 #define ANY 3
5800
5801 int squaresLeft[4];
5802 int piecesLeft[(int)BlackPawn];
5803 int seed, nrOfShuffles;
5804
5805 void
5806 GetPositionNumber ()
5807 {       // sets global variable seed
5808         int i;
5809
5810         seed = appData.defaultFrcPosition;
5811         if(seed < 0) { // randomize based on time for negative FRC position numbers
5812                 for(i=0; i<50; i++) seed += random();
5813                 seed = random() ^ random() >> 8 ^ random() << 8;
5814                 if(seed<0) seed = -seed;
5815         }
5816 }
5817
5818 int
5819 put (Board board, int pieceType, int rank, int n, int shade)
5820 // put the piece on the (n-1)-th empty squares of the given shade
5821 {
5822         int i;
5823
5824         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) {
5825                 if( (((i-BOARD_LEFT)&1)+1) & shade && board[rank][i] == EmptySquare && n-- == 0) {
5826                         board[rank][i] = (ChessSquare) pieceType;
5827                         squaresLeft[((i-BOARD_LEFT)&1) + 1]--;
5828                         squaresLeft[ANY]--;
5829                         piecesLeft[pieceType]--;
5830                         return i;
5831                 }
5832         }
5833         return -1;
5834 }
5835
5836
5837 void
5838 AddOnePiece (Board board, int pieceType, int rank, int shade)
5839 // calculate where the next piece goes, (any empty square), and put it there
5840 {
5841         int i;
5842
5843         i = seed % squaresLeft[shade];
5844         nrOfShuffles *= squaresLeft[shade];
5845         seed /= squaresLeft[shade];
5846         put(board, pieceType, rank, i, shade);
5847 }
5848
5849 void
5850 AddTwoPieces (Board board, int pieceType, int rank)
5851 // calculate where the next 2 identical pieces go, (any empty square), and put it there
5852 {
5853         int i, n=squaresLeft[ANY], j=n-1, k;
5854
5855         k = n*(n-1)/2; // nr of possibilities, not counting permutations
5856         i = seed % k;  // pick one
5857         nrOfShuffles *= k;
5858         seed /= k;
5859         while(i >= j) i -= j--;
5860         j = n - 1 - j; i += j;
5861         put(board, pieceType, rank, j, ANY);
5862         put(board, pieceType, rank, i, ANY);
5863 }
5864
5865 void
5866 SetUpShuffle (Board board, int number)
5867 {
5868         int i, p, first=1;
5869
5870         GetPositionNumber(); nrOfShuffles = 1;
5871
5872         squaresLeft[DARK] = (BOARD_RGHT - BOARD_LEFT + 1)/2;
5873         squaresLeft[ANY]  = BOARD_RGHT - BOARD_LEFT;
5874         squaresLeft[LITE] = squaresLeft[ANY] - squaresLeft[DARK];
5875
5876         for(p = 0; p<=(int)WhiteKing; p++) piecesLeft[p] = 0;
5877
5878         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) { // count pieces and clear board
5879             p = (int) board[0][i];
5880             if(p < (int) BlackPawn) piecesLeft[p] ++;
5881             board[0][i] = EmptySquare;
5882         }
5883
5884         if(PosFlags(0) & F_ALL_CASTLE_OK) {
5885             // shuffles restricted to allow normal castling put KRR first
5886             if(piecesLeft[(int)WhiteKing]) // King goes rightish of middle
5887                 put(board, WhiteKing, 0, (gameInfo.boardWidth+1)/2, ANY);
5888             else if(piecesLeft[(int)WhiteUnicorn]) // in Knightmate Unicorn castles
5889                 put(board, WhiteUnicorn, 0, (gameInfo.boardWidth+1)/2, ANY);
5890             if(piecesLeft[(int)WhiteRook]) // First supply a Rook for K-side castling
5891                 put(board, WhiteRook, 0, gameInfo.boardWidth-2, ANY);
5892             if(piecesLeft[(int)WhiteRook]) // Then supply a Rook for Q-side castling
5893                 put(board, WhiteRook, 0, 0, ANY);
5894             // in variants with super-numerary Kings and Rooks, we leave these for the shuffle
5895         }
5896
5897         if(((BOARD_RGHT-BOARD_LEFT) & 1) == 0)
5898             // only for even boards make effort to put pairs of colorbound pieces on opposite colors
5899             for(p = (int) WhiteKing; p > (int) WhitePawn; p--) {
5900                 if(p != (int) WhiteBishop && p != (int) WhiteFerz && p != (int) WhiteAlfil) continue;
5901                 while(piecesLeft[p] >= 2) {
5902                     AddOnePiece(board, p, 0, LITE);
5903                     AddOnePiece(board, p, 0, DARK);
5904                 }
5905                 // Odd color-bound pieces are shuffled with the rest (to not run out of paired squares)
5906             }
5907
5908         for(p = (int) WhiteKing - 2; p > (int) WhitePawn; p--) {
5909             // Remaining pieces (non-colorbound, or odd color bound) can be put anywhere
5910             // but we leave King and Rooks for last, to possibly obey FRC restriction
5911             if(p == (int)WhiteRook) continue;
5912             while(piecesLeft[p] >= 2) AddTwoPieces(board, p, 0); // add in pairs, for not counting permutations
5913             if(piecesLeft[p]) AddOnePiece(board, p, 0, ANY);     // add the odd piece
5914         }
5915
5916         // now everything is placed, except perhaps King (Unicorn) and Rooks
5917
5918         if(PosFlags(0) & F_FRC_TYPE_CASTLING) {
5919             // Last King gets castling rights
5920             while(piecesLeft[(int)WhiteUnicorn]) {
5921                 i = put(board, WhiteUnicorn, 0, piecesLeft[(int)WhiteRook]/2, ANY);
5922                 initialRights[2]  = initialRights[5]  = board[CASTLING][2] = board[CASTLING][5] = i;
5923             }
5924
5925             while(piecesLeft[(int)WhiteKing]) {
5926                 i = put(board, WhiteKing, 0, piecesLeft[(int)WhiteRook]/2, ANY);
5927                 initialRights[2]  = initialRights[5]  = board[CASTLING][2] = board[CASTLING][5] = i;
5928             }
5929
5930
5931         } else {
5932             while(piecesLeft[(int)WhiteKing])    AddOnePiece(board, WhiteKing, 0, ANY);
5933             while(piecesLeft[(int)WhiteUnicorn]) AddOnePiece(board, WhiteUnicorn, 0, ANY);
5934         }
5935
5936         // Only Rooks can be left; simply place them all
5937         while(piecesLeft[(int)WhiteRook]) {
5938                 i = put(board, WhiteRook, 0, 0, ANY);
5939                 if(PosFlags(0) & F_FRC_TYPE_CASTLING) { // first and last Rook get FRC castling rights
5940                         if(first) {
5941                                 first=0;
5942                                 initialRights[1]  = initialRights[4]  = board[CASTLING][1] = board[CASTLING][4] = i;
5943                         }
5944                         initialRights[0]  = initialRights[3]  = board[CASTLING][0] = board[CASTLING][3] = i;
5945                 }
5946         }
5947         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) { // copy black from white
5948             board[BOARD_HEIGHT-1][i] =  (int) board[0][i] < BlackPawn ? WHITE_TO_BLACK board[0][i] : EmptySquare;
5949         }
5950
5951         if(number >= 0) appData.defaultFrcPosition %= nrOfShuffles; // normalize
5952 }
5953
5954 int
5955 ptclen (const char *s, char *escapes)
5956 {
5957     int n = 0;
5958     if(!*escapes) return strlen(s);
5959     while(*s) n += (*s != '/' && !strchr(escapes, *s)), s++;
5960     return n;
5961 }
5962
5963 int
5964 SetCharTableEsc (unsigned char *table, const char * map, char * escapes)
5965 /* [HGM] moved here from winboard.c because of its general usefulness */
5966 /*       Basically a safe strcpy that uses the last character as King */
5967 {
5968     int result = FALSE; int NrPieces, offs;
5969
5970     if( map != NULL && (NrPieces=ptclen(map, escapes)) <= (int) EmptySquare
5971                     && NrPieces >= 12 && !(NrPieces&1)) {
5972         int i, j = 0; /* [HGM] Accept even length from 12 to 88 */
5973
5974         for( i=0; i<(int) EmptySquare; i++ ) table[i] = '.';
5975         for( i=offs=0; i<NrPieces/2-1; i++ ) {
5976             char *p;
5977             if(map[j] == '/' && *escapes) offs = WhiteTokin - i, j++;
5978             table[i + offs] = map[j++];
5979             if(p = strchr(escapes, map[j])) j++, table[i + offs] += 64*(p - escapes + 1);
5980         }
5981         table[(int) WhiteKing]  = map[j++];
5982         for( i=offs=0; i<NrPieces/2-1; i++ ) {
5983             char *p;
5984             if(map[j] == '/' && *escapes) offs = WhiteTokin - i, j++;
5985             table[WHITE_TO_BLACK i + offs] = map[j++];
5986             if(p = strchr(escapes, map[j])) j++, table[WHITE_TO_BLACK i + offs] += 64*(p - escapes + 1);
5987         }
5988         table[(int) BlackKing]  = map[j++];
5989
5990         result = TRUE;
5991     }
5992
5993     return result;
5994 }
5995
5996 int
5997 SetCharTable (unsigned char *table, const char * map)
5998 {
5999     return SetCharTableEsc(table, map, "");
6000 }
6001
6002 void
6003 Prelude (Board board)
6004 {       // [HGM] superchess: random selection of exo-pieces
6005         int i, j, k; ChessSquare p;
6006         static ChessSquare exoPieces[4] = { WhiteAngel, WhiteMarshall, WhiteSilver, WhiteLance };
6007
6008         GetPositionNumber(); // use FRC position number
6009
6010         if(appData.pieceToCharTable != NULL) { // select pieces to participate from given char table
6011             SetCharTable(pieceToChar, appData.pieceToCharTable);
6012             for(i=(int)WhiteQueen+1, j=0; i<(int)WhiteKing && j<4; i++)
6013                 if(PieceToChar((ChessSquare)i) != '.') exoPieces[j++] = (ChessSquare) i;
6014         }
6015
6016         j = seed%4;                 seed /= 4;
6017         p = board[0][BOARD_LEFT+j];   board[0][BOARD_LEFT+j] = EmptySquare; k = PieceToNumber(p);
6018         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
6019         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
6020         j = seed%3 + (seed%3 >= j); seed /= 3;
6021         p = board[0][BOARD_LEFT+j];   board[0][BOARD_LEFT+j] = EmptySquare; k = PieceToNumber(p);
6022         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
6023         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
6024         j = seed%3;                 seed /= 3;
6025         p = board[0][BOARD_LEFT+j+5]; board[0][BOARD_LEFT+j+5] = EmptySquare; k = PieceToNumber(p);
6026         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
6027         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
6028         j = seed%2 + (seed%2 >= j); seed /= 2;
6029         p = board[0][BOARD_LEFT+j+5]; board[0][BOARD_LEFT+j+5] = EmptySquare; k = PieceToNumber(p);
6030         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
6031         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
6032         j = seed%4; seed /= 4; put(board, exoPieces[3],    0, j, ANY);
6033         j = seed%3; seed /= 3; put(board, exoPieces[2],   0, j, ANY);
6034         j = seed%2; seed /= 2; put(board, exoPieces[1], 0, j, ANY);
6035         put(board, exoPieces[0],    0, 0, ANY);
6036         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) board[BOARD_HEIGHT-1][i] = WHITE_TO_BLACK board[0][i];
6037 }
6038
6039 void
6040 InitPosition (int redraw)
6041 {
6042     ChessSquare (* pieces)[BOARD_FILES];
6043     int i, j, pawnRow=1, pieceRows=1, overrule,
6044     oldx = gameInfo.boardWidth,
6045     oldy = gameInfo.boardHeight,
6046     oldh = gameInfo.holdingsWidth;
6047     static int oldv;
6048
6049     if(appData.icsActive) shuffleOpenings = appData.fischerCastling = FALSE; // [HGM] shuffle: in ICS mode, only shuffle on ICS request
6050
6051     /* [AS] Initialize pv info list [HGM] and game status */
6052     {
6053         for( i=0; i<=framePtr; i++ ) { // [HGM] vari: spare saved variations
6054             pvInfoList[i].depth = 0;
6055             boards[i][EP_STATUS] = EP_NONE;
6056             for( j=0; j<BOARD_FILES-2; j++ ) boards[i][CASTLING][j] = NoRights;
6057         }
6058
6059         initialRulePlies = 0; /* 50-move counter start */
6060
6061         castlingRank[0] = castlingRank[1] = castlingRank[2] = 0;
6062         castlingRank[3] = castlingRank[4] = castlingRank[5] = BOARD_HEIGHT-1;
6063     }
6064
6065
6066     /* [HGM] logic here is completely changed. In stead of full positions */
6067     /* the initialized data only consist of the two backranks. The switch */
6068     /* selects which one we will use, which is than copied to the Board   */
6069     /* initialPosition, which for the rest is initialized by Pawns and    */
6070     /* empty squares. This initial position is then copied to boards[0],  */
6071     /* possibly after shuffling, so that it remains available.            */
6072
6073     gameInfo.holdingsWidth = 0; /* default board sizes */
6074     gameInfo.boardWidth    = 8;
6075     gameInfo.boardHeight   = 8;
6076     gameInfo.holdingsSize  = 0;
6077     nrCastlingRights = -1; /* [HGM] Kludge to indicate default should be used */
6078     for(i=0; i<BOARD_FILES-6; i++)
6079       initialPosition[CASTLING][i] = initialRights[i] = NoRights; /* but no rights yet */
6080     initialPosition[EP_STATUS] = EP_NONE;
6081     initialPosition[TOUCHED_W] = initialPosition[TOUCHED_B] = 0;
6082     SetCharTable(pieceToChar, "PNBRQ...........Kpnbrq...........k");
6083     if(startVariant == gameInfo.variant) // [HGM] nicks: enable nicknames in original variant
6084          SetCharTable(pieceNickName, appData.pieceNickNames);
6085     else SetCharTable(pieceNickName, "............");
6086     pieces = FIDEArray;
6087
6088     switch (gameInfo.variant) {
6089     case VariantFischeRandom:
6090       shuffleOpenings = TRUE;
6091       appData.fischerCastling = TRUE;
6092     default:
6093       break;
6094     case VariantShatranj:
6095       pieces = ShatranjArray;
6096       nrCastlingRights = 0;
6097       SetCharTable(pieceToChar, "PN.R.QB...Kpn.r.qb...k");
6098       break;
6099     case VariantMakruk:
6100       pieces = makrukArray;
6101       nrCastlingRights = 0;
6102       SetCharTable(pieceToChar, "PN.R.M....SKpn.r.m....sk");
6103       break;
6104     case VariantASEAN:
6105       pieces = aseanArray;
6106       nrCastlingRights = 0;
6107       SetCharTable(pieceToChar, "PN.R.Q....BKpn.r.q....bk");
6108       break;
6109     case VariantTwoKings:
6110       pieces = twoKingsArray;
6111       break;
6112     case VariantGrand:
6113       pieces = GrandArray;
6114       nrCastlingRights = 0;
6115       SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
6116       gameInfo.boardWidth = 10;
6117       gameInfo.boardHeight = 10;
6118       gameInfo.holdingsSize = 7;
6119       break;
6120     case VariantCapaRandom:
6121       shuffleOpenings = TRUE;
6122       appData.fischerCastling = TRUE;
6123     case VariantCapablanca:
6124       pieces = CapablancaArray;
6125       gameInfo.boardWidth = 10;
6126       SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
6127       break;
6128     case VariantGothic:
6129       pieces = GothicArray;
6130       gameInfo.boardWidth = 10;
6131       SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
6132       break;
6133     case VariantSChess:
6134       SetCharTable(pieceToChar, "PNBRQ..HEKpnbrq..hek");
6135       gameInfo.holdingsSize = 7;
6136       for(i=0; i<BOARD_FILES; i++) initialPosition[VIRGIN][i] = VIRGIN_W | VIRGIN_B;
6137       break;
6138     case VariantJanus:
6139       pieces = JanusArray;
6140       gameInfo.boardWidth = 10;
6141       SetCharTable(pieceToChar, "PNBRQ..JKpnbrq..jk");
6142       nrCastlingRights = 6;
6143         initialPosition[CASTLING][0] = initialRights[0] = BOARD_RGHT-1;
6144         initialPosition[CASTLING][1] = initialRights[1] = BOARD_LEFT;
6145         initialPosition[CASTLING][2] = initialRights[2] =(BOARD_WIDTH-1)>>1;
6146         initialPosition[CASTLING][3] = initialRights[3] = BOARD_RGHT-1;
6147         initialPosition[CASTLING][4] = initialRights[4] = BOARD_LEFT;
6148         initialPosition[CASTLING][5] = initialRights[5] =(BOARD_WIDTH-1)>>1;
6149       break;
6150     case VariantFalcon:
6151       pieces = FalconArray;
6152       gameInfo.boardWidth = 10;
6153       SetCharTable(pieceToChar, "PNBRQ............FKpnbrq............fk");
6154       break;
6155     case VariantXiangqi:
6156       pieces = XiangqiArray;
6157       gameInfo.boardWidth  = 9;
6158       gameInfo.boardHeight = 10;
6159       nrCastlingRights = 0;
6160       SetCharTable(pieceToChar, "PH.R.AE..K.C.ph.r.ae..k.c.");
6161       break;
6162     case VariantShogi:
6163       pieces = ShogiArray;
6164       gameInfo.boardWidth  = 9;
6165       gameInfo.boardHeight = 9;
6166       gameInfo.holdingsSize = 7;
6167       nrCastlingRights = 0;
6168       SetCharTable(pieceToChar, "PNBRLS...G.++++++Kpnbrls...g.++++++k");
6169       break;
6170     case VariantChu:
6171       pieces = ChuArray; pieceRows = 3;
6172       gameInfo.boardWidth  = 12;
6173       gameInfo.boardHeight = 12;
6174       nrCastlingRights = 0;
6175       SetCharTableEsc(pieceToChar, "P.BRQSEXOGCATHD.VMLIFN/+.++.++++++++++.+++++K"
6176                                    "p.brqsexogcathd.vmlifn/+.++.++++++++++.+++++k", SUFFIXES);
6177       break;
6178     case VariantCourier:
6179       pieces = CourierArray;
6180       gameInfo.boardWidth  = 12;
6181       nrCastlingRights = 0;
6182       SetCharTable(pieceToChar, "PNBR.FE..WMKpnbr.fe..wmk");
6183       break;
6184     case VariantKnightmate:
6185       pieces = KnightmateArray;
6186       SetCharTable(pieceToChar, "P.BRQ.....M.........K.p.brq.....m.........k.");
6187       break;
6188     case VariantSpartan:
6189       pieces = SpartanArray;
6190       SetCharTable(pieceToChar, "PNBRQ................K......lwg.....c...h..k");
6191       break;
6192     case VariantLion:
6193       pieces = lionArray;
6194       SetCharTable(pieceToChar, "PNBRQ................LKpnbrq................lk");
6195       break;
6196     case VariantChuChess:
6197       pieces = ChuChessArray;
6198       gameInfo.boardWidth = 10;
6199       gameInfo.boardHeight = 10;
6200       SetCharTable(pieceToChar, "PNBRQ.....M.+++......LKpnbrq.....m.+++......lk");
6201       break;
6202     case VariantFairy:
6203       pieces = fairyArray;
6204       SetCharTable(pieceToChar, "PNBRQFEACWMOHIJGDVLSUKpnbrqfeacwmohijgdvlsuk");
6205       break;
6206     case VariantGreat:
6207       pieces = GreatArray;
6208       gameInfo.boardWidth = 10;
6209       SetCharTable(pieceToChar, "PN....E...S..HWGMKpn....e...s..hwgmk");
6210       gameInfo.holdingsSize = 8;
6211       break;
6212     case VariantSuper:
6213       pieces = FIDEArray;
6214       SetCharTable(pieceToChar, "PNBRQ..SE.......V.AKpnbrq..se.......v.ak");
6215       gameInfo.holdingsSize = 8;
6216       startedFromSetupPosition = TRUE;
6217       break;
6218     case VariantCrazyhouse:
6219     case VariantBughouse:
6220       pieces = FIDEArray;
6221       SetCharTable(pieceToChar, "PNBRQ.......~~~~Kpnbrq.......~~~~k");
6222       gameInfo.holdingsSize = 5;
6223       break;
6224     case VariantWildCastle:
6225       pieces = FIDEArray;
6226       /* !!?shuffle with kings guaranteed to be on d or e file */
6227       shuffleOpenings = 1;
6228       break;
6229     case VariantNoCastle:
6230       pieces = FIDEArray;
6231       nrCastlingRights = 0;
6232       /* !!?unconstrained back-rank shuffle */
6233       shuffleOpenings = 1;
6234       break;
6235     }
6236
6237     overrule = 0;
6238     if(appData.NrFiles >= 0) {
6239         if(gameInfo.boardWidth != appData.NrFiles) overrule++;
6240         gameInfo.boardWidth = appData.NrFiles;
6241     }
6242     if(appData.NrRanks >= 0) {
6243         gameInfo.boardHeight = appData.NrRanks;
6244     }
6245     if(appData.holdingsSize >= 0) {
6246         i = appData.holdingsSize;
6247         if(i > gameInfo.boardHeight) i = gameInfo.boardHeight;
6248         gameInfo.holdingsSize = i;
6249     }
6250     if(gameInfo.holdingsSize) gameInfo.holdingsWidth = 2;
6251     if(BOARD_HEIGHT > BOARD_RANKS || BOARD_WIDTH > BOARD_FILES)
6252         DisplayFatalError(_("Recompile to support this BOARD_RANKS or BOARD_FILES!"), 0, 2);
6253
6254     pawnRow = gameInfo.boardHeight - 7; /* seems to work in all common variants */
6255     if(pawnRow < 1) pawnRow = 1;
6256     if(gameInfo.variant == VariantMakruk || gameInfo.variant == VariantASEAN ||
6257        gameInfo.variant == VariantGrand || gameInfo.variant == VariantChuChess) pawnRow = 2;
6258     if(gameInfo.variant == VariantChu) pawnRow = 3;
6259
6260     /* User pieceToChar list overrules defaults */
6261     if(appData.pieceToCharTable != NULL)
6262         SetCharTableEsc(pieceToChar, appData.pieceToCharTable, SUFFIXES);
6263
6264     for( j=0; j<BOARD_WIDTH; j++ ) { ChessSquare s = EmptySquare;
6265
6266         if(j==BOARD_LEFT-1 || j==BOARD_RGHT)
6267             s = (ChessSquare) 0; /* account holding counts in guard band */
6268         for( i=0; i<BOARD_HEIGHT; i++ )
6269             initialPosition[i][j] = s;
6270
6271         if(j < BOARD_LEFT || j >= BOARD_RGHT || overrule) continue;
6272         initialPosition[gameInfo.variant == VariantGrand || gameInfo.variant == VariantChuChess][j] = pieces[0][j-gameInfo.holdingsWidth];
6273         initialPosition[pawnRow][j] = WhitePawn;
6274         initialPosition[BOARD_HEIGHT-pawnRow-1][j] = gameInfo.variant == VariantSpartan ? BlackLance : BlackPawn;
6275         if(gameInfo.variant == VariantXiangqi) {
6276             if(j&1) {
6277                 initialPosition[pawnRow][j] =
6278                 initialPosition[BOARD_HEIGHT-pawnRow-1][j] = EmptySquare;
6279                 if(j==BOARD_LEFT+1 || j>=BOARD_RGHT-2) {
6280                    initialPosition[2][j] = WhiteCannon;
6281                    initialPosition[BOARD_HEIGHT-3][j] = BlackCannon;
6282                 }
6283             }
6284         }
6285         if(gameInfo.variant == VariantChu) {
6286              if(j == (BOARD_WIDTH-2)/3 || j == BOARD_WIDTH - (BOARD_WIDTH+1)/3)
6287                initialPosition[pawnRow+1][j] = WhiteCobra,
6288                initialPosition[BOARD_HEIGHT-pawnRow-2][j] = BlackCobra;
6289              for(i=1; i<pieceRows; i++) {
6290                initialPosition[i][j] = pieces[2*i][j-gameInfo.holdingsWidth];
6291                initialPosition[BOARD_HEIGHT-1-i][j] =  pieces[2*i+1][j-gameInfo.holdingsWidth];
6292              }
6293         }
6294         if(gameInfo.variant == VariantGrand || gameInfo.variant == VariantChuChess) {
6295             if(j==BOARD_LEFT || j>=BOARD_RGHT-1) {
6296                initialPosition[0][j] = WhiteRook;
6297                initialPosition[BOARD_HEIGHT-1][j] = BlackRook;
6298             }
6299         }
6300         initialPosition[BOARD_HEIGHT-1-(gameInfo.variant == VariantGrand || gameInfo.variant == VariantChuChess)][j] =  pieces[1][j-gameInfo.holdingsWidth];
6301     }
6302     if(gameInfo.variant == VariantChuChess) initialPosition[0][BOARD_WIDTH/2] = WhiteKing, initialPosition[BOARD_HEIGHT-1][BOARD_WIDTH/2-1] = BlackKing;
6303     if( (gameInfo.variant == VariantShogi) && !overrule ) {
6304
6305             j=BOARD_LEFT+1;
6306             initialPosition[1][j] = WhiteBishop;
6307             initialPosition[BOARD_HEIGHT-2][j] = BlackRook;
6308             j=BOARD_RGHT-2;
6309             initialPosition[1][j] = WhiteRook;
6310             initialPosition[BOARD_HEIGHT-2][j] = BlackBishop;
6311     }
6312
6313     if( nrCastlingRights == -1) {
6314         /* [HGM] Build normal castling rights (must be done after board sizing!) */
6315         /*       This sets default castling rights from none to normal corners   */
6316         /* Variants with other castling rights must set them themselves above    */
6317         nrCastlingRights = 6;
6318
6319         initialPosition[CASTLING][0] = initialRights[0] = BOARD_RGHT-1;
6320         initialPosition[CASTLING][1] = initialRights[1] = BOARD_LEFT;
6321         initialPosition[CASTLING][2] = initialRights[2] = BOARD_WIDTH>>1;
6322         initialPosition[CASTLING][3] = initialRights[3] = BOARD_RGHT-1;
6323         initialPosition[CASTLING][4] = initialRights[4] = BOARD_LEFT;
6324         initialPosition[CASTLING][5] = initialRights[5] = BOARD_WIDTH>>1;
6325      }
6326
6327      if(gameInfo.variant == VariantSuper) Prelude(initialPosition);
6328      if(gameInfo.variant == VariantGreat) { // promotion commoners
6329         initialPosition[PieceToNumber(WhiteMan)][BOARD_WIDTH-1] = WhiteMan;
6330         initialPosition[PieceToNumber(WhiteMan)][BOARD_WIDTH-2] = 9;
6331         initialPosition[BOARD_HEIGHT-1-PieceToNumber(WhiteMan)][0] = BlackMan;
6332         initialPosition[BOARD_HEIGHT-1-PieceToNumber(WhiteMan)][1] = 9;
6333      }
6334      if( gameInfo.variant == VariantSChess ) {
6335       initialPosition[1][0] = BlackMarshall;
6336       initialPosition[2][0] = BlackAngel;
6337       initialPosition[6][BOARD_WIDTH-1] = WhiteMarshall;
6338       initialPosition[5][BOARD_WIDTH-1] = WhiteAngel;
6339       initialPosition[1][1] = initialPosition[2][1] =
6340       initialPosition[6][BOARD_WIDTH-2] = initialPosition[5][BOARD_WIDTH-2] = 1;
6341      }
6342   if (appData.debugMode) {
6343     fprintf(debugFP, "shuffleOpenings = %d\n", shuffleOpenings);
6344   }
6345     if(shuffleOpenings) {
6346         SetUpShuffle(initialPosition, appData.defaultFrcPosition);
6347         startedFromSetupPosition = TRUE;
6348     }
6349     if(startedFromPositionFile) {
6350       /* [HGM] loadPos: use PositionFile for every new game */
6351       CopyBoard(initialPosition, filePosition);
6352       for(i=0; i<nrCastlingRights; i++)
6353           initialRights[i] = filePosition[CASTLING][i];
6354       startedFromSetupPosition = TRUE;
6355     }
6356
6357     CopyBoard(boards[0], initialPosition);
6358
6359     if(oldx != gameInfo.boardWidth ||
6360        oldy != gameInfo.boardHeight ||
6361        oldv != gameInfo.variant ||
6362        oldh != gameInfo.holdingsWidth
6363                                          )
6364             InitDrawingSizes(-2 ,0);
6365
6366     oldv = gameInfo.variant;
6367     if (redraw)
6368       DrawPosition(TRUE, boards[currentMove]);
6369 }
6370
6371 void
6372 SendBoard (ChessProgramState *cps, int moveNum)
6373 {
6374     char message[MSG_SIZ];
6375
6376     if (cps->useSetboard) {
6377       char* fen = PositionToFEN(moveNum, cps->fenOverride, 1);
6378       snprintf(message, MSG_SIZ,"setboard %s\n", fen);
6379       SendToProgram(message, cps);
6380       free(fen);
6381
6382     } else {
6383       ChessSquare *bp;
6384       int i, j, left=0, right=BOARD_WIDTH;
6385       /* Kludge to set black to move, avoiding the troublesome and now
6386        * deprecated "black" command.
6387        */
6388       if (!WhiteOnMove(moveNum)) // [HGM] but better a deprecated command than an illegal move...
6389         SendToProgram(boards[0][1][BOARD_LEFT] == WhitePawn ? "a2a3\n" : "black\n", cps);
6390
6391       if(!cps->extendedEdit) left = BOARD_LEFT, right = BOARD_RGHT; // only board proper
6392
6393       SendToProgram("edit\n", cps);
6394       SendToProgram("#\n", cps);
6395       for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
6396         bp = &boards[moveNum][i][left];
6397         for (j = left; j < right; j++, bp++) {
6398           if(j == BOARD_LEFT-1 || j == BOARD_RGHT) continue;
6399           if ((int) *bp < (int) BlackPawn) {
6400             if(j == BOARD_RGHT+1)
6401                  snprintf(message, MSG_SIZ, "%c@%d\n", PieceToChar(*bp), bp[-1]);
6402             else snprintf(message, MSG_SIZ, "%c%c%d\n", PieceToChar(*bp), AAA + j, ONE + i - '0');
6403             if(message[0] == '+' || message[0] == '~') {
6404               snprintf(message, MSG_SIZ,"%c%c%d+\n",
6405                         PieceToChar((ChessSquare)(DEMOTED *bp)),
6406                         AAA + j, ONE + i - '0');
6407             }
6408             if(cps->alphaRank) { /* [HGM] shogi: translate coords */
6409                 message[1] = BOARD_RGHT   - 1 - j + '1';
6410                 message[2] = BOARD_HEIGHT - 1 - i + 'a';
6411             }
6412             SendToProgram(message, cps);
6413           }
6414         }
6415       }
6416
6417       SendToProgram("c\n", cps);
6418       for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
6419         bp = &boards[moveNum][i][left];
6420         for (j = left; j < right; j++, bp++) {
6421           if(j == BOARD_LEFT-1 || j == BOARD_RGHT) continue;
6422           if (((int) *bp != (int) EmptySquare)
6423               && ((int) *bp >= (int) BlackPawn)) {
6424             if(j == BOARD_LEFT-2)
6425                  snprintf(message, MSG_SIZ, "%c@%d\n", ToUpper(PieceToChar(*bp)), bp[1]);
6426             else snprintf(message,MSG_SIZ, "%c%c%d\n", ToUpper(PieceToChar(*bp)),
6427                     AAA + j, ONE + i - '0');
6428             if(message[0] == '+' || message[0] == '~') {
6429               snprintf(message, MSG_SIZ,"%c%c%d+\n",
6430                         PieceToChar((ChessSquare)(DEMOTED *bp)),
6431                         AAA + j, ONE + i - '0');
6432             }
6433             if(cps->alphaRank) { /* [HGM] shogi: translate coords */
6434                 message[1] = BOARD_RGHT   - 1 - j + '1';
6435                 message[2] = BOARD_HEIGHT - 1 - i + 'a';
6436             }
6437             SendToProgram(message, cps);
6438           }
6439         }
6440       }
6441
6442       SendToProgram(".\n", cps);
6443     }
6444     setboardSpoiledMachineBlack = 0; /* [HGM] assume WB 4.2.7 already solves this after sending setboard */
6445 }
6446
6447 char exclusionHeader[MSG_SIZ];
6448 int exCnt, excludePtr;
6449 typedef struct { int ff, fr, tf, tr, pc, mark; } Exclusion;
6450 static Exclusion excluTab[200];
6451 static char excludeMap[(BOARD_RANKS*BOARD_FILES*BOARD_RANKS*BOARD_FILES+7)/8]; // [HGM] exclude: bitmap for excluced moves
6452
6453 static void
6454 WriteMap (int s)
6455 {
6456     int j;
6457     for(j=0; j<(BOARD_RANKS*BOARD_FILES*BOARD_RANKS*BOARD_FILES+7)/8; j++) excludeMap[j] = s;
6458     exclusionHeader[19] = s ? '-' : '+'; // update tail state
6459 }
6460
6461 static void
6462 ClearMap ()
6463 {
6464     safeStrCpy(exclusionHeader, "exclude: none best +tail                                          \n", MSG_SIZ);
6465     excludePtr = 24; exCnt = 0;
6466     WriteMap(0);
6467 }
6468
6469 static void
6470 UpdateExcludeHeader (int fromY, int fromX, int toY, int toX, char promoChar, char state)
6471 {   // search given move in table of header moves, to know where it is listed (and add if not there), and update state
6472     char buf[2*MOVE_LEN], *p;
6473     Exclusion *e = excluTab;
6474     int i;
6475     for(i=0; i<exCnt; i++)
6476         if(e[i].ff == fromX && e[i].fr == fromY &&
6477            e[i].tf == toX   && e[i].tr == toY && e[i].pc == promoChar) break;
6478     if(i == exCnt) { // was not in exclude list; add it
6479         CoordsToAlgebraic(boards[currentMove], PosFlags(currentMove), fromY, fromX, toY, toX, promoChar, buf);
6480         if(strlen(exclusionHeader + excludePtr) < strlen(buf)) { // no space to write move
6481             if(state != exclusionHeader[19]) exclusionHeader[19] = '*'; // tail is now in mixed state
6482             return; // abort
6483         }
6484         e[i].ff = fromX; e[i].fr = fromY; e[i].tf = toX; e[i].tr = toY; e[i].pc = promoChar;
6485         excludePtr++; e[i].mark = excludePtr++;
6486         for(p=buf; *p; p++) exclusionHeader[excludePtr++] = *p; // copy move
6487         exCnt++;
6488     }
6489     exclusionHeader[e[i].mark] = state;
6490 }
6491
6492 static int
6493 ExcludeOneMove (int fromY, int fromX, int toY, int toX, char promoChar, char state)
6494 {   // include or exclude the given move, as specified by state ('+' or '-'), or toggle
6495     char buf[MSG_SIZ];
6496     int j, k;
6497     ChessMove moveType;
6498     if((signed char)promoChar == -1) { // kludge to indicate best move
6499         if(!ParseOneMove(lastPV[0], currentMove, &moveType, &fromX, &fromY, &toX, &toY, &promoChar)) // get current best move from last PV
6500             return 1; // if unparsable, abort
6501     }
6502     // update exclusion map (resolving toggle by consulting existing state)
6503     k=(BOARD_FILES*fromY+fromX)*BOARD_RANKS*BOARD_FILES + (BOARD_FILES*toY+toX);
6504     j = k%8; k >>= 3;
6505     if(state == '*') state = (excludeMap[k] & 1<<j ? '+' : '-'); // toggle
6506     if(state == '-' && !promoChar) // only non-promotions get marked as excluded, to allow exclusion of under-promotions
6507          excludeMap[k] |=   1<<j;
6508     else excludeMap[k] &= ~(1<<j);
6509     // update header
6510     UpdateExcludeHeader(fromY, fromX, toY, toX, promoChar, state);
6511     // inform engine
6512     snprintf(buf, MSG_SIZ, "%sclude ", state == '+' ? "in" : "ex");
6513     CoordsToComputerAlgebraic(fromY, fromX, toY, toX, promoChar, buf+8);
6514     SendToBoth(buf);
6515     return (state == '+');
6516 }
6517
6518 static void
6519 ExcludeClick (int index)
6520 {
6521     int i, j;
6522     Exclusion *e = excluTab;
6523     if(index < 25) { // none, best or tail clicked
6524         if(index < 13) { // none: include all
6525             WriteMap(0); // clear map
6526             for(i=0; i<exCnt; i++) exclusionHeader[excluTab[i].mark] = '+'; // and moves
6527             SendToBoth("include all\n"); // and inform engine
6528         } else if(index > 18) { // tail
6529             if(exclusionHeader[19] == '-') { // tail was excluded
6530                 SendToBoth("include all\n");
6531                 WriteMap(0); // clear map completely
6532                 // now re-exclude selected moves
6533                 for(i=0; i<exCnt; i++) if(exclusionHeader[e[i].mark] == '-')
6534                     ExcludeOneMove(e[i].fr, e[i].ff, e[i].tr, e[i].tf, e[i].pc, '-');
6535             } else { // tail was included or in mixed state
6536                 SendToBoth("exclude all\n");
6537                 WriteMap(0xFF); // fill map completely
6538                 // now re-include selected moves
6539                 j = 0; // count them
6540                 for(i=0; i<exCnt; i++) if(exclusionHeader[e[i].mark] == '+')
6541                     ExcludeOneMove(e[i].fr, e[i].ff, e[i].tr, e[i].tf, e[i].pc, '+'), j++;
6542                 if(!j) ExcludeOneMove(0, 0, 0, 0, -1, '+'); // if no moves were selected, keep best
6543             }
6544         } else { // best
6545             ExcludeOneMove(0, 0, 0, 0, -1, '-'); // exclude it
6546         }
6547     } else {
6548         for(i=0; i<exCnt; i++) if(i == exCnt-1 || excluTab[i+1].mark > index) {
6549             char *p=exclusionHeader + excluTab[i].mark; // do trust header more than map (promotions!)
6550             ExcludeOneMove(e[i].fr, e[i].ff, e[i].tr, e[i].tf, e[i].pc, *p == '+' ? '-' : '+');
6551             break;
6552         }
6553     }
6554 }
6555
6556 ChessSquare
6557 DefaultPromoChoice (int white)
6558 {
6559     ChessSquare result;
6560     if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier ||
6561        gameInfo.variant == VariantMakruk)
6562         result = WhiteFerz; // no choice
6563     else if(gameInfo.variant == VariantASEAN)
6564         result = WhiteRook; // no choice
6565     else if(gameInfo.variant == VariantSuicide || gameInfo.variant == VariantGiveaway)
6566         result= WhiteKing; // in Suicide Q is the last thing we want
6567     else if(gameInfo.variant == VariantSpartan)
6568         result = white ? WhiteQueen : WhiteAngel;
6569     else result = WhiteQueen;
6570     if(!white) result = WHITE_TO_BLACK result;
6571     return result;
6572 }
6573
6574 static int autoQueen; // [HGM] oneclick
6575
6576 int
6577 HasPromotionChoice (int fromX, int fromY, int toX, int toY, char *promoChoice, int sweepSelect)
6578 {
6579     /* [HGM] rewritten IsPromotion to only flag promotions that offer a choice */
6580     /* [HGM] add Shogi promotions */
6581     int promotionZoneSize=1, highestPromotingPiece = (int)WhitePawn;
6582     ChessSquare piece, partner;
6583     ChessMove moveType;
6584     Boolean premove;
6585
6586     if(fromX < BOARD_LEFT || fromX >= BOARD_RGHT) return FALSE; // drop
6587     if(toX   < BOARD_LEFT || toX   >= BOARD_RGHT) return FALSE; // move into holdings
6588
6589     if(gameMode == EditPosition || gameInfo.variant == VariantXiangqi || // no promotions
6590       !(fromX >=0 && fromY >= 0 && toX >= 0 && toY >= 0) ) // invalid move
6591         return FALSE;
6592
6593     piece = boards[currentMove][fromY][fromX];
6594     if(gameInfo.variant == VariantChu) {
6595         int p = piece >= BlackPawn ? BLACK_TO_WHITE piece : piece;
6596         promotionZoneSize = BOARD_HEIGHT/3;
6597         highestPromotingPiece = (p >= WhiteLion || PieceToChar(piece + 22) == '.') ? WhitePawn : WhiteLion;
6598     } else if(gameInfo.variant == VariantShogi) {
6599         promotionZoneSize = BOARD_HEIGHT/3 +(BOARD_HEIGHT == 8);
6600         highestPromotingPiece = (int)WhiteAlfil;
6601     } else if(gameInfo.variant == VariantMakruk || gameInfo.variant == VariantGrand || gameInfo.variant == VariantChuChess) {
6602         promotionZoneSize = 3;
6603     }
6604
6605     // Treat Lance as Pawn when it is not representing Amazon or Lance
6606     if(gameInfo.variant != VariantSuper && gameInfo.variant != VariantChu) {
6607         if(piece == WhiteLance) piece = WhitePawn; else
6608         if(piece == BlackLance) piece = BlackPawn;
6609     }
6610
6611     // next weed out all moves that do not touch the promotion zone at all
6612     if((int)piece >= BlackPawn) {
6613         if(toY >= promotionZoneSize && fromY >= promotionZoneSize)
6614              return FALSE;
6615         if(fromY < promotionZoneSize && gameInfo.variant == VariantChuChess) return FALSE;
6616         highestPromotingPiece = WHITE_TO_BLACK highestPromotingPiece;
6617     } else {
6618         if(  toY < BOARD_HEIGHT - promotionZoneSize &&
6619            fromY < BOARD_HEIGHT - promotionZoneSize) return FALSE;
6620         if(fromY >= BOARD_HEIGHT - promotionZoneSize && gameInfo.variant == VariantChuChess)
6621              return FALSE;
6622     }
6623
6624     if( (int)piece > highestPromotingPiece ) return FALSE; // non-promoting piece
6625
6626     // weed out mandatory Shogi promotions
6627     if(gameInfo.variant == VariantShogi) {
6628         if(piece >= BlackPawn) {
6629             if(toY == 0 && piece == BlackPawn ||
6630                toY == 0 && piece == BlackQueen ||
6631                toY <= 1 && piece == BlackKnight) {
6632                 *promoChoice = '+';
6633                 return FALSE;
6634             }
6635         } else {
6636             if(toY == BOARD_HEIGHT-1 && piece == WhitePawn ||
6637                toY == BOARD_HEIGHT-1 && piece == WhiteQueen ||
6638                toY >= BOARD_HEIGHT-2 && piece == WhiteKnight) {
6639                 *promoChoice = '+';
6640                 return FALSE;
6641             }
6642         }
6643     }
6644
6645     // weed out obviously illegal Pawn moves
6646     if(appData.testLegality  && (piece == WhitePawn || piece == BlackPawn) ) {
6647         if(toX > fromX+1 || toX < fromX-1) return FALSE; // wide
6648         if(piece == WhitePawn && toY != fromY+1) return FALSE; // deep
6649         if(piece == BlackPawn && toY != fromY-1) return FALSE; // deep
6650         if(fromX != toX && gameInfo.variant == VariantShogi) return FALSE;
6651         // note we are not allowed to test for valid (non-)capture, due to premove
6652     }
6653
6654     // we either have a choice what to promote to, or (in Shogi) whether to promote
6655     if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier ||
6656        gameInfo.variant == VariantMakruk) {
6657         ChessSquare p=BlackFerz;  // no choice
6658         while(p < EmptySquare) {  //but make sure we use piece that exists
6659             *promoChoice = PieceToChar(p++);
6660             if(*promoChoice != '.') break;
6661         }
6662         return FALSE;
6663     }
6664     // no sense asking what we must promote to if it is going to explode...
6665     if(gameInfo.variant == VariantAtomic && boards[currentMove][toY][toX] != EmptySquare) {
6666         *promoChoice = PieceToChar(BlackQueen); // Queen as good as any
6667         return FALSE;
6668     }
6669     // give caller the default choice even if we will not make it
6670     *promoChoice = ToLower(PieceToChar(defaultPromoChoice));
6671     partner = piece; // pieces can promote if the pieceToCharTable says so
6672     if(IS_SHOGI(gameInfo.variant)) *promoChoice = (defaultPromoChoice == piece && sweepSelect ? '=' : '+'); // obsolete?
6673     else if(Partner(&partner))     *promoChoice = (defaultPromoChoice == piece && sweepSelect ? NULLCHAR : '+');
6674     if(        sweepSelect && gameInfo.variant != VariantGreat
6675                            && gameInfo.variant != VariantGrand
6676                            && gameInfo.variant != VariantSuper) return FALSE;
6677     if(autoQueen) return FALSE; // predetermined
6678
6679     // suppress promotion popup on illegal moves that are not premoves
6680     premove = gameMode == IcsPlayingWhite && !WhiteOnMove(currentMove) ||
6681               gameMode == IcsPlayingBlack &&  WhiteOnMove(currentMove);
6682     if(appData.testLegality && !premove) {
6683         moveType = LegalityTest(boards[currentMove], PosFlags(currentMove),
6684                         fromY, fromX, toY, toX, IS_SHOGI(gameInfo.variant) || gameInfo.variant == VariantChuChess ? '+' : NULLCHAR);
6685         if(moveType == IllegalMove) *promoChoice = NULLCHAR; // could be the fact we promoted was illegal
6686         if(moveType != WhitePromotion && moveType  != BlackPromotion)
6687             return FALSE;
6688     }
6689
6690     return TRUE;
6691 }
6692
6693 int
6694 InPalace (int row, int column)
6695 {   /* [HGM] for Xiangqi */
6696     if( (row < 3 || row > BOARD_HEIGHT-4) &&
6697          column < (BOARD_WIDTH + 4)/2 &&
6698          column > (BOARD_WIDTH - 5)/2 ) return TRUE;
6699     return FALSE;
6700 }
6701
6702 int
6703 PieceForSquare (int x, int y)
6704 {
6705   if (x < 0 || x >= BOARD_WIDTH || y < 0 || y >= BOARD_HEIGHT)
6706      return -1;
6707   else
6708      return boards[currentMove][y][x];
6709 }
6710
6711 int
6712 OKToStartUserMove (int x, int y)
6713 {
6714     ChessSquare from_piece;
6715     int white_piece;
6716
6717     if (matchMode) return FALSE;
6718     if (gameMode == EditPosition) return TRUE;
6719
6720     if (x >= 0 && y >= 0)
6721       from_piece = boards[currentMove][y][x];
6722     else
6723       from_piece = EmptySquare;
6724
6725     if (from_piece == EmptySquare) return FALSE;
6726
6727     white_piece = (int)from_piece >= (int)WhitePawn &&
6728       (int)from_piece < (int)BlackPawn; /* [HGM] can be > King! */
6729
6730     switch (gameMode) {
6731       case AnalyzeFile:
6732       case TwoMachinesPlay:
6733       case EndOfGame:
6734         return FALSE;
6735
6736       case IcsObserving:
6737       case IcsIdle:
6738         return FALSE;
6739
6740       case MachinePlaysWhite:
6741       case IcsPlayingBlack:
6742         if (appData.zippyPlay) return FALSE;
6743         if (white_piece) {
6744             DisplayMoveError(_("You are playing Black"));
6745             return FALSE;
6746         }
6747         break;
6748
6749       case MachinePlaysBlack:
6750       case IcsPlayingWhite:
6751         if (appData.zippyPlay) return FALSE;
6752         if (!white_piece) {
6753             DisplayMoveError(_("You are playing White"));
6754             return FALSE;
6755         }
6756         break;
6757
6758       case PlayFromGameFile:
6759             if(!shiftKey || !appData.variations) return FALSE; // [HGM] allow starting variation in this mode
6760       case EditGame:
6761         if (!white_piece && WhiteOnMove(currentMove)) {
6762             DisplayMoveError(_("It is White's turn"));
6763             return FALSE;
6764         }
6765         if (white_piece && !WhiteOnMove(currentMove)) {
6766             DisplayMoveError(_("It is Black's turn"));
6767             return FALSE;
6768         }
6769         if (cmailMsgLoaded && (currentMove < cmailOldMove)) {
6770             /* Editing correspondence game history */
6771             /* Could disallow this or prompt for confirmation */
6772             cmailOldMove = -1;
6773         }
6774         break;
6775
6776       case BeginningOfGame:
6777         if (appData.icsActive) return FALSE;
6778         if (!appData.noChessProgram) {
6779             if (!white_piece) {
6780                 DisplayMoveError(_("You are playing White"));
6781                 return FALSE;
6782             }
6783         }
6784         break;
6785
6786       case Training:
6787         if (!white_piece && WhiteOnMove(currentMove)) {
6788             DisplayMoveError(_("It is White's turn"));
6789             return FALSE;
6790         }
6791         if (white_piece && !WhiteOnMove(currentMove)) {
6792             DisplayMoveError(_("It is Black's turn"));
6793             return FALSE;
6794         }
6795         break;
6796
6797       default:
6798       case IcsExamining:
6799         break;
6800     }
6801     if (currentMove != forwardMostMove && gameMode != AnalyzeMode
6802         && gameMode != EditGame // [HGM] vari: treat as AnalyzeMode
6803         && gameMode != PlayFromGameFile // [HGM] as EditGame, with protected main line
6804         && gameMode != AnalyzeFile && gameMode != Training) {
6805         DisplayMoveError(_("Displayed position is not current"));
6806         return FALSE;
6807     }
6808     return TRUE;
6809 }
6810
6811 Boolean
6812 OnlyMove (int *x, int *y, Boolean captures)
6813 {
6814     DisambiguateClosure cl;
6815     if (appData.zippyPlay || !appData.testLegality) return FALSE;
6816     switch(gameMode) {
6817       case MachinePlaysBlack:
6818       case IcsPlayingWhite:
6819       case BeginningOfGame:
6820         if(!WhiteOnMove(currentMove)) return FALSE;
6821         break;
6822       case MachinePlaysWhite:
6823       case IcsPlayingBlack:
6824         if(WhiteOnMove(currentMove)) return FALSE;
6825         break;
6826       case EditGame:
6827         break;
6828       default:
6829         return FALSE;
6830     }
6831     cl.pieceIn = EmptySquare;
6832     cl.rfIn = *y;
6833     cl.ffIn = *x;
6834     cl.rtIn = -1;
6835     cl.ftIn = -1;
6836     cl.promoCharIn = NULLCHAR;
6837     Disambiguate(boards[currentMove], PosFlags(currentMove), &cl);
6838     if( cl.kind == NormalMove ||
6839         cl.kind == AmbiguousMove && captures && cl.captures == 1 ||
6840         cl.kind == WhitePromotion || cl.kind == BlackPromotion ||
6841         cl.kind == WhiteCapturesEnPassant || cl.kind == BlackCapturesEnPassant) {
6842       fromX = cl.ff;
6843       fromY = cl.rf;
6844       *x = cl.ft;
6845       *y = cl.rt;
6846       return TRUE;
6847     }
6848     if(cl.kind != ImpossibleMove) return FALSE;
6849     cl.pieceIn = EmptySquare;
6850     cl.rfIn = -1;
6851     cl.ffIn = -1;
6852     cl.rtIn = *y;
6853     cl.ftIn = *x;
6854     cl.promoCharIn = NULLCHAR;
6855     Disambiguate(boards[currentMove], PosFlags(currentMove), &cl);
6856     if( cl.kind == NormalMove ||
6857         cl.kind == AmbiguousMove && captures && cl.captures == 1 ||
6858         cl.kind == WhitePromotion || cl.kind == BlackPromotion ||
6859         cl.kind == WhiteCapturesEnPassant || cl.kind == BlackCapturesEnPassant) {
6860       fromX = cl.ff;
6861       fromY = cl.rf;
6862       *x = cl.ft;
6863       *y = cl.rt;
6864       autoQueen = TRUE; // act as if autoQueen on when we click to-square
6865       return TRUE;
6866     }
6867     return FALSE;
6868 }
6869
6870 FILE *lastLoadGameFP = NULL, *lastLoadPositionFP = NULL;
6871 int lastLoadGameNumber = 0, lastLoadPositionNumber = 0;
6872 int lastLoadGameUseList = FALSE;
6873 char lastLoadGameTitle[MSG_SIZ], lastLoadPositionTitle[MSG_SIZ];
6874 ChessMove lastLoadGameStart = EndOfFile;
6875 int doubleClick;
6876 Boolean addToBookFlag;
6877
6878 void
6879 UserMoveEvent(int fromX, int fromY, int toX, int toY, int promoChar)
6880 {
6881     ChessMove moveType;
6882     ChessSquare pup;
6883     int ff=fromX, rf=fromY, ft=toX, rt=toY;
6884
6885     /* Check if the user is playing in turn.  This is complicated because we
6886        let the user "pick up" a piece before it is his turn.  So the piece he
6887        tried to pick up may have been captured by the time he puts it down!
6888        Therefore we use the color the user is supposed to be playing in this
6889        test, not the color of the piece that is currently on the starting
6890        square---except in EditGame mode, where the user is playing both
6891        sides; fortunately there the capture race can't happen.  (It can
6892        now happen in IcsExamining mode, but that's just too bad.  The user
6893        will get a somewhat confusing message in that case.)
6894        */
6895
6896     switch (gameMode) {
6897       case AnalyzeFile:
6898       case TwoMachinesPlay:
6899       case EndOfGame:
6900       case IcsObserving:
6901       case IcsIdle:
6902         /* We switched into a game mode where moves are not accepted,
6903            perhaps while the mouse button was down. */
6904         return;
6905
6906       case MachinePlaysWhite:
6907         /* User is moving for Black */
6908         if (WhiteOnMove(currentMove)) {
6909             DisplayMoveError(_("It is White's turn"));
6910             return;
6911         }
6912         break;
6913
6914       case MachinePlaysBlack:
6915         /* User is moving for White */
6916         if (!WhiteOnMove(currentMove)) {
6917             DisplayMoveError(_("It is Black's turn"));
6918             return;
6919         }
6920         break;
6921
6922       case PlayFromGameFile:
6923             if(!shiftKey ||!appData.variations) return; // [HGM] only variations
6924       case EditGame:
6925       case IcsExamining:
6926       case BeginningOfGame:
6927       case AnalyzeMode:
6928       case Training:
6929         if(fromY == DROP_RANK) break; // [HGM] drop moves (entered through move type-in) are automatically assigned to side-to-move
6930         if ((int) boards[currentMove][fromY][fromX] >= (int) BlackPawn &&
6931             (int) boards[currentMove][fromY][fromX] < (int) EmptySquare) {
6932             /* User is moving for Black */
6933             if (WhiteOnMove(currentMove)) {
6934                 DisplayMoveError(_("It is White's turn"));
6935                 return;
6936             }
6937         } else {
6938             /* User is moving for White */
6939             if (!WhiteOnMove(currentMove)) {
6940                 DisplayMoveError(_("It is Black's turn"));
6941                 return;
6942             }
6943         }
6944         break;
6945
6946       case IcsPlayingBlack:
6947         /* User is moving for Black */
6948         if (WhiteOnMove(currentMove)) {
6949             if (!appData.premove) {
6950                 DisplayMoveError(_("It is White's turn"));
6951             } else if (toX >= 0 && toY >= 0) {
6952                 premoveToX = toX;
6953                 premoveToY = toY;
6954                 premoveFromX = fromX;
6955                 premoveFromY = fromY;
6956                 premovePromoChar = promoChar;
6957                 gotPremove = 1;
6958                 if (appData.debugMode)
6959                     fprintf(debugFP, "Got premove: fromX %d,"
6960                             "fromY %d, toX %d, toY %d\n",
6961                             fromX, fromY, toX, toY);
6962             }
6963             return;
6964         }
6965         break;
6966
6967       case IcsPlayingWhite:
6968         /* User is moving for White */
6969         if (!WhiteOnMove(currentMove)) {
6970             if (!appData.premove) {
6971                 DisplayMoveError(_("It is Black's turn"));
6972             } else if (toX >= 0 && toY >= 0) {
6973                 premoveToX = toX;
6974                 premoveToY = toY;
6975                 premoveFromX = fromX;
6976                 premoveFromY = fromY;
6977                 premovePromoChar = promoChar;
6978                 gotPremove = 1;
6979                 if (appData.debugMode)
6980                     fprintf(debugFP, "Got premove: fromX %d,"
6981                             "fromY %d, toX %d, toY %d\n",
6982                             fromX, fromY, toX, toY);
6983             }
6984             return;
6985         }
6986         break;
6987
6988       default:
6989         break;
6990
6991       case EditPosition:
6992         /* EditPosition, empty square, or different color piece;
6993            click-click move is possible */
6994         if (toX == -2 || toY == -2) {
6995             boards[0][fromY][fromX] = (boards[0][fromY][fromX] == EmptySquare ? DarkSquare : EmptySquare);
6996             DrawPosition(FALSE, boards[currentMove]);
6997             return;
6998         } else if (toX >= 0 && toY >= 0) {
6999             if(!appData.pieceMenu && toX == fromX && toY == fromY && boards[0][rf][ff] != EmptySquare) {
7000                 ChessSquare q, p = boards[0][rf][ff];
7001                 if(p >= BlackPawn) p = BLACK_TO_WHITE p;
7002                 if(CHUPROMOTED p < BlackPawn) p = q = CHUPROMOTED boards[0][rf][ff];
7003                 else p = CHUDEMOTED (q = boards[0][rf][ff]);
7004                 if(PieceToChar(q) == '+') gatingPiece = p;
7005             }
7006             boards[0][toY][toX] = boards[0][fromY][fromX];
7007             if(fromX == BOARD_LEFT-2) { // handle 'moves' out of holdings
7008                 if(boards[0][fromY][0] != EmptySquare) {
7009                     if(boards[0][fromY][1]) boards[0][fromY][1]--;
7010                     if(boards[0][fromY][1] == 0)  boards[0][fromY][0] = EmptySquare;
7011                 }
7012             } else
7013             if(fromX == BOARD_RGHT+1) {
7014                 if(boards[0][fromY][BOARD_WIDTH-1] != EmptySquare) {
7015                     if(boards[0][fromY][BOARD_WIDTH-2]) boards[0][fromY][BOARD_WIDTH-2]--;
7016                     if(boards[0][fromY][BOARD_WIDTH-2] == 0)  boards[0][fromY][BOARD_WIDTH-1] = EmptySquare;
7017                 }
7018             } else
7019             boards[0][fromY][fromX] = gatingPiece;
7020             DrawPosition(FALSE, boards[currentMove]);
7021             return;
7022         }
7023         return;
7024     }
7025
7026     if((toX < 0 || toY < 0) && (fromY != DROP_RANK || fromX != EmptySquare)) return;
7027     pup = boards[currentMove][toY][toX];
7028
7029     /* [HGM] If move started in holdings, it means a drop. Convert to standard form */
7030     if( (fromX == BOARD_LEFT-2 || fromX == BOARD_RGHT+1) && fromY != DROP_RANK ) {
7031          if( pup != EmptySquare ) return;
7032          moveType = WhiteOnMove(currentMove) ? WhiteDrop : BlackDrop;
7033            if(appData.debugMode) fprintf(debugFP, "Drop move %d, curr=%d, x=%d,y=%d, p=%d\n",
7034                 moveType, currentMove, fromX, fromY, boards[currentMove][fromY][fromX]);
7035            // holdings might not be sent yet in ICS play; we have to figure out which piece belongs here
7036            if(fromX == 0) fromY = BOARD_HEIGHT-1 - fromY; // black holdings upside-down
7037            fromX = fromX ? WhitePawn : BlackPawn; // first piece type in selected holdings
7038            while(PieceToChar(fromX) == '.' || PieceToChar(fromX) == '+' || PieceToNumber(fromX) != fromY && fromX != (int) EmptySquare) fromX++;
7039          fromY = DROP_RANK;
7040     }
7041
7042     /* [HGM] always test for legality, to get promotion info */
7043     moveType = LegalityTest(boards[currentMove], PosFlags(currentMove),
7044                                          fromY, fromX, toY, toX, promoChar);
7045
7046     if(fromY == DROP_RANK && fromX == EmptySquare && (gameMode == AnalyzeMode || gameMode == EditGame || PosFlags(0) & F_NULL_MOVE)) moveType = NormalMove;
7047
7048     /* [HGM] but possibly ignore an IllegalMove result */
7049     if (appData.testLegality) {
7050         if (moveType == IllegalMove || moveType == ImpossibleMove) {
7051             DisplayMoveError(_("Illegal move"));
7052             return;
7053         }
7054     }
7055
7056     if(doubleClick && gameMode == AnalyzeMode) { // [HGM] exclude: move entered with double-click on from square is for exclusion, not playing
7057         if(ExcludeOneMove(fromY, fromX, toY, toX, promoChar, '*')) // toggle
7058              ClearPremoveHighlights(); // was included
7059         else ClearHighlights(), SetPremoveHighlights(ff, rf, ft, rt); // exclusion indicated  by premove highlights
7060         return;
7061     }
7062
7063     if(addToBookFlag) { // adding moves to book
7064         char buf[MSG_SIZ], move[MSG_SIZ];
7065         CoordsToAlgebraic(boards[currentMove], PosFlags(currentMove), fromY, fromX, toY, toX, promoChar, move);
7066         if(killX >= 0) snprintf(move, MSG_SIZ, "%c%dx%c%d-%c%d", fromX + AAA, fromY + ONE - '0', killX + AAA, killY + ONE - '0', toX + AAA, toY + ONE - '0');
7067         snprintf(buf, MSG_SIZ, "  0.0%%     1  %s\n", move);
7068         AddBookMove(buf);
7069         addToBookFlag = FALSE;
7070         ClearHighlights();
7071         return;
7072     }
7073
7074     FinishMove(moveType, fromX, fromY, toX, toY, promoChar);
7075 }
7076
7077 /* Common tail of UserMoveEvent and DropMenuEvent */
7078 int
7079 FinishMove (ChessMove moveType, int fromX, int fromY, int toX, int toY, int promoChar)
7080 {
7081     char *bookHit = 0;
7082
7083     if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat || gameInfo.variant == VariantGrand) && promoChar != NULLCHAR) {
7084         // [HGM] superchess: suppress promotions to non-available piece (but P always allowed)
7085         int k = PieceToNumber(CharToPiece(ToUpper(promoChar)));
7086         if(WhiteOnMove(currentMove)) {
7087             if(!boards[currentMove][k][BOARD_WIDTH-2]) return 0;
7088         } else {
7089             if(!boards[currentMove][BOARD_HEIGHT-1-k][1]) return 0;
7090         }
7091     }
7092
7093     /* [HGM] <popupFix> kludge to avoid having to know the exact promotion
7094        move type in caller when we know the move is a legal promotion */
7095     if(moveType == NormalMove && promoChar)
7096         moveType = WhiteOnMove(currentMove) ? WhitePromotion : BlackPromotion;
7097
7098     /* [HGM] <popupFix> The following if has been moved here from
7099        UserMoveEvent(). Because it seemed to belong here (why not allow
7100        piece drops in training games?), and because it can only be
7101        performed after it is known to what we promote. */
7102     if (gameMode == Training) {
7103       /* compare the move played on the board to the next move in the
7104        * game. If they match, display the move and the opponent's response.
7105        * If they don't match, display an error message.
7106        */
7107       int saveAnimate;
7108       Board testBoard;
7109       CopyBoard(testBoard, boards[currentMove]);
7110       ApplyMove(fromX, fromY, toX, toY, promoChar, testBoard);
7111
7112       if (CompareBoards(testBoard, boards[currentMove+1])) {
7113         ForwardInner(currentMove+1);
7114
7115         /* Autoplay the opponent's response.
7116          * if appData.animate was TRUE when Training mode was entered,
7117          * the response will be animated.
7118          */
7119         saveAnimate = appData.animate;
7120         appData.animate = animateTraining;
7121         ForwardInner(currentMove+1);
7122         appData.animate = saveAnimate;
7123
7124         /* check for the end of the game */
7125         if (currentMove >= forwardMostMove) {
7126           gameMode = PlayFromGameFile;
7127           ModeHighlight();
7128           SetTrainingModeOff();
7129           DisplayInformation(_("End of game"));
7130         }
7131       } else {
7132         DisplayError(_("Incorrect move"), 0);
7133       }
7134       return 1;
7135     }
7136
7137   /* Ok, now we know that the move is good, so we can kill
7138      the previous line in Analysis Mode */
7139   if ((gameMode == AnalyzeMode || gameMode == EditGame || gameMode == PlayFromGameFile && appData.variations && shiftKey)
7140                                 && currentMove < forwardMostMove) {
7141     if(appData.variations && shiftKey) PushTail(currentMove, forwardMostMove); // [HGM] vari: save tail of game
7142     else forwardMostMove = currentMove;
7143   }
7144
7145   ClearMap();
7146
7147   /* If we need the chess program but it's dead, restart it */
7148   ResurrectChessProgram();
7149
7150   /* A user move restarts a paused game*/
7151   if (pausing)
7152     PauseEvent();
7153
7154   thinkOutput[0] = NULLCHAR;
7155
7156   MakeMove(fromX, fromY, toX, toY, promoChar); /*updates forwardMostMove*/
7157
7158   if(Adjudicate(NULL)) { // [HGM] adjudicate: take care of automatic game end
7159     ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
7160     return 1;
7161   }
7162
7163   if (gameMode == BeginningOfGame) {
7164     if (appData.noChessProgram) {
7165       gameMode = EditGame;
7166       SetGameInfo();
7167     } else {
7168       char buf[MSG_SIZ];
7169       gameMode = MachinePlaysBlack;
7170       StartClocks();
7171       SetGameInfo();
7172       snprintf(buf, MSG_SIZ, "%s %s %s", gameInfo.white, _("vs."), gameInfo.black);
7173       DisplayTitle(buf);
7174       if (first.sendName) {
7175         snprintf(buf, MSG_SIZ,"name %s\n", gameInfo.white);
7176         SendToProgram(buf, &first);
7177       }
7178       StartClocks();
7179     }
7180     ModeHighlight();
7181   }
7182
7183   /* Relay move to ICS or chess engine */
7184   if (appData.icsActive) {
7185     if (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack ||
7186         gameMode == IcsExamining) {
7187       if(userOfferedDraw && (signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
7188         SendToICS(ics_prefix); // [HGM] drawclaim: send caim and move on one line for FICS
7189         SendToICS("draw ");
7190         SendMoveToICS(moveType, fromX, fromY, toX, toY, promoChar);
7191       }
7192       // also send plain move, in case ICS does not understand atomic claims
7193       SendMoveToICS(moveType, fromX, fromY, toX, toY, promoChar);
7194       ics_user_moved = 1;
7195     }
7196   } else {
7197     if (first.sendTime && (gameMode == BeginningOfGame ||
7198                            gameMode == MachinePlaysWhite ||
7199                            gameMode == MachinePlaysBlack)) {
7200       SendTimeRemaining(&first, gameMode != MachinePlaysBlack);
7201     }
7202     if (gameMode != EditGame && gameMode != PlayFromGameFile && gameMode != AnalyzeMode) {
7203          // [HGM] book: if program might be playing, let it use book
7204         bookHit = SendMoveToBookUser(forwardMostMove-1, &first, FALSE);
7205         first.maybeThinking = TRUE;
7206     } else if(fromY == DROP_RANK && fromX == EmptySquare) {
7207         if(!first.useSetboard) SendToProgram("undo\n", &first); // kludge to change stm in engines that do not support setboard
7208         SendBoard(&first, currentMove+1);
7209         if(second.analyzing) {
7210             if(!second.useSetboard) SendToProgram("undo\n", &second);
7211             SendBoard(&second, currentMove+1);
7212         }
7213     } else {
7214         SendMoveToProgram(forwardMostMove-1, &first);
7215         if(second.analyzing) SendMoveToProgram(forwardMostMove-1, &second);
7216     }
7217     if (currentMove == cmailOldMove + 1) {
7218       cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
7219     }
7220   }
7221
7222   ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
7223
7224   switch (gameMode) {
7225   case EditGame:
7226     if(appData.testLegality)
7227     switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
7228     case MT_NONE:
7229     case MT_CHECK:
7230       break;
7231     case MT_CHECKMATE:
7232     case MT_STAINMATE:
7233       if (WhiteOnMove(currentMove)) {
7234         GameEnds(BlackWins, "Black mates", GE_PLAYER);
7235       } else {
7236         GameEnds(WhiteWins, "White mates", GE_PLAYER);
7237       }
7238       break;
7239     case MT_STALEMATE:
7240       GameEnds(GameIsDrawn, "Stalemate", GE_PLAYER);
7241       break;
7242     }
7243     break;
7244
7245   case MachinePlaysBlack:
7246   case MachinePlaysWhite:
7247     /* disable certain menu options while machine is thinking */
7248     SetMachineThinkingEnables();
7249     break;
7250
7251   default:
7252     break;
7253   }
7254
7255   userOfferedDraw = FALSE; // [HGM] drawclaim: after move made, and tested for claimable draw
7256   promoDefaultAltered = FALSE; // [HGM] fall back on default choice
7257
7258   if(bookHit) { // [HGM] book: simulate book reply
7259         static char bookMove[MSG_SIZ]; // a bit generous?
7260
7261         programStats.nodes = programStats.depth = programStats.time =
7262         programStats.score = programStats.got_only_move = 0;
7263         sprintf(programStats.movelist, "%s (xbook)", bookHit);
7264
7265         safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
7266         strcat(bookMove, bookHit);
7267         HandleMachineMove(bookMove, &first);
7268   }
7269   return 1;
7270 }
7271
7272 void
7273 MarkByFEN(char *fen)
7274 {
7275         int r, f;
7276         if(!appData.markers || !appData.highlightDragging) return;
7277         for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) legal[r][f] = 0;
7278         r=BOARD_HEIGHT-1; f=BOARD_LEFT;
7279         while(*fen) {
7280             int s = 0;
7281             marker[r][f] = 0;
7282             if(*fen == 'M') legal[r][f] = 2; else // request promotion choice
7283             if(*fen >= 'A' && *fen <= 'Z') legal[r][f] = 1; else
7284             if(*fen >= 'a' && *fen <= 'z') *fen += 'A' - 'a';
7285             if(*fen == '/' && f > BOARD_LEFT) f = BOARD_LEFT, r--; else
7286             if(*fen == 'T') marker[r][f++] = 0; else
7287             if(*fen == 'Y') marker[r][f++] = 1; else
7288             if(*fen == 'G') marker[r][f++] = 3; else
7289             if(*fen == 'B') marker[r][f++] = 4; else
7290             if(*fen == 'C') marker[r][f++] = 5; else
7291             if(*fen == 'M') marker[r][f++] = 6; else
7292             if(*fen == 'W') marker[r][f++] = 7; else
7293             if(*fen == 'D') marker[r][f++] = 8; else
7294             if(*fen == 'R') marker[r][f++] = 2; else {
7295                 while(*fen <= '9' && *fen >= '0') s = 10*s + *fen++ - '0';
7296               f += s; fen -= s>0;
7297             }
7298             while(f >= BOARD_RGHT) f -= BOARD_RGHT - BOARD_LEFT, r--;
7299             if(r < 0) break;
7300             fen++;
7301         }
7302         DrawPosition(TRUE, NULL);
7303 }
7304
7305 static char baseMarker[BOARD_RANKS][BOARD_FILES], baseLegal[BOARD_RANKS][BOARD_FILES];
7306
7307 void
7308 Mark (Board board, int flags, ChessMove kind, int rf, int ff, int rt, int ft, VOIDSTAR closure)
7309 {
7310     typedef char Markers[BOARD_RANKS][BOARD_FILES];
7311     Markers *m = (Markers *) closure;
7312     if(rf == fromY && ff == fromX && (killX < 0 ? !(rt == rf && ft == ff) && legNr & 1 : rt == killY && ft == killX || legNr & 2))
7313         (*m)[rt][ft] = 1 + (board[rt][ft] != EmptySquare
7314                          || kind == WhiteCapturesEnPassant
7315                          || kind == BlackCapturesEnPassant) + 3*(kind == FirstLeg && killX < 0), legal[rt][ft] = 1;
7316     else if(flags & F_MANDATORY_CAPTURE && board[rt][ft] != EmptySquare) (*m)[rt][ft] = 3, legal[rt][ft] = 1;
7317 }
7318
7319 static int hoverSavedValid;
7320
7321 void
7322 MarkTargetSquares (int clear)
7323 {
7324   int x, y, sum=0;
7325   if(clear) { // no reason to ever suppress clearing
7326     for(x=0; x<BOARD_WIDTH; x++) for(y=0; y<BOARD_HEIGHT; y++) sum += marker[y][x], marker[y][x] = 0;
7327     hoverSavedValid = 0;
7328     if(!sum) return; // nothing was cleared,no redraw needed
7329   } else {
7330     int capt = 0;
7331     if(!appData.markers || !appData.highlightDragging || appData.icsActive && gameInfo.variant < VariantShogi ||
7332        !appData.testLegality && !pieceDefs || gameMode == EditPosition) return;
7333     GenLegal(boards[currentMove], PosFlags(currentMove), Mark, (void*) marker, EmptySquare);
7334     if(PosFlags(0) & F_MANDATORY_CAPTURE) {
7335       for(x=0; x<BOARD_WIDTH; x++) for(y=0; y<BOARD_HEIGHT; y++) if(marker[y][x]>1) capt++;
7336       if(capt)
7337       for(x=0; x<BOARD_WIDTH; x++) for(y=0; y<BOARD_HEIGHT; y++) if(marker[y][x] == 1) marker[y][x] = 0;
7338     }
7339   }
7340   DrawPosition(FALSE, NULL);
7341 }
7342
7343 int
7344 Explode (Board board, int fromX, int fromY, int toX, int toY)
7345 {
7346     if(gameInfo.variant == VariantAtomic &&
7347        (board[toY][toX] != EmptySquare ||                     // capture?
7348         toX != fromX && (board[fromY][fromX] == WhitePawn ||  // e.p. ?
7349                          board[fromY][fromX] == BlackPawn   )
7350       )) {
7351         AnimateAtomicCapture(board, fromX, fromY, toX, toY);
7352         return TRUE;
7353     }
7354     return FALSE;
7355 }
7356
7357 ChessSquare gatingPiece = EmptySquare; // exported to front-end, for dragging
7358
7359 int
7360 CanPromote (ChessSquare piece, int y)
7361 {
7362         int zone = (gameInfo.variant == VariantChuChess ? 3 : 1);
7363         if(gameMode == EditPosition) return FALSE; // no promotions when editing position
7364         // some variants have fixed promotion piece, no promotion at all, or another selection mechanism
7365         if(IS_SHOGI(gameInfo.variant)          || gameInfo.variant == VariantXiangqi ||
7366            gameInfo.variant == VariantSuper    || gameInfo.variant == VariantGreat   ||
7367            gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier ||
7368          gameInfo.variant == VariantMakruk) return FALSE;
7369         return (piece == BlackPawn && y <= zone ||
7370                 piece == WhitePawn && y >= BOARD_HEIGHT-1-zone ||
7371                 piece == BlackLance && y <= zone ||
7372                 piece == WhiteLance && y >= BOARD_HEIGHT-1-zone );
7373 }
7374
7375 void
7376 HoverEvent (int xPix, int yPix, int x, int y)
7377 {
7378         static int oldX = -1, oldY = -1, oldFromX = -1, oldFromY = -1;
7379         int r, f;
7380         if(!first.highlight) return;
7381         if(fromX != oldFromX || fromY != oldFromY)  oldX = oldY = -1; // kludge to fake entry on from-click
7382         if(x == oldX && y == oldY) return; // only do something if we enter new square
7383         oldFromX = fromX; oldFromY = fromY;
7384         if(oldX == -1 && oldY == -1 && x == fromX && y == fromY) { // record markings after from-change
7385           for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++)
7386             baseMarker[r][f] = marker[r][f], baseLegal[r][f] = legal[r][f];
7387           hoverSavedValid = 1;
7388         } else if(oldX != x || oldY != y) {
7389           // [HGM] lift: entered new to-square; redraw arrow, and inform engine
7390           if(hoverSavedValid) // don't restore markers that are supposed to be cleared
7391           for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++)
7392             marker[r][f] = baseMarker[r][f], legal[r][f] = baseLegal[r][f];
7393           if((marker[y][x] == 2 || marker[y][x] == 6) && legal[y][x]) {
7394             char buf[MSG_SIZ];
7395             snprintf(buf, MSG_SIZ, "hover %c%d\n", x + AAA, y + ONE - '0');
7396             SendToProgram(buf, &first);
7397           }
7398           oldX = x; oldY = y;
7399 //        SetHighlights(fromX, fromY, x, y);
7400         }
7401 }
7402
7403 void ReportClick(char *action, int x, int y)
7404 {
7405         char buf[MSG_SIZ]; // Inform engine of what user does
7406         int r, f;
7407         if(action[0] == 'l') // mark any target square of a lifted piece as legal to-square, clear markers
7408           for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++)
7409             legal[r][f] = !pieceDefs || !appData.markers, marker[r][f] = 0;
7410         if(!first.highlight || gameMode == EditPosition) return;
7411         snprintf(buf, MSG_SIZ, "%s %c%d%s\n", action, x+AAA, y+ONE-'0', controlKey && action[0]=='p' ? "," : "");
7412         SendToProgram(buf, &first);
7413 }
7414
7415 Boolean right; // instructs front-end to use button-1 events as if they were button 3
7416
7417 void
7418 LeftClick (ClickType clickType, int xPix, int yPix)
7419 {
7420     int x, y;
7421     Boolean saveAnimate;
7422     static int second = 0, promotionChoice = 0, clearFlag = 0, sweepSelecting = 0;
7423     char promoChoice = NULLCHAR;
7424     ChessSquare piece;
7425     static TimeMark lastClickTime, prevClickTime;
7426
7427     x = EventToSquare(xPix, BOARD_WIDTH);
7428     y = EventToSquare(yPix, BOARD_HEIGHT);
7429     if (!flipView && y >= 0) {
7430         y = BOARD_HEIGHT - 1 - y;
7431     }
7432     if (flipView && x >= 0) {
7433         x = BOARD_WIDTH - 1 - x;
7434     }
7435
7436     if(appData.monoMouse && gameMode == EditPosition && fromX < 0 && clickType == Press && boards[currentMove][y][x] == EmptySquare) {
7437         static int dummy;
7438         RightClick(clickType, xPix, yPix, &dummy, &dummy);
7439         right = TRUE;
7440         return;
7441     }
7442
7443     if(SeekGraphClick(clickType, xPix, yPix, 0)) return;
7444
7445     prevClickTime = lastClickTime; GetTimeMark(&lastClickTime);
7446
7447     if (clickType == Press) ErrorPopDown();
7448     lastClickType = clickType, lastLeftX = xPix, lastLeftY = yPix; // [HGM] alien: remember state
7449
7450     if(promoSweep != EmptySquare) { // up-click during sweep-select of promo-piece
7451         defaultPromoChoice = promoSweep;
7452         promoSweep = EmptySquare;   // terminate sweep
7453         promoDefaultAltered = TRUE;
7454         if(!selectFlag && !sweepSelecting && (x != toX || y != toY)) x = fromX, y = fromY; // and fake up-click on same square if we were still selecting
7455     }
7456
7457     if(promotionChoice) { // we are waiting for a click to indicate promotion piece
7458         if(clickType == Release) return; // ignore upclick of click-click destination
7459         promotionChoice = FALSE; // only one chance: if click not OK it is interpreted as cancel
7460         if(appData.debugMode) fprintf(debugFP, "promotion click, x=%d, y=%d\n", x, y);
7461         if(gameInfo.holdingsWidth &&
7462                 (WhiteOnMove(currentMove)
7463                         ? x == BOARD_WIDTH-1 && y < gameInfo.holdingsSize && y >= 0
7464                         : x == 0 && y >= BOARD_HEIGHT - gameInfo.holdingsSize && y < BOARD_HEIGHT) ) {
7465             // click in right holdings, for determining promotion piece
7466             ChessSquare p = boards[currentMove][y][x];
7467             if(appData.debugMode) fprintf(debugFP, "square contains %d\n", (int)p);
7468             if(p == WhitePawn || p == BlackPawn) p = EmptySquare; // [HGM] Pawns could be valid as deferral
7469             if(p != EmptySquare || gameInfo.variant == VariantGrand && toY != 0 && toY != BOARD_HEIGHT-1) { // [HGM] grand: empty square means defer
7470                 FinishMove(NormalMove, fromX, fromY, toX, toY, p==EmptySquare ? NULLCHAR : ToLower(PieceToChar(p)));
7471                 fromX = fromY = -1;
7472                 return;
7473             }
7474         }
7475         DrawPosition(FALSE, boards[currentMove]);
7476         return;
7477     }
7478
7479     /* [HGM] holdings: next 5 lines: ignore all clicks between board and holdings */
7480     if(clickType == Press
7481             && ( x == BOARD_LEFT-1 || x == BOARD_RGHT
7482               || x == BOARD_LEFT-2 && y < BOARD_HEIGHT-gameInfo.holdingsSize
7483               || x == BOARD_RGHT+1 && y >= gameInfo.holdingsSize) )
7484         return;
7485
7486     if(gotPremove && x == premoveFromX && y == premoveFromY && clickType == Release) {
7487         // could be static click on premove from-square: abort premove
7488         gotPremove = 0;
7489         ClearPremoveHighlights();
7490     }
7491
7492     if(clickType == Press && fromX == x && fromY == y && promoDefaultAltered && SubtractTimeMarks(&lastClickTime, &prevClickTime) >= 200)
7493         fromX = fromY = -1; // second click on piece after altering default promo piece treated as first click
7494
7495     if(!promoDefaultAltered) { // determine default promotion piece, based on the side the user is moving for
7496         int side = (gameMode == IcsPlayingWhite || gameMode == MachinePlaysBlack ||
7497                     gameMode != MachinePlaysWhite && gameMode != IcsPlayingBlack && WhiteOnMove(currentMove));
7498         defaultPromoChoice = DefaultPromoChoice(side);
7499     }
7500
7501     autoQueen = appData.alwaysPromoteToQueen;
7502
7503     if (fromX == -1) {
7504       int originalY = y;
7505       gatingPiece = EmptySquare;
7506       if (clickType != Press) {
7507         if(dragging) { // [HGM] from-square must have been reset due to game end since last press
7508             DragPieceEnd(xPix, yPix); dragging = 0;
7509             DrawPosition(FALSE, NULL);
7510         }
7511         return;
7512       }
7513       doubleClick = FALSE;
7514       if(gameMode == AnalyzeMode && (pausing || controlKey) && first.excludeMoves) { // use pause state to exclude moves
7515         doubleClick = TRUE; gatingPiece = boards[currentMove][y][x];
7516       }
7517       fromX = x; fromY = y; toX = toY = killX = killY = -1;
7518       if(!appData.oneClick || !OnlyMove(&x, &y, FALSE) ||
7519          // even if only move, we treat as normal when this would trigger a promotion popup, to allow sweep selection
7520          appData.sweepSelect && CanPromote(boards[currentMove][fromY][fromX], fromY) && originalY != y) {
7521             /* First square */
7522             if (OKToStartUserMove(fromX, fromY)) {
7523                 second = 0;
7524                 ReportClick("lift", x, y);
7525                 MarkTargetSquares(0);
7526                 if(gameMode == EditPosition && controlKey) gatingPiece = boards[currentMove][fromY][fromX];
7527                 DragPieceBegin(xPix, yPix, FALSE); dragging = 1;
7528                 if(appData.sweepSelect && CanPromote(piece = boards[currentMove][fromY][fromX], fromY)) {
7529                     promoSweep = defaultPromoChoice;
7530                     selectFlag = 0; lastX = xPix; lastY = yPix;
7531                     Sweep(0); // Pawn that is going to promote: preview promotion piece
7532                     DisplayMessage("", _("Pull pawn backwards to under-promote"));
7533                 }
7534                 if (appData.highlightDragging) {
7535                     SetHighlights(fromX, fromY, -1, -1);
7536                 } else {
7537                     ClearHighlights();
7538                 }
7539             } else fromX = fromY = -1;
7540             return;
7541         }
7542     }
7543 printf("to click %d,%d\n",x,y);
7544     /* fromX != -1 */
7545     if (clickType == Press && gameMode != EditPosition) {
7546         ChessSquare fromP;
7547         ChessSquare toP;
7548         int frc;
7549
7550         // ignore off-board to clicks
7551         if(y < 0 || x < 0) return;
7552
7553         /* Check if clicking again on the same color piece */
7554         fromP = boards[currentMove][fromY][fromX];
7555         toP = boards[currentMove][y][x];
7556         frc = appData.fischerCastling || gameInfo.variant == VariantSChess;
7557         if( (killX < 0 || x != fromX || y != fromY) && // [HGM] lion: do not interpret igui as deselect!
7558             marker[y][x] == 0 && // if engine told we can move to here, do it even if own piece
7559            ((WhitePawn <= fromP && fromP <= WhiteKing &&
7560              WhitePawn <= toP && toP <= WhiteKing &&
7561              !(fromP == WhiteKing && toP == WhiteRook && frc) &&
7562              !(fromP == WhiteRook && toP == WhiteKing && frc)) ||
7563             (BlackPawn <= fromP && fromP <= BlackKing &&
7564              BlackPawn <= toP && toP <= BlackKing &&
7565              !(fromP == BlackRook && toP == BlackKing && frc) && // allow also RxK as FRC castling
7566              !(fromP == BlackKing && toP == BlackRook && frc)))) {
7567             /* Clicked again on same color piece -- changed his mind */
7568             second = (x == fromX && y == fromY);
7569             killX = killY = -1;
7570             if(second && gameMode == AnalyzeMode && SubtractTimeMarks(&lastClickTime, &prevClickTime) < 200) {
7571                 second = FALSE; // first double-click rather than scond click
7572                 doubleClick = first.excludeMoves; // used by UserMoveEvent to recognize exclude moves
7573             }
7574             promoDefaultAltered = FALSE;
7575             MarkTargetSquares(1);
7576            if(!(second && appData.oneClick && OnlyMove(&x, &y, TRUE))) {
7577             if (appData.highlightDragging) {
7578                 SetHighlights(x, y, -1, -1);
7579             } else {
7580                 ClearHighlights();
7581             }
7582             if (OKToStartUserMove(x, y)) {
7583                 if(gameInfo.variant == VariantSChess && // S-Chess: back-rank piece selected after holdings means gating
7584                   (fromX == BOARD_LEFT-2 || fromX == BOARD_RGHT+1) &&
7585                y == (toP < BlackPawn ? 0 : BOARD_HEIGHT-1))
7586                  gatingPiece = boards[currentMove][fromY][fromX];
7587                 else gatingPiece = doubleClick ? fromP : EmptySquare;
7588                 fromX = x;
7589                 fromY = y; dragging = 1;
7590                 if(!second) ReportClick("lift", x, y);
7591                 MarkTargetSquares(0);
7592                 DragPieceBegin(xPix, yPix, FALSE);
7593                 if(appData.sweepSelect && CanPromote(piece = boards[currentMove][y][x], y)) {
7594                     promoSweep = defaultPromoChoice;
7595                     selectFlag = 0; lastX = xPix; lastY = yPix;
7596                     Sweep(0); // Pawn that is going to promote: preview promotion piece
7597                 }
7598             }
7599            }
7600            if(x == fromX && y == fromY) return; // if OnlyMove altered (x,y) we go on
7601            second = FALSE;
7602         }
7603         // ignore clicks on holdings
7604         if(x < BOARD_LEFT || x >= BOARD_RGHT) return;
7605     }
7606 printf("A type=%d\n",clickType);
7607
7608     if(x == fromX && y == fromY && gameMode == EditPosition && SubtractTimeMarks(&lastClickTime, &prevClickTime) < 200) {
7609         gatingPiece = boards[currentMove][fromY][fromX]; // prepare to copy rather than move
7610         return;
7611     }
7612
7613     if (clickType == Release && x == fromX && y == fromY && killX < 0 && !sweepSelecting) {
7614         DragPieceEnd(xPix, yPix); dragging = 0;
7615         if(clearFlag) {
7616             // a deferred attempt to click-click move an empty square on top of a piece
7617             boards[currentMove][y][x] = EmptySquare;
7618             ClearHighlights();
7619             DrawPosition(FALSE, boards[currentMove]);
7620             fromX = fromY = -1; clearFlag = 0;
7621             return;
7622         }
7623         if (appData.animateDragging) {
7624             /* Undo animation damage if any */
7625             DrawPosition(FALSE, NULL);
7626         }
7627         if (second) {
7628             /* Second up/down in same square; just abort move */
7629             second = 0;
7630             fromX = fromY = -1;
7631             gatingPiece = EmptySquare;
7632             MarkTargetSquares(1);
7633             ClearHighlights();
7634             gotPremove = 0;
7635             ClearPremoveHighlights();
7636         } else {
7637             /* First upclick in same square; start click-click mode */
7638             SetHighlights(x, y, -1, -1);
7639         }
7640         return;
7641     }
7642
7643     clearFlag = 0;
7644 printf("B\n");
7645     if(gameMode != EditPosition && !appData.testLegality && !legal[y][x] &&
7646        fromX >= BOARD_LEFT && fromX < BOARD_RGHT && (x != killX || y != killY) && !sweepSelecting) {
7647         if(dragging) DragPieceEnd(xPix, yPix), dragging = 0;
7648         DisplayMessage(_("only marked squares are legal"),"");
7649         DrawPosition(TRUE, NULL);
7650         return; // ignore to-click
7651     }
7652 printf("(%d,%d)-(%d,%d) %d %d\n",fromX,fromY,toX,toY,x,y);
7653     /* we now have a different from- and (possibly off-board) to-square */
7654     /* Completed move */
7655     if(!sweepSelecting) {
7656         toX = x;
7657         toY = y;
7658     }
7659
7660     piece = boards[currentMove][fromY][fromX];
7661
7662     saveAnimate = appData.animate;
7663     if (clickType == Press) {
7664         if(gameInfo.variant == VariantChuChess && piece != WhitePawn && piece != BlackPawn) defaultPromoChoice = piece;
7665         if(gameMode == EditPosition && boards[currentMove][fromY][fromX] == EmptySquare) {
7666             // must be Edit Position mode with empty-square selected
7667             fromX = x; fromY = y; DragPieceBegin(xPix, yPix, FALSE); dragging = 1; // consider this a new attempt to drag
7668             if(x >= BOARD_LEFT && x < BOARD_RGHT) clearFlag = 1; // and defer click-click move of empty-square to up-click
7669             return;
7670         }
7671         if(dragging == 2) {  // [HGM] lion: just turn buttonless drag into normal drag, and let release to the job
7672             return;
7673         }
7674         if(x == killX && y == killY) {              // second click on this square, which was selected as first-leg target
7675             killX = killY = -1;                     // this informs us no second leg is coming, so treat as to-click without intermediate
7676         } else
7677         if(marker[y][x] == 5) return; // [HGM] lion: to-click on cyan square; defer action to release
7678         if(legal[y][x] == 2 || HasPromotionChoice(fromX, fromY, toX, toY, &promoChoice, FALSE)) {
7679           if(appData.sweepSelect) {
7680             promoSweep = defaultPromoChoice;
7681             if(gameInfo.variant != VariantChuChess && PieceToChar(CHUPROMOTED piece) == '+') promoSweep = CHUPROMOTED piece;
7682             selectFlag = 0; lastX = xPix; lastY = yPix;
7683             Sweep(0); // Pawn that is going to promote: preview promotion piece
7684             sweepSelecting = 1;
7685             DisplayMessage("", _("Pull pawn backwards to under-promote"));
7686             MarkTargetSquares(1);
7687           }
7688           return; // promo popup appears on up-click
7689         }
7690         /* Finish clickclick move */
7691         if (appData.animate || appData.highlightLastMove) {
7692             SetHighlights(fromX, fromY, toX, toY);
7693         } else {
7694             ClearHighlights();
7695         }
7696     } else if(sweepSelecting) { // this must be the up-click corresponding to the down-click that started the sweep
7697         sweepSelecting = 0; appData.animate = FALSE; // do not animate, a selected piece already on to-square
7698         if (appData.animate || appData.highlightLastMove) {
7699             SetHighlights(fromX, fromY, toX, toY);
7700         } else {
7701             ClearHighlights();
7702         }
7703     } else {
7704 #if 0
7705 // [HGM] this must be done after the move is made, as with arrow it could lead to a board redraw with piece still on from square
7706         /* Finish drag move */
7707         if (appData.highlightLastMove) {
7708             SetHighlights(fromX, fromY, toX, toY);
7709         } else {
7710             ClearHighlights();
7711         }
7712 #endif
7713         if(gameInfo.variant == VariantChuChess && piece != WhitePawn && piece != BlackPawn) defaultPromoChoice = piece;
7714         if(marker[y][x] == 5) { // [HGM] lion: this was the release of a to-click or drag on a cyan square
7715           dragging *= 2;            // flag button-less dragging if we are dragging
7716           MarkTargetSquares(1);
7717           if(x == killX && y == killY) killX = kill2X, killY = kill2Y, kill2X = kill2Y = -1; // cancel last kill
7718           else {
7719             kill2X = killX; kill2Y = killY;
7720             killX = x; killY = y;     //remeber this square as intermediate
7721             ReportClick("put", x, y); // and inform engine
7722             ReportClick("lift", x, y);
7723             MarkTargetSquares(0);
7724             return;
7725           }
7726         }
7727         DragPieceEnd(xPix, yPix); dragging = 0;
7728         /* Don't animate move and drag both */
7729         appData.animate = FALSE;
7730     }
7731
7732     // moves into holding are invalid for now (except in EditPosition, adapting to-square)
7733     if(x >= 0 && x < BOARD_LEFT || x >= BOARD_RGHT) {
7734         ChessSquare piece = boards[currentMove][fromY][fromX];
7735         if(gameMode == EditPosition && piece != EmptySquare &&
7736            fromX >= BOARD_LEFT && fromX < BOARD_RGHT) {
7737             int n;
7738
7739             if(x == BOARD_LEFT-2 && piece >= BlackPawn) {
7740                 n = PieceToNumber(piece - (int)BlackPawn);
7741                 if(n >= gameInfo.holdingsSize) { n = 0; piece = BlackPawn; }
7742                 boards[currentMove][BOARD_HEIGHT-1 - n][0] = piece;
7743                 boards[currentMove][BOARD_HEIGHT-1 - n][1]++;
7744             } else
7745             if(x == BOARD_RGHT+1 && piece < BlackPawn) {
7746                 n = PieceToNumber(piece);
7747                 if(n >= gameInfo.holdingsSize) { n = 0; piece = WhitePawn; }
7748                 boards[currentMove][n][BOARD_WIDTH-1] = piece;
7749                 boards[currentMove][n][BOARD_WIDTH-2]++;
7750             }
7751             boards[currentMove][fromY][fromX] = EmptySquare;
7752         }
7753         ClearHighlights();
7754         fromX = fromY = -1;
7755         MarkTargetSquares(1);
7756         DrawPosition(TRUE, boards[currentMove]);
7757         return;
7758     }
7759
7760     // off-board moves should not be highlighted
7761     if(x < 0 || y < 0) ClearHighlights();
7762     else ReportClick("put", x, y);
7763
7764     if(gatingPiece != EmptySquare && gameInfo.variant == VariantSChess) promoChoice = ToLower(PieceToChar(gatingPiece));
7765
7766     if(legal[toY][toX] == 2) promoChoice = ToLower(PieceToChar(defaultPromoChoice)); // highlight-induced promotion
7767
7768     if (legal[toY][toX] == 2 && !appData.sweepSelect || HasPromotionChoice(fromX, fromY, toX, toY, &promoChoice, appData.sweepSelect)) {
7769         SetHighlights(fromX, fromY, toX, toY);
7770         MarkTargetSquares(1);
7771         if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat || gameInfo.variant == VariantGrand) {
7772             // [HGM] super: promotion to captured piece selected from holdings
7773             ChessSquare p = boards[currentMove][fromY][fromX], q = boards[currentMove][toY][toX];
7774             promotionChoice = TRUE;
7775             // kludge follows to temporarily execute move on display, without promoting yet
7776             boards[currentMove][fromY][fromX] = EmptySquare; // move Pawn to 8th rank
7777             boards[currentMove][toY][toX] = p;
7778             DrawPosition(FALSE, boards[currentMove]);
7779             boards[currentMove][fromY][fromX] = p; // take back, but display stays
7780             boards[currentMove][toY][toX] = q;
7781             DisplayMessage("Click in holdings to choose piece", "");
7782             return;
7783         }
7784         PromotionPopUp(promoChoice);
7785     } else {
7786         int oldMove = currentMove;
7787         UserMoveEvent(fromX, fromY, toX, toY, promoChoice);
7788         if (!appData.highlightLastMove || gotPremove) ClearHighlights();
7789         if (gotPremove) SetPremoveHighlights(fromX, fromY, toX, toY);
7790         if(saveAnimate && !appData.animate && currentMove != oldMove && // drag-move was performed
7791            Explode(boards[currentMove-1], fromX, fromY, toX, toY))
7792             DrawPosition(TRUE, boards[currentMove]);
7793         MarkTargetSquares(1);
7794         fromX = fromY = -1;
7795     }
7796     appData.animate = saveAnimate;
7797     if (appData.animate || appData.animateDragging) {
7798         /* Undo animation damage if needed */
7799         DrawPosition(FALSE, NULL);
7800     }
7801 }
7802
7803 int
7804 RightClick (ClickType action, int x, int y, int *fromX, int *fromY)
7805 {   // front-end-free part taken out of PieceMenuPopup
7806     int whichMenu; int xSqr, ySqr;
7807
7808     if(seekGraphUp) { // [HGM] seekgraph
7809         if(action == Press)   SeekGraphClick(Press, x, y, 2); // 2 indicates right-click: no pop-down on miss
7810         if(action == Release) SeekGraphClick(Release, x, y, 2); // and no challenge on hit
7811         return -2;
7812     }
7813
7814     if((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack)
7815          && !appData.zippyPlay && appData.bgObserve) { // [HGM] bughouse: show background game
7816         if(!partnerBoardValid) return -2; // suppress display of uninitialized boards
7817         if( appData.dualBoard) return -2; // [HGM] dual: is already displayed
7818         if(action == Press)   {
7819             originalFlip = flipView;
7820             flipView = !flipView; // temporarily flip board to see game from partners perspective
7821             DrawPosition(TRUE, partnerBoard);
7822             DisplayMessage(partnerStatus, "");
7823             partnerUp = TRUE;
7824         } else if(action == Release) {
7825             flipView = originalFlip;
7826             DrawPosition(TRUE, boards[currentMove]);
7827             partnerUp = FALSE;
7828         }
7829         return -2;
7830     }
7831
7832     xSqr = EventToSquare(x, BOARD_WIDTH);
7833     ySqr = EventToSquare(y, BOARD_HEIGHT);
7834     if (action == Release) {
7835         if(pieceSweep != EmptySquare) {
7836             EditPositionMenuEvent(pieceSweep, toX, toY);
7837             pieceSweep = EmptySquare;
7838         } else UnLoadPV(); // [HGM] pv
7839     }
7840     if (action != Press) return -2; // return code to be ignored
7841     switch (gameMode) {
7842       case IcsExamining:
7843         if(xSqr < BOARD_LEFT || xSqr >= BOARD_RGHT) return -1;
7844       case EditPosition:
7845         if (xSqr == BOARD_LEFT-1 || xSqr == BOARD_RGHT) return -1;
7846         if (xSqr < 0 || ySqr < 0) return -1;
7847         if(appData.pieceMenu) { whichMenu = 0; break; } // edit-position menu
7848         pieceSweep = shiftKey ? BlackPawn : WhitePawn;  // [HGM] sweep: prepare selecting piece by mouse sweep
7849         toX = xSqr; toY = ySqr; lastX = x, lastY = y;
7850         if(flipView) toX = BOARD_WIDTH - 1 - toX; else toY = BOARD_HEIGHT - 1 - toY;
7851         NextPiece(0);
7852         return 2; // grab
7853       case IcsObserving:
7854         if(!appData.icsEngineAnalyze) return -1;
7855       case IcsPlayingWhite:
7856       case IcsPlayingBlack:
7857         if(!appData.zippyPlay) goto noZip;
7858       case AnalyzeMode:
7859       case AnalyzeFile:
7860       case MachinePlaysWhite:
7861       case MachinePlaysBlack:
7862       case TwoMachinesPlay: // [HGM] pv: use for showing PV
7863         if (!appData.dropMenu) {
7864           LoadPV(x, y);
7865           return 2; // flag front-end to grab mouse events
7866         }
7867         if(gameMode == TwoMachinesPlay || gameMode == AnalyzeMode ||
7868            gameMode == AnalyzeFile || gameMode == IcsObserving) return -1;
7869       case EditGame:
7870       noZip:
7871         if (xSqr < 0 || ySqr < 0) return -1;
7872         if (!appData.dropMenu || appData.testLegality &&
7873             gameInfo.variant != VariantBughouse &&
7874             gameInfo.variant != VariantCrazyhouse) return -1;
7875         whichMenu = 1; // drop menu
7876         break;
7877       default:
7878         return -1;
7879     }
7880
7881     if (((*fromX = xSqr) < 0) ||
7882         ((*fromY = ySqr) < 0)) {
7883         *fromX = *fromY = -1;
7884         return -1;
7885     }
7886     if (flipView)
7887       *fromX = BOARD_WIDTH - 1 - *fromX;
7888     else
7889       *fromY = BOARD_HEIGHT - 1 - *fromY;
7890
7891     return whichMenu;
7892 }
7893
7894 void
7895 SendProgramStatsToFrontend (ChessProgramState * cps, ChessProgramStats * cpstats)
7896 {
7897 //    char * hint = lastHint;
7898     FrontEndProgramStats stats;
7899
7900     stats.which = cps == &first ? 0 : 1;
7901     stats.depth = cpstats->depth;
7902     stats.nodes = cpstats->nodes;
7903     stats.score = cpstats->score;
7904     stats.time = cpstats->time;
7905     stats.pv = cpstats->movelist;
7906     stats.hint = lastHint;
7907     stats.an_move_index = 0;
7908     stats.an_move_count = 0;
7909
7910     if( gameMode == AnalyzeMode || gameMode == AnalyzeFile ) {
7911         stats.hint = cpstats->move_name;
7912         stats.an_move_index = cpstats->nr_moves - cpstats->moves_left;
7913         stats.an_move_count = cpstats->nr_moves;
7914     }
7915
7916     if(stats.pv && stats.pv[0]) safeStrCpy(lastPV[stats.which], stats.pv, sizeof(lastPV[stats.which])/sizeof(lastPV[stats.which][0])); // [HGM] pv: remember last PV of each
7917
7918     SetProgramStats( &stats );
7919 }
7920
7921 void
7922 ClearEngineOutputPane (int which)
7923 {
7924     static FrontEndProgramStats dummyStats;
7925     dummyStats.which = which;
7926     dummyStats.pv = "#";
7927     SetProgramStats( &dummyStats );
7928 }
7929
7930 #define MAXPLAYERS 500
7931
7932 char *
7933 TourneyStandings (int display)
7934 {
7935     int i, w, b, color, wScore, bScore, dummy, nr=0, nPlayers=0;
7936     int score[MAXPLAYERS], ranking[MAXPLAYERS], points[MAXPLAYERS], games[MAXPLAYERS];
7937     char result, *p, *names[MAXPLAYERS];
7938
7939     if(appData.tourneyType < 0 && !strchr(appData.results, '*'))
7940         return strdup(_("Swiss tourney finished")); // standings of Swiss yet TODO
7941     names[0] = p = strdup(appData.participants);
7942     while(p = strchr(p, '\n')) *p++ = NULLCHAR, names[++nPlayers] = p; // count participants
7943
7944     for(i=0; i<nPlayers; i++) score[i] = games[i] = 0;
7945
7946     while(result = appData.results[nr]) {
7947         color = Pairing(nr, nPlayers, &w, &b, &dummy);
7948         if(!(color ^ matchGame & 1)) { dummy = w; w = b; b = dummy; }
7949         wScore = bScore = 0;
7950         switch(result) {
7951           case '+': wScore = 2; break;
7952           case '-': bScore = 2; break;
7953           case '=': wScore = bScore = 1; break;
7954           case ' ':
7955           case '*': return strdup("busy"); // tourney not finished
7956         }
7957         score[w] += wScore;
7958         score[b] += bScore;
7959         games[w]++;
7960         games[b]++;
7961         nr++;
7962     }
7963     if(appData.tourneyType > 0) nPlayers = appData.tourneyType; // in gauntlet, list only gauntlet engine(s)
7964     for(w=0; w<nPlayers; w++) {
7965         bScore = -1;
7966         for(i=0; i<nPlayers; i++) if(score[i] > bScore) bScore = score[i], b = i;
7967         ranking[w] = b; points[w] = bScore; score[b] = -2;
7968     }
7969     p = malloc(nPlayers*34+1);
7970     for(w=0; w<nPlayers && w<display; w++)
7971         sprintf(p+34*w, "%2d. %5.1f/%-3d %-19.19s\n", w+1, points[w]/2., games[ranking[w]], names[ranking[w]]);
7972     free(names[0]);
7973     return p;
7974 }
7975
7976 void
7977 Count (Board board, int pCnt[], int *nW, int *nB, int *wStale, int *bStale, int *bishopColor)
7978 {       // count all piece types
7979         int p, f, r;
7980         *nB = *nW = *wStale = *bStale = *bishopColor = 0;
7981         for(p=WhitePawn; p<=EmptySquare; p++) pCnt[p] = 0;
7982         for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
7983                 p = board[r][f];
7984                 pCnt[p]++;
7985                 if(p == WhitePawn && r == BOARD_HEIGHT-1) (*wStale)++; else
7986                 if(p == BlackPawn && r == 0) (*bStale)++; // count last-Rank Pawns (XQ) separately
7987                 if(p <= WhiteKing) (*nW)++; else if(p <= BlackKing) (*nB)++;
7988                 if(p == WhiteBishop || p == WhiteFerz || p == WhiteAlfil ||
7989                    p == BlackBishop || p == BlackFerz || p == BlackAlfil   )
7990                         *bishopColor |= 1 << ((f^r)&1); // track square color of color-bound pieces
7991         }
7992 }
7993
7994 int
7995 SufficientDefence (int pCnt[], int side, int nMine, int nHis)
7996 {
7997         int myPawns = pCnt[WhitePawn+side]; // my total Pawn count;
7998         int majorDefense = pCnt[BlackRook-side] + pCnt[BlackCannon-side] + pCnt[BlackKnight-side];
7999
8000         nMine -= pCnt[WhiteFerz+side] + pCnt[WhiteAlfil+side]; // discount defenders
8001         if(nMine - myPawns > 2) return FALSE; // no trivial draws with more than 1 major
8002         if(myPawns == 2 && nMine == 3) // KPP
8003             return majorDefense || pCnt[BlackFerz-side] + pCnt[BlackAlfil-side] >= 3;
8004         if(myPawns == 1 && nMine == 2) // KP
8005             return majorDefense || pCnt[BlackFerz-side] + pCnt[BlackAlfil-side]  + pCnt[BlackPawn-side] >= 1;
8006         if(myPawns == 1 && nMine == 3 && pCnt[WhiteKnight+side]) // KHP
8007             return majorDefense || pCnt[BlackFerz-side] + pCnt[BlackAlfil-side]*2 >= 5;
8008         if(myPawns) return FALSE;
8009         if(pCnt[WhiteRook+side])
8010             return pCnt[BlackRook-side] ||
8011                    pCnt[BlackCannon-side] && (pCnt[BlackFerz-side] >= 2 || pCnt[BlackAlfil-side] >= 2) ||
8012                    pCnt[BlackKnight-side] && pCnt[BlackFerz-side] + pCnt[BlackAlfil-side] > 2 ||
8013                    pCnt[BlackFerz-side] + pCnt[BlackAlfil-side] >= 4;
8014         if(pCnt[WhiteCannon+side]) {
8015             if(pCnt[WhiteFerz+side] + myPawns == 0) return TRUE; // Cannon needs platform
8016             return majorDefense || pCnt[BlackAlfil-side] >= 2;
8017         }
8018         if(pCnt[WhiteKnight+side])
8019             return majorDefense || pCnt[BlackFerz-side] >= 2 || pCnt[BlackAlfil-side] + pCnt[BlackPawn-side] >= 1;
8020         return FALSE;
8021 }
8022
8023 int
8024 MatingPotential (int pCnt[], int side, int nMine, int nHis, int stale, int bisColor)
8025 {
8026         VariantClass v = gameInfo.variant;
8027
8028         if(v == VariantShogi || v == VariantCrazyhouse || v == VariantBughouse) return TRUE; // drop games always winnable
8029         if(v == VariantShatranj) return TRUE; // always winnable through baring
8030         if(v == VariantLosers || v == VariantSuicide || v == VariantGiveaway) return TRUE;
8031         if(v == Variant3Check || v == VariantAtomic) return nMine > 1; // can win through checking / exploding King
8032
8033         if(v == VariantXiangqi) {
8034                 int majors = 5*pCnt[BlackKnight-side] + 7*pCnt[BlackCannon-side] + 7*pCnt[BlackRook-side];
8035
8036                 nMine -= pCnt[WhiteFerz+side] + pCnt[WhiteAlfil+side] + stale; // discount defensive pieces and back-rank Pawns
8037                 if(nMine + stale == 1) return (pCnt[BlackFerz-side] > 1 && pCnt[BlackKnight-side] > 0); // bare K can stalemate KHAA (!)
8038                 if(nMine > 2) return TRUE; // if we don't have P, H or R, we must have CC
8039                 if(nMine == 2 && pCnt[WhiteCannon+side] == 0) return TRUE; // We have at least one P, H or R
8040                 // if we get here, we must have KC... or KP..., possibly with additional A, E or last-rank P
8041                 if(stale) // we have at least one last-rank P plus perhaps C
8042                     return majors // KPKX
8043                         || pCnt[BlackFerz-side] && pCnt[BlackFerz-side] + pCnt[WhiteCannon+side] + stale > 2; // KPKAA, KPPKA and KCPKA
8044                 else // KCA*E*
8045                     return pCnt[WhiteFerz+side] // KCAK
8046                         || pCnt[WhiteAlfil+side] && pCnt[BlackRook-side] + pCnt[BlackCannon-side] + pCnt[BlackFerz-side] // KCEKA, KCEKX (X!=H)
8047                         || majors + (12*pCnt[BlackFerz-side] | 6*pCnt[BlackAlfil-side]) > 16; // KCKAA, KCKAX, KCKEEX, KCKEXX (XX!=HH), KCKXXX
8048                 // TO DO: cases wih an unpromoted f-Pawn acting as platform for an opponent Cannon
8049
8050         } else if(v == VariantKnightmate) {
8051                 if(nMine == 1) return FALSE;
8052                 if(nMine == 2 && nHis == 1 && pCnt[WhiteBishop+side] + pCnt[WhiteFerz+side] + pCnt[WhiteKnight+side]) return FALSE; // KBK is only draw
8053         } else if(pCnt[WhiteKing] == 1 && pCnt[BlackKing] == 1) { // other variants with orthodox Kings
8054                 int nBishops = pCnt[WhiteBishop+side] + pCnt[WhiteFerz+side];
8055
8056                 if(nMine == 1) return FALSE; // bare King
8057                 if(nBishops && bisColor == 3) return TRUE; // There must be a second B/A/F, which can either block (his) or attack (mine) the escape square
8058                 nMine += (nBishops > 0) - nBishops; // By now all Bishops (and Ferz) on like-colored squares, so count as one
8059                 if(nMine > 2 && nMine != pCnt[WhiteAlfil+side] + 1) return TRUE; // At least two pieces, not all Alfils
8060                 // by now we have King + 1 piece (or multiple Bishops on the same color)
8061                 if(pCnt[WhiteKnight+side])
8062                         return (pCnt[BlackKnight-side] + pCnt[BlackBishop-side] + pCnt[BlackMan-side] +
8063                                 pCnt[BlackWazir-side] + pCnt[BlackSilver-side] + bisColor // KNKN, KNKB, KNKF, KNKE, KNKW, KNKM, KNKS
8064                              || nHis > 3); // be sure to cover suffocation mates in corner (e.g. KNKQCA)
8065                 if(nBishops)
8066                         return (pCnt[BlackKnight-side]); // KBKN, KFKN
8067                 if(pCnt[WhiteAlfil+side])
8068                         return (nHis > 2); // Alfils can in general not reach a corner square, but there might be edge (suffocation) mates
8069                 if(pCnt[WhiteWazir+side])
8070                         return (pCnt[BlackKnight-side] + pCnt[BlackWazir-side] + pCnt[BlackAlfil-side]); // KWKN, KWKW, KWKE
8071         }
8072
8073         return TRUE;
8074 }
8075
8076 int
8077 CompareWithRights (Board b1, Board b2)
8078 {
8079     int rights = 0;
8080     if(!CompareBoards(b1, b2)) return FALSE;
8081     if(b1[EP_STATUS] != b2[EP_STATUS]) return FALSE;
8082     /* compare castling rights */
8083     if( b1[CASTLING][2] != b2[CASTLING][2] && (b2[CASTLING][0] != NoRights || b2[CASTLING][1] != NoRights) )
8084            rights++; /* King lost rights, while rook still had them */
8085     if( b1[CASTLING][2] != NoRights ) { /* king has rights */
8086         if( b1[CASTLING][0] != b2[CASTLING][0] || b1[CASTLING][1] != b2[CASTLING][1] )
8087            rights++; /* but at least one rook lost them */
8088     }
8089     if( b1[CASTLING][5] != b1[CASTLING][5] && (b2[CASTLING][3] != NoRights || b2[CASTLING][4] != NoRights) )
8090            rights++;
8091     if( b1[CASTLING][5] != NoRights ) {
8092         if( b1[CASTLING][3] != b2[CASTLING][3] || b1[CASTLING][4] != b2[CASTLING][4] )
8093            rights++;
8094     }
8095     return rights == 0;
8096 }
8097
8098 int
8099 Adjudicate (ChessProgramState *cps)
8100 {       // [HGM] some adjudications useful with buggy engines
8101         // [HGM] adjudicate: made into separate routine, which now can be called after every move
8102         //       In any case it determnes if the game is a claimable draw (filling in EP_STATUS).
8103         //       Actually ending the game is now based on the additional internal condition canAdjudicate.
8104         //       Only when the game is ended, and the opponent is a computer, this opponent gets the move relayed.
8105         int k, drop, count = 0; static int bare = 1;
8106         ChessProgramState *engineOpponent = (gameMode == TwoMachinesPlay ? cps->other : (cps ? NULL : &first));
8107         Boolean canAdjudicate = !appData.icsActive;
8108
8109         // most tests only when we understand the game, i.e. legality-checking on
8110             if( appData.testLegality )
8111             {   /* [HGM] Some more adjudications for obstinate engines */
8112                 int nrW, nrB, bishopColor, staleW, staleB, nr[EmptySquare+2], i;
8113                 static int moveCount = 6;
8114                 ChessMove result;
8115                 char *reason = NULL;
8116
8117                 /* Count what is on board. */
8118                 Count(boards[forwardMostMove], nr, &nrW, &nrB, &staleW, &staleB, &bishopColor);
8119
8120                 /* Some material-based adjudications that have to be made before stalemate test */
8121                 if(gameInfo.variant == VariantAtomic && nr[WhiteKing] + nr[BlackKing] < 2) {
8122                     // [HGM] atomic: stm must have lost his King on previous move, as destroying own K is illegal
8123                      boards[forwardMostMove][EP_STATUS] = EP_CHECKMATE; // make claimable as if stm is checkmated
8124                      if(canAdjudicate && appData.checkMates) {
8125                          if(engineOpponent)
8126                            SendMoveToProgram(forwardMostMove-1, engineOpponent); // make sure opponent gets move
8127                          GameEnds( WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins,
8128                                                         "Xboard adjudication: King destroyed", GE_XBOARD );
8129                          return 1;
8130                      }
8131                 }
8132
8133                 /* Bare King in Shatranj (loses) or Losers (wins) */
8134                 if( nrW == 1 || nrB == 1) {
8135                   if( gameInfo.variant == VariantLosers) { // [HGM] losers: bare King wins (stm must have it first)
8136                      boards[forwardMostMove][EP_STATUS] = EP_WINS;  // mark as win, so it becomes claimable
8137                      if(canAdjudicate && appData.checkMates) {
8138                          if(engineOpponent)
8139                            SendMoveToProgram(forwardMostMove-1, engineOpponent); // make sure opponent gets to see move
8140                          GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
8141                                                         "Xboard adjudication: Bare king", GE_XBOARD );
8142                          return 1;
8143                      }
8144                   } else
8145                   if( gameInfo.variant == VariantShatranj && --bare < 0)
8146                   {    /* bare King */
8147                         boards[forwardMostMove][EP_STATUS] = EP_WINS; // make claimable as win for stm
8148                         if(canAdjudicate && appData.checkMates) {
8149                             /* but only adjudicate if adjudication enabled */
8150                             if(engineOpponent)
8151                               SendMoveToProgram(forwardMostMove-1, engineOpponent); // make sure opponent gets move
8152                             GameEnds( nrW > 1 ? WhiteWins : nrB > 1 ? BlackWins : GameIsDrawn,
8153                                                         "Xboard adjudication: Bare king", GE_XBOARD );
8154                             return 1;
8155                         }
8156                   }
8157                 } else bare = 1;
8158
8159
8160             // don't wait for engine to announce game end if we can judge ourselves
8161             switch (MateTest(boards[forwardMostMove], PosFlags(forwardMostMove)) ) {
8162               case MT_CHECK:
8163                 if(gameInfo.variant == Variant3Check) { // [HGM] 3check: when in check, test if 3rd time
8164                     int i, checkCnt = 0;    // (should really be done by making nr of checks part of game state)
8165                     for(i=forwardMostMove-2; i>=backwardMostMove; i-=2) {
8166                         if(MateTest(boards[i], PosFlags(i)) == MT_CHECK)
8167                             checkCnt++;
8168                         if(checkCnt >= 2) {
8169                             reason = "Xboard adjudication: 3rd check";
8170                             boards[forwardMostMove][EP_STATUS] = EP_CHECKMATE;
8171                             break;
8172                         }
8173                     }
8174                 }
8175               case MT_NONE:
8176               default:
8177                 break;
8178               case MT_STEALMATE:
8179               case MT_STALEMATE:
8180               case MT_STAINMATE:
8181                 reason = "Xboard adjudication: Stalemate";
8182                 if((signed char)boards[forwardMostMove][EP_STATUS] != EP_CHECKMATE) { // [HGM] don't touch win through baring or K-capt
8183                     boards[forwardMostMove][EP_STATUS] = EP_STALEMATE;   // default result for stalemate is draw
8184                     if(gameInfo.variant == VariantLosers  || gameInfo.variant == VariantGiveaway) // [HGM] losers:
8185                         boards[forwardMostMove][EP_STATUS] = EP_WINS;    // in these variants stalemated is always a win
8186                     else if(gameInfo.variant == VariantSuicide) // in suicide it depends
8187                         boards[forwardMostMove][EP_STATUS] = nrW == nrB ? EP_STALEMATE :
8188                                                    ((nrW < nrB) != WhiteOnMove(forwardMostMove) ?
8189                                                                         EP_CHECKMATE : EP_WINS);
8190                     else if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantXiangqi || gameInfo.variant == VariantShogi)
8191                         boards[forwardMostMove][EP_STATUS] = EP_CHECKMATE; // and in these variants being stalemated loses
8192                 }
8193                 break;
8194               case MT_CHECKMATE:
8195                 reason = "Xboard adjudication: Checkmate";
8196                 boards[forwardMostMove][EP_STATUS] = (gameInfo.variant == VariantLosers ? EP_WINS : EP_CHECKMATE);
8197                 if(gameInfo.variant == VariantShogi) {
8198                     if(forwardMostMove > backwardMostMove
8199                        && moveList[forwardMostMove-1][1] == '@'
8200                        && CharToPiece(ToUpper(moveList[forwardMostMove-1][0])) == WhitePawn) {
8201                         reason = "XBoard adjudication: pawn-drop mate";
8202                         boards[forwardMostMove][EP_STATUS] = EP_WINS;
8203                     }
8204                 }
8205                 break;
8206             }
8207
8208                 switch(i = (signed char)boards[forwardMostMove][EP_STATUS]) {
8209                     case EP_STALEMATE:
8210                         result = GameIsDrawn; break;
8211                     case EP_CHECKMATE:
8212                         result = WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins; break;
8213                     case EP_WINS:
8214                         result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins; break;
8215                     default:
8216                         result = EndOfFile;
8217                 }
8218                 if(canAdjudicate && appData.checkMates && result) { // [HGM] mates: adjudicate finished games if requested
8219                     if(engineOpponent)
8220                       SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
8221                     GameEnds( result, reason, GE_XBOARD );
8222                     return 1;
8223                 }
8224
8225                 /* Next absolutely insufficient mating material. */
8226                 if(!MatingPotential(nr, WhitePawn, nrW, nrB, staleW, bishopColor) &&
8227                    !MatingPotential(nr, BlackPawn, nrB, nrW, staleB, bishopColor))
8228                 {    /* includes KBK, KNK, KK of KBKB with like Bishops */
8229
8230                      /* always flag draws, for judging claims */
8231                      boards[forwardMostMove][EP_STATUS] = EP_INSUF_DRAW;
8232
8233                      if(canAdjudicate && appData.materialDraws) {
8234                          /* but only adjudicate them if adjudication enabled */
8235                          if(engineOpponent) {
8236                            SendToProgram("force\n", engineOpponent); // suppress reply
8237                            SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see last move */
8238                          }
8239                          GameEnds( GameIsDrawn, "Xboard adjudication: Insufficient mating material", GE_XBOARD );
8240                          return 1;
8241                      }
8242                 }
8243
8244                 /* Then some trivial draws (only adjudicate, cannot be claimed) */
8245                 if(gameInfo.variant == VariantXiangqi ?
8246                        SufficientDefence(nr, WhitePawn, nrW, nrB) && SufficientDefence(nr, BlackPawn, nrB, nrW)
8247                  : nrW + nrB == 4 &&
8248                    (   nr[WhiteRook] == 1 && nr[BlackRook] == 1 /* KRKR */
8249                    || nr[WhiteQueen] && nr[BlackQueen]==1     /* KQKQ */
8250                    || nr[WhiteKnight]==2 || nr[BlackKnight]==2     /* KNNK */
8251                    || nr[WhiteKnight]+nr[WhiteBishop] == 1 && nr[BlackKnight]+nr[BlackBishop] == 1 /* KBKN, KBKB, KNKN */
8252                    ) ) {
8253                      if(--moveCount < 0 && appData.trivialDraws && canAdjudicate)
8254                      {    /* if the first 3 moves do not show a tactical win, declare draw */
8255                           if(engineOpponent) {
8256                             SendToProgram("force\n", engineOpponent); // suppress reply
8257                             SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
8258                           }
8259                           GameEnds( GameIsDrawn, "Xboard adjudication: Trivial draw", GE_XBOARD );
8260                           return 1;
8261                      }
8262                 } else moveCount = 6;
8263             }
8264
8265         // Repetition draws and 50-move rule can be applied independently of legality testing
8266
8267                 /* Check for rep-draws */
8268                 count = 0;
8269                 drop = gameInfo.holdingsSize && (gameInfo.variant != VariantSuper && gameInfo.variant != VariantSChess
8270                                               && gameInfo.variant != VariantGreat && gameInfo.variant != VariantGrand);
8271                 for(k = forwardMostMove-2;
8272                     k>=backwardMostMove && k>=forwardMostMove-100 && (drop ||
8273                         (signed char)boards[k][EP_STATUS] < EP_UNKNOWN &&
8274                         (signed char)boards[k+2][EP_STATUS] <= EP_NONE && (signed char)boards[k+1][EP_STATUS] <= EP_NONE);
8275                     k-=2)
8276                 {   int rights=0;
8277                     if(CompareBoards(boards[k], boards[forwardMostMove])) {
8278                         /* compare castling rights */
8279                         if( boards[forwardMostMove][CASTLING][2] != boards[k][CASTLING][2] &&
8280                              (boards[k][CASTLING][0] != NoRights || boards[k][CASTLING][1] != NoRights) )
8281                                 rights++; /* King lost rights, while rook still had them */
8282                         if( boards[forwardMostMove][CASTLING][2] != NoRights ) { /* king has rights */
8283                             if( boards[forwardMostMove][CASTLING][0] != boards[k][CASTLING][0] ||
8284                                 boards[forwardMostMove][CASTLING][1] != boards[k][CASTLING][1] )
8285                                    rights++; /* but at least one rook lost them */
8286                         }
8287                         if( boards[forwardMostMove][CASTLING][5] != boards[k][CASTLING][5] &&
8288                              (boards[k][CASTLING][3] != NoRights || boards[k][CASTLING][4] != NoRights) )
8289                                 rights++;
8290                         if( boards[forwardMostMove][CASTLING][5] != NoRights ) {
8291                             if( boards[forwardMostMove][CASTLING][3] != boards[k][CASTLING][3] ||
8292                                 boards[forwardMostMove][CASTLING][4] != boards[k][CASTLING][4] )
8293                                    rights++;
8294                         }
8295                         if( rights == 0 && ++count > appData.drawRepeats-2 && canAdjudicate
8296                             && appData.drawRepeats > 1) {
8297                              /* adjudicate after user-specified nr of repeats */
8298                              int result = GameIsDrawn;
8299                              char *details = "XBoard adjudication: repetition draw";
8300                              if((gameInfo.variant == VariantXiangqi || gameInfo.variant == VariantShogi) && appData.testLegality) {
8301                                 // [HGM] xiangqi: check for forbidden perpetuals
8302                                 int m, ourPerpetual = 1, hisPerpetual = 1;
8303                                 for(m=forwardMostMove; m>k; m-=2) {
8304                                     if(MateTest(boards[m], PosFlags(m)) != MT_CHECK)
8305                                         ourPerpetual = 0; // the current mover did not always check
8306                                     if(MateTest(boards[m-1], PosFlags(m-1)) != MT_CHECK)
8307                                         hisPerpetual = 0; // the opponent did not always check
8308                                 }
8309                                 if(appData.debugMode) fprintf(debugFP, "XQ perpetual test, our=%d, his=%d\n",
8310                                                                         ourPerpetual, hisPerpetual);
8311                                 if(ourPerpetual && !hisPerpetual) { // we are actively checking him: forfeit
8312                                     result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
8313                                     details = "Xboard adjudication: perpetual checking";
8314                                 } else
8315                                 if(hisPerpetual && !ourPerpetual) { // he is checking us, but did not repeat yet
8316                                     break; // (or we would have caught him before). Abort repetition-checking loop.
8317                                 } else
8318                                 if(gameInfo.variant == VariantShogi) { // in Shogi other repetitions are draws
8319                                     if(BOARD_HEIGHT == 5 && BOARD_RGHT - BOARD_LEFT == 5) { // but in mini-Shogi gote wins!
8320                                         result = BlackWins;
8321                                         details = "Xboard adjudication: repetition";
8322                                     }
8323                                 } else // it must be XQ
8324                                 // Now check for perpetual chases
8325                                 if(!ourPerpetual && !hisPerpetual) { // no perpetual check, test for chase
8326                                     hisPerpetual = PerpetualChase(k, forwardMostMove);
8327                                     ourPerpetual = PerpetualChase(k+1, forwardMostMove);
8328                                     if(ourPerpetual && !hisPerpetual) { // we are actively chasing him: forfeit
8329                                         static char resdet[MSG_SIZ];
8330                                         result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
8331                                         details = resdet;
8332                                         snprintf(resdet, MSG_SIZ, "Xboard adjudication: perpetual chasing of %c%c", ourPerpetual>>8, ourPerpetual&255);
8333                                     } else
8334                                     if(hisPerpetual && !ourPerpetual)   // he is chasing us, but did not repeat yet
8335                                         break; // Abort repetition-checking loop.
8336                                 }
8337                                 // if neither of us is checking or chasing all the time, or both are, it is draw
8338                              }
8339                              if(engineOpponent) {
8340                                SendToProgram("force\n", engineOpponent); // suppress reply
8341                                SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
8342                              }
8343                              GameEnds( result, details, GE_XBOARD );
8344                              return 1;
8345                         }
8346                         if( rights == 0 && count > 1 ) /* occurred 2 or more times before */
8347                              boards[forwardMostMove][EP_STATUS] = EP_REP_DRAW;
8348                     }
8349                 }
8350
8351                 /* Now we test for 50-move draws. Determine ply count */
8352                 count = forwardMostMove;
8353                 /* look for last irreversble move */
8354                 while( (signed char)boards[count][EP_STATUS] <= EP_NONE && count > backwardMostMove )
8355                     count--;
8356                 /* if we hit starting position, add initial plies */
8357                 if( count == backwardMostMove )
8358                     count -= initialRulePlies;
8359                 count = forwardMostMove - count;
8360                 if(gameInfo.variant == VariantXiangqi && ( count >= 100 || count >= 2*appData.ruleMoves ) ) {
8361                         // adjust reversible move counter for checks in Xiangqi
8362                         int i = forwardMostMove - count, inCheck = 0, lastCheck;
8363                         if(i < backwardMostMove) i = backwardMostMove;
8364                         while(i <= forwardMostMove) {
8365                                 lastCheck = inCheck; // check evasion does not count
8366                                 inCheck = (MateTest(boards[i], PosFlags(i)) == MT_CHECK);
8367                                 if(inCheck || lastCheck) count--; // check does not count
8368                                 i++;
8369                         }
8370                 }
8371                 if( count >= 100)
8372                          boards[forwardMostMove][EP_STATUS] = EP_RULE_DRAW;
8373                          /* this is used to judge if draw claims are legal */
8374                 if(canAdjudicate && appData.ruleMoves > 0 && count >= 2*appData.ruleMoves) {
8375                          if(engineOpponent) {
8376                            SendToProgram("force\n", engineOpponent); // suppress reply
8377                            SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
8378                          }
8379                          GameEnds( GameIsDrawn, "Xboard adjudication: 50-move rule", GE_XBOARD );
8380                          return 1;
8381                 }
8382
8383                 /* if draw offer is pending, treat it as a draw claim
8384                  * when draw condition present, to allow engines a way to
8385                  * claim draws before making their move to avoid a race
8386                  * condition occurring after their move
8387                  */
8388                 if((gameMode == TwoMachinesPlay ? second.offeredDraw : userOfferedDraw) || first.offeredDraw ) {
8389                          char *p = NULL;
8390                          if((signed char)boards[forwardMostMove][EP_STATUS] == EP_RULE_DRAW)
8391                              p = "Draw claim: 50-move rule";
8392                          if((signed char)boards[forwardMostMove][EP_STATUS] == EP_REP_DRAW)
8393                              p = "Draw claim: 3-fold repetition";
8394                          if((signed char)boards[forwardMostMove][EP_STATUS] == EP_INSUF_DRAW)
8395                              p = "Draw claim: insufficient mating material";
8396                          if( p != NULL && canAdjudicate) {
8397                              if(engineOpponent) {
8398                                SendToProgram("force\n", engineOpponent); // suppress reply
8399                                SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
8400                              }
8401                              GameEnds( GameIsDrawn, p, GE_XBOARD );
8402                              return 1;
8403                          }
8404                 }
8405
8406                 if( canAdjudicate && appData.adjudicateDrawMoves > 0 && forwardMostMove > (2*appData.adjudicateDrawMoves) ) {
8407                     if(engineOpponent) {
8408                       SendToProgram("force\n", engineOpponent); // suppress reply
8409                       SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
8410                     }
8411                     GameEnds( GameIsDrawn, "Xboard adjudication: long game", GE_XBOARD );
8412                     return 1;
8413                 }
8414         return 0;
8415 }
8416
8417 typedef int (CDECL *PPROBE_EGBB) (int player, int *piece, int *square);
8418 typedef int (CDECL *PLOAD_EGBB) (char *path, int cache_size, int load_options);
8419 static int egbbCode[] = { 6, 5, 4, 3, 2, 1 };
8420
8421 static int
8422 BitbaseProbe ()
8423 {
8424     int pieces[10], squares[10], cnt=0, r, f, res;
8425     static int loaded;
8426     static PPROBE_EGBB probeBB;
8427     if(!appData.testLegality) return 10;
8428     if(BOARD_HEIGHT != 8 || BOARD_RGHT-BOARD_LEFT != 8) return 12;
8429     if(gameInfo.holdingsSize && gameInfo.variant != VariantSuper && gameInfo.variant != VariantSChess) return 12;
8430     if(loaded == 2 && forwardMostMove < 2) loaded = 0; // retry on new game
8431     for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
8432         ChessSquare piece = boards[forwardMostMove][r][f];
8433         int black = (piece >= BlackPawn);
8434         int type = piece - black*BlackPawn;
8435         if(piece == EmptySquare) continue;
8436         if(type != WhiteKing && type > WhiteQueen) return 12; // unorthodox piece
8437         if(type == WhiteKing) type = WhiteQueen + 1;
8438         type = egbbCode[type];
8439         squares[cnt] = r*(BOARD_RGHT - BOARD_LEFT) + f - BOARD_LEFT;
8440         pieces[cnt] = type + black*6;
8441         if(++cnt > 5) return 11;
8442     }
8443     pieces[cnt] = squares[cnt] = 0;
8444     // probe EGBB
8445     if(loaded == 2) return 13; // loading failed before
8446     if(loaded == 0) {
8447         char *p, *path = strstr(appData.egtFormats, "scorpio:"), buf[MSG_SIZ];
8448         HMODULE lib;
8449         PLOAD_EGBB loadBB;
8450         loaded = 2; // prepare for failure
8451         if(!path) return 13; // no egbb installed
8452         strncpy(buf, path + 8, MSG_SIZ);
8453         if(p = strchr(buf, ',')) *p = NULLCHAR; else p = buf + strlen(buf);
8454         snprintf(p, MSG_SIZ - strlen(buf), "%c%s", SLASH, EGBB_NAME);
8455         lib = LoadLibrary(buf);
8456         if(!lib) { DisplayError(_("could not load EGBB library"), 0); return 13; }
8457         loadBB = (PLOAD_EGBB) GetProcAddress(lib, "load_egbb_xmen");
8458         probeBB = (PPROBE_EGBB) GetProcAddress(lib, "probe_egbb_xmen");
8459         if(!loadBB || !probeBB) { DisplayError(_("wrong EGBB version"), 0); return 13; }
8460         p[1] = NULLCHAR; loadBB(buf, 64*1028, 2); // 2 = SMART_LOAD
8461         loaded = 1; // success!
8462     }
8463     res = probeBB(forwardMostMove & 1, pieces, squares);
8464     return res > 0 ? 1 : res < 0 ? -1 : 0;
8465 }
8466
8467 char *
8468 SendMoveToBookUser (int moveNr, ChessProgramState *cps, int initial)
8469 {   // [HGM] book: this routine intercepts moves to simulate book replies
8470     char *bookHit = NULL;
8471
8472     if(cps->drawDepth && BitbaseProbe() == 0) { // [HG} egbb: reduce depth in drawn position
8473         char buf[MSG_SIZ];
8474         snprintf(buf, MSG_SIZ, "sd %d\n", cps->drawDepth);
8475         SendToProgram(buf, cps);
8476     }
8477     //first determine if the incoming move brings opponent into his book
8478     if(appData.usePolyglotBook && (cps == &first ? !appData.firstHasOwnBookUCI : !appData.secondHasOwnBookUCI))
8479         bookHit = ProbeBook(moveNr+1, appData.polyglotBook); // returns move
8480     if(appData.debugMode) fprintf(debugFP, "book hit = %s\n", bookHit ? bookHit : "(NULL)");
8481     if(bookHit != NULL && !cps->bookSuspend) {
8482         // make sure opponent is not going to reply after receiving move to book position
8483         SendToProgram("force\n", cps);
8484         cps->bookSuspend = TRUE; // flag indicating it has to be restarted
8485     }
8486     if(bookHit) setboardSpoiledMachineBlack = FALSE; // suppress 'go' in SendMoveToProgram
8487     if(!initial) SendMoveToProgram(moveNr, cps); // with hit on initial position there is no move
8488     // now arrange restart after book miss
8489     if(bookHit) {
8490         // after a book hit we never send 'go', and the code after the call to this routine
8491         // has '&& !bookHit' added to suppress potential sending there (based on 'firstMove').
8492         char buf[MSG_SIZ], *move = bookHit;
8493         if(cps->useSAN) {
8494             int fromX, fromY, toX, toY;
8495             char promoChar;
8496             ChessMove moveType;
8497             move = buf + 30;
8498             if (ParseOneMove(bookHit, forwardMostMove, &moveType,
8499                                  &fromX, &fromY, &toX, &toY, &promoChar)) {
8500                 (void) CoordsToAlgebraic(boards[forwardMostMove],
8501                                     PosFlags(forwardMostMove),
8502                                     fromY, fromX, toY, toX, promoChar, move);
8503             } else {
8504                 if(appData.debugMode) fprintf(debugFP, "Book move could not be parsed\n");
8505                 bookHit = NULL;
8506             }
8507         }
8508         snprintf(buf, MSG_SIZ, "%s%s\n", (cps->useUsermove ? "usermove " : ""), move); // force book move into program supposed to play it
8509         SendToProgram(buf, cps);
8510         if(!initial) firstMove = FALSE; // normally we would clear the firstMove condition after return & sending 'go'
8511     } else if(initial) { // 'go' was needed irrespective of firstMove, and it has to be done in this routine
8512         SendToProgram("go\n", cps);
8513         cps->bookSuspend = FALSE; // after a 'go' we are never suspended
8514     } else { // 'go' might be sent based on 'firstMove' after this routine returns
8515         if(cps->bookSuspend && !firstMove) // 'go' needed, and it will not be done after we return
8516             SendToProgram("go\n", cps);
8517         cps->bookSuspend = FALSE; // anyhow, we will not be suspended after a miss
8518     }
8519     return bookHit; // notify caller of hit, so it can take action to send move to opponent
8520 }
8521
8522 int
8523 LoadError (char *errmess, ChessProgramState *cps)
8524 {   // unloads engine and switches back to -ncp mode if it was first
8525     if(cps->initDone) return FALSE;
8526     cps->isr = NULL; // this should suppress further error popups from breaking pipes
8527     DestroyChildProcess(cps->pr, 9 ); // just to be sure
8528     cps->pr = NoProc;
8529     if(cps == &first) {
8530         appData.noChessProgram = TRUE;
8531         gameMode = MachinePlaysBlack; ModeHighlight(); // kludge to unmark Machine Black menu
8532         gameMode = BeginningOfGame; ModeHighlight();
8533         SetNCPMode();
8534     }
8535     if(GetDelayedEvent()) CancelDelayedEvent(), ThawUI(); // [HGM] cancel remaining loading effort scheduled after feature timeout
8536     DisplayMessage("", ""); // erase waiting message
8537     if(errmess) DisplayError(errmess, 0); // announce reason, if given
8538     return TRUE;
8539 }
8540
8541 char *savedMessage;
8542 ChessProgramState *savedState;
8543 void
8544 DeferredBookMove (void)
8545 {
8546         if(savedState->lastPing != savedState->lastPong)
8547                     ScheduleDelayedEvent(DeferredBookMove, 10);
8548         else
8549         HandleMachineMove(savedMessage, savedState);
8550 }
8551
8552 static int savedWhitePlayer, savedBlackPlayer, pairingReceived;
8553 static ChessProgramState *stalledEngine;
8554 static char stashedInputMove[MSG_SIZ];
8555
8556 void
8557 HandleMachineMove (char *message, ChessProgramState *cps)
8558 {
8559     static char firstLeg[20];
8560     char machineMove[MSG_SIZ], buf1[MSG_SIZ*10], buf2[MSG_SIZ];
8561     char realname[MSG_SIZ];
8562     int fromX, fromY, toX, toY;
8563     ChessMove moveType;
8564     char promoChar, roar;
8565     char *p, *pv=buf1;
8566     int machineWhite, oldError;
8567     char *bookHit;
8568
8569     if(cps == &pairing && sscanf(message, "%d-%d", &savedWhitePlayer, &savedBlackPlayer) == 2) {
8570         // [HGM] pairing: Mega-hack! Pairing engine also uses this routine (so it could give other WB commands).
8571         if(savedWhitePlayer == 0 || savedBlackPlayer == 0) {
8572             DisplayError(_("Invalid pairing from pairing engine"), 0);
8573             return;
8574         }
8575         pairingReceived = 1;
8576         NextMatchGame();
8577         return; // Skim the pairing messages here.
8578     }
8579
8580     oldError = cps->userError; cps->userError = 0;
8581
8582 FakeBookMove: // [HGM] book: we jump here to simulate machine moves after book hit
8583     /*
8584      * Kludge to ignore BEL characters
8585      */
8586     while (*message == '\007') message++;
8587
8588     /*
8589      * [HGM] engine debug message: ignore lines starting with '#' character
8590      */
8591     if(cps->debug && *message == '#') return;
8592
8593     /*
8594      * Look for book output
8595      */
8596     if (cps == &first && bookRequested) {
8597         if (message[0] == '\t' || message[0] == ' ') {
8598             /* Part of the book output is here; append it */
8599             strcat(bookOutput, message);
8600             strcat(bookOutput, "  \n");
8601             return;
8602         } else if (bookOutput[0] != NULLCHAR) {
8603             /* All of book output has arrived; display it */
8604             char *p = bookOutput;
8605             while (*p != NULLCHAR) {
8606                 if (*p == '\t') *p = ' ';
8607                 p++;
8608             }
8609             DisplayInformation(bookOutput);
8610             bookRequested = FALSE;
8611             /* Fall through to parse the current output */
8612         }
8613     }
8614
8615     /*
8616      * Look for machine move.
8617      */
8618     if ((sscanf(message, "%s %s %s", buf1, buf2, machineMove) == 3 && strcmp(buf2, "...") == 0) ||
8619         (sscanf(message, "%s %s", buf1, machineMove) == 2 && strcmp(buf1, "move") == 0))
8620     {
8621         if(pausing && !cps->pause) { // for pausing engine that does not support 'pause', we stash its move for processing when we resume.
8622             if(appData.debugMode) fprintf(debugFP, "pause %s engine after move\n", cps->which);
8623             safeStrCpy(stashedInputMove, message, MSG_SIZ);
8624             stalledEngine = cps;
8625             if(appData.ponderNextMove) { // bring opponent out of ponder
8626                 if(gameMode == TwoMachinesPlay) {
8627                     if(cps->other->pause)
8628                         PauseEngine(cps->other);
8629                     else
8630                         SendToProgram("easy\n", cps->other);
8631                 }
8632             }
8633             StopClocks();
8634             return;
8635         }
8636
8637         /* This method is only useful on engines that support ping */
8638         if (cps->lastPing != cps->lastPong) {
8639           if (gameMode == BeginningOfGame) {
8640             /* Extra move from before last new; ignore */
8641             if (appData.debugMode) {
8642                 fprintf(debugFP, "Ignoring extra move from %s\n", cps->which);
8643             }
8644           } else {
8645             if (appData.debugMode) {
8646                 fprintf(debugFP, "Undoing extra move from %s, gameMode %d\n",
8647                         cps->which, gameMode);
8648             }
8649
8650             SendToProgram("undo\n", cps);
8651           }
8652           return;
8653         }
8654
8655         switch (gameMode) {
8656           case BeginningOfGame:
8657             /* Extra move from before last reset; ignore */
8658             if (appData.debugMode) {
8659                 fprintf(debugFP, "Ignoring extra move from %s\n", cps->which);
8660             }
8661             return;
8662
8663           case EndOfGame:
8664           case IcsIdle:
8665           default:
8666             /* Extra move after we tried to stop.  The mode test is
8667                not a reliable way of detecting this problem, but it's
8668                the best we can do on engines that don't support ping.
8669             */
8670             if (appData.debugMode) {
8671                 fprintf(debugFP, "Undoing extra move from %s, gameMode %d\n",
8672                         cps->which, gameMode);
8673             }
8674             SendToProgram("undo\n", cps);
8675             return;
8676
8677           case MachinePlaysWhite:
8678           case IcsPlayingWhite:
8679             machineWhite = TRUE;
8680             break;
8681
8682           case MachinePlaysBlack:
8683           case IcsPlayingBlack:
8684             machineWhite = FALSE;
8685             break;
8686
8687           case TwoMachinesPlay:
8688             machineWhite = (cps->twoMachinesColor[0] == 'w');
8689             break;
8690         }
8691         if (WhiteOnMove(forwardMostMove) != machineWhite) {
8692             if (appData.debugMode) {
8693                 fprintf(debugFP,
8694                         "Ignoring move out of turn by %s, gameMode %d"
8695                         ", forwardMost %d\n",
8696                         cps->which, gameMode, forwardMostMove);
8697             }
8698             return;
8699         }
8700
8701         if(cps->alphaRank) AlphaRank(machineMove, 4);
8702
8703         // [HGM] lion: (some very limited) support for Alien protocol
8704         killX = killY = kill2X = kill2Y = -1;
8705         if(machineMove[strlen(machineMove)-1] == ',') { // move ends in coma: non-final leg of composite move
8706             safeStrCpy(firstLeg, machineMove, 20); // just remember it for processing when second leg arrives
8707             return;
8708         }
8709         if(p = strchr(machineMove, ',')) {         // we got both legs in one (happens on book move)
8710             safeStrCpy(firstLeg, machineMove, 20); // kludge: fake we received the first leg earlier, and clip it off
8711             safeStrCpy(machineMove, firstLeg + (p - machineMove) + 1, 20);
8712         }
8713         if(firstLeg[0]) { // there was a previous leg;
8714             // only support case where same piece makes two step
8715             char buf[20], *p = machineMove+1, *q = buf+1, f;
8716             safeStrCpy(buf, machineMove, 20);
8717             while(isdigit(*q)) q++; // find start of to-square
8718             safeStrCpy(machineMove, firstLeg, 20);
8719             while(isdigit(*p)) p++; // to-square of first leg (which is now copied to machineMove)
8720             if(*p == *buf)          // if first-leg to not equal to second-leg from first leg says unmodified (assume it ia King move of castling)
8721             safeStrCpy(p, q, 20); // glue to-square of second leg to from-square of first, to process over-all move
8722             sscanf(buf, "%c%d", &f, &killY); killX = f - AAA; killY -= ONE - '0'; // pass intermediate square to MakeMove in global
8723             firstLeg[0] = NULLCHAR;
8724         }
8725
8726         if (!ParseOneMove(machineMove, forwardMostMove, &moveType,
8727                               &fromX, &fromY, &toX, &toY, &promoChar)) {
8728             /* Machine move could not be parsed; ignore it. */
8729           snprintf(buf1, MSG_SIZ*10, _("Illegal move \"%s\" from %s machine"),
8730                     machineMove, _(cps->which));
8731             DisplayMoveError(buf1);
8732             snprintf(buf1, MSG_SIZ*10, "Xboard: Forfeit due to invalid move: %s (%c%c%c%c via %c%c, %c%c) res=%d",
8733                     machineMove, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, killX+AAA, killY+ONE, kill2X+AAA, kill2Y+ONE, moveType);
8734             if (gameMode == TwoMachinesPlay) {
8735               GameEnds(machineWhite ? BlackWins : WhiteWins,
8736                        buf1, GE_XBOARD);
8737             }
8738             return;
8739         }
8740
8741         /* [HGM] Apparently legal, but so far only tested with EP_UNKOWN */
8742         /* So we have to redo legality test with true e.p. status here,  */
8743         /* to make sure an illegal e.p. capture does not slip through,   */
8744         /* to cause a forfeit on a justified illegal-move complaint      */
8745         /* of the opponent.                                              */
8746         if( gameMode==TwoMachinesPlay && appData.testLegality ) {
8747            ChessMove moveType;
8748            moveType = LegalityTest(boards[forwardMostMove], PosFlags(forwardMostMove),
8749                              fromY, fromX, toY, toX, promoChar);
8750             if(moveType == IllegalMove) {
8751               snprintf(buf1, MSG_SIZ*10, "Xboard: Forfeit due to illegal move: %s (%c%c%c%c)%c",
8752                         machineMove, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, 0);
8753                 GameEnds(machineWhite ? BlackWins : WhiteWins,
8754                            buf1, GE_XBOARD);
8755                 return;
8756            } else if(!appData.fischerCastling)
8757            /* [HGM] Kludge to handle engines that send FRC-style castling
8758               when they shouldn't (like TSCP-Gothic) */
8759            switch(moveType) {
8760              case WhiteASideCastleFR:
8761              case BlackASideCastleFR:
8762                toX+=2;
8763                currentMoveString[2]++;
8764                break;
8765              case WhiteHSideCastleFR:
8766              case BlackHSideCastleFR:
8767                toX--;
8768                currentMoveString[2]--;
8769                break;
8770              default: ; // nothing to do, but suppresses warning of pedantic compilers
8771            }
8772         }
8773         hintRequested = FALSE;
8774         lastHint[0] = NULLCHAR;
8775         bookRequested = FALSE;
8776         /* Program may be pondering now */
8777         cps->maybeThinking = TRUE;
8778         if (cps->sendTime == 2) cps->sendTime = 1;
8779         if (cps->offeredDraw) cps->offeredDraw--;
8780
8781         /* [AS] Save move info*/
8782         pvInfoList[ forwardMostMove ].score = programStats.score;
8783         pvInfoList[ forwardMostMove ].depth = programStats.depth;
8784         pvInfoList[ forwardMostMove ].time =  programStats.time; // [HGM] PGNtime: take time from engine stats
8785
8786         MakeMove(fromX, fromY, toX, toY, promoChar);/*updates forwardMostMove*/
8787
8788         /* Test suites abort the 'game' after one move */
8789         if(*appData.finger) {
8790            static FILE *f;
8791            char *fen = PositionToFEN(backwardMostMove, NULL, 0); // no counts in EPD
8792            if(!f) f = fopen(appData.finger, "w");
8793            if(f) fprintf(f, "%s bm %s;\n", fen, parseList[backwardMostMove]), fflush(f);
8794            else { DisplayFatalError("Bad output file", errno, 0); return; }
8795            free(fen);
8796            GameEnds(GameUnfinished, NULL, GE_XBOARD);
8797         }
8798         if(appData.epd) {
8799            if(solvingTime >= 0) {
8800               snprintf(buf1, MSG_SIZ, "%d. %4.2fs\n", matchGame, solvingTime/100.);
8801               totalTime += solvingTime; first.matchWins++;
8802            } else {
8803               snprintf(buf1, MSG_SIZ, "%d. wrong (%s)\n", matchGame, parseList[backwardMostMove]);
8804               second.matchWins++;
8805            }
8806            OutputKibitz(2, buf1);
8807            GameEnds(GameUnfinished, NULL, GE_XBOARD);
8808         }
8809
8810         /* [AS] Adjudicate game if needed (note: remember that forwardMostMove now points past the last move) */
8811         if( gameMode == TwoMachinesPlay && appData.adjudicateLossThreshold != 0 && forwardMostMove >= adjudicateLossPlies ) {
8812             int count = 0;
8813
8814             while( count < adjudicateLossPlies ) {
8815                 int score = pvInfoList[ forwardMostMove - count - 1 ].score;
8816
8817                 if( count & 1 ) {
8818                     score = -score; /* Flip score for winning side */
8819                 }
8820
8821                 if( score > appData.adjudicateLossThreshold ) {
8822                     break;
8823                 }
8824
8825                 count++;
8826             }
8827
8828             if( count >= adjudicateLossPlies ) {
8829                 ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
8830
8831                 GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
8832                     "Xboard adjudication",
8833                     GE_XBOARD );
8834
8835                 return;
8836             }
8837         }
8838
8839         if(Adjudicate(cps)) {
8840             ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
8841             return; // [HGM] adjudicate: for all automatic game ends
8842         }
8843
8844 #if ZIPPY
8845         if ((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack) &&
8846             first.initDone) {
8847           if(cps->offeredDraw && (signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
8848                 SendToICS(ics_prefix); // [HGM] drawclaim: send caim and move on one line for FICS
8849                 SendToICS("draw ");
8850                 SendMoveToICS(moveType, fromX, fromY, toX, toY, promoChar);
8851           }
8852           SendMoveToICS(moveType, fromX, fromY, toX, toY, promoChar);
8853           ics_user_moved = 1;
8854           if(appData.autoKibitz && !appData.icsEngineAnalyze ) { /* [HGM] kibitz: send most-recent PV info to ICS */
8855                 char buf[3*MSG_SIZ];
8856
8857                 snprintf(buf, 3*MSG_SIZ, "kibitz !!! %+.2f/%d (%.2f sec, %u nodes, %.0f knps) PV=%s\n",
8858                         programStats.score / 100.,
8859                         programStats.depth,
8860                         programStats.time / 100.,
8861                         (unsigned int)programStats.nodes,
8862                         (unsigned int)programStats.nodes / (10*abs(programStats.time) + 1.),
8863                         programStats.movelist);
8864                 SendToICS(buf);
8865           }
8866         }
8867 #endif
8868
8869         /* [AS] Clear stats for next move */
8870         ClearProgramStats();
8871         thinkOutput[0] = NULLCHAR;
8872         hiddenThinkOutputState = 0;
8873
8874         bookHit = NULL;
8875         if (gameMode == TwoMachinesPlay) {
8876             /* [HGM] relaying draw offers moved to after reception of move */
8877             /* and interpreting offer as claim if it brings draw condition */
8878             if (cps->offeredDraw == 1 && cps->other->sendDrawOffers) {
8879                 SendToProgram("draw\n", cps->other);
8880             }
8881             if (cps->other->sendTime) {
8882                 SendTimeRemaining(cps->other,
8883                                   cps->other->twoMachinesColor[0] == 'w');
8884             }
8885             bookHit = SendMoveToBookUser(forwardMostMove-1, cps->other, FALSE);
8886             if (firstMove && !bookHit) {
8887                 firstMove = FALSE;
8888                 if (cps->other->useColors) {
8889                   SendToProgram(cps->other->twoMachinesColor, cps->other);
8890                 }
8891                 SendToProgram("go\n", cps->other);
8892             }
8893             cps->other->maybeThinking = TRUE;
8894         }
8895
8896         roar = (killX >= 0 && IS_LION(boards[forwardMostMove][toY][toX]));
8897
8898         ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
8899
8900         if (!pausing && appData.ringBellAfterMoves) {
8901             if(!roar) RingBell();
8902         }
8903
8904         /*
8905          * Reenable menu items that were disabled while
8906          * machine was thinking
8907          */
8908         if (gameMode != TwoMachinesPlay)
8909             SetUserThinkingEnables();
8910
8911         // [HGM] book: after book hit opponent has received move and is now in force mode
8912         // force the book reply into it, and then fake that it outputted this move by jumping
8913         // back to the beginning of HandleMachineMove, with cps toggled and message set to this move
8914         if(bookHit) {
8915                 static char bookMove[MSG_SIZ]; // a bit generous?
8916
8917                 safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
8918                 strcat(bookMove, bookHit);
8919                 message = bookMove;
8920                 cps = cps->other;
8921                 programStats.nodes = programStats.depth = programStats.time =
8922                 programStats.score = programStats.got_only_move = 0;
8923                 sprintf(programStats.movelist, "%s (xbook)", bookHit);
8924
8925                 if(cps->lastPing != cps->lastPong) {
8926                     savedMessage = message; // args for deferred call
8927                     savedState = cps;
8928                     ScheduleDelayedEvent(DeferredBookMove, 10);
8929                     return;
8930                 }
8931                 goto FakeBookMove;
8932         }
8933
8934         return;
8935     }
8936
8937     /* Set special modes for chess engines.  Later something general
8938      *  could be added here; for now there is just one kludge feature,
8939      *  needed because Crafty 15.10 and earlier don't ignore SIGINT
8940      *  when "xboard" is given as an interactive command.
8941      */
8942     if (strncmp(message, "kibitz Hello from Crafty", 24) == 0) {
8943         cps->useSigint = FALSE;
8944         cps->useSigterm = FALSE;
8945     }
8946     if (strncmp(message, "feature ", 8) == 0) { // [HGM] moved forward to pre-empt non-compliant commands
8947       ParseFeatures(message+8, cps);
8948       return; // [HGM] This return was missing, causing option features to be recognized as non-compliant commands!
8949     }
8950
8951     if (!strncmp(message, "setup ", 6) &&
8952         (!appData.testLegality || gameInfo.variant == VariantFairy || gameInfo.variant == VariantUnknown ||
8953           NonStandardBoardSize(gameInfo.variant, gameInfo.boardWidth, gameInfo.boardHeight, gameInfo.holdingsSize))
8954                                         ) { // [HGM] allow first engine to define opening position
8955       int dummy, w, h, hand, s=6; char buf[MSG_SIZ], varName[MSG_SIZ];
8956       if(appData.icsActive || forwardMostMove != 0 || cps != &first) return;
8957       *buf = NULLCHAR;
8958       if(sscanf(message, "setup (%s", buf) == 1) {
8959         s = 8 + strlen(buf), buf[s-9] = NULLCHAR, SetCharTableEsc(pieceToChar, buf, SUFFIXES);
8960         ASSIGN(appData.pieceToCharTable, buf);
8961       }
8962       dummy = sscanf(message+s, "%dx%d+%d_%s", &w, &h, &hand, varName);
8963       if(dummy >= 3) {
8964         while(message[s] && message[s++] != ' ');
8965         if(BOARD_HEIGHT != h || BOARD_WIDTH != w + 4*(hand != 0) || gameInfo.holdingsSize != hand ||
8966            dummy == 4 && gameInfo.variant != StringToVariant(varName) ) { // engine wants to change board format or variant
8967             appData.NrFiles = w; appData.NrRanks = h; appData.holdingsSize = hand;
8968             if(dummy == 4) gameInfo.variant = StringToVariant(varName);     // parent variant
8969           InitPosition(1); // calls InitDrawingSizes to let new parameters take effect
8970           if(*buf) SetCharTableEsc(pieceToChar, buf, SUFFIXES); // do again, for it was spoiled by InitPosition
8971           startedFromSetupPosition = FALSE;
8972         }
8973       }
8974       if(startedFromSetupPosition) return;
8975       ParseFEN(boards[0], &dummy, message+s, FALSE);
8976       DrawPosition(TRUE, boards[0]);
8977       CopyBoard(initialPosition, boards[0]);
8978       startedFromSetupPosition = TRUE;
8979       return;
8980     }
8981     if(sscanf(message, "piece %s %s", buf2, buf1) == 2) {
8982       ChessSquare piece = WhitePawn;
8983       char *p=message+6, *q, *s = SUFFIXES, ID = *p;
8984       if(*p == '+') piece = CHUPROMOTED WhitePawn, ID = *++p;
8985       if(q = strchr(s, p[1])) ID += 64*(q - s + 1), p++;
8986       piece += CharToPiece(ID & 255) - WhitePawn;
8987       if(cps != &first || appData.testLegality && *engineVariant == NULLCHAR
8988       /* always accept definition of  */       && piece != WhiteFalcon && piece != BlackFalcon
8989       /* wild-card pieces.            */       && piece != WhiteCobra  && piece != BlackCobra
8990       /* For variants we don't have   */       && gameInfo.variant != VariantBerolina
8991       /* correct rules for, we cannot */       && gameInfo.variant != VariantCylinder
8992       /* enforce legality on our own! */       && gameInfo.variant != VariantUnknown
8993                                                && gameInfo.variant != VariantGreat
8994                                                && gameInfo.variant != VariantFairy    ) return;
8995       if(piece < EmptySquare) {
8996         pieceDefs = TRUE;
8997         ASSIGN(pieceDesc[piece], buf1);
8998         if((ID & 32) == 0 && p[1] == '&') { ASSIGN(pieceDesc[WHITE_TO_BLACK piece], buf1); }
8999       }
9000       return;
9001     }
9002     /* [HGM] Allow engine to set up a position. Don't ask me why one would
9003      * want this, I was asked to put it in, and obliged.
9004      */
9005     if (!strncmp(message, "setboard ", 9)) {
9006         Board initial_position;
9007
9008         GameEnds(GameUnfinished, "Engine aborts game", GE_XBOARD);
9009
9010         if (!ParseFEN(initial_position, &blackPlaysFirst, message + 9, FALSE)) {
9011             DisplayError(_("Bad FEN received from engine"), 0);
9012             return ;
9013         } else {
9014            Reset(TRUE, FALSE);
9015            CopyBoard(boards[0], initial_position);
9016            initialRulePlies = FENrulePlies;
9017            if(blackPlaysFirst) gameMode = MachinePlaysWhite;
9018            else gameMode = MachinePlaysBlack;
9019            DrawPosition(FALSE, boards[currentMove]);
9020         }
9021         return;
9022     }
9023
9024     /*
9025      * Look for communication commands
9026      */
9027     if (!strncmp(message, "telluser ", 9)) {
9028         if(message[9] == '\\' && message[10] == '\\')
9029             EscapeExpand(message+9, message+11); // [HGM] esc: allow escape sequences in popup box
9030         PlayTellSound();
9031         DisplayNote(message + 9);
9032         return;
9033     }
9034     if (!strncmp(message, "tellusererror ", 14)) {
9035         cps->userError = 1;
9036         if(message[14] == '\\' && message[15] == '\\')
9037             EscapeExpand(message+14, message+16); // [HGM] esc: allow escape sequences in popup box
9038         PlayTellSound();
9039         DisplayError(message + 14, 0);
9040         return;
9041     }
9042     if (!strncmp(message, "tellopponent ", 13)) {
9043       if (appData.icsActive) {
9044         if (loggedOn) {
9045           snprintf(buf1, sizeof(buf1), "%ssay %s\n", ics_prefix, message + 13);
9046           SendToICS(buf1);
9047         }
9048       } else {
9049         DisplayNote(message + 13);
9050       }
9051       return;
9052     }
9053     if (!strncmp(message, "tellothers ", 11)) {
9054       if (appData.icsActive) {
9055         if (loggedOn) {
9056           snprintf(buf1, sizeof(buf1), "%swhisper %s\n", ics_prefix, message + 11);
9057           SendToICS(buf1);
9058         }
9059       } else if(appData.autoComment) AppendComment (forwardMostMove, message + 11, 1); // in local mode, add as move comment
9060       return;
9061     }
9062     if (!strncmp(message, "tellall ", 8)) {
9063       if (appData.icsActive) {
9064         if (loggedOn) {
9065           snprintf(buf1, sizeof(buf1), "%skibitz %s\n", ics_prefix, message + 8);
9066           SendToICS(buf1);
9067         }
9068       } else {
9069         DisplayNote(message + 8);
9070       }
9071       return;
9072     }
9073     if (strncmp(message, "warning", 7) == 0) {
9074         /* Undocumented feature, use tellusererror in new code */
9075         DisplayError(message, 0);
9076         return;
9077     }
9078     if (sscanf(message, "askuser %s %[^\n]", buf1, buf2) == 2) {
9079         safeStrCpy(realname, cps->tidy, sizeof(realname)/sizeof(realname[0]));
9080         strcat(realname, " query");
9081         AskQuestion(realname, buf2, buf1, cps->pr);
9082         return;
9083     }
9084     /* Commands from the engine directly to ICS.  We don't allow these to be
9085      *  sent until we are logged on. Crafty kibitzes have been known to
9086      *  interfere with the login process.
9087      */
9088     if (loggedOn) {
9089         if (!strncmp(message, "tellics ", 8)) {
9090             SendToICS(message + 8);
9091             SendToICS("\n");
9092             return;
9093         }
9094         if (!strncmp(message, "tellicsnoalias ", 15)) {
9095             SendToICS(ics_prefix);
9096             SendToICS(message + 15);
9097             SendToICS("\n");
9098             return;
9099         }
9100         /* The following are for backward compatibility only */
9101         if (!strncmp(message,"whisper",7) || !strncmp(message,"kibitz",6) ||
9102             !strncmp(message,"draw",4) || !strncmp(message,"tell",3)) {
9103             SendToICS(ics_prefix);
9104             SendToICS(message);
9105             SendToICS("\n");
9106             return;
9107         }
9108     }
9109     if (sscanf(message, "pong %d", &cps->lastPong) == 1) {
9110         if(initPing == cps->lastPong) {
9111             if(gameInfo.variant == VariantUnknown) {
9112                 DisplayError(_("Engine did not send setup for non-standard variant"), 0);
9113                 *engineVariant = NULLCHAR; appData.variant = VariantNormal; // back to normal as error recovery?
9114                 GameEnds(GameUnfinished, NULL, GE_XBOARD);
9115             }
9116             initPing = -1;
9117         }
9118         return;
9119     }
9120     if(!strncmp(message, "highlight ", 10)) {
9121         if(appData.testLegality && !*engineVariant && appData.markers) return;
9122         MarkByFEN(message+10); // [HGM] alien: allow engine to mark board squares
9123         return;
9124     }
9125     if(!strncmp(message, "click ", 6)) {
9126         char f, c=0; int x, y; // [HGM] alien: allow engine to finish user moves (i.e. engine-driven one-click moving)
9127         if(appData.testLegality || !appData.oneClick) return;
9128         sscanf(message+6, "%c%d%c", &f, &y, &c);
9129         x = f - 'a' + BOARD_LEFT, y -= ONE - '0';
9130         if(flipView) x = BOARD_WIDTH-1 - x; else y = BOARD_HEIGHT-1 - y;
9131         x = x*squareSize + (x+1)*lineGap + squareSize/2;
9132         y = y*squareSize + (y+1)*lineGap + squareSize/2;
9133         f = first.highlight; first.highlight = 0; // kludge to suppress lift/put in response to own clicks
9134         if(lastClickType == Press) // if button still down, fake release on same square, to be ready for next click
9135             LeftClick(Release, lastLeftX, lastLeftY);
9136         controlKey  = (c == ',');
9137         LeftClick(Press, x, y);
9138         LeftClick(Release, x, y);
9139         first.highlight = f;
9140         return;
9141     }
9142     /*
9143      * If the move is illegal, cancel it and redraw the board.
9144      * Also deal with other error cases.  Matching is rather loose
9145      * here to accommodate engines written before the spec.
9146      */
9147     if (strncmp(message + 1, "llegal move", 11) == 0 ||
9148         strncmp(message, "Error", 5) == 0) {
9149         if (StrStr(message, "name") ||
9150             StrStr(message, "rating") || StrStr(message, "?") ||
9151             StrStr(message, "result") || StrStr(message, "board") ||
9152             StrStr(message, "bk") || StrStr(message, "computer") ||
9153             StrStr(message, "variant") || StrStr(message, "hint") ||
9154             StrStr(message, "random") || StrStr(message, "depth") ||
9155             StrStr(message, "accepted")) {
9156             return;
9157         }
9158         if (StrStr(message, "protover")) {
9159           /* Program is responding to input, so it's apparently done
9160              initializing, and this error message indicates it is
9161              protocol version 1.  So we don't need to wait any longer
9162              for it to initialize and send feature commands. */
9163           FeatureDone(cps, 1);
9164           cps->protocolVersion = 1;
9165           return;
9166         }
9167         cps->maybeThinking = FALSE;
9168
9169         if (StrStr(message, "draw")) {
9170             /* Program doesn't have "draw" command */
9171             cps->sendDrawOffers = 0;
9172             return;
9173         }
9174         if (cps->sendTime != 1 &&
9175             (StrStr(message, "time") || StrStr(message, "otim"))) {
9176           /* Program apparently doesn't have "time" or "otim" command */
9177           cps->sendTime = 0;
9178           return;
9179         }
9180         if (StrStr(message, "analyze")) {
9181             cps->analysisSupport = FALSE;
9182             cps->analyzing = FALSE;
9183 //          Reset(FALSE, TRUE); // [HGM] this caused discrepancy between display and internal state!
9184             EditGameEvent(); // [HGM] try to preserve loaded game
9185             snprintf(buf2,MSG_SIZ, _("%s does not support analysis"), cps->tidy);
9186             DisplayError(buf2, 0);
9187             return;
9188         }
9189         if (StrStr(message, "(no matching move)st")) {
9190           /* Special kludge for GNU Chess 4 only */
9191           cps->stKludge = TRUE;
9192           SendTimeControl(cps, movesPerSession, timeControl,
9193                           timeIncrement, appData.searchDepth,
9194                           searchTime);
9195           return;
9196         }
9197         if (StrStr(message, "(no matching move)sd")) {
9198           /* Special kludge for GNU Chess 4 only */
9199           cps->sdKludge = TRUE;
9200           SendTimeControl(cps, movesPerSession, timeControl,
9201                           timeIncrement, appData.searchDepth,
9202                           searchTime);
9203           return;
9204         }
9205         if (!StrStr(message, "llegal")) {
9206             return;
9207         }
9208         if (gameMode == BeginningOfGame || gameMode == EndOfGame ||
9209             gameMode == IcsIdle) return;
9210         if (forwardMostMove <= backwardMostMove) return;
9211         if (pausing) PauseEvent();
9212       if(appData.forceIllegal) {
9213             // [HGM] illegal: machine refused move; force position after move into it
9214           SendToProgram("force\n", cps);
9215           if(!cps->useSetboard) { // hideous kludge on kludge, because SendBoard sucks.
9216                 // we have a real problem now, as SendBoard will use the a2a3 kludge
9217                 // when black is to move, while there might be nothing on a2 or black
9218                 // might already have the move. So send the board as if white has the move.
9219                 // But first we must change the stm of the engine, as it refused the last move
9220                 SendBoard(cps, 0); // always kludgeless, as white is to move on boards[0]
9221                 if(WhiteOnMove(forwardMostMove)) {
9222                     SendToProgram("a7a6\n", cps); // for the engine black still had the move
9223                     SendBoard(cps, forwardMostMove); // kludgeless board
9224                 } else {
9225                     SendToProgram("a2a3\n", cps); // for the engine white still had the move
9226                     CopyBoard(boards[forwardMostMove+1], boards[forwardMostMove]);
9227                     SendBoard(cps, forwardMostMove+1); // kludgeless board
9228                 }
9229           } else SendBoard(cps, forwardMostMove); // FEN case, also sets stm properly
9230             if(gameMode == MachinePlaysWhite || gameMode == MachinePlaysBlack ||
9231                  gameMode == TwoMachinesPlay)
9232               SendToProgram("go\n", cps);
9233             return;
9234       } else
9235         if (gameMode == PlayFromGameFile) {
9236             /* Stop reading this game file */
9237             gameMode = EditGame;
9238             ModeHighlight();
9239         }
9240         /* [HGM] illegal-move claim should forfeit game when Xboard */
9241         /* only passes fully legal moves                            */
9242         if( appData.testLegality && gameMode == TwoMachinesPlay ) {
9243             GameEnds( cps->twoMachinesColor[0] == 'w' ? BlackWins : WhiteWins,
9244                                 "False illegal-move claim", GE_XBOARD );
9245             return; // do not take back move we tested as valid
9246         }
9247         currentMove = forwardMostMove-1;
9248         DisplayMove(currentMove-1); /* before DisplayMoveError */
9249         SwitchClocks(forwardMostMove-1); // [HGM] race
9250         DisplayBothClocks();
9251         snprintf(buf1, 10*MSG_SIZ, _("Illegal move \"%s\" (rejected by %s chess program)"),
9252                 parseList[currentMove], _(cps->which));
9253         DisplayMoveError(buf1);
9254         DrawPosition(FALSE, boards[currentMove]);
9255
9256         SetUserThinkingEnables();
9257         return;
9258     }
9259     if (strncmp(message, "time", 4) == 0 && StrStr(message, "Illegal")) {
9260         /* Program has a broken "time" command that
9261            outputs a string not ending in newline.
9262            Don't use it. */
9263         cps->sendTime = 0;
9264     }
9265     if (cps->pseudo) { // [HGM] pseudo-engine, granted unusual powers
9266         if (sscanf(message, "wtime %ld\n", &whiteTimeRemaining) == 1 || // adjust clock times
9267             sscanf(message, "btime %ld\n", &blackTimeRemaining) == 1   ) return;
9268     }
9269
9270     /*
9271      * If chess program startup fails, exit with an error message.
9272      * Attempts to recover here are futile. [HGM] Well, we try anyway
9273      */
9274     if ((StrStr(message, "unknown host") != NULL)
9275         || (StrStr(message, "No remote directory") != NULL)
9276         || (StrStr(message, "not found") != NULL)
9277         || (StrStr(message, "No such file") != NULL)
9278         || (StrStr(message, "can't alloc") != NULL)
9279         || (StrStr(message, "Permission denied") != NULL)) {
9280
9281         cps->maybeThinking = FALSE;
9282         snprintf(buf1, sizeof(buf1), _("Failed to start %s chess program %s on %s: %s\n"),
9283                 _(cps->which), cps->program, cps->host, message);
9284         RemoveInputSource(cps->isr);
9285         if(appData.icsActive) DisplayFatalError(buf1, 0, 1); else {
9286             if(LoadError(oldError ? NULL : buf1, cps)) return; // error has then been handled by LoadError
9287             if(!oldError) DisplayError(buf1, 0); // if reason neatly announced, suppress general error popup
9288         }
9289         return;
9290     }
9291
9292     /*
9293      * Look for hint output
9294      */
9295     if (sscanf(message, "Hint: %s", buf1) == 1) {
9296         if (cps == &first && hintRequested) {
9297             hintRequested = FALSE;
9298             if (ParseOneMove(buf1, forwardMostMove, &moveType,
9299                                  &fromX, &fromY, &toX, &toY, &promoChar)) {
9300                 (void) CoordsToAlgebraic(boards[forwardMostMove],
9301                                     PosFlags(forwardMostMove),
9302                                     fromY, fromX, toY, toX, promoChar, buf1);
9303                 snprintf(buf2, sizeof(buf2), _("Hint: %s"), buf1);
9304                 DisplayInformation(buf2);
9305             } else {
9306                 /* Hint move could not be parsed!? */
9307               snprintf(buf2, sizeof(buf2),
9308                         _("Illegal hint move \"%s\"\nfrom %s chess program"),
9309                         buf1, _(cps->which));
9310                 DisplayError(buf2, 0);
9311             }
9312         } else {
9313           safeStrCpy(lastHint, buf1, sizeof(lastHint)/sizeof(lastHint[0]));
9314         }
9315         return;
9316     }
9317
9318     /*
9319      * Ignore other messages if game is not in progress
9320      */
9321     if (gameMode == BeginningOfGame || gameMode == EndOfGame ||
9322         gameMode == IcsIdle || cps->lastPing != cps->lastPong) return;
9323
9324     /*
9325      * look for win, lose, draw, or draw offer
9326      */
9327     if (strncmp(message, "1-0", 3) == 0) {
9328         char *p, *q, *r = "";
9329         p = strchr(message, '{');
9330         if (p) {
9331             q = strchr(p, '}');
9332             if (q) {
9333                 *q = NULLCHAR;
9334                 r = p + 1;
9335             }
9336         }
9337         GameEnds(WhiteWins, r, GE_ENGINE1 + (cps != &first)); /* [HGM] pass claimer indication for claim test */
9338         return;
9339     } else if (strncmp(message, "0-1", 3) == 0) {
9340         char *p, *q, *r = "";
9341         p = strchr(message, '{');
9342         if (p) {
9343             q = strchr(p, '}');
9344             if (q) {
9345                 *q = NULLCHAR;
9346                 r = p + 1;
9347             }
9348         }
9349         /* Kludge for Arasan 4.1 bug */
9350         if (strcmp(r, "Black resigns") == 0) {
9351             GameEnds(WhiteWins, r, GE_ENGINE1 + (cps != &first));
9352             return;
9353         }
9354         GameEnds(BlackWins, r, GE_ENGINE1 + (cps != &first));
9355         return;
9356     } else if (strncmp(message, "1/2", 3) == 0) {
9357         char *p, *q, *r = "";
9358         p = strchr(message, '{');
9359         if (p) {
9360             q = strchr(p, '}');
9361             if (q) {
9362                 *q = NULLCHAR;
9363                 r = p + 1;
9364             }
9365         }
9366
9367         GameEnds(GameIsDrawn, r, GE_ENGINE1 + (cps != &first));
9368         return;
9369
9370     } else if (strncmp(message, "White resign", 12) == 0) {
9371         GameEnds(BlackWins, "White resigns", GE_ENGINE1 + (cps != &first));
9372         return;
9373     } else if (strncmp(message, "Black resign", 12) == 0) {
9374         GameEnds(WhiteWins, "Black resigns", GE_ENGINE1 + (cps != &first));
9375         return;
9376     } else if (strncmp(message, "White matches", 13) == 0 ||
9377                strncmp(message, "Black matches", 13) == 0   ) {
9378         /* [HGM] ignore GNUShogi noises */
9379         return;
9380     } else if (strncmp(message, "White", 5) == 0 &&
9381                message[5] != '(' &&
9382                StrStr(message, "Black") == NULL) {
9383         GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
9384         return;
9385     } else if (strncmp(message, "Black", 5) == 0 &&
9386                message[5] != '(') {
9387         GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
9388         return;
9389     } else if (strcmp(message, "resign") == 0 ||
9390                strcmp(message, "computer resigns") == 0) {
9391         switch (gameMode) {
9392           case MachinePlaysBlack:
9393           case IcsPlayingBlack:
9394             GameEnds(WhiteWins, "Black resigns", GE_ENGINE);
9395             break;
9396           case MachinePlaysWhite:
9397           case IcsPlayingWhite:
9398             GameEnds(BlackWins, "White resigns", GE_ENGINE);
9399             break;
9400           case TwoMachinesPlay:
9401             if (cps->twoMachinesColor[0] == 'w')
9402               GameEnds(BlackWins, "White resigns", GE_ENGINE1 + (cps != &first));
9403             else
9404               GameEnds(WhiteWins, "Black resigns", GE_ENGINE1 + (cps != &first));
9405             break;
9406           default:
9407             /* can't happen */
9408             break;
9409         }
9410         return;
9411     } else if (strncmp(message, "opponent mates", 14) == 0) {
9412         switch (gameMode) {
9413           case MachinePlaysBlack:
9414           case IcsPlayingBlack:
9415             GameEnds(WhiteWins, "White mates", GE_ENGINE);
9416             break;
9417           case MachinePlaysWhite:
9418           case IcsPlayingWhite:
9419             GameEnds(BlackWins, "Black mates", GE_ENGINE);
9420             break;
9421           case TwoMachinesPlay:
9422             if (cps->twoMachinesColor[0] == 'w')
9423               GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
9424             else
9425               GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
9426             break;
9427           default:
9428             /* can't happen */
9429             break;
9430         }
9431         return;
9432     } else if (strncmp(message, "computer mates", 14) == 0) {
9433         switch (gameMode) {
9434           case MachinePlaysBlack:
9435           case IcsPlayingBlack:
9436             GameEnds(BlackWins, "Black mates", GE_ENGINE1);
9437             break;
9438           case MachinePlaysWhite:
9439           case IcsPlayingWhite:
9440             GameEnds(WhiteWins, "White mates", GE_ENGINE);
9441             break;
9442           case TwoMachinesPlay:
9443             if (cps->twoMachinesColor[0] == 'w')
9444               GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
9445             else
9446               GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
9447             break;
9448           default:
9449             /* can't happen */
9450             break;
9451         }
9452         return;
9453     } else if (strncmp(message, "checkmate", 9) == 0) {
9454         if (WhiteOnMove(forwardMostMove)) {
9455             GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
9456         } else {
9457             GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
9458         }
9459         return;
9460     } else if (strstr(message, "Draw") != NULL ||
9461                strstr(message, "game is a draw") != NULL) {
9462         GameEnds(GameIsDrawn, "Draw", GE_ENGINE1 + (cps != &first));
9463         return;
9464     } else if (strstr(message, "offer") != NULL &&
9465                strstr(message, "draw") != NULL) {
9466 #if ZIPPY
9467         if (appData.zippyPlay && first.initDone) {
9468             /* Relay offer to ICS */
9469             SendToICS(ics_prefix);
9470             SendToICS("draw\n");
9471         }
9472 #endif
9473         cps->offeredDraw = 2; /* valid until this engine moves twice */
9474         if (gameMode == TwoMachinesPlay) {
9475             if (cps->other->offeredDraw) {
9476                 GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
9477             /* [HGM] in two-machine mode we delay relaying draw offer      */
9478             /* until after we also have move, to see if it is really claim */
9479             }
9480         } else if (gameMode == MachinePlaysWhite ||
9481                    gameMode == MachinePlaysBlack) {
9482           if (userOfferedDraw) {
9483             DisplayInformation(_("Machine accepts your draw offer"));
9484             GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
9485           } else {
9486             DisplayInformation(_("Machine offers a draw.\nSelect Action / Draw to accept."));
9487           }
9488         }
9489     }
9490
9491
9492     /*
9493      * Look for thinking output
9494      */
9495     if ( appData.showThinking // [HGM] thinking: test all options that cause this output
9496           || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp()
9497                                 ) {
9498         int plylev, mvleft, mvtot, curscore, time;
9499         char mvname[MOVE_LEN];
9500         u64 nodes; // [DM]
9501         char plyext;
9502         int ignore = FALSE;
9503         int prefixHint = FALSE;
9504         mvname[0] = NULLCHAR;
9505
9506         switch (gameMode) {
9507           case MachinePlaysBlack:
9508           case IcsPlayingBlack:
9509             if (WhiteOnMove(forwardMostMove)) prefixHint = TRUE;
9510             break;
9511           case MachinePlaysWhite:
9512           case IcsPlayingWhite:
9513             if (!WhiteOnMove(forwardMostMove)) prefixHint = TRUE;
9514             break;
9515           case AnalyzeMode:
9516           case AnalyzeFile:
9517             break;
9518           case IcsObserving: /* [DM] icsEngineAnalyze */
9519             if (!appData.icsEngineAnalyze) ignore = TRUE;
9520             break;
9521           case TwoMachinesPlay:
9522             if ((cps->twoMachinesColor[0] == 'w') != WhiteOnMove(forwardMostMove)) {
9523                 ignore = TRUE;
9524             }
9525             break;
9526           default:
9527             ignore = TRUE;
9528             break;
9529         }
9530
9531         if (!ignore) {
9532             ChessProgramStats tempStats = programStats; // [HGM] info: filter out info lines
9533             buf1[0] = NULLCHAR;
9534             if (sscanf(message, "%d%c %d %d " u64Display " %[^\n]\n",
9535                        &plylev, &plyext, &curscore, &time, &nodes, buf1) >= 5) {
9536                 char score_buf[MSG_SIZ];
9537
9538                 if(nodes>>32 == u64Const(0xFFFFFFFF))   // [HGM] negative node count read
9539                     nodes += u64Const(0x100000000);
9540
9541                 if (plyext != ' ' && plyext != '\t') {
9542                     time *= 100;
9543                 }
9544
9545                 /* [AS] Negate score if machine is playing black and reporting absolute scores */
9546                 if( cps->scoreIsAbsolute &&
9547                     ( gameMode == MachinePlaysBlack ||
9548                       gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b' ||
9549                       gameMode == IcsPlayingBlack ||     // [HGM] also add other situations where engine should report black POV
9550                      (gameMode == AnalyzeMode || gameMode == AnalyzeFile || gameMode == IcsObserving && appData.icsEngineAnalyze) &&
9551                      !WhiteOnMove(currentMove)
9552                     ) )
9553                 {
9554                     curscore = -curscore;
9555                 }
9556
9557                 if(appData.pvSAN[cps==&second]) pv = PvToSAN(buf1);
9558
9559                 if(*bestMove) { // rememer time best EPD move was first found
9560                     int ff1, tf1, fr1, tr1, ff2, tf2, fr2, tr2; char pp1, pp2;
9561                     ChessMove mt;
9562                     int ok = ParseOneMove(bestMove, forwardMostMove, &mt, &ff1, &fr1, &tf1, &tr1, &pp1);
9563                     ok    &= ParseOneMove(pv, forwardMostMove, &mt, &ff2, &fr2, &tf2, &tr2, &pp2);
9564                     solvingTime = (ok && ff1==ff2 && fr1==fr2 && tf1==tf2 && tr1==tr2 && pp1==pp2 ? time : -1);
9565                 }
9566
9567                 if(serverMoves && (time > 100 || time == 0 && plylev > 7)) {
9568                         char buf[MSG_SIZ];
9569                         FILE *f;
9570                         snprintf(buf, MSG_SIZ, "%s", appData.serverMovesName);
9571                         buf[strlen(buf)-1] = gameMode == MachinePlaysWhite ? 'w' :
9572                                              gameMode == MachinePlaysBlack ? 'b' : cps->twoMachinesColor[0];
9573                         if(appData.debugMode) fprintf(debugFP, "write PV on file '%s'\n", buf);
9574                         if(f = fopen(buf, "w")) { // export PV to applicable PV file
9575                                 fprintf(f, "%5.2f/%-2d %s", curscore/100., plylev, pv);
9576                                 fclose(f);
9577                         }
9578                         else
9579                           /* TRANSLATORS: PV = principal variation, the variation the chess engine thinks is the best for everyone */
9580                           DisplayError(_("failed writing PV"), 0);
9581                 }
9582
9583                 tempStats.depth = plylev;
9584                 tempStats.nodes = nodes;
9585                 tempStats.time = time;
9586                 tempStats.score = curscore;
9587                 tempStats.got_only_move = 0;
9588
9589                 if(cps->nps >= 0) { /* [HGM] nps: use engine nodes or time to decrement clock */
9590                         int ticklen;
9591
9592                         if(cps->nps == 0) ticklen = 10*time;                    // use engine reported time
9593                         else ticklen = (1000. * u64ToDouble(nodes)) / cps->nps; // convert node count to time
9594                         if(WhiteOnMove(forwardMostMove) && (gameMode == MachinePlaysWhite ||
9595                                                 gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'w'))
9596                              whiteTimeRemaining = timeRemaining[0][forwardMostMove] - ticklen;
9597                         if(!WhiteOnMove(forwardMostMove) && (gameMode == MachinePlaysBlack ||
9598                                                 gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b'))
9599                              blackTimeRemaining = timeRemaining[1][forwardMostMove] - ticklen;
9600                 }
9601
9602                 /* Buffer overflow protection */
9603                 if (pv[0] != NULLCHAR) {
9604                     if (strlen(pv) >= sizeof(tempStats.movelist)
9605                         && appData.debugMode) {
9606                         fprintf(debugFP,
9607                                 "PV is too long; using the first %u bytes.\n",
9608                                 (unsigned) sizeof(tempStats.movelist) - 1);
9609                     }
9610
9611                     safeStrCpy( tempStats.movelist, pv, sizeof(tempStats.movelist)/sizeof(tempStats.movelist[0]) );
9612                 } else {
9613                     sprintf(tempStats.movelist, " no PV\n");
9614                 }
9615
9616                 if (tempStats.seen_stat) {
9617                     tempStats.ok_to_send = 1;
9618                 }
9619
9620                 if (strchr(tempStats.movelist, '(') != NULL) {
9621                     tempStats.line_is_book = 1;
9622                     tempStats.nr_moves = 0;
9623                     tempStats.moves_left = 0;
9624                 } else {
9625                     tempStats.line_is_book = 0;
9626                 }
9627
9628                     if(tempStats.score != 0 || tempStats.nodes != 0 || tempStats.time != 0)
9629                         programStats = tempStats; // [HGM] info: only set stats if genuine PV and not an info line
9630
9631                 SendProgramStatsToFrontend( cps, &tempStats );
9632
9633                 /*
9634                     [AS] Protect the thinkOutput buffer from overflow... this
9635                     is only useful if buf1 hasn't overflowed first!
9636                 */
9637                 if(curscore >= MATE_SCORE)
9638                     snprintf(score_buf, MSG_SIZ, "#%d", curscore - MATE_SCORE);
9639                 else if(curscore <= -MATE_SCORE)
9640                     snprintf(score_buf, MSG_SIZ, "#%d", curscore + MATE_SCORE);
9641                 else
9642                     snprintf(score_buf, MSG_SIZ, "%+.2f", ((double) curscore) / 100.0);
9643                 snprintf(thinkOutput, sizeof(thinkOutput)/sizeof(thinkOutput[0]), "[%d]%c%s %s%s",
9644                          plylev,
9645                          (gameMode == TwoMachinesPlay ?
9646                           ToUpper(cps->twoMachinesColor[0]) : ' '),
9647                          score_buf,
9648                          prefixHint ? lastHint : "",
9649                          prefixHint ? " " : "" );
9650
9651                 if( buf1[0] != NULLCHAR ) {
9652                     unsigned max_len = sizeof(thinkOutput) - strlen(thinkOutput) - 1;
9653
9654                     if( strlen(pv) > max_len ) {
9655                         if( appData.debugMode) {
9656                             fprintf(debugFP,"PV is too long for thinkOutput, truncating.\n");
9657                         }
9658                         pv[max_len+1] = '\0';
9659                     }
9660
9661                     strcat( thinkOutput, pv);
9662                 }
9663
9664                 if (currentMove == forwardMostMove || gameMode == AnalyzeMode
9665                         || gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
9666                     DisplayMove(currentMove - 1);
9667                 }
9668                 return;
9669
9670             } else if ((p=StrStr(message, "(only move)")) != NULL) {
9671                 /* crafty (9.25+) says "(only move) <move>"
9672                  * if there is only 1 legal move
9673                  */
9674                 sscanf(p, "(only move) %s", buf1);
9675                 snprintf(thinkOutput, sizeof(thinkOutput)/sizeof(thinkOutput[0]), "%s (only move)", buf1);
9676                 sprintf(programStats.movelist, "%s (only move)", buf1);
9677                 programStats.depth = 1;
9678                 programStats.nr_moves = 1;
9679                 programStats.moves_left = 1;
9680                 programStats.nodes = 1;
9681                 programStats.time = 1;
9682                 programStats.got_only_move = 1;
9683
9684                 /* Not really, but we also use this member to
9685                    mean "line isn't going to change" (Crafty
9686                    isn't searching, so stats won't change) */
9687                 programStats.line_is_book = 1;
9688
9689                 SendProgramStatsToFrontend( cps, &programStats );
9690
9691                 if (currentMove == forwardMostMove || gameMode==AnalyzeMode ||
9692                            gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
9693                     DisplayMove(currentMove - 1);
9694                 }
9695                 return;
9696             } else if (sscanf(message,"stat01: %d " u64Display " %d %d %d %s",
9697                               &time, &nodes, &plylev, &mvleft,
9698                               &mvtot, mvname) >= 5) {
9699                 /* The stat01: line is from Crafty (9.29+) in response
9700                    to the "." command */
9701                 programStats.seen_stat = 1;
9702                 cps->maybeThinking = TRUE;
9703
9704                 if (programStats.got_only_move || !appData.periodicUpdates)
9705                   return;
9706
9707                 programStats.depth = plylev;
9708                 programStats.time = time;
9709                 programStats.nodes = nodes;
9710                 programStats.moves_left = mvleft;
9711                 programStats.nr_moves = mvtot;
9712                 safeStrCpy(programStats.move_name, mvname, sizeof(programStats.move_name)/sizeof(programStats.move_name[0]));
9713                 programStats.ok_to_send = 1;
9714                 programStats.movelist[0] = '\0';
9715
9716                 SendProgramStatsToFrontend( cps, &programStats );
9717
9718                 return;
9719
9720             } else if (strncmp(message,"++",2) == 0) {
9721                 /* Crafty 9.29+ outputs this */
9722                 programStats.got_fail = 2;
9723                 return;
9724
9725             } else if (strncmp(message,"--",2) == 0) {
9726                 /* Crafty 9.29+ outputs this */
9727                 programStats.got_fail = 1;
9728                 return;
9729
9730             } else if (thinkOutput[0] != NULLCHAR &&
9731                        strncmp(message, "    ", 4) == 0) {
9732                 unsigned message_len;
9733
9734                 p = message;
9735                 while (*p && *p == ' ') p++;
9736
9737                 message_len = strlen( p );
9738
9739                 /* [AS] Avoid buffer overflow */
9740                 if( sizeof(thinkOutput) - strlen(thinkOutput) - 1 > message_len ) {
9741                     strcat(thinkOutput, " ");
9742                     strcat(thinkOutput, p);
9743                 }
9744
9745                 if( sizeof(programStats.movelist) - strlen(programStats.movelist) - 1 > message_len ) {
9746                     strcat(programStats.movelist, " ");
9747                     strcat(programStats.movelist, p);
9748                 }
9749
9750                 if (currentMove == forwardMostMove || gameMode==AnalyzeMode ||
9751                            gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
9752                     DisplayMove(currentMove - 1);
9753                 }
9754                 return;
9755             }
9756         }
9757         else {
9758             buf1[0] = NULLCHAR;
9759
9760             if (sscanf(message, "%d%c %d %d " u64Display " %[^\n]\n",
9761                        &plylev, &plyext, &curscore, &time, &nodes, buf1) >= 5)
9762             {
9763                 ChessProgramStats cpstats;
9764
9765                 if (plyext != ' ' && plyext != '\t') {
9766                     time *= 100;
9767                 }
9768
9769                 /* [AS] Negate score if machine is playing black and reporting absolute scores */
9770                 if( cps->scoreIsAbsolute && ((gameMode == MachinePlaysBlack) || (gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b')) ) {
9771                     curscore = -curscore;
9772                 }
9773
9774                 cpstats.depth = plylev;
9775                 cpstats.nodes = nodes;
9776                 cpstats.time = time;
9777                 cpstats.score = curscore;
9778                 cpstats.got_only_move = 0;
9779                 cpstats.movelist[0] = '\0';
9780
9781                 if (buf1[0] != NULLCHAR) {
9782                     safeStrCpy( cpstats.movelist, buf1, sizeof(cpstats.movelist)/sizeof(cpstats.movelist[0]) );
9783                 }
9784
9785                 cpstats.ok_to_send = 0;
9786                 cpstats.line_is_book = 0;
9787                 cpstats.nr_moves = 0;
9788                 cpstats.moves_left = 0;
9789
9790                 SendProgramStatsToFrontend( cps, &cpstats );
9791             }
9792         }
9793     }
9794 }
9795
9796
9797 /* Parse a game score from the character string "game", and
9798    record it as the history of the current game.  The game
9799    score is NOT assumed to start from the standard position.
9800    The display is not updated in any way.
9801    */
9802 void
9803 ParseGameHistory (char *game)
9804 {
9805     ChessMove moveType;
9806     int fromX, fromY, toX, toY, boardIndex;
9807     char promoChar;
9808     char *p, *q;
9809     char buf[MSG_SIZ];
9810
9811     if (appData.debugMode)
9812       fprintf(debugFP, "Parsing game history: %s\n", game);
9813
9814     if (gameInfo.event == NULL) gameInfo.event = StrSave("ICS game");
9815     gameInfo.site = StrSave(appData.icsHost);
9816     gameInfo.date = PGNDate();
9817     gameInfo.round = StrSave("-");
9818
9819     /* Parse out names of players */
9820     while (*game == ' ') game++;
9821     p = buf;
9822     while (*game != ' ') *p++ = *game++;
9823     *p = NULLCHAR;
9824     gameInfo.white = StrSave(buf);
9825     while (*game == ' ') game++;
9826     p = buf;
9827     while (*game != ' ' && *game != '\n') *p++ = *game++;
9828     *p = NULLCHAR;
9829     gameInfo.black = StrSave(buf);
9830
9831     /* Parse moves */
9832     boardIndex = blackPlaysFirst ? 1 : 0;
9833     yynewstr(game);
9834     for (;;) {
9835         yyboardindex = boardIndex;
9836         moveType = (ChessMove) Myylex();
9837         switch (moveType) {
9838           case IllegalMove:             /* maybe suicide chess, etc. */
9839   if (appData.debugMode) {
9840     fprintf(debugFP, "Illegal move from ICS: '%s'\n", yy_text);
9841     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
9842     setbuf(debugFP, NULL);
9843   }
9844           case WhitePromotion:
9845           case BlackPromotion:
9846           case WhiteNonPromotion:
9847           case BlackNonPromotion:
9848           case NormalMove:
9849           case FirstLeg:
9850           case WhiteCapturesEnPassant:
9851           case BlackCapturesEnPassant:
9852           case WhiteKingSideCastle:
9853           case WhiteQueenSideCastle:
9854           case BlackKingSideCastle:
9855           case BlackQueenSideCastle:
9856           case WhiteKingSideCastleWild:
9857           case WhiteQueenSideCastleWild:
9858           case BlackKingSideCastleWild:
9859           case BlackQueenSideCastleWild:
9860           /* PUSH Fabien */
9861           case WhiteHSideCastleFR:
9862           case WhiteASideCastleFR:
9863           case BlackHSideCastleFR:
9864           case BlackASideCastleFR:
9865           /* POP Fabien */
9866             fromX = currentMoveString[0] - AAA;
9867             fromY = currentMoveString[1] - ONE;
9868             toX = currentMoveString[2] - AAA;
9869             toY = currentMoveString[3] - ONE;
9870             promoChar = currentMoveString[4];
9871             break;
9872           case WhiteDrop:
9873           case BlackDrop:
9874             if(currentMoveString[0] == '@') continue; // no null moves in ICS mode!
9875             fromX = moveType == WhiteDrop ?
9876               (int) CharToPiece(ToUpper(currentMoveString[0])) :
9877             (int) CharToPiece(ToLower(currentMoveString[0]));
9878             fromY = DROP_RANK;
9879             toX = currentMoveString[2] - AAA;
9880             toY = currentMoveString[3] - ONE;
9881             promoChar = NULLCHAR;
9882             break;
9883           case AmbiguousMove:
9884             /* bug? */
9885             snprintf(buf, MSG_SIZ, _("Ambiguous move in ICS output: \"%s\""), yy_text);
9886   if (appData.debugMode) {
9887     fprintf(debugFP, "Ambiguous move from ICS: '%s'\n", yy_text);
9888     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
9889     setbuf(debugFP, NULL);
9890   }
9891             DisplayError(buf, 0);
9892             return;
9893           case ImpossibleMove:
9894             /* bug? */
9895             snprintf(buf, MSG_SIZ, _("Illegal move in ICS output: \"%s\""), yy_text);
9896   if (appData.debugMode) {
9897     fprintf(debugFP, "Impossible move from ICS: '%s'\n", yy_text);
9898     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
9899     setbuf(debugFP, NULL);
9900   }
9901             DisplayError(buf, 0);
9902             return;
9903           case EndOfFile:
9904             if (boardIndex < backwardMostMove) {
9905                 /* Oops, gap.  How did that happen? */
9906                 DisplayError(_("Gap in move list"), 0);
9907                 return;
9908             }
9909             backwardMostMove =  blackPlaysFirst ? 1 : 0;
9910             if (boardIndex > forwardMostMove) {
9911                 forwardMostMove = boardIndex;
9912             }
9913             return;
9914           case ElapsedTime:
9915             if (boardIndex > (blackPlaysFirst ? 1 : 0)) {
9916                 strcat(parseList[boardIndex-1], " ");
9917                 strcat(parseList[boardIndex-1], yy_text);
9918             }
9919             continue;
9920           case Comment:
9921           case PGNTag:
9922           case NAG:
9923           default:
9924             /* ignore */
9925             continue;
9926           case WhiteWins:
9927           case BlackWins:
9928           case GameIsDrawn:
9929           case GameUnfinished:
9930             if (gameMode == IcsExamining) {
9931                 if (boardIndex < backwardMostMove) {
9932                     /* Oops, gap.  How did that happen? */
9933                     return;
9934                 }
9935                 backwardMostMove = blackPlaysFirst ? 1 : 0;
9936                 return;
9937             }
9938             gameInfo.result = moveType;
9939             p = strchr(yy_text, '{');
9940             if (p == NULL) p = strchr(yy_text, '(');
9941             if (p == NULL) {
9942                 p = yy_text;
9943                 if (p[0] == '0' || p[0] == '1' || p[0] == '*') p = "";
9944             } else {
9945                 q = strchr(p, *p == '{' ? '}' : ')');
9946                 if (q != NULL) *q = NULLCHAR;
9947                 p++;
9948             }
9949             while(q = strchr(p, '\n')) *q = ' '; // [HGM] crush linefeeds in result message
9950             gameInfo.resultDetails = StrSave(p);
9951             continue;
9952         }
9953         if (boardIndex >= forwardMostMove &&
9954             !(gameMode == IcsObserving && ics_gamenum == -1)) {
9955             backwardMostMove = blackPlaysFirst ? 1 : 0;
9956             return;
9957         }
9958         (void) CoordsToAlgebraic(boards[boardIndex], PosFlags(boardIndex),
9959                                  fromY, fromX, toY, toX, promoChar,
9960                                  parseList[boardIndex]);
9961         CopyBoard(boards[boardIndex + 1], boards[boardIndex]);
9962         /* currentMoveString is set as a side-effect of yylex */
9963         safeStrCpy(moveList[boardIndex], currentMoveString, sizeof(moveList[boardIndex])/sizeof(moveList[boardIndex][0]));
9964         strcat(moveList[boardIndex], "\n");
9965         boardIndex++;
9966         ApplyMove(fromX, fromY, toX, toY, promoChar, boards[boardIndex]);
9967         switch (MateTest(boards[boardIndex], PosFlags(boardIndex)) ) {
9968           case MT_NONE:
9969           case MT_STALEMATE:
9970           default:
9971             break;
9972           case MT_CHECK:
9973             if(!IS_SHOGI(gameInfo.variant))
9974                 strcat(parseList[boardIndex - 1], "+");
9975             break;
9976           case MT_CHECKMATE:
9977           case MT_STAINMATE:
9978             strcat(parseList[boardIndex - 1], "#");
9979             break;
9980         }
9981     }
9982 }
9983
9984
9985 /* Apply a move to the given board  */
9986 void
9987 ApplyMove (int fromX, int fromY, int toX, int toY, int promoChar, Board board)
9988 {
9989   ChessSquare captured = board[toY][toX], piece, pawn, king, killed, killed2; int p, rookX, oldEP, epRank, berolina = 0;
9990   int promoRank = gameInfo.variant == VariantMakruk || gameInfo.variant == VariantGrand || gameInfo.variant == VariantChuChess ? 3 : 1;
9991
9992     /* [HGM] compute & store e.p. status and castling rights for new position */
9993     /* we can always do that 'in place', now pointers to these rights are passed to ApplyMove */
9994
9995       if(gameInfo.variant == VariantBerolina) berolina = EP_BEROLIN_A;
9996       oldEP = (signed char)board[EP_FILE]; epRank = board[EP_RANK];
9997       board[EP_STATUS] = EP_NONE;
9998       board[EP_FILE] = board[EP_RANK] = 100;
9999
10000   if (fromY == DROP_RANK) {
10001         /* must be first */
10002         if(fromX == EmptySquare) { // [HGM] pass: empty drop encodes null move; nothing to change.
10003             board[EP_STATUS] = EP_CAPTURE; // null move considered irreversible
10004             return;
10005         }
10006         piece = board[toY][toX] = (ChessSquare) fromX;
10007   } else {
10008 //      ChessSquare victim;
10009       int i;
10010
10011       if( killX >= 0 && killY >= 0 ) { // [HGM] lion: Lion trampled over something
10012 //           victim = board[killY][killX],
10013            killed = board[killY][killX],
10014            board[killY][killX] = EmptySquare,
10015            board[EP_STATUS] = EP_CAPTURE;
10016            if( kill2X >= 0 && kill2Y >= 0)
10017              killed2 = board[kill2Y][kill2X], board[kill2Y][kill2X] = EmptySquare;
10018       }
10019
10020       if( board[toY][toX] != EmptySquare ) {
10021            board[EP_STATUS] = EP_CAPTURE;
10022            if( (fromX != toX || fromY != toY) && // not igui!
10023                (captured == WhiteLion && board[fromY][fromX] != BlackLion ||
10024                 captured == BlackLion && board[fromY][fromX] != WhiteLion   ) ) { // [HGM] lion: Chu Lion-capture rules
10025                board[EP_STATUS] = EP_IRON_LION; // non-Lion x Lion: no counter-strike allowed
10026            }
10027       }
10028
10029       pawn = board[fromY][fromX];
10030       if( pawn == WhiteLance || pawn == BlackLance ) {
10031            if( gameInfo.variant != VariantSuper && gameInfo.variant != VariantChu ) {
10032                if(gameInfo.variant == VariantSpartan) board[EP_STATUS] = EP_PAWN_MOVE; // in Spartan no e.p. rights must be set
10033                else pawn += WhitePawn - WhiteLance; // Lance is Pawn-like in most variants, so let Pawn code treat it by this kludge
10034            }
10035       }
10036       if( pawn == WhitePawn ) {
10037            if(fromY != toY) // [HGM] Xiangqi sideway Pawn moves should not count as 50-move breakers
10038                board[EP_STATUS] = EP_PAWN_MOVE;
10039            if( toY-fromY>=2) {
10040                board[EP_FILE] = (fromX + toX)/2; board[EP_RANK] = toY - 1 | 128*(toY - fromY > 2);
10041                if(toX>BOARD_LEFT   && board[toY][toX-1] == BlackPawn &&
10042                         gameInfo.variant != VariantBerolina || toX < fromX)
10043                       board[EP_STATUS] = toX | berolina;
10044                if(toX<BOARD_RGHT-1 && board[toY][toX+1] == BlackPawn &&
10045                         gameInfo.variant != VariantBerolina || toX > fromX)
10046                       board[EP_STATUS] = toX;
10047            }
10048       } else
10049       if( pawn == BlackPawn ) {
10050            if(fromY != toY) // [HGM] Xiangqi sideway Pawn moves should not count as 50-move breakers
10051                board[EP_STATUS] = EP_PAWN_MOVE;
10052            if( toY-fromY<= -2) {
10053                board[EP_FILE] = (fromX + toX)/2; board[EP_RANK] = toY + 1 | 128*(fromY - toY > 2);
10054                if(toX>BOARD_LEFT   && board[toY][toX-1] == WhitePawn &&
10055                         gameInfo.variant != VariantBerolina || toX < fromX)
10056                       board[EP_STATUS] = toX | berolina;
10057                if(toX<BOARD_RGHT-1 && board[toY][toX+1] == WhitePawn &&
10058                         gameInfo.variant != VariantBerolina || toX > fromX)
10059                       board[EP_STATUS] = toX;
10060            }
10061        }
10062
10063        if(fromY == 0) board[TOUCHED_W] |= 1<<fromX; else // new way to keep track of virginity
10064        if(fromY == BOARD_HEIGHT-1) board[TOUCHED_B] |= 1<<fromX;
10065        if(toY == 0) board[TOUCHED_W] |= 1<<toX; else
10066        if(toY == BOARD_HEIGHT-1) board[TOUCHED_B] |= 1<<toX;
10067
10068        for(i=0; i<nrCastlingRights; i++) {
10069            if(board[CASTLING][i] == fromX && castlingRank[i] == fromY ||
10070               board[CASTLING][i] == toX   && castlingRank[i] == toY
10071              ) board[CASTLING][i] = NoRights; // revoke for moved or captured piece
10072        }
10073
10074        if(gameInfo.variant == VariantSChess) { // update virginity
10075            if(fromY == 0)              board[VIRGIN][fromX] &= ~VIRGIN_W; // loss by moving
10076            if(fromY == BOARD_HEIGHT-1) board[VIRGIN][fromX] &= ~VIRGIN_B;
10077            if(toY == 0)                board[VIRGIN][toX]   &= ~VIRGIN_W; // loss by capture
10078            if(toY == BOARD_HEIGHT-1)   board[VIRGIN][toX]   &= ~VIRGIN_B;
10079        }
10080
10081      if (fromX == toX && fromY == toY) return;
10082
10083      piece = board[fromY][fromX]; /* [HGM] remember, for Shogi promotion */
10084      king = piece < (int) BlackPawn ? WhiteKing : BlackKing; /* [HGM] Knightmate simplify testing for castling */
10085      if(gameInfo.variant == VariantKnightmate)
10086          king += (int) WhiteUnicorn - (int) WhiteKing;
10087
10088     if(pieceDesc[piece] && killX >= 0 && strchr(pieceDesc[piece], 'O') // Betza castling-enabled
10089        && (piece < BlackPawn ? killed < BlackPawn : killed >= BlackPawn)) {    // and tramples own
10090         board[toY][toX] = piece; board[fromY][fromX] = EmptySquare;
10091         board[toY][toX + (killX < fromX ? 1 : -1)] = killed;
10092         board[EP_STATUS] = EP_NONE; // capture was fake!
10093     } else
10094     /* Code added by Tord: */
10095     /* FRC castling assumed when king captures friendly rook. [HGM] or RxK for S-Chess */
10096     if (board[fromY][fromX] == WhiteKing && board[toY][toX] == WhiteRook ||
10097         board[fromY][fromX] == WhiteRook && board[toY][toX] == WhiteKing) {
10098       board[EP_STATUS] = EP_NONE; // capture was fake!
10099       board[fromY][fromX] = EmptySquare;
10100       board[toY][toX] = EmptySquare;
10101       if((toX > fromX) != (piece == WhiteRook)) {
10102         board[0][BOARD_RGHT-2] = WhiteKing; board[0][BOARD_RGHT-3] = WhiteRook;
10103       } else {
10104         board[0][BOARD_LEFT+2] = WhiteKing; board[0][BOARD_LEFT+3] = WhiteRook;
10105       }
10106     } else if (board[fromY][fromX] == BlackKing && board[toY][toX] == BlackRook ||
10107                board[fromY][fromX] == BlackRook && board[toY][toX] == BlackKing) {
10108       board[EP_STATUS] = EP_NONE;
10109       board[fromY][fromX] = EmptySquare;
10110       board[toY][toX] = EmptySquare;
10111       if((toX > fromX) != (piece == BlackRook)) {
10112         board[BOARD_HEIGHT-1][BOARD_RGHT-2] = BlackKing; board[BOARD_HEIGHT-1][BOARD_RGHT-3] = BlackRook;
10113       } else {
10114         board[BOARD_HEIGHT-1][BOARD_LEFT+2] = BlackKing; board[BOARD_HEIGHT-1][BOARD_LEFT+3] = BlackRook;
10115       }
10116     /* End of code added by Tord */
10117
10118     } else if (pieceDesc[piece] && piece == king && !strchr(pieceDesc[piece], 'O') && strchr(pieceDesc[piece], 'i')) {
10119         board[fromY][fromX] = EmptySquare; // never castle if King has virgin moves defined on it other than castling
10120         board[toY][toX] = piece;
10121     } else if (board[fromY][fromX] == king
10122         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
10123         && toY == fromY && toX > fromX+1) {
10124         for(rookX=fromX+1; board[toY][rookX] == EmptySquare && rookX < BOARD_RGHT-1; rookX++); // castle with nearest piece
10125         board[fromY][toX-1] = board[fromY][rookX];
10126         board[fromY][rookX] = EmptySquare;
10127         board[fromY][fromX] = EmptySquare;
10128         board[toY][toX] = king;
10129     } else if (board[fromY][fromX] == king
10130         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
10131                && toY == fromY && toX < fromX-1) {
10132         for(rookX=fromX-1; board[toY][rookX] == EmptySquare && rookX > 0; rookX--); // castle with nearest piece
10133         board[fromY][toX+1] = board[fromY][rookX];
10134         board[fromY][rookX] = EmptySquare;
10135         board[fromY][fromX] = EmptySquare;
10136         board[toY][toX] = king;
10137     } else if ((board[fromY][fromX] == WhitePawn && gameInfo.variant != VariantXiangqi ||
10138                 board[fromY][fromX] == WhiteLance && gameInfo.variant != VariantSuper && gameInfo.variant != VariantChu)
10139                && toY >= BOARD_HEIGHT-promoRank && promoChar // defaulting to Q is done elsewhere
10140                ) {
10141         /* white pawn promotion */
10142         board[toY][toX] = CharToPiece(ToUpper(promoChar));
10143         if(board[toY][toX] < WhiteCannon && PieceToChar(PROMOTED board[toY][toX]) == '~') /* [HGM] use shadow piece (if available) */
10144             board[toY][toX] = (ChessSquare) (PROMOTED board[toY][toX]);
10145         board[fromY][fromX] = EmptySquare;
10146     } else if ((fromY >= BOARD_HEIGHT>>1)
10147                && (oldEP == toX || oldEP == EP_UNKNOWN || appData.testLegality || abs(toX - fromX) > 4)
10148                && (toX != fromX)
10149                && gameInfo.variant != VariantXiangqi
10150                && gameInfo.variant != VariantBerolina
10151                && (pawn == WhitePawn)
10152                && (board[toY][toX] == EmptySquare)) {
10153         board[fromY][fromX] = EmptySquare;
10154         board[toY][toX] = piece;
10155         if(toY == epRank - 128 + 1)
10156             captured = board[toY - 2][toX], board[toY - 2][toX] = EmptySquare;
10157         else
10158             captured = board[toY - 1][toX], board[toY - 1][toX] = EmptySquare;
10159     } else if ((fromY == BOARD_HEIGHT-4)
10160                && (toX == fromX)
10161                && gameInfo.variant == VariantBerolina
10162                && (board[fromY][fromX] == WhitePawn)
10163                && (board[toY][toX] == EmptySquare)) {
10164         board[fromY][fromX] = EmptySquare;
10165         board[toY][toX] = WhitePawn;
10166         if(oldEP & EP_BEROLIN_A) {
10167                 captured = board[fromY][fromX-1];
10168                 board[fromY][fromX-1] = EmptySquare;
10169         }else{  captured = board[fromY][fromX+1];
10170                 board[fromY][fromX+1] = EmptySquare;
10171         }
10172     } else if (board[fromY][fromX] == king
10173         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
10174                && toY == fromY && toX > fromX+1) {
10175         for(rookX=toX+1; board[toY][rookX] == EmptySquare && rookX < BOARD_RGHT - 1; rookX++);
10176         board[fromY][toX-1] = board[fromY][rookX];
10177         board[fromY][rookX] = EmptySquare;
10178         board[fromY][fromX] = EmptySquare;
10179         board[toY][toX] = king;
10180     } else if (board[fromY][fromX] == king
10181         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
10182                && toY == fromY && toX < fromX-1) {
10183         for(rookX=toX-1; board[toY][rookX] == EmptySquare && rookX > 0; rookX--);
10184         board[fromY][toX+1] = board[fromY][rookX];
10185         board[fromY][rookX] = EmptySquare;
10186         board[fromY][fromX] = EmptySquare;
10187         board[toY][toX] = king;
10188     } else if (fromY == 7 && fromX == 3
10189                && board[fromY][fromX] == BlackKing
10190                && toY == 7 && toX == 5) {
10191         board[fromY][fromX] = EmptySquare;
10192         board[toY][toX] = BlackKing;
10193         board[fromY][7] = EmptySquare;
10194         board[toY][4] = BlackRook;
10195     } else if (fromY == 7 && fromX == 3
10196                && board[fromY][fromX] == BlackKing
10197                && toY == 7 && toX == 1) {
10198         board[fromY][fromX] = EmptySquare;
10199         board[toY][toX] = BlackKing;
10200         board[fromY][0] = EmptySquare;
10201         board[toY][2] = BlackRook;
10202     } else if ((board[fromY][fromX] == BlackPawn && gameInfo.variant != VariantXiangqi ||
10203                 board[fromY][fromX] == BlackLance && gameInfo.variant != VariantSuper && gameInfo.variant != VariantChu)
10204                && toY < promoRank && promoChar
10205                ) {
10206         /* black pawn promotion */
10207         board[toY][toX] = CharToPiece(ToLower(promoChar));
10208         if(board[toY][toX] < BlackCannon && PieceToChar(PROMOTED board[toY][toX]) == '~') /* [HGM] use shadow piece (if available) */
10209             board[toY][toX] = (ChessSquare) (PROMOTED board[toY][toX]);
10210         board[fromY][fromX] = EmptySquare;
10211     } else if ((fromY < BOARD_HEIGHT>>1)
10212                && (oldEP == toX || oldEP == EP_UNKNOWN || appData.testLegality || abs(toX - fromX) > 4)
10213                && (toX != fromX)
10214                && gameInfo.variant != VariantXiangqi
10215                && gameInfo.variant != VariantBerolina
10216                && (pawn == BlackPawn)
10217                && (board[toY][toX] == EmptySquare)) {
10218         board[fromY][fromX] = EmptySquare;
10219         board[toY][toX] = piece;
10220         if(toY == epRank - 128 - 1)
10221             captured = board[toY + 2][toX], board[toY + 2][toX] = EmptySquare;
10222         else
10223             captured = board[toY + 1][toX], board[toY + 1][toX] = EmptySquare;
10224     } else if ((fromY == 3)
10225                && (toX == fromX)
10226                && gameInfo.variant == VariantBerolina
10227                && (board[fromY][fromX] == BlackPawn)
10228                && (board[toY][toX] == EmptySquare)) {
10229         board[fromY][fromX] = EmptySquare;
10230         board[toY][toX] = BlackPawn;
10231         if(oldEP & EP_BEROLIN_A) {
10232                 captured = board[fromY][fromX-1];
10233                 board[fromY][fromX-1] = EmptySquare;
10234         }else{  captured = board[fromY][fromX+1];
10235                 board[fromY][fromX+1] = EmptySquare;
10236         }
10237     } else {
10238         ChessSquare piece = board[fromY][fromX]; // [HGM] lion: allow for igui (where from == to)
10239         board[fromY][fromX] = EmptySquare;
10240         board[toY][toX] = piece;
10241     }
10242   }
10243
10244     if (gameInfo.holdingsWidth != 0) {
10245
10246       /* !!A lot more code needs to be written to support holdings  */
10247       /* [HGM] OK, so I have written it. Holdings are stored in the */
10248       /* penultimate board files, so they are automaticlly stored   */
10249       /* in the game history.                                       */
10250       if (fromY == DROP_RANK || gameInfo.variant == VariantSChess
10251                                 && promoChar && piece != WhitePawn && piece != BlackPawn) {
10252         /* Delete from holdings, by decreasing count */
10253         /* and erasing image if necessary            */
10254         p = fromY == DROP_RANK ? (int) fromX : CharToPiece(piece > BlackPawn ? ToLower(promoChar) : ToUpper(promoChar));
10255         if(p < (int) BlackPawn) { /* white drop */
10256              p -= (int)WhitePawn;
10257                  p = PieceToNumber((ChessSquare)p);
10258              if(p >= gameInfo.holdingsSize) p = 0;
10259              if(--board[p][BOARD_WIDTH-2] <= 0)
10260                   board[p][BOARD_WIDTH-1] = EmptySquare;
10261              if((int)board[p][BOARD_WIDTH-2] < 0)
10262                         board[p][BOARD_WIDTH-2] = 0;
10263         } else {                  /* black drop */
10264              p -= (int)BlackPawn;
10265                  p = PieceToNumber((ChessSquare)p);
10266              if(p >= gameInfo.holdingsSize) p = 0;
10267              if(--board[BOARD_HEIGHT-1-p][1] <= 0)
10268                   board[BOARD_HEIGHT-1-p][0] = EmptySquare;
10269              if((int)board[BOARD_HEIGHT-1-p][1] < 0)
10270                         board[BOARD_HEIGHT-1-p][1] = 0;
10271         }
10272       }
10273       if (captured != EmptySquare && gameInfo.holdingsSize > 0
10274           && gameInfo.variant != VariantBughouse && gameInfo.variant != VariantSChess        ) {
10275         /* [HGM] holdings: Add to holdings, if holdings exist */
10276         if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat || gameInfo.variant == VariantGrand) {
10277                 // [HGM] superchess: suppress flipping color of captured pieces by reverse pre-flip
10278                 captured = (int) captured >= (int) BlackPawn ? BLACK_TO_WHITE captured : WHITE_TO_BLACK captured;
10279         }
10280         p = (int) captured;
10281         if (p >= (int) BlackPawn) {
10282           p -= (int)BlackPawn;
10283           if(DEMOTED p >= 0 && PieceToChar(p) == '+') {
10284                   /* Restore shogi-promoted piece to its original  first */
10285                   captured = (ChessSquare) (DEMOTED captured);
10286                   p = DEMOTED p;
10287           }
10288           p = PieceToNumber((ChessSquare)p);
10289           if(p >= gameInfo.holdingsSize) { p = 0; captured = BlackPawn; }
10290           board[p][BOARD_WIDTH-2]++;
10291           board[p][BOARD_WIDTH-1] = BLACK_TO_WHITE captured;
10292         } else {
10293           p -= (int)WhitePawn;
10294           if(DEMOTED p >= 0 && PieceToChar(p) == '+') {
10295                   captured = (ChessSquare) (DEMOTED captured);
10296                   p = DEMOTED p;
10297           }
10298           p = PieceToNumber((ChessSquare)p);
10299           if(p >= gameInfo.holdingsSize) { p = 0; captured = WhitePawn; }
10300           board[BOARD_HEIGHT-1-p][1]++;
10301           board[BOARD_HEIGHT-1-p][0] = WHITE_TO_BLACK captured;
10302         }
10303       }
10304     } else if (gameInfo.variant == VariantAtomic) {
10305       if (captured != EmptySquare) {
10306         int y, x;
10307         for (y = toY-1; y <= toY+1; y++) {
10308           for (x = toX-1; x <= toX+1; x++) {
10309             if (y >= 0 && y < BOARD_HEIGHT && x >= BOARD_LEFT && x < BOARD_RGHT &&
10310                 board[y][x] != WhitePawn && board[y][x] != BlackPawn) {
10311               board[y][x] = EmptySquare;
10312             }
10313           }
10314         }
10315         board[toY][toX] = EmptySquare;
10316       }
10317     }
10318
10319     if(gameInfo.variant == VariantSChess && promoChar != NULLCHAR && promoChar != '=' && piece != WhitePawn && piece != BlackPawn) {
10320         board[fromY][fromX] = CharToPiece(piece < BlackPawn ? ToUpper(promoChar) : ToLower(promoChar)); // S-Chess gating
10321     } else
10322     if(promoChar == '+') {
10323         /* [HGM] Shogi-style promotions, to piece implied by original (Might overwrite ordinary Pawn promotion) */
10324         board[toY][toX] = (ChessSquare) (CHUPROMOTED piece);
10325         if(gameInfo.variant == VariantChuChess && (piece == WhiteKnight || piece == BlackKnight))
10326           board[toY][toX] = piece + WhiteLion - WhiteKnight; // adjust Knight promotions to Lion
10327     } else if(!appData.testLegality && promoChar != NULLCHAR && promoChar != '=') { // without legality testing, unconditionally believe promoChar
10328         ChessSquare newPiece = CharToPiece(piece < BlackPawn ? ToUpper(promoChar) : ToLower(promoChar));
10329         if((newPiece <= WhiteMan || newPiece >= BlackPawn && newPiece <= BlackMan) // unpromoted piece specified
10330            && pieceToChar[PROMOTED newPiece] == '~') newPiece = PROMOTED newPiece; // but promoted version available
10331         board[toY][toX] = newPiece;
10332     }
10333     if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat || gameInfo.variant == VariantGrand)
10334                 && promoChar != NULLCHAR && gameInfo.holdingsSize) {
10335         // [HGM] superchess: take promotion piece out of holdings
10336         int k = PieceToNumber(CharToPiece(ToUpper(promoChar)));
10337         if((int)piece < (int)BlackPawn) { // determine stm from piece color
10338             if(!--board[k][BOARD_WIDTH-2])
10339                 board[k][BOARD_WIDTH-1] = EmptySquare;
10340         } else {
10341             if(!--board[BOARD_HEIGHT-1-k][1])
10342                 board[BOARD_HEIGHT-1-k][0] = EmptySquare;
10343         }
10344     }
10345 }
10346
10347 /* Updates forwardMostMove */
10348 void
10349 MakeMove (int fromX, int fromY, int toX, int toY, int promoChar)
10350 {
10351     int x = toX, y = toY;
10352     char *s = parseList[forwardMostMove];
10353     ChessSquare p = boards[forwardMostMove][toY][toX];
10354 //    forwardMostMove++; // [HGM] bare: moved downstream
10355
10356     if(killX >= 0 && killY >= 0) x = killX, y = killY; // [HGM] lion: make SAN move to intermediate square, if there is one
10357     (void) CoordsToAlgebraic(boards[forwardMostMove],
10358                              PosFlags(forwardMostMove),
10359                              fromY, fromX, y, x, promoChar,
10360                              s);
10361     if(killX >= 0 && killY >= 0)
10362         sprintf(s + strlen(s), "%c%c%d", p == EmptySquare || toX == fromX && toY == fromY ? '-' : 'x', toX + AAA, toY + ONE - '0');
10363
10364     if(serverMoves != NULL) { /* [HGM] write moves on file for broadcasting (should be separate routine, really) */
10365         int timeLeft; static int lastLoadFlag=0; int king, piece;
10366         piece = boards[forwardMostMove][fromY][fromX];
10367         king = piece < (int) BlackPawn ? WhiteKing : BlackKing;
10368         if(gameInfo.variant == VariantKnightmate)
10369             king += (int) WhiteUnicorn - (int) WhiteKing;
10370         if(forwardMostMove == 0) {
10371             if(gameMode == MachinePlaysBlack || gameMode == BeginningOfGame)
10372                 fprintf(serverMoves, "%s;", UserName());
10373             else if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b')
10374                 fprintf(serverMoves, "%s;", second.tidy);
10375             fprintf(serverMoves, "%s;", first.tidy);
10376             if(gameMode == MachinePlaysWhite)
10377                 fprintf(serverMoves, "%s;", UserName());
10378             else if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'w')
10379                 fprintf(serverMoves, "%s;", second.tidy);
10380         } else fprintf(serverMoves, loadFlag|lastLoadFlag ? ":" : ";");
10381         lastLoadFlag = loadFlag;
10382         // print base move
10383         fprintf(serverMoves, "%c%c:%c%c", AAA+fromX, ONE+fromY, AAA+toX, ONE+toY);
10384         // print castling suffix
10385         if( toY == fromY && piece == king ) {
10386             if(toX-fromX > 1)
10387                 fprintf(serverMoves, ":%c%c:%c%c", AAA+BOARD_RGHT-1, ONE+fromY, AAA+toX-1,ONE+toY);
10388             if(fromX-toX >1)
10389                 fprintf(serverMoves, ":%c%c:%c%c", AAA+BOARD_LEFT, ONE+fromY, AAA+toX+1,ONE+toY);
10390         }
10391         // e.p. suffix
10392         if( (boards[forwardMostMove][fromY][fromX] == WhitePawn ||
10393              boards[forwardMostMove][fromY][fromX] == BlackPawn   ) &&
10394              boards[forwardMostMove][toY][toX] == EmptySquare
10395              && fromX != toX && fromY != toY)
10396                 fprintf(serverMoves, ":%c%c:%c%c", AAA+fromX, ONE+fromY, AAA+toX, ONE+fromY);
10397         // promotion suffix
10398         if(promoChar != NULLCHAR) {
10399             if(fromY == 0 || fromY == BOARD_HEIGHT-1)
10400                  fprintf(serverMoves, ":%c%c:%c%c", WhiteOnMove(forwardMostMove) ? 'w' : 'b',
10401                                                  ToLower(promoChar), AAA+fromX, ONE+fromY); // Seirawan gating
10402             else fprintf(serverMoves, ":%c:%c%c", ToLower(promoChar), AAA+toX, ONE+toY);
10403         }
10404         if(!loadFlag) {
10405                 char buf[MOVE_LEN*2], *p; int len;
10406             fprintf(serverMoves, "/%d/%d",
10407                pvInfoList[forwardMostMove].depth, pvInfoList[forwardMostMove].score);
10408             if(forwardMostMove+1 & 1) timeLeft = whiteTimeRemaining/1000;
10409             else                      timeLeft = blackTimeRemaining/1000;
10410             fprintf(serverMoves, "/%d", timeLeft);
10411                 strncpy(buf, parseList[forwardMostMove], MOVE_LEN*2);
10412                 if(p = strchr(buf, '/')) *p = NULLCHAR; else
10413                 if(p = strchr(buf, '=')) *p = NULLCHAR;
10414                 len = strlen(buf); if(len > 1 && buf[len-2] != '-') buf[len-2] = NULLCHAR; // strip to-square
10415             fprintf(serverMoves, "/%s", buf);
10416         }
10417         fflush(serverMoves);
10418     }
10419
10420     if (forwardMostMove+1 > framePtr) { // [HGM] vari: do not run into saved variations..
10421         GameEnds(GameUnfinished, _("Game too long; increase MAX_MOVES and recompile"), GE_XBOARD);
10422       return;
10423     }
10424     UnLoadPV(); // [HGM] pv: if we are looking at a PV, abort this
10425     if (commentList[forwardMostMove+1] != NULL) {
10426         free(commentList[forwardMostMove+1]);
10427         commentList[forwardMostMove+1] = NULL;
10428     }
10429     CopyBoard(boards[forwardMostMove+1], boards[forwardMostMove]);
10430     ApplyMove(fromX, fromY, toX, toY, promoChar, boards[forwardMostMove+1]);
10431     // forwardMostMove++; // [HGM] bare: moved to after ApplyMove, to make sure clock interrupt finds complete board
10432     SwitchClocks(forwardMostMove+1); // [HGM] race: incrementing move nr inside
10433     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
10434     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
10435     adjustedClock = FALSE;
10436     gameInfo.result = GameUnfinished;
10437     if (gameInfo.resultDetails != NULL) {
10438         free(gameInfo.resultDetails);
10439         gameInfo.resultDetails = NULL;
10440     }
10441     CoordsToComputerAlgebraic(fromY, fromX, toY, toX, promoChar,
10442                               moveList[forwardMostMove - 1]);
10443     switch (MateTest(boards[forwardMostMove], PosFlags(forwardMostMove)) ) {
10444       case MT_NONE:
10445       case MT_STALEMATE:
10446       default:
10447         break;
10448       case MT_CHECK:
10449         if(!IS_SHOGI(gameInfo.variant))
10450             strcat(parseList[forwardMostMove - 1], "+");
10451         break;
10452       case MT_CHECKMATE:
10453       case MT_STAINMATE:
10454         strcat(parseList[forwardMostMove - 1], "#");
10455         break;
10456     }
10457 }
10458
10459 /* Updates currentMove if not pausing */
10460 void
10461 ShowMove (int fromX, int fromY, int toX, int toY)
10462 {
10463     int instant = (gameMode == PlayFromGameFile) ?
10464         (matchMode || (appData.timeDelay == 0 && !pausing)) : pausing;
10465     if(appData.noGUI) return;
10466     if (!pausing || gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
10467         if (!instant) {
10468             if (forwardMostMove == currentMove + 1) {
10469                 AnimateMove(boards[forwardMostMove - 1],
10470                             fromX, fromY, toX, toY);
10471             }
10472         }
10473         currentMove = forwardMostMove;
10474     }
10475
10476     killX = killY = -1; // [HGM] lion: used up
10477
10478     if (instant) return;
10479
10480     DisplayMove(currentMove - 1);
10481     if (!pausing || gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
10482             if (appData.highlightLastMove) { // [HGM] moved to after DrawPosition, as with arrow it could redraw old board
10483                 SetHighlights(fromX, fromY, toX, toY);
10484             }
10485     }
10486     DrawPosition(FALSE, boards[currentMove]);
10487     DisplayBothClocks();
10488     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
10489 }
10490
10491 void
10492 SendEgtPath (ChessProgramState *cps)
10493 {       /* [HGM] EGT: match formats given in feature with those given by user, and send info for each match */
10494         char buf[MSG_SIZ], name[MSG_SIZ], *p;
10495
10496         if((p = cps->egtFormats) == NULL || appData.egtFormats == NULL) return;
10497
10498         while(*p) {
10499             char c, *q = name+1, *r, *s;
10500
10501             name[0] = ','; // extract next format name from feature and copy with prefixed ','
10502             while(*p && *p != ',') *q++ = *p++;
10503             *q++ = ':'; *q = 0;
10504             if( appData.defaultPathEGTB && appData.defaultPathEGTB[0] &&
10505                 strcmp(name, ",nalimov:") == 0 ) {
10506                 // take nalimov path from the menu-changeable option first, if it is defined
10507               snprintf(buf, MSG_SIZ, "egtpath nalimov %s\n", appData.defaultPathEGTB);
10508                 SendToProgram(buf,cps);     // send egtbpath command for nalimov
10509             } else
10510             if( (s = StrStr(appData.egtFormats, name+1)) == appData.egtFormats ||
10511                 (s = StrStr(appData.egtFormats, name)) != NULL) {
10512                 // format name occurs amongst user-supplied formats, at beginning or immediately after comma
10513                 s = r = StrStr(s, ":") + 1; // beginning of path info
10514                 while(*r && *r != ',') r++; // path info is everything upto next ';' or end of string
10515                 c = *r; *r = 0;             // temporarily null-terminate path info
10516                     *--q = 0;               // strip of trailig ':' from name
10517                     snprintf(buf, MSG_SIZ, "egtpath %s %s\n", name+1, s);
10518                 *r = c;
10519                 SendToProgram(buf,cps);     // send egtbpath command for this format
10520             }
10521             if(*p == ',') p++; // read away comma to position for next format name
10522         }
10523 }
10524
10525 static int
10526 NonStandardBoardSize (VariantClass v, int boardWidth, int boardHeight, int holdingsSize)
10527 {
10528       int width = 8, height = 8, holdings = 0;             // most common sizes
10529       if( v == VariantUnknown || *engineVariant) return 0; // engine-defined name never needs prefix
10530       // correct the deviations default for each variant
10531       if( v == VariantXiangqi ) width = 9,  height = 10;
10532       if( v == VariantShogi )   width = 9,  height = 9,  holdings = 7;
10533       if( v == VariantBughouse || v == VariantCrazyhouse) holdings = 5;
10534       if( v == VariantCapablanca || v == VariantCapaRandom ||
10535           v == VariantGothic || v == VariantFalcon || v == VariantJanus )
10536                                 width = 10;
10537       if( v == VariantCourier ) width = 12;
10538       if( v == VariantSuper )                            holdings = 8;
10539       if( v == VariantGreat )   width = 10,              holdings = 8;
10540       if( v == VariantSChess )                           holdings = 7;
10541       if( v == VariantGrand )   width = 10, height = 10, holdings = 7;
10542       if( v == VariantChuChess) width = 10, height = 10;
10543       if( v == VariantChu )     width = 12, height = 12;
10544       return boardWidth >= 0   && boardWidth   != width  || // -1 is default,
10545              boardHeight >= 0  && boardHeight  != height || // and thus by definition OK
10546              holdingsSize >= 0 && holdingsSize != holdings;
10547 }
10548
10549 char variantError[MSG_SIZ];
10550
10551 char *
10552 SupportedVariant (char *list, VariantClass v, int boardWidth, int boardHeight, int holdingsSize, int proto, char *engine)
10553 {     // returns error message (recognizable by upper-case) if engine does not support the variant
10554       char *p, *variant = VariantName(v);
10555       static char b[MSG_SIZ];
10556       if(NonStandardBoardSize(v, boardWidth, boardHeight, holdingsSize)) { /* [HGM] make prefix for non-standard board size. */
10557            snprintf(b, MSG_SIZ, "%dx%d+%d_%s", boardWidth, boardHeight,
10558                                                holdingsSize, variant); // cook up sized variant name
10559            /* [HGM] varsize: try first if this deviant size variant is specifically known */
10560            if(StrStr(list, b) == NULL) {
10561                // specific sized variant not known, check if general sizing allowed
10562                if(proto != 1 && StrStr(list, "boardsize") == NULL) {
10563                    snprintf(variantError, MSG_SIZ, "Board size %dx%d+%d not supported by %s",
10564                             boardWidth, boardHeight, holdingsSize, engine);
10565                    return NULL;
10566                }
10567                /* [HGM] here we really should compare with the maximum supported board size */
10568            }
10569       } else snprintf(b, MSG_SIZ,"%s", variant);
10570       if(proto == 1) return b; // for protocol 1 we cannot check and hope for the best
10571       p = StrStr(list, b);
10572       while(p && (p != list && p[-1] != ',' || p[strlen(b)] && p[strlen(b)] != ',') ) p = StrStr(p+1, b);
10573       if(p == NULL) {
10574           // occurs not at all in list, or only as sub-string
10575           snprintf(variantError, MSG_SIZ, _("Variant %s not supported by %s"), b, engine);
10576           if(p = StrStr(list, b)) { // handle requesting parent variant when only size-overridden is supported
10577               int l = strlen(variantError);
10578               char *q;
10579               while(p != list && p[-1] != ',') p--;
10580               q = strchr(p, ',');
10581               if(q) *q = NULLCHAR;
10582               snprintf(variantError + l, MSG_SIZ - l,  _(", but %s is"), p);
10583               if(q) *q= ',';
10584           }
10585           return NULL;
10586       }
10587       return b;
10588 }
10589
10590 void
10591 InitChessProgram (ChessProgramState *cps, int setup)
10592 /* setup needed to setup FRC opening position */
10593 {
10594     char buf[MSG_SIZ], *b;
10595     if (appData.noChessProgram) return;
10596     hintRequested = FALSE;
10597     bookRequested = FALSE;
10598
10599     ParseFeatures(appData.features[cps == &second], cps); // [HGM] allow user to overrule features
10600     /* [HGM] some new WB protocol commands to configure engine are sent now, if engine supports them */
10601     /*       moved to before sending initstring in 4.3.15, so Polyglot can delay UCI 'isready' to recepton of 'new' */
10602     if(cps->memSize) { /* [HGM] memory */
10603       snprintf(buf, MSG_SIZ, "memory %d\n", appData.defaultHashSize + appData.defaultCacheSizeEGTB);
10604         SendToProgram(buf, cps);
10605     }
10606     SendEgtPath(cps); /* [HGM] EGT */
10607     if(cps->maxCores) { /* [HGM] SMP: (protocol specified must be last settings command before new!) */
10608       snprintf(buf, MSG_SIZ, "cores %d\n", appData.smpCores);
10609         SendToProgram(buf, cps);
10610     }
10611
10612     setboardSpoiledMachineBlack = FALSE;
10613     SendToProgram(cps->initString, cps);
10614     if (gameInfo.variant != VariantNormal &&
10615         gameInfo.variant != VariantLoadable
10616         /* [HGM] also send variant if board size non-standard */
10617         || gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0) {
10618
10619       b = SupportedVariant(cps->variants, gameInfo.variant, gameInfo.boardWidth,
10620                            gameInfo.boardHeight, gameInfo.holdingsSize, cps->protocolVersion, cps->tidy);
10621       if (b == NULL) {
10622         VariantClass v;
10623         char c, *q = cps->variants, *p = strchr(q, ',');
10624         if(p) *p = NULLCHAR;
10625         v = StringToVariant(q);
10626         DisplayError(variantError, 0);
10627         if(v != VariantUnknown && cps == &first) {
10628             int w, h, s;
10629             if(sscanf(q, "%dx%d+%d_%c", &w, &h, &s, &c) == 4) // get size overrides the engine needs with it (if any)
10630                 appData.NrFiles = w, appData.NrRanks = h, appData.holdingsSize = s, q = strchr(q, '_') + 1;
10631             ASSIGN(appData.variant, q);
10632             Reset(TRUE, FALSE);
10633         }
10634         if(p) *p = ',';
10635         return;
10636       }
10637
10638       snprintf(buf, MSG_SIZ, "variant %s\n", b);
10639       SendToProgram(buf, cps);
10640     }
10641     currentlyInitializedVariant = gameInfo.variant;
10642
10643     /* [HGM] send opening position in FRC to first engine */
10644     if(setup) {
10645           SendToProgram("force\n", cps);
10646           SendBoard(cps, 0);
10647           /* engine is now in force mode! Set flag to wake it up after first move. */
10648           setboardSpoiledMachineBlack = 1;
10649     }
10650
10651     if (cps->sendICS) {
10652       snprintf(buf, sizeof(buf), "ics %s\n", appData.icsActive ? appData.icsHost : "-");
10653       SendToProgram(buf, cps);
10654     }
10655     cps->maybeThinking = FALSE;
10656     cps->offeredDraw = 0;
10657     if (!appData.icsActive) {
10658         SendTimeControl(cps, movesPerSession, timeControl,
10659                         timeIncrement, appData.searchDepth,
10660                         searchTime);
10661     }
10662     if (appData.showThinking
10663         // [HGM] thinking: four options require thinking output to be sent
10664         || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp()
10665                                 ) {
10666         SendToProgram("post\n", cps);
10667     }
10668     SendToProgram("hard\n", cps);
10669     if (!appData.ponderNextMove) {
10670         /* Warning: "easy" is a toggle in GNU Chess, so don't send
10671            it without being sure what state we are in first.  "hard"
10672            is not a toggle, so that one is OK.
10673          */
10674         SendToProgram("easy\n", cps);
10675     }
10676     if (cps->usePing) {
10677       snprintf(buf, MSG_SIZ, "ping %d\n", initPing = ++cps->lastPing);
10678       SendToProgram(buf, cps);
10679     }
10680     cps->initDone = TRUE;
10681     ClearEngineOutputPane(cps == &second);
10682 }
10683
10684
10685 void
10686 ResendOptions (ChessProgramState *cps)
10687 { // send the stored value of the options
10688   int i;
10689   char buf[MSG_SIZ];
10690   Option *opt = cps->option;
10691   for(i=0; i<cps->nrOptions; i++, opt++) {
10692       switch(opt->type) {
10693         case Spin:
10694         case Slider:
10695         case CheckBox:
10696             snprintf(buf, MSG_SIZ, "option %s=%d\n", opt->name, opt->value);
10697           break;
10698         case ComboBox:
10699           snprintf(buf, MSG_SIZ, "option %s=%s\n", opt->name, opt->choice[opt->value]);
10700           break;
10701         default:
10702             snprintf(buf, MSG_SIZ, "option %s=%s\n", opt->name, opt->textValue);
10703           break;
10704         case Button:
10705         case SaveButton:
10706           continue;
10707       }
10708       SendToProgram(buf, cps);
10709   }
10710 }
10711
10712 void
10713 StartChessProgram (ChessProgramState *cps)
10714 {
10715     char buf[MSG_SIZ];
10716     int err;
10717
10718     if (appData.noChessProgram) return;
10719     cps->initDone = FALSE;
10720
10721     if (strcmp(cps->host, "localhost") == 0) {
10722         err = StartChildProcess(cps->program, cps->dir, &cps->pr);
10723     } else if (*appData.remoteShell == NULLCHAR) {
10724         err = OpenRcmd(cps->host, appData.remoteUser, cps->program, &cps->pr);
10725     } else {
10726         if (*appData.remoteUser == NULLCHAR) {
10727           snprintf(buf, sizeof(buf), "%s %s %s", appData.remoteShell, cps->host,
10728                     cps->program);
10729         } else {
10730           snprintf(buf, sizeof(buf), "%s %s -l %s %s", appData.remoteShell,
10731                     cps->host, appData.remoteUser, cps->program);
10732         }
10733         err = StartChildProcess(buf, "", &cps->pr);
10734     }
10735
10736     if (err != 0) {
10737       snprintf(buf, MSG_SIZ, _("Startup failure on '%s'"), cps->program);
10738         DisplayError(buf, err); // [HGM] bit of a rough kludge: ignore failure, (which XBoard would do anyway), and let I/O discover it
10739         if(cps != &first) return;
10740         appData.noChessProgram = TRUE;
10741         ThawUI();
10742         SetNCPMode();
10743 //      DisplayFatalError(buf, err, 1);
10744 //      cps->pr = NoProc;
10745 //      cps->isr = NULL;
10746         return;
10747     }
10748
10749     cps->isr = AddInputSource(cps->pr, TRUE, ReceiveFromProgram, cps);
10750     if (cps->protocolVersion > 1) {
10751       snprintf(buf, MSG_SIZ, "xboard\nprotover %d\n", cps->protocolVersion);
10752       if(!cps->reload) { // do not clear options when reloading because of -xreuse
10753         cps->nrOptions = 0; // [HGM] options: clear all engine-specific options
10754         cps->comboCnt = 0;  //                and values of combo boxes
10755       }
10756       SendToProgram(buf, cps);
10757       if(cps->reload) ResendOptions(cps);
10758     } else {
10759       SendToProgram("xboard\n", cps);
10760     }
10761 }
10762
10763 void
10764 TwoMachinesEventIfReady P((void))
10765 {
10766   static int curMess = 0;
10767   if (first.lastPing != first.lastPong) {
10768     if(curMess != 1) DisplayMessage("", _("Waiting for first chess program")); curMess = 1;
10769     ScheduleDelayedEvent(TwoMachinesEventIfReady, 10); // [HGM] fast: lowered from 1000
10770     return;
10771   }
10772   if (second.lastPing != second.lastPong) {
10773     if(curMess != 2) DisplayMessage("", _("Waiting for second chess program")); curMess = 2;
10774     ScheduleDelayedEvent(TwoMachinesEventIfReady, 10); // [HGM] fast: lowered from 1000
10775     return;
10776   }
10777   DisplayMessage("", ""); curMess = 0;
10778   TwoMachinesEvent();
10779 }
10780
10781 char *
10782 MakeName (char *template)
10783 {
10784     time_t clock;
10785     struct tm *tm;
10786     static char buf[MSG_SIZ];
10787     char *p = buf;
10788     int i;
10789
10790     clock = time((time_t *)NULL);
10791     tm = localtime(&clock);
10792
10793     while(*p++ = *template++) if(p[-1] == '%') {
10794         switch(*template++) {
10795           case 0:   *p = 0; return buf;
10796           case 'Y': i = tm->tm_year+1900; break;
10797           case 'y': i = tm->tm_year-100; break;
10798           case 'M': i = tm->tm_mon+1; break;
10799           case 'd': i = tm->tm_mday; break;
10800           case 'h': i = tm->tm_hour; break;
10801           case 'm': i = tm->tm_min; break;
10802           case 's': i = tm->tm_sec; break;
10803           default:  i = 0;
10804         }
10805         snprintf(p-1, MSG_SIZ-10 - (p - buf), "%02d", i); p += strlen(p);
10806     }
10807     return buf;
10808 }
10809
10810 int
10811 CountPlayers (char *p)
10812 {
10813     int n = 0;
10814     while(p = strchr(p, '\n')) p++, n++; // count participants
10815     return n;
10816 }
10817
10818 FILE *
10819 WriteTourneyFile (char *results, FILE *f)
10820 {   // write tournament parameters on tourneyFile; on success return the stream pointer for closing
10821     if(f == NULL) f = fopen(appData.tourneyFile, "w");
10822     if(f == NULL) DisplayError(_("Could not write on tourney file"), 0); else {
10823         // create a file with tournament description
10824         fprintf(f, "-participants {%s}\n", appData.participants);
10825         fprintf(f, "-seedBase %d\n", appData.seedBase);
10826         fprintf(f, "-tourneyType %d\n", appData.tourneyType);
10827         fprintf(f, "-tourneyCycles %d\n", appData.tourneyCycles);
10828         fprintf(f, "-defaultMatchGames %d\n", appData.defaultMatchGames);
10829         fprintf(f, "-syncAfterRound %s\n", appData.roundSync ? "true" : "false");
10830         fprintf(f, "-syncAfterCycle %s\n", appData.cycleSync ? "true" : "false");
10831         fprintf(f, "-saveGameFile \"%s\"\n", appData.saveGameFile);
10832         fprintf(f, "-loadGameFile \"%s\"\n", appData.loadGameFile);
10833         fprintf(f, "-loadGameIndex %d\n", appData.loadGameIndex);
10834         fprintf(f, "-loadPositionFile \"%s\"\n", appData.loadPositionFile);
10835         fprintf(f, "-loadPositionIndex %d\n", appData.loadPositionIndex);
10836         fprintf(f, "-rewindIndex %d\n", appData.rewindIndex);
10837         fprintf(f, "-usePolyglotBook %s\n", appData.usePolyglotBook ? "true" : "false");
10838         fprintf(f, "-polyglotBook \"%s\"\n", appData.polyglotBook);
10839         fprintf(f, "-bookDepth %d\n", appData.bookDepth);
10840         fprintf(f, "-bookVariation %d\n", appData.bookStrength);
10841         fprintf(f, "-discourageOwnBooks %s\n", appData.defNoBook ? "true" : "false");
10842         fprintf(f, "-defaultHashSize %d\n", appData.defaultHashSize);
10843         fprintf(f, "-defaultCacheSizeEGTB %d\n", appData.defaultCacheSizeEGTB);
10844         fprintf(f, "-ponderNextMove %s\n", appData.ponderNextMove ? "true" : "false");
10845         fprintf(f, "-smpCores %d\n", appData.smpCores);
10846         if(searchTime > 0)
10847                 fprintf(f, "-searchTime \"%d:%02d\"\n", searchTime/60, searchTime%60);
10848         else {
10849                 fprintf(f, "-mps %d\n", appData.movesPerSession);
10850                 fprintf(f, "-tc %s\n", appData.timeControl);
10851                 fprintf(f, "-inc %.2f\n", appData.timeIncrement);
10852         }
10853         fprintf(f, "-results \"%s\"\n", results);
10854     }
10855     return f;
10856 }
10857
10858 char *command[MAXENGINES], *mnemonic[MAXENGINES];
10859
10860 void
10861 Substitute (char *participants, int expunge)
10862 {
10863     int i, changed, changes=0, nPlayers=0;
10864     char *p, *q, *r, buf[MSG_SIZ];
10865     if(participants == NULL) return;
10866     if(appData.tourneyFile[0] == NULLCHAR) { free(participants); return; }
10867     r = p = participants; q = appData.participants;
10868     while(*p && *p == *q) {
10869         if(*p == '\n') r = p+1, nPlayers++;
10870         p++; q++;
10871     }
10872     if(*p) { // difference
10873         while(*p && *p++ != '\n');
10874         while(*q && *q++ != '\n');
10875       changed = nPlayers;
10876         changes = 1 + (strcmp(p, q) != 0);
10877     }
10878     if(changes == 1) { // a single engine mnemonic was changed
10879         q = r; while(*q) nPlayers += (*q++ == '\n');
10880         p = buf; while(*r && (*p = *r++) != '\n') p++;
10881         *p = NULLCHAR;
10882         NamesToList(firstChessProgramNames, command, mnemonic, "all");
10883         for(i=1; mnemonic[i]; i++) if(!strcmp(buf, mnemonic[i])) break;
10884         if(mnemonic[i]) { // The substitute is valid
10885             FILE *f;
10886             if(appData.tourneyFile[0] && (f = fopen(appData.tourneyFile, "r+")) ) {
10887                 flock(fileno(f), LOCK_EX);
10888                 ParseArgsFromFile(f);
10889                 fseek(f, 0, SEEK_SET);
10890                 FREE(appData.participants); appData.participants = participants;
10891                 if(expunge) { // erase results of replaced engine
10892                     int len = strlen(appData.results), w, b, dummy;
10893                     for(i=0; i<len; i++) {
10894                         Pairing(i, nPlayers, &w, &b, &dummy);
10895                         if((w == changed || b == changed) && appData.results[i] == '*') {
10896                             DisplayError(_("You cannot replace an engine while it is engaged!\nTerminate its game first."), 0);
10897                             fclose(f);
10898                             return;
10899                         }
10900                     }
10901                     for(i=0; i<len; i++) {
10902                         Pairing(i, nPlayers, &w, &b, &dummy);
10903                         if(w == changed || b == changed) appData.results[i] = ' '; // mark as not played
10904                     }
10905                 }
10906                 WriteTourneyFile(appData.results, f);
10907                 fclose(f); // release lock
10908                 return;
10909             }
10910         } else DisplayError(_("No engine with the name you gave is installed"), 0);
10911     }
10912     if(changes == 0) DisplayError(_("First change an engine by editing the participants list\nof the Tournament Options dialog"), 0);
10913     if(changes > 1)  DisplayError(_("You can only change one engine at the time"), 0);
10914     free(participants);
10915     return;
10916 }
10917
10918 int
10919 CheckPlayers (char *participants)
10920 {
10921         int i;
10922         char buf[MSG_SIZ], *p;
10923         NamesToList(firstChessProgramNames, command, mnemonic, "all");
10924         while(p = strchr(participants, '\n')) {
10925             *p = NULLCHAR;
10926             for(i=1; mnemonic[i]; i++) if(!strcmp(participants, mnemonic[i])) break;
10927             if(!mnemonic[i]) {
10928                 snprintf(buf, MSG_SIZ, _("No engine %s is installed"), participants);
10929                 *p = '\n';
10930                 DisplayError(buf, 0);
10931                 return 1;
10932             }
10933             *p = '\n';
10934             participants = p + 1;
10935         }
10936         return 0;
10937 }
10938
10939 int
10940 CreateTourney (char *name)
10941 {
10942         FILE *f;
10943         if(matchMode && strcmp(name, appData.tourneyFile)) {
10944              ASSIGN(name, appData.tourneyFile); //do not allow change of tourneyfile while playing
10945         }
10946         if(name[0] == NULLCHAR) {
10947             if(appData.participants[0])
10948                 DisplayError(_("You must supply a tournament file,\nfor storing the tourney progress"), 0);
10949             return 0;
10950         }
10951         f = fopen(name, "r");
10952         if(f) { // file exists
10953             ASSIGN(appData.tourneyFile, name);
10954             ParseArgsFromFile(f); // parse it
10955         } else {
10956             if(!appData.participants[0]) return 0; // ignore tourney file if non-existing & no participants
10957             if(CountPlayers(appData.participants) < (appData.tourneyType>0 ? appData.tourneyType+1 : 2)) {
10958                 DisplayError(_("Not enough participants"), 0);
10959                 return 0;
10960             }
10961             if(CheckPlayers(appData.participants)) return 0;
10962             ASSIGN(appData.tourneyFile, name);
10963             if(appData.tourneyType < 0) appData.defaultMatchGames = 1; // Swiss forces games/pairing = 1
10964             if((f = WriteTourneyFile("", NULL)) == NULL) return 0;
10965         }
10966         fclose(f);
10967         appData.noChessProgram = FALSE;
10968         appData.clockMode = TRUE;
10969         SetGNUMode();
10970         return 1;
10971 }
10972
10973 int
10974 NamesToList (char *names, char **engineList, char **engineMnemonic, char *group)
10975 {
10976     char buf[MSG_SIZ], *p, *q;
10977     int i=1, header, skip, all = !strcmp(group, "all"), depth = 0;
10978     insert = names; // afterwards, this global will point just after last retrieved engine line or group end in the 'names'
10979     skip = !all && group[0]; // if group requested, we start in skip mode
10980     for(;*names && depth >= 0 && i < MAXENGINES-1; names = p) {
10981         p = names; q = buf; header = 0;
10982         while(*p && *p != '\n') *q++ = *p++;
10983         *q = 0;
10984         if(*p == '\n') p++;
10985         if(buf[0] == '#') {
10986             if(strstr(buf, "# end") == buf) { if(!--depth) insert = p; continue; } // leave group, and suppress printing label
10987             depth++; // we must be entering a new group
10988             if(all) continue; // suppress printing group headers when complete list requested
10989             header = 1;
10990             if(skip && !strcmp(group, buf)) { depth = 0; skip = FALSE; } // start when we reach requested group
10991         }
10992         if(depth != header && !all || skip) continue; // skip contents of group (but print first-level header)
10993         if(engineList[i]) free(engineList[i]);
10994         engineList[i] = strdup(buf);
10995         if(buf[0] != '#') insert = p, TidyProgramName(engineList[i], "localhost", buf); // group headers not tidied
10996         if(engineMnemonic[i]) free(engineMnemonic[i]);
10997         if((q = strstr(engineList[i]+2, "variant")) && q[-2]== ' ' && (q[-1]=='/' || q[-1]=='-') && (q[7]==' ' || q[7]=='=')) {
10998             strcat(buf, " (");
10999             sscanf(q + 8, "%s", buf + strlen(buf));
11000             strcat(buf, ")");
11001         }
11002         engineMnemonic[i] = strdup(buf);
11003         i++;
11004     }
11005     engineList[i] = engineMnemonic[i] = NULL;
11006     return i;
11007 }
11008
11009 // following implemented as macro to avoid type limitations
11010 #define SWAP(item, temp) temp = appData.item[0]; appData.item[0] = appData.item[n]; appData.item[n] = temp;
11011
11012 void
11013 SwapEngines (int n)
11014 {   // swap settings for first engine and other engine (so far only some selected options)
11015     int h;
11016     char *p;
11017     if(n == 0) return;
11018     SWAP(directory, p)
11019     SWAP(chessProgram, p)
11020     SWAP(isUCI, h)
11021     SWAP(hasOwnBookUCI, h)
11022     SWAP(protocolVersion, h)
11023     SWAP(reuse, h)
11024     SWAP(scoreIsAbsolute, h)
11025     SWAP(timeOdds, h)
11026     SWAP(logo, p)
11027     SWAP(pgnName, p)
11028     SWAP(pvSAN, h)
11029     SWAP(engOptions, p)
11030     SWAP(engInitString, p)
11031     SWAP(computerString, p)
11032     SWAP(features, p)
11033     SWAP(fenOverride, p)
11034     SWAP(NPS, h)
11035     SWAP(accumulateTC, h)
11036     SWAP(drawDepth, h)
11037     SWAP(host, p)
11038     SWAP(pseudo, h)
11039 }
11040
11041 int
11042 GetEngineLine (char *s, int n)
11043 {
11044     int i;
11045     char buf[MSG_SIZ];
11046     extern char *icsNames;
11047     if(!s || !*s) return 0;
11048     NamesToList(n >= 10 ? icsNames : firstChessProgramNames, command, mnemonic, "all");
11049     for(i=1; mnemonic[i]; i++) if(!strcmp(s, mnemonic[i])) break;
11050     if(!mnemonic[i]) return 0;
11051     if(n == 11) return 1; // just testing if there was a match
11052     snprintf(buf, MSG_SIZ, "-%s %s", n == 10 ? "icshost" : "fcp", command[i]);
11053     if(n == 1) SwapEngines(n);
11054     ParseArgsFromString(buf);
11055     if(n == 1) SwapEngines(n);
11056     if(n == 0 && *appData.secondChessProgram == NULLCHAR) {
11057         SwapEngines(1); // set second same as first if not yet set (to suppress WB startup dialog)
11058         ParseArgsFromString(buf);
11059     }
11060     return 1;
11061 }
11062
11063 int
11064 SetPlayer (int player, char *p)
11065 {   // [HGM] find the engine line of the partcipant given by number, and parse its options.
11066     int i;
11067     char buf[MSG_SIZ], *engineName;
11068     for(i=0; i<player; i++) p = strchr(p, '\n') + 1;
11069     engineName = strdup(p); if(p = strchr(engineName, '\n')) *p = NULLCHAR;
11070     for(i=1; command[i]; i++) if(!strcmp(mnemonic[i], engineName)) break;
11071     if(mnemonic[i]) {
11072         snprintf(buf, MSG_SIZ, "-fcp %s", command[i]);
11073         ParseArgsFromString(resetOptions); appData.fenOverride[0] = NULL; appData.pvSAN[0] = FALSE;
11074         appData.firstHasOwnBookUCI = !appData.defNoBook; appData.protocolVersion[0] = PROTOVER;
11075         ParseArgsFromString(buf);
11076     } else { // no engine with this nickname is installed!
11077         snprintf(buf, MSG_SIZ, _("No engine %s is installed"), engineName);
11078         ReserveGame(nextGame, ' '); // unreserve game and drop out of match mode with error
11079         matchMode = FALSE; appData.matchGames = matchGame = roundNr = 0;
11080         ModeHighlight();
11081         DisplayError(buf, 0);
11082         return 0;
11083     }
11084     free(engineName);
11085     return i;
11086 }
11087
11088 char *recentEngines;
11089
11090 void
11091 RecentEngineEvent (int nr)
11092 {
11093     int n;
11094 //    SwapEngines(1); // bump first to second
11095 //    ReplaceEngine(&second, 1); // and load it there
11096     NamesToList(firstChessProgramNames, command, mnemonic, "all"); // get mnemonics of installed engines
11097     n = SetPlayer(nr, recentEngines); // select new (using original menu order!)
11098     if(mnemonic[n]) { // if somehow the engine with the selected nickname is no longer found in the list, we skip
11099         ReplaceEngine(&first, 0);
11100         FloatToFront(&appData.recentEngineList, command[n]);
11101     }
11102 }
11103
11104 int
11105 Pairing (int nr, int nPlayers, int *whitePlayer, int *blackPlayer, int *syncInterval)
11106 {   // determine players from game number
11107     int curCycle, curRound, curPairing, gamesPerCycle, gamesPerRound, roundsPerCycle=1, pairingsPerRound=1;
11108
11109     if(appData.tourneyType == 0) {
11110         roundsPerCycle = (nPlayers - 1) | 1;
11111         pairingsPerRound = nPlayers / 2;
11112     } else if(appData.tourneyType > 0) {
11113         roundsPerCycle = nPlayers - appData.tourneyType;
11114         pairingsPerRound = appData.tourneyType;
11115     }
11116     gamesPerRound = pairingsPerRound * appData.defaultMatchGames;
11117     gamesPerCycle = gamesPerRound * roundsPerCycle;
11118     appData.matchGames = gamesPerCycle * appData.tourneyCycles - 1; // fake like all games are one big match
11119     curCycle = nr / gamesPerCycle; nr %= gamesPerCycle;
11120     curRound = nr / gamesPerRound; nr %= gamesPerRound;
11121     curPairing = nr / appData.defaultMatchGames; nr %= appData.defaultMatchGames;
11122     matchGame = nr + curCycle * appData.defaultMatchGames + 1; // fake game nr that loads correct game or position from file
11123     roundNr = (curCycle * roundsPerCycle + curRound) * appData.defaultMatchGames + nr + 1;
11124
11125     if(appData.cycleSync) *syncInterval = gamesPerCycle;
11126     if(appData.roundSync) *syncInterval = gamesPerRound;
11127
11128     if(appData.debugMode) fprintf(debugFP, "cycle=%d, round=%d, pairing=%d curGame=%d\n", curCycle, curRound, curPairing, matchGame);
11129
11130     if(appData.tourneyType == 0) {
11131         if(curPairing == (nPlayers-1)/2 ) {
11132             *whitePlayer = curRound;
11133             *blackPlayer = nPlayers - 1; // this is the 'bye' when nPlayer is odd
11134         } else {
11135             *whitePlayer = curRound - (nPlayers-1)/2 + curPairing;
11136             if(*whitePlayer < 0) *whitePlayer += nPlayers-1+(nPlayers&1);
11137             *blackPlayer = curRound + (nPlayers-1)/2 - curPairing;
11138             if(*blackPlayer >= nPlayers-1+(nPlayers&1)) *blackPlayer -= nPlayers-1+(nPlayers&1);
11139         }
11140     } else if(appData.tourneyType > 1) {
11141         *blackPlayer = curPairing; // in multi-gauntlet, assign gauntlet engines to second, so first an be kept loaded during round
11142         *whitePlayer = curRound + appData.tourneyType;
11143     } else if(appData.tourneyType > 0) {
11144         *whitePlayer = curPairing;
11145         *blackPlayer = curRound + appData.tourneyType;
11146     }
11147
11148     // take care of white/black alternation per round.
11149     // For cycles and games this is already taken care of by default, derived from matchGame!
11150     return curRound & 1;
11151 }
11152
11153 int
11154 NextTourneyGame (int nr, int *swapColors)
11155 {   // !!!major kludge!!! fiddle appData settings to get everything in order for next tourney game
11156     char *p, *q;
11157     int whitePlayer, blackPlayer, firstBusy=1000000000, syncInterval = 0, nPlayers, OK = 1;
11158     FILE *tf;
11159     if(appData.tourneyFile[0] == NULLCHAR) return 1; // no tourney, always allow next game
11160     tf = fopen(appData.tourneyFile, "r");
11161     if(tf == NULL) { DisplayFatalError(_("Bad tournament file"), 0, 1); return 0; }
11162     ParseArgsFromFile(tf); fclose(tf);
11163     InitTimeControls(); // TC might be altered from tourney file
11164
11165     nPlayers = CountPlayers(appData.participants); // count participants
11166     if(appData.tourneyType < 0) syncInterval = nPlayers/2; else
11167     *swapColors = Pairing(nr<0 ? 0 : nr, nPlayers, &whitePlayer, &blackPlayer, &syncInterval);
11168
11169     if(syncInterval) {
11170         p = q = appData.results;
11171         while(*q) if(*q++ == '*' || q[-1] == ' ') { firstBusy = q - p - 1; break; }
11172         if(firstBusy/syncInterval < (nextGame/syncInterval)) {
11173             DisplayMessage(_("Waiting for other game(s)"),"");
11174             waitingForGame = TRUE;
11175             ScheduleDelayedEvent(NextMatchGame, 1000); // wait for all games of previous round to finish
11176             return 0;
11177         }
11178         waitingForGame = FALSE;
11179     }
11180
11181     if(appData.tourneyType < 0) {
11182         if(nr>=0 && !pairingReceived) {
11183             char buf[1<<16];
11184             if(pairing.pr == NoProc) {
11185                 if(!appData.pairingEngine[0]) {
11186                     DisplayFatalError(_("No pairing engine specified"), 0, 1);
11187                     return 0;
11188                 }
11189                 StartChessProgram(&pairing); // starts the pairing engine
11190             }
11191             snprintf(buf, 1<<16, "results %d %s\n", nPlayers, appData.results);
11192             SendToProgram(buf, &pairing);
11193             snprintf(buf, 1<<16, "pairing %d\n", nr+1);
11194             SendToProgram(buf, &pairing);
11195             return 0; // wait for pairing engine to answer (which causes NextTourneyGame to be called again...
11196         }
11197         pairingReceived = 0;                              // ... so we continue here
11198         *swapColors = 0;
11199         appData.matchGames = appData.tourneyCycles * syncInterval - 1;
11200         whitePlayer = savedWhitePlayer-1; blackPlayer = savedBlackPlayer-1;
11201         matchGame = 1; roundNr = nr / syncInterval + 1;
11202     }
11203
11204     if(first.pr != NoProc && second.pr != NoProc || nr<0) return 1; // engines already loaded
11205
11206     // redefine engines, engine dir, etc.
11207     NamesToList(firstChessProgramNames, command, mnemonic, "all"); // get mnemonics of installed engines
11208     if(first.pr == NoProc) {
11209       if(!SetPlayer(whitePlayer, appData.participants)) OK = 0; // find white player amongst it, and parse its engine line
11210       InitEngine(&first, 0);  // initialize ChessProgramStates based on new settings.
11211     }
11212     if(second.pr == NoProc) {
11213       SwapEngines(1);
11214       if(!SetPlayer(blackPlayer, appData.participants)) OK = 0; // find black player amongst it, and parse its engine line
11215       SwapEngines(1);         // and make that valid for second engine by swapping
11216       InitEngine(&second, 1);
11217     }
11218     CommonEngineInit();     // after this TwoMachinesEvent will create correct engine processes
11219     UpdateLogos(FALSE);     // leave display to ModeHiglight()
11220     return OK;
11221 }
11222
11223 void
11224 NextMatchGame ()
11225 {   // performs game initialization that does not invoke engines, and then tries to start the game
11226     int res, firstWhite, swapColors = 0;
11227     if(!NextTourneyGame(nextGame, &swapColors)) return; // this sets matchGame, -fcp / -scp and other options for next game, if needed
11228     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
11229         char buf[MSG_SIZ];
11230         snprintf(buf, MSG_SIZ, appData.nameOfDebugFile, nextGame+1); // expand name of debug file with %d in it
11231         if(strcmp(buf, currentDebugFile)) { // name has changed
11232             FILE *f = fopen(buf, "w");
11233             if(f) { // if opening the new file failed, just keep using the old one
11234                 ASSIGN(currentDebugFile, buf);
11235                 fclose(debugFP);
11236                 debugFP = f;
11237             }
11238             if(appData.serverFileName) {
11239                 if(serverFP) fclose(serverFP);
11240                 serverFP = fopen(appData.serverFileName, "w");
11241                 if(serverFP && first.pr != NoProc) fprintf(serverFP, "StartChildProcess (dir=\".\") .\\%s\n", first.tidy);
11242                 if(serverFP && second.pr != NoProc) fprintf(serverFP, "StartChildProcess (dir=\".\") .\\%s\n", second.tidy);
11243             }
11244         }
11245     }
11246     firstWhite = appData.firstPlaysBlack ^ (matchGame & 1 | appData.sameColorGames > 1); // non-incremental default
11247     firstWhite ^= swapColors; // reverses if NextTourneyGame says we are in an odd round
11248     first.twoMachinesColor =  firstWhite ? "white\n" : "black\n";   // perform actual color assignement
11249     second.twoMachinesColor = firstWhite ? "black\n" : "white\n";
11250     appData.noChessProgram = (first.pr == NoProc); // kludge to prevent Reset from starting up chess program
11251     if(appData.loadGameIndex == -2) srandom(appData.seedBase + 68163*(nextGame & ~1)); // deterministic seed to force same opening
11252     Reset(FALSE, first.pr != NoProc);
11253     res = LoadGameOrPosition(matchGame); // setup game
11254     appData.noChessProgram = FALSE; // LoadGameOrPosition might call Reset too!
11255     if(!res) return; // abort when bad game/pos file
11256     TwoMachinesEvent();
11257 }
11258
11259 void
11260 UserAdjudicationEvent (int result)
11261 {
11262     ChessMove gameResult = GameIsDrawn;
11263
11264     if( result > 0 ) {
11265         gameResult = WhiteWins;
11266     }
11267     else if( result < 0 ) {
11268         gameResult = BlackWins;
11269     }
11270
11271     if( gameMode == TwoMachinesPlay ) {
11272         GameEnds( gameResult, "User adjudication", GE_XBOARD );
11273     }
11274 }
11275
11276
11277 // [HGM] save: calculate checksum of game to make games easily identifiable
11278 int
11279 StringCheckSum (char *s)
11280 {
11281         int i = 0;
11282         if(s==NULL) return 0;
11283         while(*s) i = i*259 + *s++;
11284         return i;
11285 }
11286
11287 int
11288 GameCheckSum ()
11289 {
11290         int i, sum=0;
11291         for(i=backwardMostMove; i<forwardMostMove; i++) {
11292                 sum += pvInfoList[i].depth;
11293                 sum += StringCheckSum(parseList[i]);
11294                 sum += StringCheckSum(commentList[i]);
11295                 sum *= 261;
11296         }
11297         if(i>1 && sum==0) sum++; // make sure never zero for non-empty game
11298         return sum + StringCheckSum(commentList[i]);
11299 } // end of save patch
11300
11301 void
11302 GameEnds (ChessMove result, char *resultDetails, int whosays)
11303 {
11304     GameMode nextGameMode;
11305     int isIcsGame;
11306     char buf[MSG_SIZ], popupRequested = 0, *ranking = NULL;
11307
11308     if(endingGame) return; /* [HGM] crash: forbid recursion */
11309     endingGame = 1;
11310     if(twoBoards) { // [HGM] dual: switch back to one board
11311         twoBoards = partnerUp = 0; InitDrawingSizes(-2, 0);
11312         DrawPosition(TRUE, partnerBoard); // observed game becomes foreground
11313     }
11314     if (appData.debugMode) {
11315       fprintf(debugFP, "GameEnds(%d, %s, %d)\n",
11316               result, resultDetails ? resultDetails : "(null)", whosays);
11317     }
11318
11319     fromX = fromY = killX = killY = -1; // [HGM] abort any move the user is entering. // [HGM] lion
11320
11321     if(pausing) PauseEvent(); // can happen when we abort a paused game (New Game or Quit)
11322
11323     if (appData.icsActive && (whosays == GE_ENGINE || whosays >= GE_ENGINE1)) {
11324         /* If we are playing on ICS, the server decides when the
11325            game is over, but the engine can offer to draw, claim
11326            a draw, or resign.
11327          */
11328 #if ZIPPY
11329         if (appData.zippyPlay && first.initDone) {
11330             if (result == GameIsDrawn) {
11331                 /* In case draw still needs to be claimed */
11332                 SendToICS(ics_prefix);
11333                 SendToICS("draw\n");
11334             } else if (StrCaseStr(resultDetails, "resign")) {
11335                 SendToICS(ics_prefix);
11336                 SendToICS("resign\n");
11337             }
11338         }
11339 #endif
11340         endingGame = 0; /* [HGM] crash */
11341         return;
11342     }
11343
11344     /* If we're loading the game from a file, stop */
11345     if (whosays == GE_FILE) {
11346       (void) StopLoadGameTimer();
11347       gameFileFP = NULL;
11348     }
11349
11350     /* Cancel draw offers */
11351     first.offeredDraw = second.offeredDraw = 0;
11352
11353     /* If this is an ICS game, only ICS can really say it's done;
11354        if not, anyone can. */
11355     isIcsGame = (gameMode == IcsPlayingWhite ||
11356                  gameMode == IcsPlayingBlack ||
11357                  gameMode == IcsObserving    ||
11358                  gameMode == IcsExamining);
11359
11360     if (!isIcsGame || whosays == GE_ICS) {
11361         /* OK -- not an ICS game, or ICS said it was done */
11362         StopClocks();
11363         if (!isIcsGame && !appData.noChessProgram)
11364           SetUserThinkingEnables();
11365
11366         /* [HGM] if a machine claims the game end we verify this claim */
11367         if(gameMode == TwoMachinesPlay && appData.testClaims) {
11368             if(appData.testLegality && whosays >= GE_ENGINE1 ) {
11369                 char claimer;
11370                 ChessMove trueResult = (ChessMove) -1;
11371
11372                 claimer = whosays == GE_ENGINE1 ?      /* color of claimer */
11373                                             first.twoMachinesColor[0] :
11374                                             second.twoMachinesColor[0] ;
11375
11376                 // [HGM] losers: because the logic is becoming a bit hairy, determine true result first
11377                 if((signed char)boards[forwardMostMove][EP_STATUS] == EP_CHECKMATE) {
11378                     /* [HGM] verify: engine mate claims accepted if they were flagged */
11379                     trueResult = WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins;
11380                 } else
11381                 if((signed char)boards[forwardMostMove][EP_STATUS] == EP_WINS) { // added code for games where being mated is a win
11382                     /* [HGM] verify: engine mate claims accepted if they were flagged */
11383                     trueResult = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
11384                 } else
11385                 if((signed char)boards[forwardMostMove][EP_STATUS] == EP_STALEMATE) { // only used to indicate draws now
11386                     trueResult = GameIsDrawn; // default; in variants where stalemate loses, Status is CHECKMATE
11387                 }
11388
11389                 // now verify win claims, but not in drop games, as we don't understand those yet
11390                 if( (gameInfo.holdingsWidth == 0 || gameInfo.variant == VariantSuper
11391                                                  || gameInfo.variant == VariantGreat || gameInfo.variant == VariantGrand) &&
11392                     (result == WhiteWins && claimer == 'w' ||
11393                      result == BlackWins && claimer == 'b'   ) ) { // case to verify: engine claims own win
11394                       if (appData.debugMode) {
11395                         fprintf(debugFP, "result=%d sp=%d move=%d\n",
11396                                 result, (signed char)boards[forwardMostMove][EP_STATUS], forwardMostMove);
11397                       }
11398                       if(result != trueResult) {
11399                         snprintf(buf, MSG_SIZ, "False win claim: '%s'", resultDetails);
11400                               result = claimer == 'w' ? BlackWins : WhiteWins;
11401                               resultDetails = buf;
11402                       }
11403                 } else
11404                 if( result == GameIsDrawn && (signed char)boards[forwardMostMove][EP_STATUS] > EP_DRAWS
11405                     && (forwardMostMove <= backwardMostMove ||
11406                         (signed char)boards[forwardMostMove-1][EP_STATUS] > EP_DRAWS ||
11407                         (claimer=='b')==(forwardMostMove&1))
11408                                                                                   ) {
11409                       /* [HGM] verify: draws that were not flagged are false claims */
11410                   snprintf(buf, MSG_SIZ, "False draw claim: '%s'", resultDetails);
11411                       result = claimer == 'w' ? BlackWins : WhiteWins;
11412                       resultDetails = buf;
11413                 }
11414                 /* (Claiming a loss is accepted no questions asked!) */
11415             } else if(matchMode && result == GameIsDrawn && !strcmp(resultDetails, "Engine Abort Request")) {
11416                 forwardMostMove = backwardMostMove; // [HGM] delete game to surpress saving
11417                 result = GameUnfinished;
11418                 if(!*appData.tourneyFile) matchGame--; // replay even in plain match
11419             }
11420             /* [HGM] bare: don't allow bare King to win */
11421             if((gameInfo.holdingsWidth == 0 || gameInfo.variant == VariantSuper
11422                                             || gameInfo.variant == VariantGreat || gameInfo.variant == VariantGrand)
11423                && gameInfo.variant != VariantLosers && gameInfo.variant != VariantGiveaway
11424                && gameInfo.variant != VariantSuicide // [HGM] losers: except in losers, of course...
11425                && result != GameIsDrawn)
11426             {   int i, j, k=0, oppoKings = 0, color = (result==WhiteWins ? (int)WhitePawn : (int)BlackPawn);
11427                 for(j=BOARD_LEFT; j<BOARD_RGHT; j++) for(i=0; i<BOARD_HEIGHT; i++) {
11428                         int p = (signed char)boards[forwardMostMove][i][j] - color;
11429                         if(p >= 0 && p <= (int)WhiteKing) k++;
11430                         oppoKings += (p + color == WhiteKing + BlackPawn - color);
11431                 }
11432                 if (appData.debugMode) {
11433                      fprintf(debugFP, "GE(%d, %s, %d) bare king k=%d color=%d\n",
11434                         result, resultDetails ? resultDetails : "(null)", whosays, k, color);
11435                 }
11436                 if(k <= 1 && oppoKings > 0) { // the latter needed in Atomic, where bare K wins if opponent King already destroyed
11437                         result = GameIsDrawn;
11438                         snprintf(buf, MSG_SIZ, "%s but bare king", resultDetails);
11439                         resultDetails = buf;
11440                 }
11441             }
11442         }
11443
11444
11445         if(serverMoves != NULL && !loadFlag) { char c = '=';
11446             if(result==WhiteWins) c = '+';
11447             if(result==BlackWins) c = '-';
11448             if(resultDetails != NULL)
11449                 fprintf(serverMoves, ";%c;%s\n", c, resultDetails), fflush(serverMoves);
11450         }
11451         if (resultDetails != NULL) {
11452             gameInfo.result = result;
11453             gameInfo.resultDetails = StrSave(resultDetails);
11454
11455             /* display last move only if game was not loaded from file */
11456             if ((whosays != GE_FILE) && (currentMove == forwardMostMove))
11457                 DisplayMove(currentMove - 1);
11458
11459             if (forwardMostMove != 0) {
11460                 if (gameMode != PlayFromGameFile && gameMode != EditGame
11461                     && lastSavedGame != GameCheckSum() // [HGM] save: suppress duplicates
11462                                                                 ) {
11463                     if (*appData.saveGameFile != NULLCHAR) {
11464                         if(result == GameUnfinished && matchMode && *appData.tourneyFile)
11465                             AutoSaveGame(); // [HGM] protect tourney PGN from aborted games, and prompt for name instead
11466                         else
11467                         SaveGameToFile(appData.saveGameFile, TRUE);
11468                     } else if (appData.autoSaveGames) {
11469                         if(gameMode != IcsObserving || !appData.onlyOwn) AutoSaveGame();
11470                     }
11471                     if (*appData.savePositionFile != NULLCHAR) {
11472                         SavePositionToFile(appData.savePositionFile);
11473                     }
11474                     AddGameToBook(FALSE); // Only does something during Monte-Carlo book building
11475                 }
11476             }
11477
11478             /* Tell program how game ended in case it is learning */
11479             /* [HGM] Moved this to after saving the PGN, just in case */
11480             /* engine died and we got here through time loss. In that */
11481             /* case we will get a fatal error writing the pipe, which */
11482             /* would otherwise lose us the PGN.                       */
11483             /* [HGM] crash: not needed anymore, but doesn't hurt;     */
11484             /* output during GameEnds should never be fatal anymore   */
11485             if (gameMode == MachinePlaysWhite ||
11486                 gameMode == MachinePlaysBlack ||
11487                 gameMode == TwoMachinesPlay ||
11488                 gameMode == IcsPlayingWhite ||
11489                 gameMode == IcsPlayingBlack ||
11490                 gameMode == BeginningOfGame) {
11491                 char buf[MSG_SIZ];
11492                 snprintf(buf, MSG_SIZ, "result %s {%s}\n", PGNResult(result),
11493                         resultDetails);
11494                 if (first.pr != NoProc) {
11495                     SendToProgram(buf, &first);
11496                 }
11497                 if (second.pr != NoProc &&
11498                     gameMode == TwoMachinesPlay) {
11499                     SendToProgram(buf, &second);
11500                 }
11501             }
11502         }
11503
11504         if (appData.icsActive) {
11505             if (appData.quietPlay &&
11506                 (gameMode == IcsPlayingWhite ||
11507                  gameMode == IcsPlayingBlack)) {
11508                 SendToICS(ics_prefix);
11509                 SendToICS("set shout 1\n");
11510             }
11511             nextGameMode = IcsIdle;
11512             ics_user_moved = FALSE;
11513             /* clean up premove.  It's ugly when the game has ended and the
11514              * premove highlights are still on the board.
11515              */
11516             if (gotPremove) {
11517               gotPremove = FALSE;
11518               ClearPremoveHighlights();
11519               DrawPosition(FALSE, boards[currentMove]);
11520             }
11521             if (whosays == GE_ICS) {
11522                 switch (result) {
11523                 case WhiteWins:
11524                     if (gameMode == IcsPlayingWhite)
11525                         PlayIcsWinSound();
11526                     else if(gameMode == IcsPlayingBlack)
11527                         PlayIcsLossSound();
11528                     break;
11529                 case BlackWins:
11530                     if (gameMode == IcsPlayingBlack)
11531                         PlayIcsWinSound();
11532                     else if(gameMode == IcsPlayingWhite)
11533                         PlayIcsLossSound();
11534                     break;
11535                 case GameIsDrawn:
11536                     PlayIcsDrawSound();
11537                     break;
11538                 default:
11539                     PlayIcsUnfinishedSound();
11540                 }
11541             }
11542             if(appData.quitNext) { ExitEvent(0); return; }
11543         } else if (gameMode == EditGame ||
11544                    gameMode == PlayFromGameFile ||
11545                    gameMode == AnalyzeMode ||
11546                    gameMode == AnalyzeFile) {
11547             nextGameMode = gameMode;
11548         } else {
11549             nextGameMode = EndOfGame;
11550         }
11551         pausing = FALSE;
11552         ModeHighlight();
11553     } else {
11554         nextGameMode = gameMode;
11555     }
11556
11557     if (appData.noChessProgram) {
11558         gameMode = nextGameMode;
11559         ModeHighlight();
11560         endingGame = 0; /* [HGM] crash */
11561         return;
11562     }
11563
11564     if (first.reuse) {
11565         /* Put first chess program into idle state */
11566         if (first.pr != NoProc &&
11567             (gameMode == MachinePlaysWhite ||
11568              gameMode == MachinePlaysBlack ||
11569              gameMode == TwoMachinesPlay ||
11570              gameMode == IcsPlayingWhite ||
11571              gameMode == IcsPlayingBlack ||
11572              gameMode == BeginningOfGame)) {
11573             SendToProgram("force\n", &first);
11574             if (first.usePing) {
11575               char buf[MSG_SIZ];
11576               snprintf(buf, MSG_SIZ, "ping %d\n", ++first.lastPing);
11577               SendToProgram(buf, &first);
11578             }
11579         }
11580     } else if (result != GameUnfinished || nextGameMode == IcsIdle) {
11581         /* Kill off first chess program */
11582         if (first.isr != NULL)
11583           RemoveInputSource(first.isr);
11584         first.isr = NULL;
11585
11586         if (first.pr != NoProc) {
11587             ExitAnalyzeMode();
11588             DoSleep( appData.delayBeforeQuit );
11589             SendToProgram("quit\n", &first);
11590             DestroyChildProcess(first.pr, 4 + first.useSigterm);
11591             first.reload = TRUE;
11592         }
11593         first.pr = NoProc;
11594     }
11595     if (second.reuse) {
11596         /* Put second chess program into idle state */
11597         if (second.pr != NoProc &&
11598             gameMode == TwoMachinesPlay) {
11599             SendToProgram("force\n", &second);
11600             if (second.usePing) {
11601               char buf[MSG_SIZ];
11602               snprintf(buf, MSG_SIZ, "ping %d\n", ++second.lastPing);
11603               SendToProgram(buf, &second);
11604             }
11605         }
11606     } else if (result != GameUnfinished || nextGameMode == IcsIdle) {
11607         /* Kill off second chess program */
11608         if (second.isr != NULL)
11609           RemoveInputSource(second.isr);
11610         second.isr = NULL;
11611
11612         if (second.pr != NoProc) {
11613             DoSleep( appData.delayBeforeQuit );
11614             SendToProgram("quit\n", &second);
11615             DestroyChildProcess(second.pr, 4 + second.useSigterm);
11616             second.reload = TRUE;
11617         }
11618         second.pr = NoProc;
11619     }
11620
11621     if (matchMode && (gameMode == TwoMachinesPlay || (waitingForGame || startingEngine) && exiting)) {
11622         char resChar = '=';
11623         switch (result) {
11624         case WhiteWins:
11625           resChar = '+';
11626           if (first.twoMachinesColor[0] == 'w') {
11627             first.matchWins++;
11628           } else {
11629             second.matchWins++;
11630           }
11631           break;
11632         case BlackWins:
11633           resChar = '-';
11634           if (first.twoMachinesColor[0] == 'b') {
11635             first.matchWins++;
11636           } else {
11637             second.matchWins++;
11638           }
11639           break;
11640         case GameUnfinished:
11641           resChar = ' ';
11642         default:
11643           break;
11644         }
11645
11646         if(exiting) resChar = ' '; // quit while waiting for round sync: unreserve already reserved game
11647         if(appData.tourneyFile[0]){ // [HGM] we are in a tourney; update tourney file with game result
11648             if(appData.afterGame && appData.afterGame[0]) RunCommand(appData.afterGame);
11649             ReserveGame(nextGame, resChar); // sets nextGame
11650             if(nextGame > appData.matchGames) appData.tourneyFile[0] = 0, ranking = TourneyStandings(3); // tourney is done
11651             else ranking = strdup("busy"); //suppress popup when aborted but not finished
11652         } else roundNr = nextGame = matchGame + 1; // normal match, just increment; round equals matchGame
11653
11654         if (nextGame <= appData.matchGames && !abortMatch) {
11655             gameMode = nextGameMode;
11656             matchGame = nextGame; // this will be overruled in tourney mode!
11657             GetTimeMark(&pauseStart); // [HGM] matchpause: stipulate a pause
11658             ScheduleDelayedEvent(NextMatchGame, 10); // but start game immediately (as it will wait out the pause itself)
11659             endingGame = 0; /* [HGM] crash */
11660             return;
11661         } else {
11662             gameMode = nextGameMode;
11663             snprintf(buf, MSG_SIZ, _("Match %s vs. %s: final score %d-%d-%d"),
11664                      first.tidy, second.tidy,
11665                      first.matchWins, second.matchWins,
11666                      appData.matchGames - (first.matchWins + second.matchWins));
11667             if(!appData.tourneyFile[0]) matchGame++, DisplayTwoMachinesTitle(); // [HGM] update result in window title
11668             if(ranking && strcmp(ranking, "busy") && appData.afterTourney && appData.afterTourney[0]) RunCommand(appData.afterTourney);
11669             popupRequested++; // [HGM] crash: postpone to after resetting endingGame
11670             if (appData.firstPlaysBlack) { // [HGM] match: back to original for next match
11671                 first.twoMachinesColor = "black\n";
11672                 second.twoMachinesColor = "white\n";
11673             } else {
11674                 first.twoMachinesColor = "white\n";
11675                 second.twoMachinesColor = "black\n";
11676             }
11677         }
11678     }
11679     if ((gameMode == AnalyzeMode || gameMode == AnalyzeFile) &&
11680         !(nextGameMode == AnalyzeMode || nextGameMode == AnalyzeFile))
11681       ExitAnalyzeMode();
11682     gameMode = nextGameMode;
11683     ModeHighlight();
11684     endingGame = 0;  /* [HGM] crash */
11685     if(popupRequested) { // [HGM] crash: this calls GameEnds recursively through ExitEvent! Make it a harmless tail recursion.
11686         if(matchMode == TRUE) { // match through command line: exit with or without popup
11687             if(ranking) {
11688                 ToNrEvent(forwardMostMove);
11689                 if(strcmp(ranking, "busy")) DisplayFatalError(ranking, 0, 0);
11690                 else ExitEvent(0);
11691             } else DisplayFatalError(buf, 0, 0);
11692         } else { // match through menu; just stop, with or without popup
11693             matchMode = FALSE; appData.matchGames = matchGame = roundNr = 0;
11694             ModeHighlight();
11695             if(ranking){
11696                 if(strcmp(ranking, "busy")) DisplayNote(ranking);
11697             } else DisplayNote(buf);
11698       }
11699       if(ranking) free(ranking);
11700     }
11701 }
11702
11703 /* Assumes program was just initialized (initString sent).
11704    Leaves program in force mode. */
11705 void
11706 FeedMovesToProgram (ChessProgramState *cps, int upto)
11707 {
11708     int i;
11709
11710     if (appData.debugMode)
11711       fprintf(debugFP, "Feeding %smoves %d through %d to %s chess program\n",
11712               startedFromSetupPosition ? "position and " : "",
11713               backwardMostMove, upto, cps->which);
11714     if(currentlyInitializedVariant != gameInfo.variant) {
11715       char buf[MSG_SIZ];
11716         // [HGM] variantswitch: make engine aware of new variant
11717         if(!SupportedVariant(cps->variants, gameInfo.variant, gameInfo.boardWidth,
11718                              gameInfo.boardHeight, gameInfo.holdingsSize, cps->protocolVersion, ""))
11719                 return; // [HGM] refrain from feeding moves altogether if variant is unsupported!
11720         snprintf(buf, MSG_SIZ, "variant %s\n", VariantName(gameInfo.variant));
11721         SendToProgram(buf, cps);
11722         currentlyInitializedVariant = gameInfo.variant;
11723     }
11724     SendToProgram("force\n", cps);
11725     if (startedFromSetupPosition) {
11726         SendBoard(cps, backwardMostMove);
11727     if (appData.debugMode) {
11728         fprintf(debugFP, "feedMoves\n");
11729     }
11730     }
11731     for (i = backwardMostMove; i < upto; i++) {
11732         SendMoveToProgram(i, cps);
11733     }
11734 }
11735
11736
11737 int
11738 ResurrectChessProgram ()
11739 {
11740      /* The chess program may have exited.
11741         If so, restart it and feed it all the moves made so far. */
11742     static int doInit = 0;
11743
11744     if (appData.noChessProgram) return 1;
11745
11746     if(matchMode /*&& appData.tourneyFile[0]*/) { // [HGM] tourney: make sure we get features after engine replacement. (Should we always do this?)
11747         if(WaitForEngine(&first, TwoMachinesEventIfReady)) { doInit = 1; return 0; } // request to do init on next visit, because we started engine
11748         if(!doInit) return 1; // this replaces testing first.pr != NoProc, which is true when we get here, but first time no reason to abort
11749         doInit = 0; // we fell through (first time after starting the engine); make sure it doesn't happen again
11750     } else {
11751         if (first.pr != NoProc) return 1;
11752         StartChessProgram(&first);
11753     }
11754     InitChessProgram(&first, FALSE);
11755     FeedMovesToProgram(&first, currentMove);
11756
11757     if (!first.sendTime) {
11758         /* can't tell gnuchess what its clock should read,
11759            so we bow to its notion. */
11760         ResetClocks();
11761         timeRemaining[0][currentMove] = whiteTimeRemaining;
11762         timeRemaining[1][currentMove] = blackTimeRemaining;
11763     }
11764
11765     if ((gameMode == AnalyzeMode || gameMode == AnalyzeFile ||
11766                 appData.icsEngineAnalyze) && first.analysisSupport) {
11767       SendToProgram("analyze\n", &first);
11768       first.analyzing = TRUE;
11769     }
11770     return 1;
11771 }
11772
11773 /*
11774  * Button procedures
11775  */
11776 void
11777 Reset (int redraw, int init)
11778 {
11779     int i;
11780
11781     if (appData.debugMode) {
11782         fprintf(debugFP, "Reset(%d, %d) from gameMode %d\n",
11783                 redraw, init, gameMode);
11784     }
11785     pieceDefs = FALSE; // [HGM] gen: reset engine-defined piece moves
11786     for(i=0; i<EmptySquare; i++) { FREE(pieceDesc[i]); pieceDesc[i] = NULL; }
11787     CleanupTail(); // [HGM] vari: delete any stored variations
11788     CommentPopDown(); // [HGM] make sure no comments to the previous game keep hanging on
11789     pausing = pauseExamInvalid = FALSE;
11790     startedFromSetupPosition = blackPlaysFirst = FALSE;
11791     firstMove = TRUE;
11792     whiteFlag = blackFlag = FALSE;
11793     userOfferedDraw = FALSE;
11794     hintRequested = bookRequested = FALSE;
11795     first.maybeThinking = FALSE;
11796     second.maybeThinking = FALSE;
11797     first.bookSuspend = FALSE; // [HGM] book
11798     second.bookSuspend = FALSE;
11799     thinkOutput[0] = NULLCHAR;
11800     lastHint[0] = NULLCHAR;
11801     ClearGameInfo(&gameInfo);
11802     gameInfo.variant = StringToVariant(appData.variant);
11803     if(gameInfo.variant == VariantNormal && strcmp(appData.variant, "normal")) gameInfo.variant = VariantUnknown;
11804     ics_user_moved = ics_clock_paused = FALSE;
11805     ics_getting_history = H_FALSE;
11806     ics_gamenum = -1;
11807     white_holding[0] = black_holding[0] = NULLCHAR;
11808     ClearProgramStats();
11809     opponentKibitzes = FALSE; // [HGM] kibitz: do not reserve space in engine-output window in zippy mode
11810
11811     ResetFrontEnd();
11812     ClearHighlights();
11813     flipView = appData.flipView;
11814     ClearPremoveHighlights();
11815     gotPremove = FALSE;
11816     alarmSounded = FALSE;
11817     killX = killY = -1; // [HGM] lion
11818
11819     GameEnds(EndOfFile, NULL, GE_PLAYER);
11820     if(appData.serverMovesName != NULL) {
11821         /* [HGM] prepare to make moves file for broadcasting */
11822         clock_t t = clock();
11823         if(serverMoves != NULL) fclose(serverMoves);
11824         serverMoves = fopen(appData.serverMovesName, "r");
11825         if(serverMoves != NULL) {
11826             fclose(serverMoves);
11827             /* delay 15 sec before overwriting, so all clients can see end */
11828             while(clock()-t < appData.serverPause*CLOCKS_PER_SEC);
11829         }
11830         serverMoves = fopen(appData.serverMovesName, "w");
11831     }
11832
11833     ExitAnalyzeMode();
11834     gameMode = BeginningOfGame;
11835     ModeHighlight();
11836     if(appData.icsActive) gameInfo.variant = VariantNormal;
11837     currentMove = forwardMostMove = backwardMostMove = 0;
11838     MarkTargetSquares(1);
11839     InitPosition(redraw);
11840     for (i = 0; i < MAX_MOVES; i++) {
11841         if (commentList[i] != NULL) {
11842             free(commentList[i]);
11843             commentList[i] = NULL;
11844         }
11845     }
11846     ResetClocks();
11847     timeRemaining[0][0] = whiteTimeRemaining;
11848     timeRemaining[1][0] = blackTimeRemaining;
11849
11850     if (first.pr == NoProc) {
11851         StartChessProgram(&first);
11852     }
11853     if (init) {
11854             InitChessProgram(&first, startedFromSetupPosition);
11855     }
11856     DisplayTitle("");
11857     DisplayMessage("", "");
11858     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
11859     lastSavedGame = 0; // [HGM] save: make sure next game counts as unsaved
11860     ClearMap();        // [HGM] exclude: invalidate map
11861 }
11862
11863 void
11864 AutoPlayGameLoop ()
11865 {
11866     for (;;) {
11867         if (!AutoPlayOneMove())
11868           return;
11869         if (matchMode || appData.timeDelay == 0)
11870           continue;
11871         if (appData.timeDelay < 0)
11872           return;
11873         StartLoadGameTimer((long)(1000.0f * appData.timeDelay));
11874         break;
11875     }
11876 }
11877
11878 void
11879 AnalyzeNextGame()
11880 {
11881     ReloadGame(1); // next game
11882 }
11883
11884 int
11885 AutoPlayOneMove ()
11886 {
11887     int fromX, fromY, toX, toY;
11888
11889     if (appData.debugMode) {
11890       fprintf(debugFP, "AutoPlayOneMove(): current %d\n", currentMove);
11891     }
11892
11893     if (gameMode != PlayFromGameFile && gameMode != AnalyzeFile)
11894       return FALSE;
11895
11896     if (gameMode == AnalyzeFile && currentMove > backwardMostMove && programStats.depth) {
11897       pvInfoList[currentMove].depth = programStats.depth;
11898       pvInfoList[currentMove].score = programStats.score;
11899       pvInfoList[currentMove].time  = 0;
11900       if(currentMove < forwardMostMove) AppendComment(currentMove+1, lastPV[0], 2);
11901       else { // append analysis of final position as comment
11902         char buf[MSG_SIZ];
11903         snprintf(buf, MSG_SIZ, "{final score %+4.2f/%d}", programStats.score/100., programStats.depth);
11904         AppendComment(currentMove, buf, 3); // the 3 prevents stripping of the score/depth!
11905       }
11906       programStats.depth = 0;
11907     }
11908
11909     if (currentMove >= forwardMostMove) {
11910       if(gameMode == AnalyzeFile) {
11911           if(appData.loadGameIndex == -1) {
11912             GameEnds(gameInfo.result, gameInfo.resultDetails ? gameInfo.resultDetails : "", GE_FILE);
11913           ScheduleDelayedEvent(AnalyzeNextGame, 10);
11914           } else {
11915           ExitAnalyzeMode(); SendToProgram("force\n", &first);
11916         }
11917       }
11918 //      gameMode = EndOfGame;
11919 //      ModeHighlight();
11920
11921       /* [AS] Clear current move marker at the end of a game */
11922       /* HistorySet(parseList, backwardMostMove, forwardMostMove, -1); */
11923
11924       return FALSE;
11925     }
11926
11927     toX = moveList[currentMove][2] - AAA;
11928     toY = moveList[currentMove][3] - ONE;
11929
11930     if (moveList[currentMove][1] == '@') {
11931         if (appData.highlightLastMove) {
11932             SetHighlights(-1, -1, toX, toY);
11933         }
11934     } else {
11935         int viaX = moveList[currentMove][5] - AAA;
11936         int viaY = moveList[currentMove][6] - ONE;
11937         fromX = moveList[currentMove][0] - AAA;
11938         fromY = moveList[currentMove][1] - ONE;
11939
11940         HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove); /* [AS] */
11941
11942         if(moveList[currentMove][4] == ';') { // multi-leg
11943             ChessSquare piece = boards[currentMove][viaY][viaX];
11944             AnimateMove(boards[currentMove], fromX, fromY, viaX, viaY);
11945             boards[currentMove][viaY][viaX] = boards[currentMove][fromY][fromX];
11946             AnimateMove(boards[currentMove], fromX=viaX, fromY=viaY, toX, toY);
11947             boards[currentMove][viaY][viaX] = piece;
11948         } else
11949         AnimateMove(boards[currentMove], fromX, fromY, toX, toY);
11950
11951         if (appData.highlightLastMove) {
11952             SetHighlights(fromX, fromY, toX, toY);
11953         }
11954     }
11955     DisplayMove(currentMove);
11956     SendMoveToProgram(currentMove++, &first);
11957     DisplayBothClocks();
11958     DrawPosition(FALSE, boards[currentMove]);
11959     // [HGM] PV info: always display, routine tests if empty
11960     DisplayComment(currentMove - 1, commentList[currentMove]);
11961     return TRUE;
11962 }
11963
11964
11965 int
11966 LoadGameOneMove (ChessMove readAhead)
11967 {
11968     int fromX = 0, fromY = 0, toX = 0, toY = 0, done;
11969     char promoChar = NULLCHAR;
11970     ChessMove moveType;
11971     char move[MSG_SIZ];
11972     char *p, *q;
11973
11974     if (gameMode != PlayFromGameFile && gameMode != AnalyzeFile &&
11975         gameMode != AnalyzeMode && gameMode != Training) {
11976         gameFileFP = NULL;
11977         return FALSE;
11978     }
11979
11980     yyboardindex = forwardMostMove;
11981     if (readAhead != EndOfFile) {
11982       moveType = readAhead;
11983     } else {
11984       if (gameFileFP == NULL)
11985           return FALSE;
11986       moveType = (ChessMove) Myylex();
11987     }
11988
11989     done = FALSE;
11990     switch (moveType) {
11991       case Comment:
11992         if (appData.debugMode)
11993           fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
11994         p = yy_text;
11995
11996         /* append the comment but don't display it */
11997         AppendComment(currentMove, p, FALSE);
11998         return TRUE;
11999
12000       case WhiteCapturesEnPassant:
12001       case BlackCapturesEnPassant:
12002       case WhitePromotion:
12003       case BlackPromotion:
12004       case WhiteNonPromotion:
12005       case BlackNonPromotion:
12006       case NormalMove:
12007       case FirstLeg:
12008       case WhiteKingSideCastle:
12009       case WhiteQueenSideCastle:
12010       case BlackKingSideCastle:
12011       case BlackQueenSideCastle:
12012       case WhiteKingSideCastleWild:
12013       case WhiteQueenSideCastleWild:
12014       case BlackKingSideCastleWild:
12015       case BlackQueenSideCastleWild:
12016       /* PUSH Fabien */
12017       case WhiteHSideCastleFR:
12018       case WhiteASideCastleFR:
12019       case BlackHSideCastleFR:
12020       case BlackASideCastleFR:
12021       /* POP Fabien */
12022         if (appData.debugMode)
12023           fprintf(debugFP, "Parsed %s into %s\n", yy_text, currentMoveString);
12024         fromX = currentMoveString[0] - AAA;
12025         fromY = currentMoveString[1] - ONE;
12026         toX = currentMoveString[2] - AAA;
12027         toY = currentMoveString[3] - ONE;
12028         promoChar = currentMoveString[4];
12029         if(promoChar == ';') promoChar = NULLCHAR;
12030         break;
12031
12032       case WhiteDrop:
12033       case BlackDrop:
12034         if (appData.debugMode)
12035           fprintf(debugFP, "Parsed %s into %s\n", yy_text, currentMoveString);
12036         fromX = moveType == WhiteDrop ?
12037           (int) CharToPiece(ToUpper(currentMoveString[0])) :
12038         (int) CharToPiece(ToLower(currentMoveString[0]));
12039         fromY = DROP_RANK;
12040         toX = currentMoveString[2] - AAA;
12041         toY = currentMoveString[3] - ONE;
12042         break;
12043
12044       case WhiteWins:
12045       case BlackWins:
12046       case GameIsDrawn:
12047       case GameUnfinished:
12048         if (appData.debugMode)
12049           fprintf(debugFP, "Parsed game end: %s\n", yy_text);
12050         p = strchr(yy_text, '{');
12051         if (p == NULL) p = strchr(yy_text, '(');
12052         if (p == NULL) {
12053             p = yy_text;
12054             if (p[0] == '0' || p[0] == '1' || p[0] == '*') p = "";
12055         } else {
12056             q = strchr(p, *p == '{' ? '}' : ')');
12057             if (q != NULL) *q = NULLCHAR;
12058             p++;
12059         }
12060         while(q = strchr(p, '\n')) *q = ' '; // [HGM] crush linefeeds in result message
12061         GameEnds(moveType, p, GE_FILE);
12062         done = TRUE;
12063         if (cmailMsgLoaded) {
12064             ClearHighlights();
12065             flipView = WhiteOnMove(currentMove);
12066             if (moveType == GameUnfinished) flipView = !flipView;
12067             if (appData.debugMode)
12068               fprintf(debugFP, "Setting flipView to %d\n", flipView) ;
12069         }
12070         break;
12071
12072       case EndOfFile:
12073         if (appData.debugMode)
12074           fprintf(debugFP, "Parser hit end of file\n");
12075         switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
12076           case MT_NONE:
12077           case MT_CHECK:
12078             break;
12079           case MT_CHECKMATE:
12080           case MT_STAINMATE:
12081             if (WhiteOnMove(currentMove)) {
12082                 GameEnds(BlackWins, "Black mates", GE_FILE);
12083             } else {
12084                 GameEnds(WhiteWins, "White mates", GE_FILE);
12085             }
12086             break;
12087           case MT_STALEMATE:
12088             GameEnds(GameIsDrawn, "Stalemate", GE_FILE);
12089             break;
12090         }
12091         done = TRUE;
12092         break;
12093
12094       case MoveNumberOne:
12095         if (lastLoadGameStart == GNUChessGame) {
12096             /* GNUChessGames have numbers, but they aren't move numbers */
12097             if (appData.debugMode)
12098               fprintf(debugFP, "Parser ignoring: '%s' (%d)\n",
12099                       yy_text, (int) moveType);
12100             return LoadGameOneMove(EndOfFile); /* tail recursion */
12101         }
12102         /* else fall thru */
12103
12104       case XBoardGame:
12105       case GNUChessGame:
12106       case PGNTag:
12107         /* Reached start of next game in file */
12108         if (appData.debugMode)
12109           fprintf(debugFP, "Parsed start of next game: %s\n", yy_text);
12110         switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
12111           case MT_NONE:
12112           case MT_CHECK:
12113             break;
12114           case MT_CHECKMATE:
12115           case MT_STAINMATE:
12116             if (WhiteOnMove(currentMove)) {
12117                 GameEnds(BlackWins, "Black mates", GE_FILE);
12118             } else {
12119                 GameEnds(WhiteWins, "White mates", GE_FILE);
12120             }
12121             break;
12122           case MT_STALEMATE:
12123             GameEnds(GameIsDrawn, "Stalemate", GE_FILE);
12124             break;
12125         }
12126         done = TRUE;
12127         break;
12128
12129       case PositionDiagram:     /* should not happen; ignore */
12130       case ElapsedTime:         /* ignore */
12131       case NAG:                 /* ignore */
12132         if (appData.debugMode)
12133           fprintf(debugFP, "Parser ignoring: '%s' (%d)\n",
12134                   yy_text, (int) moveType);
12135         return LoadGameOneMove(EndOfFile); /* tail recursion */
12136
12137       case IllegalMove:
12138         if (appData.testLegality) {
12139             if (appData.debugMode)
12140               fprintf(debugFP, "Parsed IllegalMove: %s\n", yy_text);
12141             snprintf(move, MSG_SIZ, _("Illegal move: %d.%s%s"),
12142                     (forwardMostMove / 2) + 1,
12143                     WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
12144             DisplayError(move, 0);
12145             done = TRUE;
12146         } else {
12147             if (appData.debugMode)
12148               fprintf(debugFP, "Parsed %s into IllegalMove %s\n",
12149                       yy_text, currentMoveString);
12150             if(currentMoveString[1] == '@') {
12151                 fromX = CharToPiece(WhiteOnMove(currentMove) ? ToUpper(currentMoveString[0]) : ToLower(currentMoveString[0]));
12152                 fromY = DROP_RANK;
12153             } else {
12154                 fromX = currentMoveString[0] - AAA;
12155                 fromY = currentMoveString[1] - ONE;
12156             }
12157             toX = currentMoveString[2] - AAA;
12158             toY = currentMoveString[3] - ONE;
12159             promoChar = currentMoveString[4];
12160         }
12161         break;
12162
12163       case AmbiguousMove:
12164         if (appData.debugMode)
12165           fprintf(debugFP, "Parsed AmbiguousMove: %s\n", yy_text);
12166         snprintf(move, MSG_SIZ, _("Ambiguous move: %d.%s%s"),
12167                 (forwardMostMove / 2) + 1,
12168                 WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
12169         DisplayError(move, 0);
12170         done = TRUE;
12171         break;
12172
12173       default:
12174       case ImpossibleMove:
12175         if (appData.debugMode)
12176           fprintf(debugFP, "Parsed ImpossibleMove (type = %d): %s\n", moveType, yy_text);
12177         snprintf(move, MSG_SIZ, _("Illegal move: %d.%s%s"),
12178                 (forwardMostMove / 2) + 1,
12179                 WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
12180         DisplayError(move, 0);
12181         done = TRUE;
12182         break;
12183     }
12184
12185     if (done) {
12186         if (appData.matchMode || (appData.timeDelay == 0 && !pausing)) {
12187             DrawPosition(FALSE, boards[currentMove]);
12188             DisplayBothClocks();
12189             if (!appData.matchMode) // [HGM] PV info: routine tests if empty
12190               DisplayComment(currentMove - 1, commentList[currentMove]);
12191         }
12192         (void) StopLoadGameTimer();
12193         gameFileFP = NULL;
12194         cmailOldMove = forwardMostMove;
12195         return FALSE;
12196     } else {
12197         /* currentMoveString is set as a side-effect of yylex */
12198
12199         thinkOutput[0] = NULLCHAR;
12200         MakeMove(fromX, fromY, toX, toY, promoChar);
12201         killX = killY = -1; // [HGM] lion: used up
12202         currentMove = forwardMostMove;
12203         return TRUE;
12204     }
12205 }
12206
12207 /* Load the nth game from the given file */
12208 int
12209 LoadGameFromFile (char *filename, int n, char *title, int useList)
12210 {
12211     FILE *f;
12212     char buf[MSG_SIZ];
12213
12214     if (strcmp(filename, "-") == 0) {
12215         f = stdin;
12216         title = "stdin";
12217     } else {
12218         f = fopen(filename, "rb");
12219         if (f == NULL) {
12220           snprintf(buf, sizeof(buf),  _("Can't open \"%s\""), filename);
12221             DisplayError(buf, errno);
12222             return FALSE;
12223         }
12224     }
12225     if (fseek(f, 0, 0) == -1) {
12226         /* f is not seekable; probably a pipe */
12227         useList = FALSE;
12228     }
12229     if (useList && n == 0) {
12230         int error = GameListBuild(f);
12231         if (error) {
12232             DisplayError(_("Cannot build game list"), error);
12233         } else if (!ListEmpty(&gameList) &&
12234                    ((ListGame *) gameList.tailPred)->number > 1) {
12235             GameListPopUp(f, title);
12236             return TRUE;
12237         }
12238         GameListDestroy();
12239         n = 1;
12240     }
12241     if (n == 0) n = 1;
12242     return LoadGame(f, n, title, FALSE);
12243 }
12244
12245
12246 void
12247 MakeRegisteredMove ()
12248 {
12249     int fromX, fromY, toX, toY;
12250     char promoChar;
12251     if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
12252         switch (cmailMoveType[lastLoadGameNumber - 1]) {
12253           case CMAIL_MOVE:
12254           case CMAIL_DRAW:
12255             if (appData.debugMode)
12256               fprintf(debugFP, "Restoring %s for game %d\n",
12257                       cmailMove[lastLoadGameNumber - 1], lastLoadGameNumber);
12258
12259             thinkOutput[0] = NULLCHAR;
12260             safeStrCpy(moveList[currentMove], cmailMove[lastLoadGameNumber - 1], sizeof(moveList[currentMove])/sizeof(moveList[currentMove][0]));
12261             fromX = cmailMove[lastLoadGameNumber - 1][0] - AAA;
12262             fromY = cmailMove[lastLoadGameNumber - 1][1] - ONE;
12263             toX = cmailMove[lastLoadGameNumber - 1][2] - AAA;
12264             toY = cmailMove[lastLoadGameNumber - 1][3] - ONE;
12265             promoChar = cmailMove[lastLoadGameNumber - 1][4];
12266             MakeMove(fromX, fromY, toX, toY, promoChar);
12267             ShowMove(fromX, fromY, toX, toY);
12268
12269             switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
12270               case MT_NONE:
12271               case MT_CHECK:
12272                 break;
12273
12274               case MT_CHECKMATE:
12275               case MT_STAINMATE:
12276                 if (WhiteOnMove(currentMove)) {
12277                     GameEnds(BlackWins, "Black mates", GE_PLAYER);
12278                 } else {
12279                     GameEnds(WhiteWins, "White mates", GE_PLAYER);
12280                 }
12281                 break;
12282
12283               case MT_STALEMATE:
12284                 GameEnds(GameIsDrawn, "Stalemate", GE_PLAYER);
12285                 break;
12286             }
12287
12288             break;
12289
12290           case CMAIL_RESIGN:
12291             if (WhiteOnMove(currentMove)) {
12292                 GameEnds(BlackWins, "White resigns", GE_PLAYER);
12293             } else {
12294                 GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
12295             }
12296             break;
12297
12298           case CMAIL_ACCEPT:
12299             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
12300             break;
12301
12302           default:
12303             break;
12304         }
12305     }
12306
12307     return;
12308 }
12309
12310 /* Wrapper around LoadGame for use when a Cmail message is loaded */
12311 int
12312 CmailLoadGame (FILE *f, int gameNumber, char *title, int useList)
12313 {
12314     int retVal;
12315
12316     if (gameNumber > nCmailGames) {
12317         DisplayError(_("No more games in this message"), 0);
12318         return FALSE;
12319     }
12320     if (f == lastLoadGameFP) {
12321         int offset = gameNumber - lastLoadGameNumber;
12322         if (offset == 0) {
12323             cmailMsg[0] = NULLCHAR;
12324             if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
12325                 cmailMoveRegistered[lastLoadGameNumber - 1] = FALSE;
12326                 nCmailMovesRegistered--;
12327             }
12328             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
12329             if (cmailResult[lastLoadGameNumber - 1] == CMAIL_NEW_RESULT) {
12330                 cmailResult[lastLoadGameNumber - 1] = CMAIL_NOT_RESULT;
12331             }
12332         } else {
12333             if (! RegisterMove()) return FALSE;
12334         }
12335     }
12336
12337     retVal = LoadGame(f, gameNumber, title, useList);
12338
12339     /* Make move registered during previous look at this game, if any */
12340     MakeRegisteredMove();
12341
12342     if (cmailCommentList[lastLoadGameNumber - 1] != NULL) {
12343         commentList[currentMove]
12344           = StrSave(cmailCommentList[lastLoadGameNumber - 1]);
12345         DisplayComment(currentMove - 1, commentList[currentMove]);
12346     }
12347
12348     return retVal;
12349 }
12350
12351 /* Support for LoadNextGame, LoadPreviousGame, ReloadSameGame */
12352 int
12353 ReloadGame (int offset)
12354 {
12355     int gameNumber = lastLoadGameNumber + offset;
12356     if (lastLoadGameFP == NULL) {
12357         DisplayError(_("No game has been loaded yet"), 0);
12358         return FALSE;
12359     }
12360     if (gameNumber <= 0) {
12361         DisplayError(_("Can't back up any further"), 0);
12362         return FALSE;
12363     }
12364     if (cmailMsgLoaded) {
12365         return CmailLoadGame(lastLoadGameFP, gameNumber,
12366                              lastLoadGameTitle, lastLoadGameUseList);
12367     } else {
12368         return LoadGame(lastLoadGameFP, gameNumber,
12369                         lastLoadGameTitle, lastLoadGameUseList);
12370     }
12371 }
12372
12373 int keys[EmptySquare+1];
12374
12375 int
12376 PositionMatches (Board b1, Board b2)
12377 {
12378     int r, f, sum=0;
12379     switch(appData.searchMode) {
12380         case 1: return CompareWithRights(b1, b2);
12381         case 2:
12382             for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12383                 if(b2[r][f] != EmptySquare && b1[r][f] != b2[r][f]) return FALSE;
12384             }
12385             return TRUE;
12386         case 3:
12387             for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12388               if((b2[r][f] == WhitePawn || b2[r][f] == BlackPawn) && b1[r][f] != b2[r][f]) return FALSE;
12389                 sum += keys[b1[r][f]] - keys[b2[r][f]];
12390             }
12391             return sum==0;
12392         case 4:
12393             for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12394                 sum += keys[b1[r][f]] - keys[b2[r][f]];
12395             }
12396             return sum==0;
12397     }
12398     return TRUE;
12399 }
12400
12401 #define Q_PROMO  4
12402 #define Q_EP     3
12403 #define Q_BCASTL 2
12404 #define Q_WCASTL 1
12405
12406 int pieceList[256], quickBoard[256];
12407 ChessSquare pieceType[256] = { EmptySquare };
12408 Board soughtBoard, reverseBoard, flipBoard, rotateBoard;
12409 int counts[EmptySquare], minSought[EmptySquare], minReverse[EmptySquare], maxSought[EmptySquare], maxReverse[EmptySquare];
12410 int soughtTotal, turn;
12411 Boolean epOK, flipSearch;
12412
12413 typedef struct {
12414     unsigned char piece, to;
12415 } Move;
12416
12417 #define DSIZE (250000)
12418
12419 Move initialSpace[DSIZE+1000]; // gamble on that game will not be more than 500 moves
12420 Move *moveDatabase = initialSpace;
12421 unsigned int movePtr, dataSize = DSIZE;
12422
12423 int
12424 MakePieceList (Board board, int *counts)
12425 {
12426     int r, f, n=Q_PROMO, total=0;
12427     for(r=0;r<EmptySquare;r++) counts[r] = 0; // piece-type counts
12428     for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12429         int sq = f + (r<<4);
12430         if(board[r][f] == EmptySquare) quickBoard[sq] = 0; else {
12431             quickBoard[sq] = ++n;
12432             pieceList[n] = sq;
12433             pieceType[n] = board[r][f];
12434             counts[board[r][f]]++;
12435             if(board[r][f] == WhiteKing) pieceList[1] = n; else
12436             if(board[r][f] == BlackKing) pieceList[2] = n; // remember which are Kings, for castling
12437             total++;
12438         }
12439     }
12440     epOK = gameInfo.variant != VariantXiangqi && gameInfo.variant != VariantBerolina;
12441     return total;
12442 }
12443
12444 void
12445 PackMove (int fromX, int fromY, int toX, int toY, ChessSquare promoPiece)
12446 {
12447     int sq = fromX + (fromY<<4);
12448     int piece = quickBoard[sq], rook;
12449     quickBoard[sq] = 0;
12450     moveDatabase[movePtr].to = pieceList[piece] = sq = toX + (toY<<4);
12451     if(piece == pieceList[1] && fromY == toY) {
12452       if((toX > fromX+1 || toX < fromX-1) && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1) {
12453         int from = toX>fromX ? BOARD_RGHT-1 : BOARD_LEFT;
12454         moveDatabase[movePtr++].piece = Q_WCASTL;
12455         quickBoard[sq] = piece;
12456         piece = quickBoard[from]; quickBoard[from] = 0;
12457         moveDatabase[movePtr].to = pieceList[piece] = sq = toX>fromX ? sq-1 : sq+1;
12458       } else if((rook = quickBoard[sq]) && pieceType[rook] == WhiteRook) { // FRC castling
12459         quickBoard[sq] = 0; // remove Rook
12460         moveDatabase[movePtr].to = sq = (toX>fromX ? BOARD_RGHT-2 : BOARD_LEFT+2); // King to-square
12461         moveDatabase[movePtr++].piece = Q_WCASTL;
12462         quickBoard[sq] = pieceList[1]; // put King
12463         piece = rook;
12464         moveDatabase[movePtr].to = pieceList[rook] = sq = toX>fromX ? sq-1 : sq+1;
12465       }
12466     } else
12467     if(piece == pieceList[2] && fromY == toY) {
12468       if((toX > fromX+1 || toX < fromX-1) && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1) {
12469         int from = (toX>fromX ? BOARD_RGHT-1 : BOARD_LEFT) + (BOARD_HEIGHT-1 <<4);
12470         moveDatabase[movePtr++].piece = Q_BCASTL;
12471         quickBoard[sq] = piece;
12472         piece = quickBoard[from]; quickBoard[from] = 0;
12473         moveDatabase[movePtr].to = pieceList[piece] = sq = toX>fromX ? sq-1 : sq+1;
12474       } else if((rook = quickBoard[sq]) && pieceType[rook] == BlackRook) { // FRC castling
12475         quickBoard[sq] = 0; // remove Rook
12476         moveDatabase[movePtr].to = sq = (toX>fromX ? BOARD_RGHT-2 : BOARD_LEFT+2);
12477         moveDatabase[movePtr++].piece = Q_BCASTL;
12478         quickBoard[sq] = pieceList[2]; // put King
12479         piece = rook;
12480         moveDatabase[movePtr].to = pieceList[rook] = sq = toX>fromX ? sq-1 : sq+1;
12481       }
12482     } else
12483     if(epOK && (pieceType[piece] == WhitePawn || pieceType[piece] == BlackPawn) && fromX != toX && quickBoard[sq] == 0) {
12484         quickBoard[(fromY<<4)+toX] = 0;
12485         moveDatabase[movePtr].piece = Q_EP;
12486         moveDatabase[movePtr++].to = (fromY<<4)+toX;
12487         moveDatabase[movePtr].to = sq;
12488     } else
12489     if(promoPiece != pieceType[piece]) {
12490         moveDatabase[movePtr++].piece = Q_PROMO;
12491         moveDatabase[movePtr].to = pieceType[piece] = (int) promoPiece;
12492     }
12493     moveDatabase[movePtr].piece = piece;
12494     quickBoard[sq] = piece;
12495     movePtr++;
12496 }
12497
12498 int
12499 PackGame (Board board)
12500 {
12501     Move *newSpace = NULL;
12502     moveDatabase[movePtr].piece = 0; // terminate previous game
12503     if(movePtr > dataSize) {
12504         if(appData.debugMode) fprintf(debugFP, "move-cache overflow, enlarge to %d MB\n", dataSize/128);
12505         dataSize *= 8; // increase size by factor 8 (512KB -> 4MB -> 32MB -> 256MB -> 2GB)
12506         if(dataSize) newSpace = (Move*) calloc(dataSize + 1000, sizeof(Move));
12507         if(newSpace) {
12508             int i;
12509             Move *p = moveDatabase, *q = newSpace;
12510             for(i=0; i<movePtr; i++) *q++ = *p++;    // copy to newly allocated space
12511             if(dataSize > 8*DSIZE) free(moveDatabase); // and free old space (if it was allocated)
12512             moveDatabase = newSpace;
12513         } else { // calloc failed, we must be out of memory. Too bad...
12514             dataSize = 0; // prevent calloc events for all subsequent games
12515             return 0;     // and signal this one isn't cached
12516         }
12517     }
12518     movePtr++;
12519     MakePieceList(board, counts);
12520     return movePtr;
12521 }
12522
12523 int
12524 QuickCompare (Board board, int *minCounts, int *maxCounts)
12525 {   // compare according to search mode
12526     int r, f;
12527     switch(appData.searchMode)
12528     {
12529       case 1: // exact position match
12530         if(!(turn & board[EP_STATUS-1])) return FALSE; // wrong side to move
12531         for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12532             if(board[r][f] != pieceType[quickBoard[(r<<4)+f]]) return FALSE;
12533         }
12534         break;
12535       case 2: // can have extra material on empty squares
12536         for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12537             if(board[r][f] == EmptySquare) continue;
12538             if(board[r][f] != pieceType[quickBoard[(r<<4)+f]]) return FALSE;
12539         }
12540         break;
12541       case 3: // material with exact Pawn structure
12542         for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12543             if(board[r][f] != WhitePawn && board[r][f] != BlackPawn) continue;
12544             if(board[r][f] != pieceType[quickBoard[(r<<4)+f]]) return FALSE;
12545         } // fall through to material comparison
12546       case 4: // exact material
12547         for(r=0; r<EmptySquare; r++) if(counts[r] != maxCounts[r]) return FALSE;
12548         break;
12549       case 6: // material range with given imbalance
12550         for(r=0; r<BlackPawn; r++) if(counts[r] - minCounts[r] != counts[r+BlackPawn] - minCounts[r+BlackPawn]) return FALSE;
12551         // fall through to range comparison
12552       case 5: // material range
12553         for(r=0; r<EmptySquare; r++) if(counts[r] < minCounts[r] || counts[r] > maxCounts[r]) return FALSE;
12554     }
12555     return TRUE;
12556 }
12557
12558 int
12559 QuickScan (Board board, Move *move)
12560 {   // reconstruct game,and compare all positions in it
12561     int cnt=0, stretch=0, found = -1, total = MakePieceList(board, counts);
12562     do {
12563         int piece = move->piece;
12564         int to = move->to, from = pieceList[piece];
12565         if(found < 0) { // if already found just scan to game end for final piece count
12566           if(QuickCompare(soughtBoard, minSought, maxSought) ||
12567            appData.ignoreColors && QuickCompare(reverseBoard, minReverse, maxReverse) ||
12568            flipSearch && (QuickCompare(flipBoard, minSought, maxSought) ||
12569                                 appData.ignoreColors && QuickCompare(rotateBoard, minReverse, maxReverse))
12570             ) {
12571             static int lastCounts[EmptySquare+1];
12572             int i;
12573             if(stretch) for(i=0; i<EmptySquare; i++) if(lastCounts[i] != counts[i]) { stretch = 0; break; } // reset if material changes
12574             if(stretch++ == 0) for(i=0; i<EmptySquare; i++) lastCounts[i] = counts[i]; // remember actual material
12575           } else stretch = 0;
12576           if(stretch && (appData.searchMode == 1 || stretch >= appData.stretch)) found = cnt + 1 - stretch;
12577           if(found >= 0 && !appData.minPieces) return found;
12578         }
12579         if(piece <= Q_PROMO) { // special moves encoded by otherwise invalid piece numbers 1-4
12580           if(!piece) return (appData.minPieces && (total < appData.minPieces || total > appData.maxPieces) ? -1 : found);
12581           if(piece == Q_PROMO) { // promotion, encoded as (Q_PROMO, to) + (piece, promoType)
12582             piece = (++move)->piece;
12583             from = pieceList[piece];
12584             counts[pieceType[piece]]--;
12585             pieceType[piece] = (ChessSquare) move->to;
12586             counts[move->to]++;
12587           } else if(piece == Q_EP) { // e.p. capture, encoded as (Q_EP, ep-sqr) + (piece, to)
12588             counts[pieceType[quickBoard[to]]]--;
12589             quickBoard[to] = 0; total--;
12590             move++;
12591             continue;
12592           } else if(piece <= Q_BCASTL) { // castling, encoded as (Q_XCASTL, king-to) + (rook, rook-to)
12593             piece = pieceList[piece]; // first two elements of pieceList contain King numbers
12594             from  = pieceList[piece]; // so this must be King
12595             quickBoard[from] = 0;
12596             pieceList[piece] = to;
12597             from = pieceList[(++move)->piece]; // for FRC this has to be done here
12598             quickBoard[from] = 0; // rook
12599             quickBoard[to] = piece;
12600             to = move->to; piece = move->piece;
12601             goto aftercastle;
12602           }
12603         }
12604         if(appData.searchMode > 2) counts[pieceType[quickBoard[to]]]--; // account capture
12605         if((total -= (quickBoard[to] != 0)) < soughtTotal && found < 0) return -1; // piece count dropped below what we search for
12606         quickBoard[from] = 0;
12607       aftercastle:
12608         quickBoard[to] = piece;
12609         pieceList[piece] = to;
12610         cnt++; turn ^= 3;
12611         move++;
12612     } while(1);
12613 }
12614
12615 void
12616 InitSearch ()
12617 {
12618     int r, f;
12619     flipSearch = FALSE;
12620     CopyBoard(soughtBoard, boards[currentMove]);
12621     soughtTotal = MakePieceList(soughtBoard, maxSought);
12622     soughtBoard[EP_STATUS-1] = (currentMove & 1) + 1;
12623     if(currentMove == 0 && gameMode == EditPosition) soughtBoard[EP_STATUS-1] = blackPlaysFirst + 1; // (!)
12624     CopyBoard(reverseBoard, boards[currentMove]);
12625     for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12626         int piece = boards[currentMove][BOARD_HEIGHT-1-r][f];
12627         if(piece < BlackPawn) piece += BlackPawn; else if(piece < EmptySquare) piece -= BlackPawn; // color-flip
12628         reverseBoard[r][f] = piece;
12629     }
12630     reverseBoard[EP_STATUS-1] = soughtBoard[EP_STATUS-1] ^ 3;
12631     for(r=0; r<6; r++) reverseBoard[CASTLING][r] = boards[currentMove][CASTLING][(r+3)%6];
12632     if(appData.findMirror && appData.searchMode <= 3 && (!nrCastlingRights
12633                  || (boards[currentMove][CASTLING][2] == NoRights ||
12634                      boards[currentMove][CASTLING][0] == NoRights && boards[currentMove][CASTLING][1] == NoRights )
12635                  && (boards[currentMove][CASTLING][5] == NoRights ||
12636                      boards[currentMove][CASTLING][3] == NoRights && boards[currentMove][CASTLING][4] == NoRights ) )
12637       ) {
12638         flipSearch = TRUE;
12639         CopyBoard(flipBoard, soughtBoard);
12640         CopyBoard(rotateBoard, reverseBoard);
12641         for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
12642             flipBoard[r][f]    = soughtBoard[r][BOARD_WIDTH-1-f];
12643             rotateBoard[r][f] = reverseBoard[r][BOARD_WIDTH-1-f];
12644         }
12645     }
12646     for(r=0; r<BlackPawn; r++) maxReverse[r] = maxSought[r+BlackPawn], maxReverse[r+BlackPawn] = maxSought[r];
12647     if(appData.searchMode >= 5) {
12648         for(r=BOARD_HEIGHT/2; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) soughtBoard[r][f] = EmptySquare;
12649         MakePieceList(soughtBoard, minSought);
12650         for(r=0; r<BlackPawn; r++) minReverse[r] = minSought[r+BlackPawn], minReverse[r+BlackPawn] = minSought[r];
12651     }
12652     if(gameInfo.variant == VariantCrazyhouse || gameInfo.variant == VariantShogi || gameInfo.variant == VariantBughouse)
12653         soughtTotal = 0; // in drop games nr of pieces does not fall monotonously
12654 }
12655
12656 GameInfo dummyInfo;
12657 static int creatingBook;
12658
12659 int
12660 GameContainsPosition (FILE *f, ListGame *lg)
12661 {
12662     int next, btm=0, plyNr=0, scratch=forwardMostMove+2&~1;
12663     int fromX, fromY, toX, toY;
12664     char promoChar;
12665     static int initDone=FALSE;
12666
12667     // weed out games based on numerical tag comparison
12668     if(lg->gameInfo.variant != gameInfo.variant) return -1; // wrong variant
12669     if(appData.eloThreshold1 && (lg->gameInfo.whiteRating < appData.eloThreshold1 && lg->gameInfo.blackRating < appData.eloThreshold1)) return -1;
12670     if(appData.eloThreshold2 && (lg->gameInfo.whiteRating < appData.eloThreshold2 || lg->gameInfo.blackRating < appData.eloThreshold2)) return -1;
12671     if(appData.dateThreshold && (!lg->gameInfo.date || atoi(lg->gameInfo.date) < appData.dateThreshold)) return -1;
12672     if(!initDone) {
12673         for(next = WhitePawn; next<EmptySquare; next++) keys[next] = random()>>8 ^ random()<<6 ^random()<<20;
12674         initDone = TRUE;
12675     }
12676     if(lg->gameInfo.fen) ParseFEN(boards[scratch], &btm, lg->gameInfo.fen, FALSE);
12677     else CopyBoard(boards[scratch], initialPosition); // default start position
12678     if(lg->moves) {
12679         turn = btm + 1;
12680         if((next = QuickScan( boards[scratch], &moveDatabase[lg->moves] )) < 0) return -1; // quick scan rules out it is there
12681         if(appData.searchMode >= 4) return next; // for material searches, trust QuickScan.
12682     }
12683     if(btm) plyNr++;
12684     if(PositionMatches(boards[scratch], boards[currentMove])) return plyNr;
12685     fseek(f, lg->offset, 0);
12686     yynewfile(f);
12687     while(1) {
12688         yyboardindex = scratch;
12689         quickFlag = plyNr+1;
12690         next = Myylex();
12691         quickFlag = 0;
12692         switch(next) {
12693             case PGNTag:
12694                 if(plyNr) return -1; // after we have seen moves, any tags will be start of next game
12695             default:
12696                 continue;
12697
12698             case XBoardGame:
12699             case GNUChessGame:
12700                 if(plyNr) return -1; // after we have seen moves, this is for new game
12701               continue;
12702
12703             case AmbiguousMove: // we cannot reconstruct the game beyond these two
12704             case ImpossibleMove:
12705             case WhiteWins: // game ends here with these four
12706             case BlackWins:
12707             case GameIsDrawn:
12708             case GameUnfinished:
12709                 return -1;
12710
12711             case IllegalMove:
12712                 if(appData.testLegality) return -1;
12713             case WhiteCapturesEnPassant:
12714             case BlackCapturesEnPassant:
12715             case WhitePromotion:
12716             case BlackPromotion:
12717             case WhiteNonPromotion:
12718             case BlackNonPromotion:
12719             case NormalMove:
12720             case FirstLeg:
12721             case WhiteKingSideCastle:
12722             case WhiteQueenSideCastle:
12723             case BlackKingSideCastle:
12724             case BlackQueenSideCastle:
12725             case WhiteKingSideCastleWild:
12726             case WhiteQueenSideCastleWild:
12727             case BlackKingSideCastleWild:
12728             case BlackQueenSideCastleWild:
12729             case WhiteHSideCastleFR:
12730             case WhiteASideCastleFR:
12731             case BlackHSideCastleFR:
12732             case BlackASideCastleFR:
12733                 fromX = currentMoveString[0] - AAA;
12734                 fromY = currentMoveString[1] - ONE;
12735                 toX = currentMoveString[2] - AAA;
12736                 toY = currentMoveString[3] - ONE;
12737                 promoChar = currentMoveString[4];
12738                 break;
12739             case WhiteDrop:
12740             case BlackDrop:
12741                 fromX = next == WhiteDrop ?
12742                   (int) CharToPiece(ToUpper(currentMoveString[0])) :
12743                   (int) CharToPiece(ToLower(currentMoveString[0]));
12744                 fromY = DROP_RANK;
12745                 toX = currentMoveString[2] - AAA;
12746                 toY = currentMoveString[3] - ONE;
12747                 promoChar = 0;
12748                 break;
12749         }
12750         // Move encountered; peform it. We need to shuttle between two boards, as even/odd index determines side to move
12751         plyNr++;
12752         ApplyMove(fromX, fromY, toX, toY, promoChar, boards[scratch]);
12753         if(PositionMatches(boards[scratch], boards[currentMove])) return plyNr;
12754         if(appData.ignoreColors && PositionMatches(boards[scratch], reverseBoard)) return plyNr;
12755         if(appData.findMirror) {
12756             if(PositionMatches(boards[scratch], flipBoard)) return plyNr;
12757             if(appData.ignoreColors && PositionMatches(boards[scratch], rotateBoard)) return plyNr;
12758         }
12759     }
12760 }
12761
12762 /* Load the nth game from open file f */
12763 int
12764 LoadGame (FILE *f, int gameNumber, char *title, int useList)
12765 {
12766     ChessMove cm;
12767     char buf[MSG_SIZ];
12768     int gn = gameNumber;
12769     ListGame *lg = NULL;
12770     int numPGNTags = 0;
12771     int err, pos = -1;
12772     GameMode oldGameMode;
12773     VariantClass v, oldVariant = gameInfo.variant; /* [HGM] PGNvariant */
12774     char oldName[MSG_SIZ];
12775
12776     safeStrCpy(oldName, engineVariant, MSG_SIZ); v = oldVariant;
12777
12778     if (appData.debugMode)
12779         fprintf(debugFP, "LoadGame(): on entry, gameMode %d\n", gameMode);
12780
12781     if (gameMode == Training )
12782         SetTrainingModeOff();
12783
12784     oldGameMode = gameMode;
12785     if (gameMode != BeginningOfGame) {
12786       Reset(FALSE, TRUE);
12787     }
12788     killX = killY = -1; // [HGM] lion: in case we did not Reset
12789
12790     gameFileFP = f;
12791     if (lastLoadGameFP != NULL && lastLoadGameFP != f) {
12792         fclose(lastLoadGameFP);
12793     }
12794
12795     if (useList) {
12796         lg = (ListGame *) ListElem(&gameList, gameNumber-1);
12797
12798         if (lg) {
12799             fseek(f, lg->offset, 0);
12800             GameListHighlight(gameNumber);
12801             pos = lg->position;
12802             gn = 1;
12803         }
12804         else {
12805             if(oldGameMode == AnalyzeFile && appData.loadGameIndex == -1)
12806               appData.loadGameIndex = 0; // [HGM] suppress error message if we reach file end after auto-stepping analysis
12807             else
12808             DisplayError(_("Game number out of range"), 0);
12809             return FALSE;
12810         }
12811     } else {
12812         GameListDestroy();
12813         if (fseek(f, 0, 0) == -1) {
12814             if (f == lastLoadGameFP ?
12815                 gameNumber == lastLoadGameNumber + 1 :
12816                 gameNumber == 1) {
12817                 gn = 1;
12818             } else {
12819                 DisplayError(_("Can't seek on game file"), 0);
12820                 return FALSE;
12821             }
12822         }
12823     }
12824     lastLoadGameFP = f;
12825     lastLoadGameNumber = gameNumber;
12826     safeStrCpy(lastLoadGameTitle, title, sizeof(lastLoadGameTitle)/sizeof(lastLoadGameTitle[0]));
12827     lastLoadGameUseList = useList;
12828
12829     yynewfile(f);
12830
12831     if (lg && lg->gameInfo.white && lg->gameInfo.black) {
12832       snprintf(buf, sizeof(buf), "%s %s %s", lg->gameInfo.white, _("vs."),
12833                 lg->gameInfo.black);
12834             DisplayTitle(buf);
12835     } else if (*title != NULLCHAR) {
12836         if (gameNumber > 1) {
12837           snprintf(buf, MSG_SIZ, "%s %d", title, gameNumber);
12838             DisplayTitle(buf);
12839         } else {
12840             DisplayTitle(title);
12841         }
12842     }
12843
12844     if (gameMode != AnalyzeFile && gameMode != AnalyzeMode) {
12845         gameMode = PlayFromGameFile;
12846         ModeHighlight();
12847     }
12848
12849     currentMove = forwardMostMove = backwardMostMove = 0;
12850     CopyBoard(boards[0], initialPosition);
12851     StopClocks();
12852
12853     /*
12854      * Skip the first gn-1 games in the file.
12855      * Also skip over anything that precedes an identifiable
12856      * start of game marker, to avoid being confused by
12857      * garbage at the start of the file.  Currently
12858      * recognized start of game markers are the move number "1",
12859      * the pattern "gnuchess .* game", the pattern
12860      * "^[#;%] [^ ]* game file", and a PGN tag block.
12861      * A game that starts with one of the latter two patterns
12862      * will also have a move number 1, possibly
12863      * following a position diagram.
12864      * 5-4-02: Let's try being more lenient and allowing a game to
12865      * start with an unnumbered move.  Does that break anything?
12866      */
12867     cm = lastLoadGameStart = EndOfFile;
12868     while (gn > 0) {
12869         yyboardindex = forwardMostMove;
12870         cm = (ChessMove) Myylex();
12871         switch (cm) {
12872           case EndOfFile:
12873             if (cmailMsgLoaded) {
12874                 nCmailGames = CMAIL_MAX_GAMES - gn;
12875             } else {
12876                 Reset(TRUE, TRUE);
12877                 DisplayError(_("Game not found in file"), 0);
12878             }
12879             return FALSE;
12880
12881           case GNUChessGame:
12882           case XBoardGame:
12883             gn--;
12884             lastLoadGameStart = cm;
12885             break;
12886
12887           case MoveNumberOne:
12888             switch (lastLoadGameStart) {
12889               case GNUChessGame:
12890               case XBoardGame:
12891               case PGNTag:
12892                 break;
12893               case MoveNumberOne:
12894               case EndOfFile:
12895                 gn--;           /* count this game */
12896                 lastLoadGameStart = cm;
12897                 break;
12898               default:
12899                 /* impossible */
12900                 break;
12901             }
12902             break;
12903
12904           case PGNTag:
12905             switch (lastLoadGameStart) {
12906               case GNUChessGame:
12907               case PGNTag:
12908               case MoveNumberOne:
12909               case EndOfFile:
12910                 gn--;           /* count this game */
12911                 lastLoadGameStart = cm;
12912                 break;
12913               case XBoardGame:
12914                 lastLoadGameStart = cm; /* game counted already */
12915                 break;
12916               default:
12917                 /* impossible */
12918                 break;
12919             }
12920             if (gn > 0) {
12921                 do {
12922                     yyboardindex = forwardMostMove;
12923                     cm = (ChessMove) Myylex();
12924                 } while (cm == PGNTag || cm == Comment);
12925             }
12926             break;
12927
12928           case WhiteWins:
12929           case BlackWins:
12930           case GameIsDrawn:
12931             if (cmailMsgLoaded && (CMAIL_MAX_GAMES == lastLoadGameNumber)) {
12932                 if (   cmailResult[CMAIL_MAX_GAMES - gn - 1]
12933                     != CMAIL_OLD_RESULT) {
12934                     nCmailResults ++ ;
12935                     cmailResult[  CMAIL_MAX_GAMES
12936                                 - gn - 1] = CMAIL_OLD_RESULT;
12937                 }
12938             }
12939             break;
12940
12941           case NormalMove:
12942           case FirstLeg:
12943             /* Only a NormalMove can be at the start of a game
12944              * without a position diagram. */
12945             if (lastLoadGameStart == EndOfFile ) {
12946               gn--;
12947               lastLoadGameStart = MoveNumberOne;
12948             }
12949             break;
12950
12951           default:
12952             break;
12953         }
12954     }
12955
12956     if (appData.debugMode)
12957       fprintf(debugFP, "Parsed game start '%s' (%d)\n", yy_text, (int) cm);
12958
12959     if (cm == XBoardGame) {
12960         /* Skip any header junk before position diagram and/or move 1 */
12961         for (;;) {
12962             yyboardindex = forwardMostMove;
12963             cm = (ChessMove) Myylex();
12964
12965             if (cm == EndOfFile ||
12966                 cm == GNUChessGame || cm == XBoardGame) {
12967                 /* Empty game; pretend end-of-file and handle later */
12968                 cm = EndOfFile;
12969                 break;
12970             }
12971
12972             if (cm == MoveNumberOne || cm == PositionDiagram ||
12973                 cm == PGNTag || cm == Comment)
12974               break;
12975         }
12976     } else if (cm == GNUChessGame) {
12977         if (gameInfo.event != NULL) {
12978             free(gameInfo.event);
12979         }
12980         gameInfo.event = StrSave(yy_text);
12981     }
12982
12983     startedFromSetupPosition = FALSE;
12984     while (cm == PGNTag) {
12985         if (appData.debugMode)
12986           fprintf(debugFP, "Parsed PGNTag: %s\n", yy_text);
12987         err = ParsePGNTag(yy_text, &gameInfo);
12988         if (!err) numPGNTags++;
12989
12990         /* [HGM] PGNvariant: automatically switch to variant given in PGN tag */
12991         if(gameInfo.variant != oldVariant && (gameInfo.variant != VariantNormal || gameInfo.variantName == NULL || *gameInfo.variantName == NULLCHAR)) {
12992             startedFromPositionFile = FALSE; /* [HGM] loadPos: variant switch likely makes position invalid */
12993             ResetFrontEnd(); // [HGM] might need other bitmaps. Cannot use Reset() because it clears gameInfo :-(
12994             InitPosition(TRUE);
12995             oldVariant = gameInfo.variant;
12996             if (appData.debugMode)
12997               fprintf(debugFP, "New variant %d\n", (int) oldVariant);
12998         }
12999
13000
13001         if (gameInfo.fen != NULL) {
13002           Board initial_position;
13003           startedFromSetupPosition = TRUE;
13004           if (!ParseFEN(initial_position, &blackPlaysFirst, gameInfo.fen, TRUE)) {
13005             Reset(TRUE, TRUE);
13006             DisplayError(_("Bad FEN position in file"), 0);
13007             return FALSE;
13008           }
13009           CopyBoard(boards[0], initial_position);
13010           if(*engineVariant) // [HGM] for now, assume FEN in engine-defined variant game is default initial position
13011             CopyBoard(initialPosition, initial_position);
13012           if (blackPlaysFirst) {
13013             currentMove = forwardMostMove = backwardMostMove = 1;
13014             CopyBoard(boards[1], initial_position);
13015             safeStrCpy(moveList[0], "", sizeof(moveList[0])/sizeof(moveList[0][0]));
13016             safeStrCpy(parseList[0], "", sizeof(parseList[0])/sizeof(parseList[0][0]));
13017             timeRemaining[0][1] = whiteTimeRemaining;
13018             timeRemaining[1][1] = blackTimeRemaining;
13019             if (commentList[0] != NULL) {
13020               commentList[1] = commentList[0];
13021               commentList[0] = NULL;
13022             }
13023           } else {
13024             currentMove = forwardMostMove = backwardMostMove = 0;
13025           }
13026           /* [HGM] copy FEN attributes as well. Bugfix 4.3.14m and 4.3.15e: moved to after 'blackPlaysFirst' */
13027           {   int i;
13028               initialRulePlies = FENrulePlies;
13029               for( i=0; i< nrCastlingRights; i++ )
13030                   initialRights[i] = initial_position[CASTLING][i];
13031           }
13032           yyboardindex = forwardMostMove;
13033           free(gameInfo.fen);
13034           gameInfo.fen = NULL;
13035         }
13036
13037         yyboardindex = forwardMostMove;
13038         cm = (ChessMove) Myylex();
13039
13040         /* Handle comments interspersed among the tags */
13041         while (cm == Comment) {
13042             char *p;
13043             if (appData.debugMode)
13044               fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
13045             p = yy_text;
13046             AppendComment(currentMove, p, FALSE);
13047             yyboardindex = forwardMostMove;
13048             cm = (ChessMove) Myylex();
13049         }
13050     }
13051
13052     /* don't rely on existence of Event tag since if game was
13053      * pasted from clipboard the Event tag may not exist
13054      */
13055     if (numPGNTags > 0){
13056         char *tags;
13057         if (gameInfo.variant == VariantNormal) {
13058           VariantClass v = StringToVariant(gameInfo.event);
13059           // [HGM] do not recognize variants from event tag that were introduced after supporting variant tag
13060           if(v < VariantShogi) gameInfo.variant = v;
13061         }
13062         if (!matchMode) {
13063           if( appData.autoDisplayTags ) {
13064             tags = PGNTags(&gameInfo);
13065             TagsPopUp(tags, CmailMsg());
13066             free(tags);
13067           }
13068         }
13069     } else {
13070         /* Make something up, but don't display it now */
13071         SetGameInfo();
13072         TagsPopDown();
13073     }
13074
13075     if (cm == PositionDiagram) {
13076         int i, j;
13077         char *p;
13078         Board initial_position;
13079
13080         if (appData.debugMode)
13081           fprintf(debugFP, "Parsed PositionDiagram: %s\n", yy_text);
13082
13083         if (!startedFromSetupPosition) {
13084             p = yy_text;
13085             for (i = BOARD_HEIGHT - 1; i >= 0; i--)
13086               for (j = BOARD_LEFT; j < BOARD_RGHT; p++)
13087                 switch (*p) {
13088                   case '{':
13089                   case '[':
13090                   case '-':
13091                   case ' ':
13092                   case '\t':
13093                   case '\n':
13094                   case '\r':
13095                     break;
13096                   default:
13097                     initial_position[i][j++] = CharToPiece(*p);
13098                     break;
13099                 }
13100             while (*p == ' ' || *p == '\t' ||
13101                    *p == '\n' || *p == '\r') p++;
13102
13103             if (strncmp(p, "black", strlen("black"))==0)
13104               blackPlaysFirst = TRUE;
13105             else
13106               blackPlaysFirst = FALSE;
13107             startedFromSetupPosition = TRUE;
13108
13109             CopyBoard(boards[0], initial_position);
13110             if (blackPlaysFirst) {
13111                 currentMove = forwardMostMove = backwardMostMove = 1;
13112                 CopyBoard(boards[1], initial_position);
13113                 safeStrCpy(moveList[0], "", sizeof(moveList[0])/sizeof(moveList[0][0]));
13114                 safeStrCpy(parseList[0], "", sizeof(parseList[0])/sizeof(parseList[0][0]));
13115                 timeRemaining[0][1] = whiteTimeRemaining;
13116                 timeRemaining[1][1] = blackTimeRemaining;
13117                 if (commentList[0] != NULL) {
13118                     commentList[1] = commentList[0];
13119                     commentList[0] = NULL;
13120                 }
13121             } else {
13122                 currentMove = forwardMostMove = backwardMostMove = 0;
13123             }
13124         }
13125         yyboardindex = forwardMostMove;
13126         cm = (ChessMove) Myylex();
13127     }
13128
13129   if(!creatingBook) {
13130     if (first.pr == NoProc) {
13131         StartChessProgram(&first);
13132     }
13133     InitChessProgram(&first, FALSE);
13134     if(gameInfo.variant == VariantUnknown && *oldName) {
13135         safeStrCpy(engineVariant, oldName, MSG_SIZ);
13136         gameInfo.variant = v;
13137     }
13138     SendToProgram("force\n", &first);
13139     if (startedFromSetupPosition) {
13140         SendBoard(&first, forwardMostMove);
13141     if (appData.debugMode) {
13142         fprintf(debugFP, "Load Game\n");
13143     }
13144         DisplayBothClocks();
13145     }
13146   }
13147
13148     /* [HGM] server: flag to write setup moves in broadcast file as one */
13149     loadFlag = appData.suppressLoadMoves;
13150
13151     while (cm == Comment) {
13152         char *p;
13153         if (appData.debugMode)
13154           fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
13155         p = yy_text;
13156         AppendComment(currentMove, p, FALSE);
13157         yyboardindex = forwardMostMove;
13158         cm = (ChessMove) Myylex();
13159     }
13160
13161     if ((cm == EndOfFile && lastLoadGameStart != EndOfFile ) ||
13162         cm == WhiteWins || cm == BlackWins ||
13163         cm == GameIsDrawn || cm == GameUnfinished) {
13164         DisplayMessage("", _("No moves in game"));
13165         if (cmailMsgLoaded) {
13166             if (appData.debugMode)
13167               fprintf(debugFP, "Setting flipView to %d.\n", FALSE);
13168             ClearHighlights();
13169             flipView = FALSE;
13170         }
13171         DrawPosition(FALSE, boards[currentMove]);
13172         DisplayBothClocks();
13173         gameMode = EditGame;
13174         ModeHighlight();
13175         gameFileFP = NULL;
13176         cmailOldMove = 0;
13177         return TRUE;
13178     }
13179
13180     // [HGM] PV info: routine tests if comment empty
13181     if (!matchMode && (pausing || appData.timeDelay != 0)) {
13182         DisplayComment(currentMove - 1, commentList[currentMove]);
13183     }
13184     if (!matchMode && appData.timeDelay != 0)
13185       DrawPosition(FALSE, boards[currentMove]);
13186
13187     if (gameMode == AnalyzeFile || gameMode == AnalyzeMode) {
13188       programStats.ok_to_send = 1;
13189     }
13190
13191     /* if the first token after the PGN tags is a move
13192      * and not move number 1, retrieve it from the parser
13193      */
13194     if (cm != MoveNumberOne)
13195         LoadGameOneMove(cm);
13196
13197     /* load the remaining moves from the file */
13198     while (LoadGameOneMove(EndOfFile)) {
13199       timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
13200       timeRemaining[1][forwardMostMove] = blackTimeRemaining;
13201     }
13202
13203     /* rewind to the start of the game */
13204     currentMove = backwardMostMove;
13205
13206     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
13207
13208     if (oldGameMode == AnalyzeFile) {
13209       appData.loadGameIndex = -1; // [HGM] order auto-stepping through games
13210       AnalyzeFileEvent();
13211     } else
13212     if (oldGameMode == AnalyzeMode) {
13213       AnalyzeFileEvent();
13214     }
13215
13216     if(gameInfo.result == GameUnfinished && gameInfo.resultDetails && appData.clockMode) {
13217         long int w, b; // [HGM] adjourn: restore saved clock times
13218         char *p = strstr(gameInfo.resultDetails, "(Clocks:");
13219         if(p && sscanf(p+8, "%ld,%ld", &w, &b) == 2) {
13220             timeRemaining[0][forwardMostMove] = whiteTimeRemaining = 1000*w + 500;
13221             timeRemaining[1][forwardMostMove] = blackTimeRemaining = 1000*b + 500;
13222         }
13223     }
13224
13225     if(creatingBook) return TRUE;
13226     if (!matchMode && pos > 0) {
13227         ToNrEvent(pos); // [HGM] no autoplay if selected on position
13228     } else
13229     if (matchMode || appData.timeDelay == 0) {
13230       ToEndEvent();
13231     } else if (appData.timeDelay > 0) {
13232       AutoPlayGameLoop();
13233     }
13234
13235     if (appData.debugMode)
13236         fprintf(debugFP, "LoadGame(): on exit, gameMode %d\n", gameMode);
13237
13238     loadFlag = 0; /* [HGM] true game starts */
13239     return TRUE;
13240 }
13241
13242 /* Support for LoadNextPosition, LoadPreviousPosition, ReloadSamePosition */
13243 int
13244 ReloadPosition (int offset)
13245 {
13246     int positionNumber = lastLoadPositionNumber + offset;
13247     if (lastLoadPositionFP == NULL) {
13248         DisplayError(_("No position has been loaded yet"), 0);
13249         return FALSE;
13250     }
13251     if (positionNumber <= 0) {
13252         DisplayError(_("Can't back up any further"), 0);
13253         return FALSE;
13254     }
13255     return LoadPosition(lastLoadPositionFP, positionNumber,
13256                         lastLoadPositionTitle);
13257 }
13258
13259 /* Load the nth position from the given file */
13260 int
13261 LoadPositionFromFile (char *filename, int n, char *title)
13262 {
13263     FILE *f;
13264     char buf[MSG_SIZ];
13265
13266     if (strcmp(filename, "-") == 0) {
13267         return LoadPosition(stdin, n, "stdin");
13268     } else {
13269         f = fopen(filename, "rb");
13270         if (f == NULL) {
13271             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
13272             DisplayError(buf, errno);
13273             return FALSE;
13274         } else {
13275             return LoadPosition(f, n, title);
13276         }
13277     }
13278 }
13279
13280 /* Load the nth position from the given open file, and close it */
13281 int
13282 LoadPosition (FILE *f, int positionNumber, char *title)
13283 {
13284     char *p, line[MSG_SIZ];
13285     Board initial_position;
13286     int i, j, fenMode, pn;
13287
13288     if (gameMode == Training )
13289         SetTrainingModeOff();
13290
13291     if (gameMode != BeginningOfGame) {
13292         Reset(FALSE, TRUE);
13293     }
13294     if (lastLoadPositionFP != NULL && lastLoadPositionFP != f) {
13295         fclose(lastLoadPositionFP);
13296     }
13297     if (positionNumber == 0) positionNumber = 1;
13298     lastLoadPositionFP = f;
13299     lastLoadPositionNumber = positionNumber;
13300     safeStrCpy(lastLoadPositionTitle, title, sizeof(lastLoadPositionTitle)/sizeof(lastLoadPositionTitle[0]));
13301     if (first.pr == NoProc && !appData.noChessProgram) {
13302       StartChessProgram(&first);
13303       InitChessProgram(&first, FALSE);
13304     }
13305     pn = positionNumber;
13306     if (positionNumber < 0) {
13307         /* Negative position number means to seek to that byte offset */
13308         if (fseek(f, -positionNumber, 0) == -1) {
13309             DisplayError(_("Can't seek on position file"), 0);
13310             return FALSE;
13311         };
13312         pn = 1;
13313     } else {
13314         if (fseek(f, 0, 0) == -1) {
13315             if (f == lastLoadPositionFP ?
13316                 positionNumber == lastLoadPositionNumber + 1 :
13317                 positionNumber == 1) {
13318                 pn = 1;
13319             } else {
13320                 DisplayError(_("Can't seek on position file"), 0);
13321                 return FALSE;
13322             }
13323         }
13324     }
13325     /* See if this file is FEN or old-style xboard */
13326     if (fgets(line, MSG_SIZ, f) == NULL) {
13327         DisplayError(_("Position not found in file"), 0);
13328         return FALSE;
13329     }
13330     // [HGM] FEN can begin with digit, any piece letter valid in this variant, or a + for Shogi promoted pieces (or * for blackout)
13331     fenMode = line[0] >= '0' && line[0] <= '9' || line[0] == '+' || line[0] == '*' || CharToPiece(line[0]) != EmptySquare;
13332
13333     if (pn >= 2) {
13334         if (fenMode || line[0] == '#') pn--;
13335         while (pn > 0) {
13336             /* skip positions before number pn */
13337             if (fgets(line, MSG_SIZ, f) == NULL) {
13338                 Reset(TRUE, TRUE);
13339                 DisplayError(_("Position not found in file"), 0);
13340                 return FALSE;
13341             }
13342             if (fenMode || line[0] == '#') pn--;
13343         }
13344     }
13345
13346     if (fenMode) {
13347         char *p;
13348         if (!ParseFEN(initial_position, &blackPlaysFirst, line, TRUE)) {
13349             DisplayError(_("Bad FEN position in file"), 0);
13350             return FALSE;
13351         }
13352         if((p = strstr(line, ";")) && (p = strstr(p+1, "bm "))) { // EPD with best move
13353             sscanf(p+3, "%s", bestMove);
13354         } else *bestMove = NULLCHAR;
13355     } else {
13356         (void) fgets(line, MSG_SIZ, f);
13357         (void) fgets(line, MSG_SIZ, f);
13358
13359         for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
13360             (void) fgets(line, MSG_SIZ, f);
13361             for (p = line, j = BOARD_LEFT; j < BOARD_RGHT; p++) {
13362                 if (*p == ' ')
13363                   continue;
13364                 initial_position[i][j++] = CharToPiece(*p);
13365             }
13366         }
13367
13368         blackPlaysFirst = FALSE;
13369         if (!feof(f)) {
13370             (void) fgets(line, MSG_SIZ, f);
13371             if (strncmp(line, "black", strlen("black"))==0)
13372               blackPlaysFirst = TRUE;
13373         }
13374     }
13375     startedFromSetupPosition = TRUE;
13376
13377     CopyBoard(boards[0], initial_position);
13378     if (blackPlaysFirst) {
13379         currentMove = forwardMostMove = backwardMostMove = 1;
13380         safeStrCpy(moveList[0], "", sizeof(moveList[0])/sizeof(moveList[0][0]));
13381         safeStrCpy(parseList[0], "", sizeof(parseList[0])/sizeof(parseList[0][0]));
13382         CopyBoard(boards[1], initial_position);
13383         DisplayMessage("", _("Black to play"));
13384     } else {
13385         currentMove = forwardMostMove = backwardMostMove = 0;
13386         DisplayMessage("", _("White to play"));
13387     }
13388     initialRulePlies = FENrulePlies; /* [HGM] copy FEN attributes as well */
13389     if(first.pr != NoProc) { // [HGM] in tourney-mode a position can be loaded before the chess engine is installed
13390         SendToProgram("force\n", &first);
13391         SendBoard(&first, forwardMostMove);
13392     }
13393     if (appData.debugMode) {
13394 int i, j;
13395   for(i=0;i<2;i++){for(j=0;j<6;j++)fprintf(debugFP, " %d", boards[i][CASTLING][j]);fprintf(debugFP,"\n");}
13396   for(j=0;j<6;j++)fprintf(debugFP, " %d", initialRights[j]);fprintf(debugFP,"\n");
13397         fprintf(debugFP, "Load Position\n");
13398     }
13399
13400     if (positionNumber > 1) {
13401       snprintf(line, MSG_SIZ, "%s %d", title, positionNumber);
13402         DisplayTitle(line);
13403     } else {
13404         DisplayTitle(title);
13405     }
13406     gameMode = EditGame;
13407     ModeHighlight();
13408     ResetClocks();
13409     timeRemaining[0][1] = whiteTimeRemaining;
13410     timeRemaining[1][1] = blackTimeRemaining;
13411     DrawPosition(FALSE, boards[currentMove]);
13412
13413     return TRUE;
13414 }
13415
13416
13417 void
13418 CopyPlayerNameIntoFileName (char **dest, char *src)
13419 {
13420     while (*src != NULLCHAR && *src != ',') {
13421         if (*src == ' ') {
13422             *(*dest)++ = '_';
13423             src++;
13424         } else {
13425             *(*dest)++ = *src++;
13426         }
13427     }
13428 }
13429
13430 char *
13431 DefaultFileName (char *ext)
13432 {
13433     static char def[MSG_SIZ];
13434     char *p;
13435
13436     if (gameInfo.white != NULL && gameInfo.white[0] != '-') {
13437         p = def;
13438         CopyPlayerNameIntoFileName(&p, gameInfo.white);
13439         *p++ = '-';
13440         CopyPlayerNameIntoFileName(&p, gameInfo.black);
13441         *p++ = '.';
13442         safeStrCpy(p, ext, MSG_SIZ-2-strlen(gameInfo.white)-strlen(gameInfo.black));
13443     } else {
13444         def[0] = NULLCHAR;
13445     }
13446     return def;
13447 }
13448
13449 /* Save the current game to the given file */
13450 int
13451 SaveGameToFile (char *filename, int append)
13452 {
13453     FILE *f;
13454     char buf[MSG_SIZ];
13455     int result, i, t,tot=0;
13456
13457     if (strcmp(filename, "-") == 0) {
13458         return SaveGame(stdout, 0, NULL);
13459     } else {
13460         for(i=0; i<10; i++) { // upto 10 tries
13461              f = fopen(filename, append ? "a" : "w");
13462              if(f && i) fprintf(f, "[Delay \"%d retries, %d msec\"]\n",i,tot);
13463              if(f || errno != 13) break;
13464              DoSleep(t = 5 + random()%11); // wait 5-15 msec
13465              tot += t;
13466         }
13467         if (f == NULL) {
13468             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
13469             DisplayError(buf, errno);
13470             return FALSE;
13471         } else {
13472             safeStrCpy(buf, lastMsg, MSG_SIZ);
13473             DisplayMessage(_("Waiting for access to save file"), "");
13474             flock(fileno(f), LOCK_EX); // [HGM] lock: lock file while we are writing
13475             DisplayMessage(_("Saving game"), "");
13476             if(lseek(fileno(f), 0, SEEK_END) == -1) DisplayError(_("Bad Seek"), errno);     // better safe than sorry...
13477             result = SaveGame(f, 0, NULL);
13478             DisplayMessage(buf, "");
13479             return result;
13480         }
13481     }
13482 }
13483
13484 char *
13485 SavePart (char *str)
13486 {
13487     static char buf[MSG_SIZ];
13488     char *p;
13489
13490     p = strchr(str, ' ');
13491     if (p == NULL) return str;
13492     strncpy(buf, str, p - str);
13493     buf[p - str] = NULLCHAR;
13494     return buf;
13495 }
13496
13497 #define PGN_MAX_LINE 75
13498
13499 #define PGN_SIDE_WHITE  0
13500 #define PGN_SIDE_BLACK  1
13501
13502 static int
13503 FindFirstMoveOutOfBook (int side)
13504 {
13505     int result = -1;
13506
13507     if( backwardMostMove == 0 && ! startedFromSetupPosition) {
13508         int index = backwardMostMove;
13509         int has_book_hit = 0;
13510
13511         if( (index % 2) != side ) {
13512             index++;
13513         }
13514
13515         while( index < forwardMostMove ) {
13516             /* Check to see if engine is in book */
13517             int depth = pvInfoList[index].depth;
13518             int score = pvInfoList[index].score;
13519             int in_book = 0;
13520
13521             if( depth <= 2 ) {
13522                 in_book = 1;
13523             }
13524             else if( score == 0 && depth == 63 ) {
13525                 in_book = 1; /* Zappa */
13526             }
13527             else if( score == 2 && depth == 99 ) {
13528                 in_book = 1; /* Abrok */
13529             }
13530
13531             has_book_hit += in_book;
13532
13533             if( ! in_book ) {
13534                 result = index;
13535
13536                 break;
13537             }
13538
13539             index += 2;
13540         }
13541     }
13542
13543     return result;
13544 }
13545
13546 void
13547 GetOutOfBookInfo (char * buf)
13548 {
13549     int oob[2];
13550     int i;
13551     int offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
13552
13553     oob[0] = FindFirstMoveOutOfBook( PGN_SIDE_WHITE );
13554     oob[1] = FindFirstMoveOutOfBook( PGN_SIDE_BLACK );
13555
13556     *buf = '\0';
13557
13558     if( oob[0] >= 0 || oob[1] >= 0 ) {
13559         for( i=0; i<2; i++ ) {
13560             int idx = oob[i];
13561
13562             if( idx >= 0 ) {
13563                 if( i > 0 && oob[0] >= 0 ) {
13564                     strcat( buf, "   " );
13565                 }
13566
13567                 sprintf( buf+strlen(buf), "%d%s. ", (idx - offset)/2 + 1, idx & 1 ? ".." : "" );
13568                 sprintf( buf+strlen(buf), "%s%.2f",
13569                     pvInfoList[idx].score >= 0 ? "+" : "",
13570                     pvInfoList[idx].score / 100.0 );
13571             }
13572         }
13573     }
13574 }
13575
13576 /* Save game in PGN style */
13577 static void
13578 SaveGamePGN2 (FILE *f)
13579 {
13580     int i, offset, linelen, newblock;
13581 //    char *movetext;
13582     char numtext[32];
13583     int movelen, numlen, blank;
13584     char move_buffer[100]; /* [AS] Buffer for move+PV info */
13585
13586     offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
13587
13588     PrintPGNTags(f, &gameInfo);
13589
13590     if(appData.numberTag && matchMode) fprintf(f, "[Number \"%d\"]\n", nextGame+1); // [HGM] number tag
13591
13592     if (backwardMostMove > 0 || startedFromSetupPosition) {
13593         char *fen = PositionToFEN(backwardMostMove, NULL, 1);
13594         fprintf(f, "[FEN \"%s\"]\n[SetUp \"1\"]\n", fen);
13595         fprintf(f, "\n{--------------\n");
13596         PrintPosition(f, backwardMostMove);
13597         fprintf(f, "--------------}\n");
13598         free(fen);
13599     }
13600     else {
13601         /* [AS] Out of book annotation */
13602         if( appData.saveOutOfBookInfo ) {
13603             char buf[64];
13604
13605             GetOutOfBookInfo( buf );
13606
13607             if( buf[0] != '\0' ) {
13608                 fprintf( f, "[%s \"%s\"]\n", PGN_OUT_OF_BOOK, buf );
13609             }
13610         }
13611
13612         fprintf(f, "\n");
13613     }
13614
13615     i = backwardMostMove;
13616     linelen = 0;
13617     newblock = TRUE;
13618
13619     while (i < forwardMostMove) {
13620         /* Print comments preceding this move */
13621         if (commentList[i] != NULL) {
13622             if (linelen > 0) fprintf(f, "\n");
13623             fprintf(f, "%s", commentList[i]);
13624             linelen = 0;
13625             newblock = TRUE;
13626         }
13627
13628         /* Format move number */
13629         if ((i % 2) == 0)
13630           snprintf(numtext, sizeof(numtext)/sizeof(numtext[0]),"%d.", (i - offset)/2 + 1);
13631         else
13632           if (newblock)
13633             snprintf(numtext, sizeof(numtext)/sizeof(numtext[0]), "%d...", (i - offset)/2 + 1);
13634           else
13635             numtext[0] = NULLCHAR;
13636
13637         numlen = strlen(numtext);
13638         newblock = FALSE;
13639
13640         /* Print move number */
13641         blank = linelen > 0 && numlen > 0;
13642         if (linelen + (blank ? 1 : 0) + numlen > PGN_MAX_LINE) {
13643             fprintf(f, "\n");
13644             linelen = 0;
13645             blank = 0;
13646         }
13647         if (blank) {
13648             fprintf(f, " ");
13649             linelen++;
13650         }
13651         fprintf(f, "%s", numtext);
13652         linelen += numlen;
13653
13654         /* Get move */
13655         safeStrCpy(move_buffer, SavePart(parseList[i]), sizeof(move_buffer)/sizeof(move_buffer[0])); // [HGM] pgn: print move via buffer, so it can be edited
13656         movelen = strlen(move_buffer); /* [HGM] pgn: line-break point before move */
13657
13658         /* Print move */
13659         blank = linelen > 0 && movelen > 0;
13660         if (linelen + (blank ? 1 : 0) + movelen > PGN_MAX_LINE) {
13661             fprintf(f, "\n");
13662             linelen = 0;
13663             blank = 0;
13664         }
13665         if (blank) {
13666             fprintf(f, " ");
13667             linelen++;
13668         }
13669         fprintf(f, "%s", move_buffer);
13670         linelen += movelen;
13671
13672         /* [AS] Add PV info if present */
13673         if( i >= 0 && appData.saveExtendedInfoInPGN && pvInfoList[i].depth > 0 ) {
13674             /* [HGM] add time */
13675             char buf[MSG_SIZ]; int seconds;
13676
13677             seconds = (pvInfoList[i].time+5)/10; // deci-seconds, rounded to nearest
13678
13679             if( seconds <= 0)
13680               buf[0] = 0;
13681             else
13682               if( seconds < 30 )
13683                 snprintf(buf, MSG_SIZ, " %3.1f%c", seconds/10., 0);
13684               else
13685                 {
13686                   seconds = (seconds + 4)/10; // round to full seconds
13687                   if( seconds < 60 )
13688                     snprintf(buf, MSG_SIZ, " %d%c", seconds, 0);
13689                   else
13690                     snprintf(buf, MSG_SIZ, " %d:%02d%c", seconds/60, seconds%60, 0);
13691                 }
13692
13693             snprintf( move_buffer, sizeof(move_buffer)/sizeof(move_buffer[0]),"{%s%.2f/%d%s}",
13694                       pvInfoList[i].score >= 0 ? "+" : "",
13695                       pvInfoList[i].score / 100.0,
13696                       pvInfoList[i].depth,
13697                       buf );
13698
13699             movelen = strlen(move_buffer); /* [HGM] pgn: line-break point after move */
13700
13701             /* Print score/depth */
13702             blank = linelen > 0 && movelen > 0;
13703             if (linelen + (blank ? 1 : 0) + movelen > PGN_MAX_LINE) {
13704                 fprintf(f, "\n");
13705                 linelen = 0;
13706                 blank = 0;
13707             }
13708             if (blank) {
13709                 fprintf(f, " ");
13710                 linelen++;
13711             }
13712             fprintf(f, "%s", move_buffer);
13713             linelen += movelen;
13714         }
13715
13716         i++;
13717     }
13718
13719     /* Start a new line */
13720     if (linelen > 0) fprintf(f, "\n");
13721
13722     /* Print comments after last move */
13723     if (commentList[i] != NULL) {
13724         fprintf(f, "%s\n", commentList[i]);
13725     }
13726
13727     /* Print result */
13728     if (gameInfo.resultDetails != NULL &&
13729         gameInfo.resultDetails[0] != NULLCHAR) {
13730         char buf[MSG_SIZ], *p = gameInfo.resultDetails;
13731         if(gameInfo.result == GameUnfinished && appData.clockMode &&
13732            (gameMode == MachinePlaysWhite || gameMode == MachinePlaysBlack || gameMode == TwoMachinesPlay)) // [HGM] adjourn: save clock settings
13733             snprintf(buf, MSG_SIZ, "%s (Clocks: %ld, %ld)", p, whiteTimeRemaining/1000, blackTimeRemaining/1000), p = buf;
13734         fprintf(f, "{%s} %s\n\n", p, PGNResult(gameInfo.result));
13735     } else {
13736         fprintf(f, "%s\n\n", PGNResult(gameInfo.result));
13737     }
13738 }
13739
13740 /* Save game in PGN style and close the file */
13741 int
13742 SaveGamePGN (FILE *f)
13743 {
13744     SaveGamePGN2(f);
13745     fclose(f);
13746     lastSavedGame = GameCheckSum(); // [HGM] save: remember ID of last saved game to prevent double saving
13747     return TRUE;
13748 }
13749
13750 /* Save game in old style and close the file */
13751 int
13752 SaveGameOldStyle (FILE *f)
13753 {
13754     int i, offset;
13755     time_t tm;
13756
13757     tm = time((time_t *) NULL);
13758
13759     fprintf(f, "# %s game file -- %s", programName, ctime(&tm));
13760     PrintOpponents(f);
13761
13762     if (backwardMostMove > 0 || startedFromSetupPosition) {
13763         fprintf(f, "\n[--------------\n");
13764         PrintPosition(f, backwardMostMove);
13765         fprintf(f, "--------------]\n");
13766     } else {
13767         fprintf(f, "\n");
13768     }
13769
13770     i = backwardMostMove;
13771     offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
13772
13773     while (i < forwardMostMove) {
13774         if (commentList[i] != NULL) {
13775             fprintf(f, "[%s]\n", commentList[i]);
13776         }
13777
13778         if ((i % 2) == 1) {
13779             fprintf(f, "%d. ...  %s\n", (i - offset)/2 + 1, parseList[i]);
13780             i++;
13781         } else {
13782             fprintf(f, "%d. %s  ", (i - offset)/2 + 1, parseList[i]);
13783             i++;
13784             if (commentList[i] != NULL) {
13785                 fprintf(f, "\n");
13786                 continue;
13787             }
13788             if (i >= forwardMostMove) {
13789                 fprintf(f, "\n");
13790                 break;
13791             }
13792             fprintf(f, "%s\n", parseList[i]);
13793             i++;
13794         }
13795     }
13796
13797     if (commentList[i] != NULL) {
13798         fprintf(f, "[%s]\n", commentList[i]);
13799     }
13800
13801     /* This isn't really the old style, but it's close enough */
13802     if (gameInfo.resultDetails != NULL &&
13803         gameInfo.resultDetails[0] != NULLCHAR) {
13804         fprintf(f, "%s (%s)\n\n", PGNResult(gameInfo.result),
13805                 gameInfo.resultDetails);
13806     } else {
13807         fprintf(f, "%s\n\n", PGNResult(gameInfo.result));
13808     }
13809
13810     fclose(f);
13811     return TRUE;
13812 }
13813
13814 /* Save the current game to open file f and close the file */
13815 int
13816 SaveGame (FILE *f, int dummy, char *dummy2)
13817 {
13818     if (gameMode == EditPosition) EditPositionDone(TRUE);
13819     lastSavedGame = GameCheckSum(); // [HGM] save: remember ID of last saved game to prevent double saving
13820     if (appData.oldSaveStyle)
13821       return SaveGameOldStyle(f);
13822     else
13823       return SaveGamePGN(f);
13824 }
13825
13826 /* Save the current position to the given file */
13827 int
13828 SavePositionToFile (char *filename)
13829 {
13830     FILE *f;
13831     char buf[MSG_SIZ];
13832
13833     if (strcmp(filename, "-") == 0) {
13834         return SavePosition(stdout, 0, NULL);
13835     } else {
13836         f = fopen(filename, "a");
13837         if (f == NULL) {
13838             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
13839             DisplayError(buf, errno);
13840             return FALSE;
13841         } else {
13842             safeStrCpy(buf, lastMsg, MSG_SIZ);
13843             DisplayMessage(_("Waiting for access to save file"), "");
13844             flock(fileno(f), LOCK_EX); // [HGM] lock
13845             DisplayMessage(_("Saving position"), "");
13846             lseek(fileno(f), 0, SEEK_END);     // better safe than sorry...
13847             SavePosition(f, 0, NULL);
13848             DisplayMessage(buf, "");
13849             return TRUE;
13850         }
13851     }
13852 }
13853
13854 /* Save the current position to the given open file and close the file */
13855 int
13856 SavePosition (FILE *f, int dummy, char *dummy2)
13857 {
13858     time_t tm;
13859     char *fen;
13860
13861     if (gameMode == EditPosition) EditPositionDone(TRUE);
13862     if (appData.oldSaveStyle) {
13863         tm = time((time_t *) NULL);
13864
13865         fprintf(f, "# %s position file -- %s", programName, ctime(&tm));
13866         PrintOpponents(f);
13867         fprintf(f, "[--------------\n");
13868         PrintPosition(f, currentMove);
13869         fprintf(f, "--------------]\n");
13870     } else {
13871         fen = PositionToFEN(currentMove, NULL, 1);
13872         fprintf(f, "%s\n", fen);
13873         free(fen);
13874     }
13875     fclose(f);
13876     return TRUE;
13877 }
13878
13879 void
13880 ReloadCmailMsgEvent (int unregister)
13881 {
13882 #if !WIN32
13883     static char *inFilename = NULL;
13884     static char *outFilename;
13885     int i;
13886     struct stat inbuf, outbuf;
13887     int status;
13888
13889     /* Any registered moves are unregistered if unregister is set, */
13890     /* i.e. invoked by the signal handler */
13891     if (unregister) {
13892         for (i = 0; i < CMAIL_MAX_GAMES; i ++) {
13893             cmailMoveRegistered[i] = FALSE;
13894             if (cmailCommentList[i] != NULL) {
13895                 free(cmailCommentList[i]);
13896                 cmailCommentList[i] = NULL;
13897             }
13898         }
13899         nCmailMovesRegistered = 0;
13900     }
13901
13902     for (i = 0; i < CMAIL_MAX_GAMES; i ++) {
13903         cmailResult[i] = CMAIL_NOT_RESULT;
13904     }
13905     nCmailResults = 0;
13906
13907     if (inFilename == NULL) {
13908         /* Because the filenames are static they only get malloced once  */
13909         /* and they never get freed                                      */
13910         inFilename = (char *) malloc(strlen(appData.cmailGameName) + 9);
13911         sprintf(inFilename, "%s.game.in", appData.cmailGameName);
13912
13913         outFilename = (char *) malloc(strlen(appData.cmailGameName) + 5);
13914         sprintf(outFilename, "%s.out", appData.cmailGameName);
13915     }
13916
13917     status = stat(outFilename, &outbuf);
13918     if (status < 0) {
13919         cmailMailedMove = FALSE;
13920     } else {
13921         status = stat(inFilename, &inbuf);
13922         cmailMailedMove = (inbuf.st_mtime < outbuf.st_mtime);
13923     }
13924
13925     /* LoadGameFromFile(CMAIL_MAX_GAMES) with cmailMsgLoaded == TRUE
13926        counts the games, notes how each one terminated, etc.
13927
13928        It would be nice to remove this kludge and instead gather all
13929        the information while building the game list.  (And to keep it
13930        in the game list nodes instead of having a bunch of fixed-size
13931        parallel arrays.)  Note this will require getting each game's
13932        termination from the PGN tags, as the game list builder does
13933        not process the game moves.  --mann
13934        */
13935     cmailMsgLoaded = TRUE;
13936     LoadGameFromFile(inFilename, CMAIL_MAX_GAMES, "", FALSE);
13937
13938     /* Load first game in the file or popup game menu */
13939     LoadGameFromFile(inFilename, 0, appData.cmailGameName, TRUE);
13940
13941 #endif /* !WIN32 */
13942     return;
13943 }
13944
13945 int
13946 RegisterMove ()
13947 {
13948     FILE *f;
13949     char string[MSG_SIZ];
13950
13951     if (   cmailMailedMove
13952         || (cmailResult[lastLoadGameNumber - 1] == CMAIL_OLD_RESULT)) {
13953         return TRUE;            /* Allow free viewing  */
13954     }
13955
13956     /* Unregister move to ensure that we don't leave RegisterMove        */
13957     /* with the move registered when the conditions for registering no   */
13958     /* longer hold                                                       */
13959     if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
13960         cmailMoveRegistered[lastLoadGameNumber - 1] = FALSE;
13961         nCmailMovesRegistered --;
13962
13963         if (cmailCommentList[lastLoadGameNumber - 1] != NULL)
13964           {
13965               free(cmailCommentList[lastLoadGameNumber - 1]);
13966               cmailCommentList[lastLoadGameNumber - 1] = NULL;
13967           }
13968     }
13969
13970     if (cmailOldMove == -1) {
13971         DisplayError(_("You have edited the game history.\nUse Reload Same Game and make your move again."), 0);
13972         return FALSE;
13973     }
13974
13975     if (currentMove > cmailOldMove + 1) {
13976         DisplayError(_("You have entered too many moves.\nBack up to the correct position and try again."), 0);
13977         return FALSE;
13978     }
13979
13980     if (currentMove < cmailOldMove) {
13981         DisplayError(_("Displayed position is not current.\nStep forward to the correct position and try again."), 0);
13982         return FALSE;
13983     }
13984
13985     if (forwardMostMove > currentMove) {
13986         /* Silently truncate extra moves */
13987         TruncateGame();
13988     }
13989
13990     if (   (currentMove == cmailOldMove + 1)
13991         || (   (currentMove == cmailOldMove)
13992             && (   (cmailMoveType[lastLoadGameNumber - 1] == CMAIL_ACCEPT)
13993                 || (cmailMoveType[lastLoadGameNumber - 1] == CMAIL_RESIGN)))) {
13994         if (gameInfo.result != GameUnfinished) {
13995             cmailResult[lastLoadGameNumber - 1] = CMAIL_NEW_RESULT;
13996         }
13997
13998         if (commentList[currentMove] != NULL) {
13999             cmailCommentList[lastLoadGameNumber - 1]
14000               = StrSave(commentList[currentMove]);
14001         }
14002         safeStrCpy(cmailMove[lastLoadGameNumber - 1], moveList[currentMove - 1], sizeof(cmailMove[lastLoadGameNumber - 1])/sizeof(cmailMove[lastLoadGameNumber - 1][0]));
14003
14004         if (appData.debugMode)
14005           fprintf(debugFP, "Saving %s for game %d\n",
14006                   cmailMove[lastLoadGameNumber - 1], lastLoadGameNumber);
14007
14008         snprintf(string, MSG_SIZ, "%s.game.out.%d", appData.cmailGameName, lastLoadGameNumber);
14009
14010         f = fopen(string, "w");
14011         if (appData.oldSaveStyle) {
14012             SaveGameOldStyle(f); /* also closes the file */
14013
14014             snprintf(string, MSG_SIZ, "%s.pos.out", appData.cmailGameName);
14015             f = fopen(string, "w");
14016             SavePosition(f, 0, NULL); /* also closes the file */
14017         } else {
14018             fprintf(f, "{--------------\n");
14019             PrintPosition(f, currentMove);
14020             fprintf(f, "--------------}\n\n");
14021
14022             SaveGame(f, 0, NULL); /* also closes the file*/
14023         }
14024
14025         cmailMoveRegistered[lastLoadGameNumber - 1] = TRUE;
14026         nCmailMovesRegistered ++;
14027     } else if (nCmailGames == 1) {
14028         DisplayError(_("You have not made a move yet"), 0);
14029         return FALSE;
14030     }
14031
14032     return TRUE;
14033 }
14034
14035 void
14036 MailMoveEvent ()
14037 {
14038 #if !WIN32
14039     static char *partCommandString = "cmail -xv%s -remail -game %s 2>&1";
14040     FILE *commandOutput;
14041     char buffer[MSG_SIZ], msg[MSG_SIZ], string[MSG_SIZ];
14042     int nBytes = 0;             /*  Suppress warnings on uninitialized variables    */
14043     int nBuffers;
14044     int i;
14045     int archived;
14046     char *arcDir;
14047
14048     if (! cmailMsgLoaded) {
14049         DisplayError(_("The cmail message is not loaded.\nUse Reload CMail Message and make your move again."), 0);
14050         return;
14051     }
14052
14053     if (nCmailGames == nCmailResults) {
14054         DisplayError(_("No unfinished games"), 0);
14055         return;
14056     }
14057
14058 #if CMAIL_PROHIBIT_REMAIL
14059     if (cmailMailedMove) {
14060       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);
14061         DisplayError(msg, 0);
14062         return;
14063     }
14064 #endif
14065
14066     if (! (cmailMailedMove || RegisterMove())) return;
14067
14068     if (   cmailMailedMove
14069         || (nCmailMovesRegistered + nCmailResults == nCmailGames)) {
14070       snprintf(string, MSG_SIZ, partCommandString,
14071                appData.debugMode ? " -v" : "", appData.cmailGameName);
14072         commandOutput = popen(string, "r");
14073
14074         if (commandOutput == NULL) {
14075             DisplayError(_("Failed to invoke cmail"), 0);
14076         } else {
14077             for (nBuffers = 0; (! feof(commandOutput)); nBuffers ++) {
14078                 nBytes = fread(buffer, 1, MSG_SIZ - 1, commandOutput);
14079             }
14080             if (nBuffers > 1) {
14081                 (void) memcpy(msg, buffer + nBytes, MSG_SIZ - nBytes - 1);
14082                 (void) memcpy(msg + MSG_SIZ - nBytes - 1, buffer, nBytes);
14083                 nBytes = MSG_SIZ - 1;
14084             } else {
14085                 (void) memcpy(msg, buffer, nBytes);
14086             }
14087             *(msg + nBytes) = '\0'; /* \0 for end-of-string*/
14088
14089             if(StrStr(msg, "Mailed cmail message to ") != NULL) {
14090                 cmailMailedMove = TRUE; /* Prevent >1 moves    */
14091
14092                 archived = TRUE;
14093                 for (i = 0; i < nCmailGames; i ++) {
14094                     if (cmailResult[i] == CMAIL_NOT_RESULT) {
14095                         archived = FALSE;
14096                     }
14097                 }
14098                 if (   archived
14099                     && (   (arcDir = (char *) getenv("CMAIL_ARCDIR"))
14100                         != NULL)) {
14101                   snprintf(buffer, MSG_SIZ, "%s/%s.%s.archive",
14102                            arcDir,
14103                            appData.cmailGameName,
14104                            gameInfo.date);
14105                     LoadGameFromFile(buffer, 1, buffer, FALSE);
14106                     cmailMsgLoaded = FALSE;
14107                 }
14108             }
14109
14110             DisplayInformation(msg);
14111             pclose(commandOutput);
14112         }
14113     } else {
14114         if ((*cmailMsg) != '\0') {
14115             DisplayInformation(cmailMsg);
14116         }
14117     }
14118
14119     return;
14120 #endif /* !WIN32 */
14121 }
14122
14123 char *
14124 CmailMsg ()
14125 {
14126 #if WIN32
14127     return NULL;
14128 #else
14129     int  prependComma = 0;
14130     char number[5];
14131     char string[MSG_SIZ];       /* Space for game-list */
14132     int  i;
14133
14134     if (!cmailMsgLoaded) return "";
14135
14136     if (cmailMailedMove) {
14137       snprintf(cmailMsg, MSG_SIZ, _("Waiting for reply from opponent\n"));
14138     } else {
14139         /* Create a list of games left */
14140       snprintf(string, MSG_SIZ, "[");
14141         for (i = 0; i < nCmailGames; i ++) {
14142             if (! (   cmailMoveRegistered[i]
14143                    || (cmailResult[i] == CMAIL_OLD_RESULT))) {
14144                 if (prependComma) {
14145                     snprintf(number, sizeof(number)/sizeof(number[0]), ",%d", i + 1);
14146                 } else {
14147                     snprintf(number, sizeof(number)/sizeof(number[0]), "%d", i + 1);
14148                     prependComma = 1;
14149                 }
14150
14151                 strcat(string, number);
14152             }
14153         }
14154         strcat(string, "]");
14155
14156         if (nCmailMovesRegistered + nCmailResults == 0) {
14157             switch (nCmailGames) {
14158               case 1:
14159                 snprintf(cmailMsg, MSG_SIZ, _("Still need to make move for game\n"));
14160                 break;
14161
14162               case 2:
14163                 snprintf(cmailMsg, MSG_SIZ, _("Still need to make moves for both games\n"));
14164                 break;
14165
14166               default:
14167                 snprintf(cmailMsg, MSG_SIZ, _("Still need to make moves for all %d games\n"),
14168                          nCmailGames);
14169                 break;
14170             }
14171         } else {
14172             switch (nCmailGames - nCmailMovesRegistered - nCmailResults) {
14173               case 1:
14174                 snprintf(cmailMsg, MSG_SIZ, _("Still need to make a move for game %s\n"),
14175                          string);
14176                 break;
14177
14178               case 0:
14179                 if (nCmailResults == nCmailGames) {
14180                   snprintf(cmailMsg, MSG_SIZ, _("No unfinished games\n"));
14181                 } else {
14182                   snprintf(cmailMsg, MSG_SIZ, _("Ready to send mail\n"));
14183                 }
14184                 break;
14185
14186               default:
14187                 snprintf(cmailMsg, MSG_SIZ, _("Still need to make moves for games %s\n"),
14188                          string);
14189             }
14190         }
14191     }
14192     return cmailMsg;
14193 #endif /* WIN32 */
14194 }
14195
14196 void
14197 ResetGameEvent ()
14198 {
14199     if (gameMode == Training)
14200       SetTrainingModeOff();
14201
14202     Reset(TRUE, TRUE);
14203     cmailMsgLoaded = FALSE;
14204     if (appData.icsActive) {
14205       SendToICS(ics_prefix);
14206       SendToICS("refresh\n");
14207     }
14208 }
14209
14210 void
14211 ExitEvent (int status)
14212 {
14213     exiting++;
14214     if (exiting > 2) {
14215       /* Give up on clean exit */
14216       exit(status);
14217     }
14218     if (exiting > 1) {
14219       /* Keep trying for clean exit */
14220       return;
14221     }
14222
14223     if (appData.icsActive) printf("\n"); // [HGM] end on new line after closing XBoard
14224     if (appData.icsActive && appData.colorize) Colorize(ColorNone, FALSE);
14225
14226     if (telnetISR != NULL) {
14227       RemoveInputSource(telnetISR);
14228     }
14229     if (icsPR != NoProc) {
14230       DestroyChildProcess(icsPR, TRUE);
14231     }
14232
14233     /* [HGM] crash: leave writing PGN and position entirely to GameEnds() */
14234     GameEnds(gameInfo.result, gameInfo.resultDetails==NULL ? "xboard exit" : gameInfo.resultDetails, GE_PLAYER);
14235
14236     /* [HGM] crash: the above GameEnds() is a dud if another one was running */
14237     /* make sure this other one finishes before killing it!                  */
14238     if(endingGame) { int count = 0;
14239         if(appData.debugMode) fprintf(debugFP, "ExitEvent() during GameEnds(), wait\n");
14240         while(endingGame && count++ < 10) DoSleep(1);
14241         if(appData.debugMode && endingGame) fprintf(debugFP, "GameEnds() seems stuck, proceed exiting\n");
14242     }
14243
14244     /* Kill off chess programs */
14245     if (first.pr != NoProc) {
14246         ExitAnalyzeMode();
14247
14248         DoSleep( appData.delayBeforeQuit );
14249         SendToProgram("quit\n", &first);
14250         DestroyChildProcess(first.pr, 4 + first.useSigterm /* [AS] first.useSigterm */ );
14251     }
14252     if (second.pr != NoProc) {
14253         DoSleep( appData.delayBeforeQuit );
14254         SendToProgram("quit\n", &second);
14255         DestroyChildProcess(second.pr, 4 + second.useSigterm /* [AS] second.useSigterm */ );
14256     }
14257     if (first.isr != NULL) {
14258         RemoveInputSource(first.isr);
14259     }
14260     if (second.isr != NULL) {
14261         RemoveInputSource(second.isr);
14262     }
14263
14264     if (pairing.pr != NoProc) SendToProgram("quit\n", &pairing);
14265     if (pairing.isr != NULL) RemoveInputSource(pairing.isr);
14266
14267     ShutDownFrontEnd();
14268     exit(status);
14269 }
14270
14271 void
14272 PauseEngine (ChessProgramState *cps)
14273 {
14274     SendToProgram("pause\n", cps);
14275     cps->pause = 2;
14276 }
14277
14278 void
14279 UnPauseEngine (ChessProgramState *cps)
14280 {
14281     SendToProgram("resume\n", cps);
14282     cps->pause = 1;
14283 }
14284
14285 void
14286 PauseEvent ()
14287 {
14288     if (appData.debugMode)
14289         fprintf(debugFP, "PauseEvent(): pausing %d\n", pausing);
14290     if (pausing) {
14291         pausing = FALSE;
14292         ModeHighlight();
14293         if(stalledEngine) { // [HGM] pause: resume game by releasing withheld move
14294             StartClocks();
14295             if(gameMode == TwoMachinesPlay) { // we might have to make the opponent resume pondering
14296                 if(stalledEngine->other->pause == 2) UnPauseEngine(stalledEngine->other);
14297                 else if(appData.ponderNextMove) SendToProgram("hard\n", stalledEngine->other);
14298             }
14299             if(appData.ponderNextMove) SendToProgram("hard\n", stalledEngine);
14300             HandleMachineMove(stashedInputMove, stalledEngine);
14301             stalledEngine = NULL;
14302             return;
14303         }
14304         if (gameMode == MachinePlaysWhite ||
14305             gameMode == TwoMachinesPlay   ||
14306             gameMode == MachinePlaysBlack) { // the thinking engine must have used pause mode, or it would have been stalledEngine
14307             if(first.pause)  UnPauseEngine(&first);
14308             else if(appData.ponderNextMove) SendToProgram("hard\n", &first);
14309             if(second.pause) UnPauseEngine(&second);
14310             else if(gameMode == TwoMachinesPlay && appData.ponderNextMove) SendToProgram("hard\n", &second);
14311             StartClocks();
14312         } else {
14313             DisplayBothClocks();
14314         }
14315         if (gameMode == PlayFromGameFile) {
14316             if (appData.timeDelay >= 0)
14317                 AutoPlayGameLoop();
14318         } else if (gameMode == IcsExamining && pauseExamInvalid) {
14319             Reset(FALSE, TRUE);
14320             SendToICS(ics_prefix);
14321             SendToICS("refresh\n");
14322         } else if (currentMove < forwardMostMove && gameMode != AnalyzeMode) {
14323             ForwardInner(forwardMostMove);
14324         }
14325         pauseExamInvalid = FALSE;
14326     } else {
14327         switch (gameMode) {
14328           default:
14329             return;
14330           case IcsExamining:
14331             pauseExamForwardMostMove = forwardMostMove;
14332             pauseExamInvalid = FALSE;
14333             /* fall through */
14334           case IcsObserving:
14335           case IcsPlayingWhite:
14336           case IcsPlayingBlack:
14337             pausing = TRUE;
14338             ModeHighlight();
14339             return;
14340           case PlayFromGameFile:
14341             (void) StopLoadGameTimer();
14342             pausing = TRUE;
14343             ModeHighlight();
14344             break;
14345           case BeginningOfGame:
14346             if (appData.icsActive) return;
14347             /* else fall through */
14348           case MachinePlaysWhite:
14349           case MachinePlaysBlack:
14350           case TwoMachinesPlay:
14351             if (forwardMostMove == 0)
14352               return;           /* don't pause if no one has moved */
14353             if(gameMode == TwoMachinesPlay) { // [HGM] pause: stop clocks if engine can be paused immediately
14354                 ChessProgramState *onMove = (WhiteOnMove(forwardMostMove) == (first.twoMachinesColor[0] == 'w') ? &first : &second);
14355                 if(onMove->pause) {           // thinking engine can be paused
14356                     PauseEngine(onMove);      // do it
14357                     if(onMove->other->pause)  // pondering opponent can always be paused immediately
14358                         PauseEngine(onMove->other);
14359                     else
14360                         SendToProgram("easy\n", onMove->other);
14361                     StopClocks();
14362                 } else if(appData.ponderNextMove) SendToProgram("easy\n", onMove); // pre-emptively bring out of ponder
14363             } else if(gameMode == (WhiteOnMove(forwardMostMove) ? MachinePlaysWhite : MachinePlaysBlack)) { // engine on move
14364                 if(first.pause) {
14365                     PauseEngine(&first);
14366                     StopClocks();
14367                 } else if(appData.ponderNextMove) SendToProgram("easy\n", &first); // pre-emptively bring out of ponder
14368             } else { // human on move, pause pondering by either method
14369                 if(first.pause)
14370                     PauseEngine(&first);
14371                 else if(appData.ponderNextMove)
14372                     SendToProgram("easy\n", &first);
14373                 StopClocks();
14374             }
14375             // if no immediate pausing is possible, wait for engine to move, and stop clocks then
14376           case AnalyzeMode:
14377             pausing = TRUE;
14378             ModeHighlight();
14379             break;
14380         }
14381     }
14382 }
14383
14384 void
14385 EditCommentEvent ()
14386 {
14387     char title[MSG_SIZ];
14388
14389     if (currentMove < 1 || parseList[currentMove - 1][0] == NULLCHAR) {
14390       safeStrCpy(title, _("Edit comment"), sizeof(title)/sizeof(title[0]));
14391     } else {
14392       snprintf(title, MSG_SIZ, _("Edit comment on %d.%s%s"), (currentMove - 1) / 2 + 1,
14393                WhiteOnMove(currentMove - 1) ? " " : ".. ",
14394                parseList[currentMove - 1]);
14395     }
14396
14397     EditCommentPopUp(currentMove, title, commentList[currentMove]);
14398 }
14399
14400
14401 void
14402 EditTagsEvent ()
14403 {
14404     char *tags = PGNTags(&gameInfo);
14405     bookUp = FALSE;
14406     EditTagsPopUp(tags, NULL);
14407     free(tags);
14408 }
14409
14410 void
14411 ToggleSecond ()
14412 {
14413   if(second.analyzing) {
14414     SendToProgram("exit\n", &second);
14415     second.analyzing = FALSE;
14416   } else {
14417     if (second.pr == NoProc) StartChessProgram(&second);
14418     InitChessProgram(&second, FALSE);
14419     FeedMovesToProgram(&second, currentMove);
14420
14421     SendToProgram("analyze\n", &second);
14422     second.analyzing = TRUE;
14423   }
14424 }
14425
14426 /* Toggle ShowThinking */
14427 void
14428 ToggleShowThinking()
14429 {
14430   appData.showThinking = !appData.showThinking;
14431   ShowThinkingEvent();
14432 }
14433
14434 int
14435 AnalyzeModeEvent ()
14436 {
14437     char buf[MSG_SIZ];
14438
14439     if (!first.analysisSupport) {
14440       snprintf(buf, sizeof(buf), _("%s does not support analysis"), first.tidy);
14441       DisplayError(buf, 0);
14442       return 0;
14443     }
14444     /* [DM] icsEngineAnalyze [HGM] This is horrible code; reverse the gameMode and isEngineAnalyze tests! */
14445     if (appData.icsActive) {
14446         if (gameMode != IcsObserving) {
14447           snprintf(buf, MSG_SIZ, _("You are not observing a game"));
14448             DisplayError(buf, 0);
14449             /* secure check */
14450             if (appData.icsEngineAnalyze) {
14451                 if (appData.debugMode)
14452                     fprintf(debugFP, "Found unexpected active ICS engine analyze \n");
14453                 ExitAnalyzeMode();
14454                 ModeHighlight();
14455             }
14456             return 0;
14457         }
14458         /* if enable, user wants to disable icsEngineAnalyze */
14459         if (appData.icsEngineAnalyze) {
14460                 ExitAnalyzeMode();
14461                 ModeHighlight();
14462                 return 0;
14463         }
14464         appData.icsEngineAnalyze = TRUE;
14465         if (appData.debugMode)
14466             fprintf(debugFP, "ICS engine analyze starting... \n");
14467     }
14468
14469     if (gameMode == AnalyzeMode) { ToggleSecond(); return 0; }
14470     if (appData.noChessProgram || gameMode == AnalyzeMode)
14471       return 0;
14472
14473     if (gameMode != AnalyzeFile) {
14474         if (!appData.icsEngineAnalyze) {
14475                EditGameEvent();
14476                if (gameMode != EditGame) return 0;
14477         }
14478         if (!appData.showThinking) ToggleShowThinking();
14479         ResurrectChessProgram();
14480         SendToProgram("analyze\n", &first);
14481         first.analyzing = TRUE;
14482         /*first.maybeThinking = TRUE;*/
14483         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
14484         EngineOutputPopUp();
14485     }
14486     if (!appData.icsEngineAnalyze) {
14487         gameMode = AnalyzeMode;
14488         ClearEngineOutputPane(0); // [TK] exclude: to print exclusion/multipv header
14489     }
14490     pausing = FALSE;
14491     ModeHighlight();
14492     SetGameInfo();
14493
14494     StartAnalysisClock();
14495     GetTimeMark(&lastNodeCountTime);
14496     lastNodeCount = 0;
14497     return 1;
14498 }
14499
14500 void
14501 AnalyzeFileEvent ()
14502 {
14503     if (appData.noChessProgram || gameMode == AnalyzeFile)
14504       return;
14505
14506     if (!first.analysisSupport) {
14507       char buf[MSG_SIZ];
14508       snprintf(buf, sizeof(buf), _("%s does not support analysis"), first.tidy);
14509       DisplayError(buf, 0);
14510       return;
14511     }
14512
14513     if (gameMode != AnalyzeMode) {
14514         keepInfo = 1; // mere annotating should not alter PGN tags
14515         EditGameEvent();
14516         keepInfo = 0;
14517         if (gameMode != EditGame) return;
14518         if (!appData.showThinking) ToggleShowThinking();
14519         ResurrectChessProgram();
14520         SendToProgram("analyze\n", &first);
14521         first.analyzing = TRUE;
14522         /*first.maybeThinking = TRUE;*/
14523         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
14524         EngineOutputPopUp();
14525     }
14526     gameMode = AnalyzeFile;
14527     pausing = FALSE;
14528     ModeHighlight();
14529
14530     StartAnalysisClock();
14531     GetTimeMark(&lastNodeCountTime);
14532     lastNodeCount = 0;
14533     if(appData.timeDelay > 0) StartLoadGameTimer((long)(1000.0f * appData.timeDelay));
14534     AnalysisPeriodicEvent(1);
14535 }
14536
14537 void
14538 MachineWhiteEvent ()
14539 {
14540     char buf[MSG_SIZ];
14541     char *bookHit = NULL;
14542
14543     if (appData.noChessProgram || (gameMode == MachinePlaysWhite))
14544       return;
14545
14546
14547     if (gameMode == PlayFromGameFile ||
14548         gameMode == TwoMachinesPlay  ||
14549         gameMode == Training         ||
14550         gameMode == AnalyzeMode      ||
14551         gameMode == EndOfGame)
14552         EditGameEvent();
14553
14554     if (gameMode == EditPosition)
14555         EditPositionDone(TRUE);
14556
14557     if (!WhiteOnMove(currentMove)) {
14558         DisplayError(_("It is not White's turn"), 0);
14559         return;
14560     }
14561
14562     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile)
14563       ExitAnalyzeMode();
14564
14565     if (gameMode == EditGame || gameMode == AnalyzeMode ||
14566         gameMode == AnalyzeFile)
14567         TruncateGame();
14568
14569     ResurrectChessProgram();    /* in case it isn't running */
14570     if(gameMode == BeginningOfGame) { /* [HGM] time odds: to get right odds in human mode */
14571         gameMode = MachinePlaysWhite;
14572         ResetClocks();
14573     } else
14574     gameMode = MachinePlaysWhite;
14575     pausing = FALSE;
14576     ModeHighlight();
14577     SetGameInfo();
14578     snprintf(buf, MSG_SIZ, "%s %s %s", gameInfo.white, _("vs."), gameInfo.black);
14579     DisplayTitle(buf);
14580     if (first.sendName) {
14581       snprintf(buf, MSG_SIZ, "name %s\n", gameInfo.black);
14582       SendToProgram(buf, &first);
14583     }
14584     if (first.sendTime) {
14585       if (first.useColors) {
14586         SendToProgram("black\n", &first); /*gnu kludge*/
14587       }
14588       SendTimeRemaining(&first, TRUE);
14589     }
14590     if (first.useColors) {
14591       SendToProgram("white\n", &first); // [HGM] book: send 'go' separately
14592     }
14593     bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: send go or retrieve book move
14594     SetMachineThinkingEnables();
14595     first.maybeThinking = TRUE;
14596     StartClocks();
14597     firstMove = FALSE;
14598
14599     if (appData.autoFlipView && !flipView) {
14600       flipView = !flipView;
14601       DrawPosition(FALSE, NULL);
14602       DisplayBothClocks();       // [HGM] logo: clocks might have to be exchanged;
14603     }
14604
14605     if(bookHit) { // [HGM] book: simulate book reply
14606         static char bookMove[MSG_SIZ]; // a bit generous?
14607
14608         programStats.nodes = programStats.depth = programStats.time =
14609         programStats.score = programStats.got_only_move = 0;
14610         sprintf(programStats.movelist, "%s (xbook)", bookHit);
14611
14612         safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
14613         strcat(bookMove, bookHit);
14614         HandleMachineMove(bookMove, &first);
14615     }
14616 }
14617
14618 void
14619 MachineBlackEvent ()
14620 {
14621   char buf[MSG_SIZ];
14622   char *bookHit = NULL;
14623
14624     if (appData.noChessProgram || (gameMode == MachinePlaysBlack))
14625         return;
14626
14627
14628     if (gameMode == PlayFromGameFile ||
14629         gameMode == TwoMachinesPlay  ||
14630         gameMode == Training         ||
14631         gameMode == AnalyzeMode      ||
14632         gameMode == EndOfGame)
14633         EditGameEvent();
14634
14635     if (gameMode == EditPosition)
14636         EditPositionDone(TRUE);
14637
14638     if (WhiteOnMove(currentMove)) {
14639         DisplayError(_("It is not Black's turn"), 0);
14640         return;
14641     }
14642
14643     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile)
14644       ExitAnalyzeMode();
14645
14646     if (gameMode == EditGame || gameMode == AnalyzeMode ||
14647         gameMode == AnalyzeFile)
14648         TruncateGame();
14649
14650     ResurrectChessProgram();    /* in case it isn't running */
14651     gameMode = MachinePlaysBlack;
14652     pausing = FALSE;
14653     ModeHighlight();
14654     SetGameInfo();
14655     snprintf(buf, MSG_SIZ, "%s %s %s", gameInfo.white, _("vs."), gameInfo.black);
14656     DisplayTitle(buf);
14657     if (first.sendName) {
14658       snprintf(buf, MSG_SIZ, "name %s\n", gameInfo.white);
14659       SendToProgram(buf, &first);
14660     }
14661     if (first.sendTime) {
14662       if (first.useColors) {
14663         SendToProgram("white\n", &first); /*gnu kludge*/
14664       }
14665       SendTimeRemaining(&first, FALSE);
14666     }
14667     if (first.useColors) {
14668       SendToProgram("black\n", &first); // [HGM] book: 'go' sent separately
14669     }
14670     bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: send go or retrieve book move
14671     SetMachineThinkingEnables();
14672     first.maybeThinking = TRUE;
14673     StartClocks();
14674
14675     if (appData.autoFlipView && flipView) {
14676       flipView = !flipView;
14677       DrawPosition(FALSE, NULL);
14678       DisplayBothClocks();       // [HGM] logo: clocks might have to be exchanged;
14679     }
14680     if(bookHit) { // [HGM] book: simulate book reply
14681         static char bookMove[MSG_SIZ]; // a bit generous?
14682
14683         programStats.nodes = programStats.depth = programStats.time =
14684         programStats.score = programStats.got_only_move = 0;
14685         sprintf(programStats.movelist, "%s (xbook)", bookHit);
14686
14687         safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
14688         strcat(bookMove, bookHit);
14689         HandleMachineMove(bookMove, &first);
14690     }
14691 }
14692
14693
14694 void
14695 DisplayTwoMachinesTitle ()
14696 {
14697     char buf[MSG_SIZ];
14698     if (appData.matchGames > 0) {
14699         if(appData.tourneyFile[0]) {
14700           snprintf(buf, MSG_SIZ, "%s %s %s (%d/%d%s)",
14701                    gameInfo.white, _("vs."), gameInfo.black,
14702                    nextGame+1, appData.matchGames+1,
14703                    appData.tourneyType>0 ? "gt" : appData.tourneyType<0 ? "sw" : "rr");
14704         } else
14705         if (first.twoMachinesColor[0] == 'w') {
14706           snprintf(buf, MSG_SIZ, "%s %s %s (%d-%d-%d)",
14707                    gameInfo.white, _("vs."),  gameInfo.black,
14708                    first.matchWins, second.matchWins,
14709                    matchGame - 1 - (first.matchWins + second.matchWins));
14710         } else {
14711           snprintf(buf, MSG_SIZ, "%s %s %s (%d-%d-%d)",
14712                    gameInfo.white, _("vs."), gameInfo.black,
14713                    second.matchWins, first.matchWins,
14714                    matchGame - 1 - (first.matchWins + second.matchWins));
14715         }
14716     } else {
14717       snprintf(buf, MSG_SIZ, "%s %s %s", gameInfo.white, _("vs."), gameInfo.black);
14718     }
14719     DisplayTitle(buf);
14720 }
14721
14722 void
14723 SettingsMenuIfReady ()
14724 {
14725   if (second.lastPing != second.lastPong) {
14726     DisplayMessage("", _("Waiting for second chess program"));
14727     ScheduleDelayedEvent(SettingsMenuIfReady, 10); // [HGM] fast: lowered from 1000
14728     return;
14729   }
14730   ThawUI();
14731   DisplayMessage("", "");
14732   SettingsPopUp(&second);
14733 }
14734
14735 int
14736 WaitForEngine (ChessProgramState *cps, DelayedEventCallback retry)
14737 {
14738     char buf[MSG_SIZ];
14739     if (cps->pr == NoProc) {
14740         StartChessProgram(cps);
14741         if (cps->protocolVersion == 1) {
14742           retry();
14743           ScheduleDelayedEvent(retry, 1); // Do this also through timeout to avoid recursive calling of 'retry'
14744         } else {
14745           /* kludge: allow timeout for initial "feature" command */
14746           if(retry != TwoMachinesEventIfReady) FreezeUI();
14747           snprintf(buf, MSG_SIZ, _("Starting %s chess program"), _(cps->which));
14748           DisplayMessage("", buf);
14749           ScheduleDelayedEvent(retry, FEATURE_TIMEOUT);
14750         }
14751         return 1;
14752     }
14753     return 0;
14754 }
14755
14756 void
14757 TwoMachinesEvent P((void))
14758 {
14759     int i;
14760     char buf[MSG_SIZ];
14761     ChessProgramState *onmove;
14762     char *bookHit = NULL;
14763     static int stalling = 0;
14764     TimeMark now;
14765     long wait;
14766
14767     if (appData.noChessProgram) return;
14768
14769     switch (gameMode) {
14770       case TwoMachinesPlay:
14771         return;
14772       case MachinePlaysWhite:
14773       case MachinePlaysBlack:
14774         if (WhiteOnMove(forwardMostMove) == (gameMode == MachinePlaysWhite)) {
14775             DisplayError(_("Wait until your turn,\nor select 'Move Now'."), 0);
14776             return;
14777         }
14778         /* fall through */
14779       case BeginningOfGame:
14780       case PlayFromGameFile:
14781       case EndOfGame:
14782         EditGameEvent();
14783         if (gameMode != EditGame) return;
14784         break;
14785       case EditPosition:
14786         EditPositionDone(TRUE);
14787         break;
14788       case AnalyzeMode:
14789       case AnalyzeFile:
14790         ExitAnalyzeMode();
14791         break;
14792       case EditGame:
14793       default:
14794         break;
14795     }
14796
14797 //    forwardMostMove = currentMove;
14798     TruncateGame(); // [HGM] vari: MachineWhite and MachineBlack do this...
14799     startingEngine = TRUE;
14800
14801     if(!ResurrectChessProgram()) return;   /* in case first program isn't running (unbalances its ping due to InitChessProgram!) */
14802
14803     if(!first.initDone && GetDelayedEvent() == TwoMachinesEventIfReady) return; // [HGM] engine #1 still waiting for feature timeout
14804     if(first.lastPing != first.lastPong) { // [HGM] wait till we are sure first engine has set up position
14805       ScheduleDelayedEvent(TwoMachinesEventIfReady, 10);
14806       return;
14807     }
14808     if(WaitForEngine(&second, TwoMachinesEventIfReady)) return; // (if needed:) started up second engine, so wait for features
14809
14810     if(!SupportedVariant(second.variants, gameInfo.variant, gameInfo.boardWidth,
14811                          gameInfo.boardHeight, gameInfo.holdingsSize, second.protocolVersion, second.tidy)) {
14812         startingEngine = matchMode = FALSE;
14813         DisplayError("second engine does not play this", 0);
14814         gameMode = TwoMachinesPlay; ModeHighlight(); // Needed to make sure menu item is unchecked
14815         EditGameEvent(); // switch back to EditGame mode
14816         return;
14817     }
14818
14819     if(!stalling) {
14820       InitChessProgram(&second, FALSE); // unbalances ping of second engine
14821       SendToProgram("force\n", &second);
14822       stalling = 1;
14823       ScheduleDelayedEvent(TwoMachinesEventIfReady, 10);
14824       return;
14825     }
14826     GetTimeMark(&now); // [HGM] matchpause: implement match pause after engine load
14827     if(appData.matchPause>10000 || appData.matchPause<10)
14828                 appData.matchPause = 10000; /* [HGM] make pause adjustable */
14829     wait = SubtractTimeMarks(&now, &pauseStart);
14830     if(wait < appData.matchPause) {
14831         ScheduleDelayedEvent(TwoMachinesEventIfReady, appData.matchPause - wait);
14832         return;
14833     }
14834     // we are now committed to starting the game
14835     stalling = 0;
14836     DisplayMessage("", "");
14837     if (startedFromSetupPosition) {
14838         SendBoard(&second, backwardMostMove);
14839     if (appData.debugMode) {
14840         fprintf(debugFP, "Two Machines\n");
14841     }
14842     }
14843     for (i = backwardMostMove; i < forwardMostMove; i++) {
14844         SendMoveToProgram(i, &second);
14845     }
14846
14847     gameMode = TwoMachinesPlay;
14848     pausing = startingEngine = FALSE;
14849     ModeHighlight(); // [HGM] logo: this triggers display update of logos
14850     SetGameInfo();
14851     DisplayTwoMachinesTitle();
14852     firstMove = TRUE;
14853     if ((first.twoMachinesColor[0] == 'w') == WhiteOnMove(forwardMostMove)) {
14854         onmove = &first;
14855     } else {
14856         onmove = &second;
14857     }
14858     if(appData.debugMode) fprintf(debugFP, "New game (%d): %s-%s (%c)\n", matchGame, first.tidy, second.tidy, first.twoMachinesColor[0]);
14859     SendToProgram(first.computerString, &first);
14860     if (first.sendName) {
14861       snprintf(buf, MSG_SIZ, "name %s\n", second.tidy);
14862       SendToProgram(buf, &first);
14863     }
14864     SendToProgram(second.computerString, &second);
14865     if (second.sendName) {
14866       snprintf(buf, MSG_SIZ, "name %s\n", first.tidy);
14867       SendToProgram(buf, &second);
14868     }
14869
14870     ResetClocks();
14871     if (!first.sendTime || !second.sendTime) {
14872         timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
14873         timeRemaining[1][forwardMostMove] = blackTimeRemaining;
14874     }
14875     if (onmove->sendTime) {
14876       if (onmove->useColors) {
14877         SendToProgram(onmove->other->twoMachinesColor, onmove); /*gnu kludge*/
14878       }
14879       SendTimeRemaining(onmove, WhiteOnMove(forwardMostMove));
14880     }
14881     if (onmove->useColors) {
14882       SendToProgram(onmove->twoMachinesColor, onmove);
14883     }
14884     bookHit = SendMoveToBookUser(forwardMostMove-1, onmove, TRUE); // [HGM] book: send go or retrieve book move
14885 //    SendToProgram("go\n", onmove);
14886     onmove->maybeThinking = TRUE;
14887     SetMachineThinkingEnables();
14888
14889     StartClocks();
14890
14891     if(bookHit) { // [HGM] book: simulate book reply
14892         static char bookMove[MSG_SIZ]; // a bit generous?
14893
14894         programStats.nodes = programStats.depth = programStats.time =
14895         programStats.score = programStats.got_only_move = 0;
14896         sprintf(programStats.movelist, "%s (xbook)", bookHit);
14897
14898         safeStrCpy(bookMove, "move ", sizeof(bookMove)/sizeof(bookMove[0]));
14899         strcat(bookMove, bookHit);
14900         savedMessage = bookMove; // args for deferred call
14901         savedState = onmove;
14902         ScheduleDelayedEvent(DeferredBookMove, 1);
14903     }
14904 }
14905
14906 void
14907 TrainingEvent ()
14908 {
14909     if (gameMode == Training) {
14910       SetTrainingModeOff();
14911       gameMode = PlayFromGameFile;
14912       DisplayMessage("", _("Training mode off"));
14913     } else {
14914       gameMode = Training;
14915       animateTraining = appData.animate;
14916
14917       /* make sure we are not already at the end of the game */
14918       if (currentMove < forwardMostMove) {
14919         SetTrainingModeOn();
14920         DisplayMessage("", _("Training mode on"));
14921       } else {
14922         gameMode = PlayFromGameFile;
14923         DisplayError(_("Already at end of game"), 0);
14924       }
14925     }
14926     ModeHighlight();
14927 }
14928
14929 void
14930 IcsClientEvent ()
14931 {
14932     if (!appData.icsActive) return;
14933     switch (gameMode) {
14934       case IcsPlayingWhite:
14935       case IcsPlayingBlack:
14936       case IcsObserving:
14937       case IcsIdle:
14938       case BeginningOfGame:
14939       case IcsExamining:
14940         return;
14941
14942       case EditGame:
14943         break;
14944
14945       case EditPosition:
14946         EditPositionDone(TRUE);
14947         break;
14948
14949       case AnalyzeMode:
14950       case AnalyzeFile:
14951         ExitAnalyzeMode();
14952         break;
14953
14954       default:
14955         EditGameEvent();
14956         break;
14957     }
14958
14959     gameMode = IcsIdle;
14960     ModeHighlight();
14961     return;
14962 }
14963
14964 void
14965 EditGameEvent ()
14966 {
14967     int i;
14968
14969     switch (gameMode) {
14970       case Training:
14971         SetTrainingModeOff();
14972         break;
14973       case MachinePlaysWhite:
14974       case MachinePlaysBlack:
14975       case BeginningOfGame:
14976         SendToProgram("force\n", &first);
14977         SetUserThinkingEnables();
14978         break;
14979       case PlayFromGameFile:
14980         (void) StopLoadGameTimer();
14981         if (gameFileFP != NULL) {
14982             gameFileFP = NULL;
14983         }
14984         break;
14985       case EditPosition:
14986         EditPositionDone(TRUE);
14987         break;
14988       case AnalyzeMode:
14989       case AnalyzeFile:
14990         ExitAnalyzeMode();
14991         SendToProgram("force\n", &first);
14992         break;
14993       case TwoMachinesPlay:
14994         GameEnds(EndOfFile, NULL, GE_PLAYER);
14995         ResurrectChessProgram();
14996         SetUserThinkingEnables();
14997         break;
14998       case EndOfGame:
14999         ResurrectChessProgram();
15000         break;
15001       case IcsPlayingBlack:
15002       case IcsPlayingWhite:
15003         DisplayError(_("Warning: You are still playing a game"), 0);
15004         break;
15005       case IcsObserving:
15006         DisplayError(_("Warning: You are still observing a game"), 0);
15007         break;
15008       case IcsExamining:
15009         DisplayError(_("Warning: You are still examining a game"), 0);
15010         break;
15011       case IcsIdle:
15012         break;
15013       case EditGame:
15014       default:
15015         return;
15016     }
15017
15018     pausing = FALSE;
15019     StopClocks();
15020     first.offeredDraw = second.offeredDraw = 0;
15021
15022     if (gameMode == PlayFromGameFile) {
15023         whiteTimeRemaining = timeRemaining[0][currentMove];
15024         blackTimeRemaining = timeRemaining[1][currentMove];
15025         DisplayTitle("");
15026     }
15027
15028     if (gameMode == MachinePlaysWhite ||
15029         gameMode == MachinePlaysBlack ||
15030         gameMode == TwoMachinesPlay ||
15031         gameMode == EndOfGame) {
15032         i = forwardMostMove;
15033         while (i > currentMove) {
15034             SendToProgram("undo\n", &first);
15035             i--;
15036         }
15037         if(!adjustedClock) {
15038         whiteTimeRemaining = timeRemaining[0][currentMove];
15039         blackTimeRemaining = timeRemaining[1][currentMove];
15040         DisplayBothClocks();
15041         }
15042         if (whiteFlag || blackFlag) {
15043             whiteFlag = blackFlag = 0;
15044         }
15045         DisplayTitle("");
15046     }
15047
15048     gameMode = EditGame;
15049     ModeHighlight();
15050     SetGameInfo();
15051 }
15052
15053
15054 void
15055 EditPositionEvent ()
15056 {
15057     if (gameMode == EditPosition) {
15058         EditGameEvent();
15059         return;
15060     }
15061
15062     EditGameEvent();
15063     if (gameMode != EditGame) return;
15064
15065     gameMode = EditPosition;
15066     ModeHighlight();
15067     SetGameInfo();
15068     if (currentMove > 0)
15069       CopyBoard(boards[0], boards[currentMove]);
15070
15071     blackPlaysFirst = !WhiteOnMove(currentMove);
15072     ResetClocks();
15073     currentMove = forwardMostMove = backwardMostMove = 0;
15074     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
15075     DisplayMove(-1);
15076     if(!appData.pieceMenu) DisplayMessage(_("Click clock to clear board"), "");
15077 }
15078
15079 void
15080 ExitAnalyzeMode ()
15081 {
15082     /* [DM] icsEngineAnalyze - possible call from other functions */
15083     if (appData.icsEngineAnalyze) {
15084         appData.icsEngineAnalyze = FALSE;
15085
15086         DisplayMessage("",_("Close ICS engine analyze..."));
15087     }
15088     if (first.analysisSupport && first.analyzing) {
15089       SendToBoth("exit\n");
15090       first.analyzing = second.analyzing = FALSE;
15091     }
15092     thinkOutput[0] = NULLCHAR;
15093 }
15094
15095 void
15096 EditPositionDone (Boolean fakeRights)
15097 {
15098     int king = gameInfo.variant == VariantKnightmate ? WhiteUnicorn : WhiteKing;
15099
15100     startedFromSetupPosition = TRUE;
15101     InitChessProgram(&first, FALSE);
15102     if(fakeRights) { // [HGM] suppress this if we just pasted a FEN.
15103       boards[0][EP_STATUS] = EP_NONE;
15104       boards[0][CASTLING][2] = boards[0][CASTLING][5] = BOARD_WIDTH>>1;
15105       if(boards[0][0][BOARD_WIDTH>>1] == king) {
15106         boards[0][CASTLING][1] = boards[0][0][BOARD_LEFT] == WhiteRook ? BOARD_LEFT : NoRights;
15107         boards[0][CASTLING][0] = boards[0][0][BOARD_RGHT-1] == WhiteRook ? BOARD_RGHT-1 : NoRights;
15108       } else boards[0][CASTLING][2] = NoRights;
15109       if(boards[0][BOARD_HEIGHT-1][BOARD_WIDTH>>1] == WHITE_TO_BLACK king) {
15110         boards[0][CASTLING][4] = boards[0][BOARD_HEIGHT-1][BOARD_LEFT] == BlackRook ? BOARD_LEFT : NoRights;
15111         boards[0][CASTLING][3] = boards[0][BOARD_HEIGHT-1][BOARD_RGHT-1] == BlackRook ? BOARD_RGHT-1 : NoRights;
15112       } else boards[0][CASTLING][5] = NoRights;
15113       if(gameInfo.variant == VariantSChess) {
15114         int i;
15115         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) { // pieces in their original position are assumed virgin
15116           boards[0][VIRGIN][i] = 0;
15117           if(boards[0][0][i]              == FIDEArray[0][i-BOARD_LEFT]) boards[0][VIRGIN][i] |= VIRGIN_W;
15118           if(boards[0][BOARD_HEIGHT-1][i] == FIDEArray[1][i-BOARD_LEFT]) boards[0][VIRGIN][i] |= VIRGIN_B;
15119         }
15120       }
15121     }
15122     SendToProgram("force\n", &first);
15123     if (blackPlaysFirst) {
15124         safeStrCpy(moveList[0], "", sizeof(moveList[0])/sizeof(moveList[0][0]));
15125         safeStrCpy(parseList[0], "", sizeof(parseList[0])/sizeof(parseList[0][0]));
15126         currentMove = forwardMostMove = backwardMostMove = 1;
15127         CopyBoard(boards[1], boards[0]);
15128     } else {
15129         currentMove = forwardMostMove = backwardMostMove = 0;
15130     }
15131     SendBoard(&first, forwardMostMove);
15132     if (appData.debugMode) {
15133         fprintf(debugFP, "EditPosDone\n");
15134     }
15135     DisplayTitle("");
15136     DisplayMessage("", "");
15137     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
15138     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
15139     gameMode = EditGame;
15140     ModeHighlight();
15141     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
15142     ClearHighlights(); /* [AS] */
15143 }
15144
15145 /* Pause for `ms' milliseconds */
15146 /* !! Ugh, this is a kludge. Fix it sometime. --tpm */
15147 void
15148 TimeDelay (long ms)
15149 {
15150     TimeMark m1, m2;
15151
15152     GetTimeMark(&m1);
15153     do {
15154         GetTimeMark(&m2);
15155     } while (SubtractTimeMarks(&m2, &m1) < ms);
15156 }
15157
15158 /* !! Ugh, this is a kludge. Fix it sometime. --tpm */
15159 void
15160 SendMultiLineToICS (char *buf)
15161 {
15162     char temp[MSG_SIZ+1], *p;
15163     int len;
15164
15165     len = strlen(buf);
15166     if (len > MSG_SIZ)
15167       len = MSG_SIZ;
15168
15169     strncpy(temp, buf, len);
15170     temp[len] = 0;
15171
15172     p = temp;
15173     while (*p) {
15174         if (*p == '\n' || *p == '\r')
15175           *p = ' ';
15176         ++p;
15177     }
15178
15179     strcat(temp, "\n");
15180     SendToICS(temp);
15181     SendToPlayer(temp, strlen(temp));
15182 }
15183
15184 void
15185 SetWhiteToPlayEvent ()
15186 {
15187     if (gameMode == EditPosition) {
15188         blackPlaysFirst = FALSE;
15189         DisplayBothClocks();    /* works because currentMove is 0 */
15190     } else if (gameMode == IcsExamining) {
15191         SendToICS(ics_prefix);
15192         SendToICS("tomove white\n");
15193     }
15194 }
15195
15196 void
15197 SetBlackToPlayEvent ()
15198 {
15199     if (gameMode == EditPosition) {
15200         blackPlaysFirst = TRUE;
15201         currentMove = 1;        /* kludge */
15202         DisplayBothClocks();
15203         currentMove = 0;
15204     } else if (gameMode == IcsExamining) {
15205         SendToICS(ics_prefix);
15206         SendToICS("tomove black\n");
15207     }
15208 }
15209
15210 void
15211 EditPositionMenuEvent (ChessSquare selection, int x, int y)
15212 {
15213     char buf[MSG_SIZ];
15214     ChessSquare piece = boards[0][y][x];
15215     static Board erasedBoard, currentBoard, menuBoard, nullBoard;
15216     static int lastVariant;
15217
15218     if (gameMode != EditPosition && gameMode != IcsExamining) return;
15219
15220     switch (selection) {
15221       case ClearBoard:
15222         fromX = fromY = killX = killY = -1; // [HGM] abort any move entry in progress
15223         MarkTargetSquares(1);
15224         CopyBoard(currentBoard, boards[0]);
15225         CopyBoard(menuBoard, initialPosition);
15226         if (gameMode == IcsExamining && ics_type == ICS_FICS) {
15227             SendToICS(ics_prefix);
15228             SendToICS("bsetup clear\n");
15229         } else if (gameMode == IcsExamining && ics_type == ICS_ICC) {
15230             SendToICS(ics_prefix);
15231             SendToICS("clearboard\n");
15232         } else {
15233             int nonEmpty = 0;
15234             for (x = 0; x < BOARD_WIDTH; x++) { ChessSquare p = EmptySquare;
15235                 if(x == BOARD_LEFT-1 || x == BOARD_RGHT) p = (ChessSquare) 0; /* [HGM] holdings */
15236                 for (y = 0; y < BOARD_HEIGHT; y++) {
15237                     if (gameMode == IcsExamining) {
15238                         if (boards[currentMove][y][x] != EmptySquare) {
15239                           snprintf(buf, MSG_SIZ, "%sx@%c%c\n", ics_prefix,
15240                                     AAA + x, ONE + y);
15241                             SendToICS(buf);
15242                         }
15243                     } else if(boards[0][y][x] != DarkSquare) {
15244                         if(boards[0][y][x] != p) nonEmpty++;
15245                         boards[0][y][x] = p;
15246                     }
15247                 }
15248             }
15249             if(gameMode != IcsExamining) { // [HGM] editpos: cycle trough boards
15250                 int r;
15251                 for(r = 0; r < BOARD_HEIGHT; r++) {
15252                   for(x = BOARD_LEFT; x < BOARD_RGHT; x++) { // create 'menu board' by removing duplicates
15253                     ChessSquare p = menuBoard[r][x];
15254                     for(y = x + 1; y < BOARD_RGHT; y++) if(menuBoard[r][y] == p) menuBoard[r][y] = EmptySquare;
15255                   }
15256                 }
15257                 DisplayMessage("Clicking clock again restores position", "");
15258                 if(gameInfo.variant != lastVariant) lastVariant = gameInfo.variant, CopyBoard(erasedBoard, boards[0]);
15259                 if(!nonEmpty) { // asked to clear an empty board
15260                     CopyBoard(boards[0], menuBoard);
15261                 } else
15262                 if(CompareBoards(currentBoard, menuBoard)) { // asked to clear an empty board
15263                     CopyBoard(boards[0], initialPosition);
15264                 } else
15265                 if(CompareBoards(currentBoard, initialPosition) && !CompareBoards(currentBoard, erasedBoard)
15266                                                                  && !CompareBoards(nullBoard, erasedBoard)) {
15267                     CopyBoard(boards[0], erasedBoard);
15268                 } else
15269                     CopyBoard(erasedBoard, currentBoard);
15270
15271             }
15272         }
15273         if (gameMode == EditPosition) {
15274             DrawPosition(FALSE, boards[0]);
15275         }
15276         break;
15277
15278       case WhitePlay:
15279         SetWhiteToPlayEvent();
15280         break;
15281
15282       case BlackPlay:
15283         SetBlackToPlayEvent();
15284         break;
15285
15286       case EmptySquare:
15287         if (gameMode == IcsExamining) {
15288             if (x < BOARD_LEFT || x >= BOARD_RGHT) break; // [HGM] holdings
15289             snprintf(buf, MSG_SIZ, "%sx@%c%c\n", ics_prefix, AAA + x, ONE + y);
15290             SendToICS(buf);
15291         } else {
15292             if(x < BOARD_LEFT || x >= BOARD_RGHT) {
15293                 if(x == BOARD_LEFT-2) {
15294                     if(y < BOARD_HEIGHT-1-gameInfo.holdingsSize) break;
15295                     boards[0][y][1] = 0;
15296                 } else
15297                 if(x == BOARD_RGHT+1) {
15298                     if(y >= gameInfo.holdingsSize) break;
15299                     boards[0][y][BOARD_WIDTH-2] = 0;
15300                 } else break;
15301             }
15302             boards[0][y][x] = EmptySquare;
15303             DrawPosition(FALSE, boards[0]);
15304         }
15305         break;
15306
15307       case PromotePiece:
15308         if(piece >= (int)WhitePawn && piece < (int)WhiteMan ||
15309            piece >= (int)BlackPawn && piece < (int)BlackMan   ) {
15310             selection = (ChessSquare) (PROMOTED piece);
15311         } else if(piece == EmptySquare) selection = WhiteSilver;
15312         else selection = (ChessSquare)((int)piece - 1);
15313         goto defaultlabel;
15314
15315       case DemotePiece:
15316         if(piece > (int)WhiteMan && piece <= (int)WhiteKing ||
15317            piece > (int)BlackMan && piece <= (int)BlackKing   ) {
15318             selection = (ChessSquare) (DEMOTED piece);
15319         } else if(piece == EmptySquare) selection = BlackSilver;
15320         else selection = (ChessSquare)((int)piece + 1);
15321         goto defaultlabel;
15322
15323       case WhiteQueen:
15324       case BlackQueen:
15325         if(gameInfo.variant == VariantShatranj ||
15326            gameInfo.variant == VariantXiangqi  ||
15327            gameInfo.variant == VariantCourier  ||
15328            gameInfo.variant == VariantASEAN    ||
15329            gameInfo.variant == VariantMakruk     )
15330             selection = (ChessSquare)((int)selection - (int)WhiteQueen + (int)WhiteFerz);
15331         goto defaultlabel;
15332
15333       case WhiteKing:
15334       case BlackKing:
15335         if(gameInfo.variant == VariantXiangqi)
15336             selection = (ChessSquare)((int)selection - (int)WhiteKing + (int)WhiteWazir);
15337         if(gameInfo.variant == VariantKnightmate)
15338             selection = (ChessSquare)((int)selection - (int)WhiteKing + (int)WhiteUnicorn);
15339       default:
15340         defaultlabel:
15341         if (gameMode == IcsExamining) {
15342             if (x < BOARD_LEFT || x >= BOARD_RGHT) break; // [HGM] holdings
15343             snprintf(buf, MSG_SIZ, "%s%c@%c%c\n", ics_prefix,
15344                      PieceToChar(selection), AAA + x, ONE + y);
15345             SendToICS(buf);
15346         } else {
15347             if(x < BOARD_LEFT || x >= BOARD_RGHT) {
15348                 int n;
15349                 if(x == BOARD_LEFT-2 && selection >= BlackPawn) {
15350                     n = PieceToNumber(selection - BlackPawn);
15351                     if(n >= gameInfo.holdingsSize) { n = 0; selection = BlackPawn; }
15352                     boards[0][BOARD_HEIGHT-1-n][0] = selection;
15353                     boards[0][BOARD_HEIGHT-1-n][1]++;
15354                 } else
15355                 if(x == BOARD_RGHT+1 && selection < BlackPawn) {
15356                     n = PieceToNumber(selection);
15357                     if(n >= gameInfo.holdingsSize) { n = 0; selection = WhitePawn; }
15358                     boards[0][n][BOARD_WIDTH-1] = selection;
15359                     boards[0][n][BOARD_WIDTH-2]++;
15360                 }
15361             } else
15362             boards[0][y][x] = selection;
15363             DrawPosition(TRUE, boards[0]);
15364             ClearHighlights();
15365             fromX = fromY = -1;
15366         }
15367         break;
15368     }
15369 }
15370
15371
15372 void
15373 DropMenuEvent (ChessSquare selection, int x, int y)
15374 {
15375     ChessMove moveType;
15376
15377     switch (gameMode) {
15378       case IcsPlayingWhite:
15379       case MachinePlaysBlack:
15380         if (!WhiteOnMove(currentMove)) {
15381             DisplayMoveError(_("It is Black's turn"));
15382             return;
15383         }
15384         moveType = WhiteDrop;
15385         break;
15386       case IcsPlayingBlack:
15387       case MachinePlaysWhite:
15388         if (WhiteOnMove(currentMove)) {
15389             DisplayMoveError(_("It is White's turn"));
15390             return;
15391         }
15392         moveType = BlackDrop;
15393         break;
15394       case EditGame:
15395         moveType = WhiteOnMove(currentMove) ? WhiteDrop : BlackDrop;
15396         break;
15397       default:
15398         return;
15399     }
15400
15401     if (moveType == BlackDrop && selection < BlackPawn) {
15402       selection = (ChessSquare) ((int) selection
15403                                  + (int) BlackPawn - (int) WhitePawn);
15404     }
15405     if (boards[currentMove][y][x] != EmptySquare) {
15406         DisplayMoveError(_("That square is occupied"));
15407         return;
15408     }
15409
15410     FinishMove(moveType, (int) selection, DROP_RANK, x, y, NULLCHAR);
15411 }
15412
15413 void
15414 AcceptEvent ()
15415 {
15416     /* Accept a pending offer of any kind from opponent */
15417
15418     if (appData.icsActive) {
15419         SendToICS(ics_prefix);
15420         SendToICS("accept\n");
15421     } else if (cmailMsgLoaded) {
15422         if (currentMove == cmailOldMove &&
15423             commentList[cmailOldMove] != NULL &&
15424             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
15425                    "Black offers a draw" : "White offers a draw")) {
15426             TruncateGame();
15427             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
15428             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_ACCEPT;
15429         } else {
15430             DisplayError(_("There is no pending offer on this move"), 0);
15431             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
15432         }
15433     } else {
15434         /* Not used for offers from chess program */
15435     }
15436 }
15437
15438 void
15439 DeclineEvent ()
15440 {
15441     /* Decline a pending offer of any kind from opponent */
15442
15443     if (appData.icsActive) {
15444         SendToICS(ics_prefix);
15445         SendToICS("decline\n");
15446     } else if (cmailMsgLoaded) {
15447         if (currentMove == cmailOldMove &&
15448             commentList[cmailOldMove] != NULL &&
15449             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
15450                    "Black offers a draw" : "White offers a draw")) {
15451 #ifdef NOTDEF
15452             AppendComment(cmailOldMove, "Draw declined", TRUE);
15453             DisplayComment(cmailOldMove - 1, "Draw declined");
15454 #endif /*NOTDEF*/
15455         } else {
15456             DisplayError(_("There is no pending offer on this move"), 0);
15457         }
15458     } else {
15459         /* Not used for offers from chess program */
15460     }
15461 }
15462
15463 void
15464 RematchEvent ()
15465 {
15466     /* Issue ICS rematch command */
15467     if (appData.icsActive) {
15468         SendToICS(ics_prefix);
15469         SendToICS("rematch\n");
15470     }
15471 }
15472
15473 void
15474 CallFlagEvent ()
15475 {
15476     /* Call your opponent's flag (claim a win on time) */
15477     if (appData.icsActive) {
15478         SendToICS(ics_prefix);
15479         SendToICS("flag\n");
15480     } else {
15481         switch (gameMode) {
15482           default:
15483             return;
15484           case MachinePlaysWhite:
15485             if (whiteFlag) {
15486                 if (blackFlag)
15487                   GameEnds(GameIsDrawn, "Both players ran out of time",
15488                            GE_PLAYER);
15489                 else
15490                   GameEnds(BlackWins, "Black wins on time", GE_PLAYER);
15491             } else {
15492                 DisplayError(_("Your opponent is not out of time"), 0);
15493             }
15494             break;
15495           case MachinePlaysBlack:
15496             if (blackFlag) {
15497                 if (whiteFlag)
15498                   GameEnds(GameIsDrawn, "Both players ran out of time",
15499                            GE_PLAYER);
15500                 else
15501                   GameEnds(WhiteWins, "White wins on time", GE_PLAYER);
15502             } else {
15503                 DisplayError(_("Your opponent is not out of time"), 0);
15504             }
15505             break;
15506         }
15507     }
15508 }
15509
15510 void
15511 ClockClick (int which)
15512 {       // [HGM] code moved to back-end from winboard.c
15513         if(which) { // black clock
15514           if (gameMode == EditPosition || gameMode == IcsExamining) {
15515             if(!appData.pieceMenu && blackPlaysFirst) EditPositionMenuEvent(ClearBoard, 0, 0);
15516             SetBlackToPlayEvent();
15517           } else if ((gameMode == AnalyzeMode || gameMode == EditGame ||
15518                       gameMode == MachinePlaysBlack && PosFlags(0) & F_NULL_MOVE && !blackFlag && !shiftKey) && WhiteOnMove(currentMove)) {
15519           UserMoveEvent((int)EmptySquare, DROP_RANK, 0, 0, 0); // [HGM] multi-move: if not out of time, enters null move
15520           } else if (shiftKey) {
15521             AdjustClock(which, -1);
15522           } else if (gameMode == IcsPlayingWhite ||
15523                      gameMode == MachinePlaysBlack) {
15524             CallFlagEvent();
15525           }
15526         } else { // white clock
15527           if (gameMode == EditPosition || gameMode == IcsExamining) {
15528             if(!appData.pieceMenu && !blackPlaysFirst) EditPositionMenuEvent(ClearBoard, 0, 0);
15529             SetWhiteToPlayEvent();
15530           } else if ((gameMode == AnalyzeMode || gameMode == EditGame ||
15531                       gameMode == MachinePlaysWhite && PosFlags(0) & F_NULL_MOVE && !whiteFlag && !shiftKey) && !WhiteOnMove(currentMove)) {
15532           UserMoveEvent((int)EmptySquare, DROP_RANK, 0, 0, 0); // [HGM] multi-move
15533           } else if (shiftKey) {
15534             AdjustClock(which, -1);
15535           } else if (gameMode == IcsPlayingBlack ||
15536                    gameMode == MachinePlaysWhite) {
15537             CallFlagEvent();
15538           }
15539         }
15540 }
15541
15542 void
15543 DrawEvent ()
15544 {
15545     /* Offer draw or accept pending draw offer from opponent */
15546
15547     if (appData.icsActive) {
15548         /* Note: tournament rules require draw offers to be
15549            made after you make your move but before you punch
15550            your clock.  Currently ICS doesn't let you do that;
15551            instead, you immediately punch your clock after making
15552            a move, but you can offer a draw at any time. */
15553
15554         SendToICS(ics_prefix);
15555         SendToICS("draw\n");
15556         userOfferedDraw = TRUE; // [HGM] drawclaim: also set flag in ICS play
15557     } else if (cmailMsgLoaded) {
15558         if (currentMove == cmailOldMove &&
15559             commentList[cmailOldMove] != NULL &&
15560             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
15561                    "Black offers a draw" : "White offers a draw")) {
15562             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
15563             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_ACCEPT;
15564         } else if (currentMove == cmailOldMove + 1) {
15565             char *offer = WhiteOnMove(cmailOldMove) ?
15566               "White offers a draw" : "Black offers a draw";
15567             AppendComment(currentMove, offer, TRUE);
15568             DisplayComment(currentMove - 1, offer);
15569             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_DRAW;
15570         } else {
15571             DisplayError(_("You must make your move before offering a draw"), 0);
15572             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
15573         }
15574     } else if (first.offeredDraw) {
15575         GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
15576     } else {
15577         if (first.sendDrawOffers) {
15578             SendToProgram("draw\n", &first);
15579             userOfferedDraw = TRUE;
15580         }
15581     }
15582 }
15583
15584 void
15585 AdjournEvent ()
15586 {
15587     /* Offer Adjourn or accept pending Adjourn offer from opponent */
15588
15589     if (appData.icsActive) {
15590         SendToICS(ics_prefix);
15591         SendToICS("adjourn\n");
15592     } else {
15593         /* Currently GNU Chess doesn't offer or accept Adjourns */
15594     }
15595 }
15596
15597
15598 void
15599 AbortEvent ()
15600 {
15601     /* Offer Abort or accept pending Abort offer from opponent */
15602
15603     if (appData.icsActive) {
15604         SendToICS(ics_prefix);
15605         SendToICS("abort\n");
15606     } else {
15607         GameEnds(GameUnfinished, "Game aborted", GE_PLAYER);
15608     }
15609 }
15610
15611 void
15612 ResignEvent ()
15613 {
15614     /* Resign.  You can do this even if it's not your turn. */
15615
15616     if (appData.icsActive) {
15617         SendToICS(ics_prefix);
15618         SendToICS("resign\n");
15619     } else {
15620         switch (gameMode) {
15621           case MachinePlaysWhite:
15622             GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
15623             break;
15624           case MachinePlaysBlack:
15625             GameEnds(BlackWins, "White resigns", GE_PLAYER);
15626             break;
15627           case EditGame:
15628             if (cmailMsgLoaded) {
15629                 TruncateGame();
15630                 if (WhiteOnMove(cmailOldMove)) {
15631                     GameEnds(BlackWins, "White resigns", GE_PLAYER);
15632                 } else {
15633                     GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
15634                 }
15635                 cmailMoveType[lastLoadGameNumber - 1] = CMAIL_RESIGN;
15636             }
15637             break;
15638           default:
15639             break;
15640         }
15641     }
15642 }
15643
15644
15645 void
15646 StopObservingEvent ()
15647 {
15648     /* Stop observing current games */
15649     SendToICS(ics_prefix);
15650     SendToICS("unobserve\n");
15651 }
15652
15653 void
15654 StopExaminingEvent ()
15655 {
15656     /* Stop observing current game */
15657     SendToICS(ics_prefix);
15658     SendToICS("unexamine\n");
15659 }
15660
15661 void
15662 ForwardInner (int target)
15663 {
15664     int limit; int oldSeekGraphUp = seekGraphUp;
15665
15666     if (appData.debugMode)
15667         fprintf(debugFP, "ForwardInner(%d), current %d, forward %d\n",
15668                 target, currentMove, forwardMostMove);
15669
15670     if (gameMode == EditPosition)
15671       return;
15672
15673     seekGraphUp = FALSE;
15674     MarkTargetSquares(1);
15675     fromX = fromY = killX = killY = -1; // [HGM] abort any move entry in progress
15676
15677     if (gameMode == PlayFromGameFile && !pausing)
15678       PauseEvent();
15679
15680     if (gameMode == IcsExamining && pausing)
15681       limit = pauseExamForwardMostMove;
15682     else
15683       limit = forwardMostMove;
15684
15685     if (target > limit) target = limit;
15686
15687     if (target > 0 && moveList[target - 1][0]) {
15688         int fromX, fromY, toX, toY;
15689         toX = moveList[target - 1][2] - AAA;
15690         toY = moveList[target - 1][3] - ONE;
15691         if (moveList[target - 1][1] == '@') {
15692             if (appData.highlightLastMove) {
15693                 SetHighlights(-1, -1, toX, toY);
15694             }
15695         } else {
15696             int viaX = moveList[target - 1][5] - AAA;
15697             int viaY = moveList[target - 1][6] - ONE;
15698             fromX = moveList[target - 1][0] - AAA;
15699             fromY = moveList[target - 1][1] - ONE;
15700             if (target == currentMove + 1) {
15701                 if(moveList[target - 1][4] == ';') { // multi-leg
15702                     ChessSquare piece = boards[currentMove][viaY][viaX];
15703                     AnimateMove(boards[currentMove], fromX, fromY, viaX, viaY);
15704                     boards[currentMove][viaY][viaX] = boards[currentMove][fromY][fromX];
15705                     AnimateMove(boards[currentMove], viaX, viaY, toX, toY);
15706                     boards[currentMove][viaY][viaX] = piece;
15707                 } else
15708                 AnimateMove(boards[currentMove], fromX, fromY, toX, toY);
15709             }
15710             if (appData.highlightLastMove) {
15711                 SetHighlights(fromX, fromY, toX, toY);
15712             }
15713         }
15714     }
15715     if (gameMode == EditGame || gameMode == AnalyzeMode ||
15716         gameMode == Training || gameMode == PlayFromGameFile ||
15717         gameMode == AnalyzeFile) {
15718         while (currentMove < target) {
15719             if(second.analyzing) SendMoveToProgram(currentMove, &second);
15720             SendMoveToProgram(currentMove++, &first);
15721         }
15722     } else {
15723         currentMove = target;
15724     }
15725
15726     if (gameMode == EditGame || gameMode == EndOfGame) {
15727         whiteTimeRemaining = timeRemaining[0][currentMove];
15728         blackTimeRemaining = timeRemaining[1][currentMove];
15729     }
15730     DisplayBothClocks();
15731     DisplayMove(currentMove - 1);
15732     DrawPosition(oldSeekGraphUp, boards[currentMove]);
15733     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
15734     if ( !matchMode && gameMode != Training) { // [HGM] PV info: routine tests if empty
15735         DisplayComment(currentMove - 1, commentList[currentMove]);
15736     }
15737     ClearMap(); // [HGM] exclude: invalidate map
15738 }
15739
15740
15741 void
15742 ForwardEvent ()
15743 {
15744     if (gameMode == IcsExamining && !pausing) {
15745         SendToICS(ics_prefix);
15746         SendToICS("forward\n");
15747     } else {
15748         ForwardInner(currentMove + 1);
15749     }
15750 }
15751
15752 void
15753 ToEndEvent ()
15754 {
15755     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
15756         /* to optimze, we temporarily turn off analysis mode while we feed
15757          * the remaining moves to the engine. Otherwise we get analysis output
15758          * after each move.
15759          */
15760         if (first.analysisSupport) {
15761           SendToProgram("exit\nforce\n", &first);
15762           first.analyzing = FALSE;
15763         }
15764     }
15765
15766     if (gameMode == IcsExamining && !pausing) {
15767         SendToICS(ics_prefix);
15768         SendToICS("forward 999999\n");
15769     } else {
15770         ForwardInner(forwardMostMove);
15771     }
15772
15773     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
15774         /* we have fed all the moves, so reactivate analysis mode */
15775         SendToProgram("analyze\n", &first);
15776         first.analyzing = TRUE;
15777         /*first.maybeThinking = TRUE;*/
15778         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
15779     }
15780 }
15781
15782 void
15783 BackwardInner (int target)
15784 {
15785     int full_redraw = TRUE; /* [AS] Was FALSE, had to change it! */
15786
15787     if (appData.debugMode)
15788         fprintf(debugFP, "BackwardInner(%d), current %d, forward %d\n",
15789                 target, currentMove, forwardMostMove);
15790
15791     if (gameMode == EditPosition) return;
15792     seekGraphUp = FALSE;
15793     MarkTargetSquares(1);
15794     fromX = fromY = killX = killY = -1; // [HGM] abort any move entry in progress
15795     if (currentMove <= backwardMostMove) {
15796         ClearHighlights();
15797         DrawPosition(full_redraw, boards[currentMove]);
15798         return;
15799     }
15800     if (gameMode == PlayFromGameFile && !pausing)
15801       PauseEvent();
15802
15803     if (moveList[target][0]) {
15804         int fromX, fromY, toX, toY;
15805         toX = moveList[target][2] - AAA;
15806         toY = moveList[target][3] - ONE;
15807         if (moveList[target][1] == '@') {
15808             if (appData.highlightLastMove) {
15809                 SetHighlights(-1, -1, toX, toY);
15810             }
15811         } else {
15812             fromX = moveList[target][0] - AAA;
15813             fromY = moveList[target][1] - ONE;
15814             if (target == currentMove - 1) {
15815                 AnimateMove(boards[currentMove], toX, toY, fromX, fromY);
15816             }
15817             if (appData.highlightLastMove) {
15818                 SetHighlights(fromX, fromY, toX, toY);
15819             }
15820         }
15821     }
15822     if (gameMode == EditGame || gameMode==AnalyzeMode ||
15823         gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
15824         while (currentMove > target) {
15825             if(moveList[currentMove-1][1] == '@' && moveList[currentMove-1][0] == '@') {
15826                 // null move cannot be undone. Reload program with move history before it.
15827                 int i;
15828                 for(i=target; i>backwardMostMove; i--) { // seek back to start or previous null move
15829                     if(moveList[i-1][1] == '@' && moveList[i-1][0] == '@') break;
15830                 }
15831                 SendBoard(&first, i);
15832               if(second.analyzing) SendBoard(&second, i);
15833                 for(currentMove=i; currentMove<target; currentMove++) {
15834                     SendMoveToProgram(currentMove, &first);
15835                     if(second.analyzing) SendMoveToProgram(currentMove, &second);
15836                 }
15837                 break;
15838             }
15839             SendToBoth("undo\n");
15840             currentMove--;
15841         }
15842     } else {
15843         currentMove = target;
15844     }
15845
15846     if (gameMode == EditGame || gameMode == EndOfGame) {
15847         whiteTimeRemaining = timeRemaining[0][currentMove];
15848         blackTimeRemaining = timeRemaining[1][currentMove];
15849     }
15850     DisplayBothClocks();
15851     DisplayMove(currentMove - 1);
15852     DrawPosition(full_redraw, boards[currentMove]);
15853     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
15854     // [HGM] PV info: routine tests if comment empty
15855     DisplayComment(currentMove - 1, commentList[currentMove]);
15856     ClearMap(); // [HGM] exclude: invalidate map
15857 }
15858
15859 void
15860 BackwardEvent ()
15861 {
15862     if (gameMode == IcsExamining && !pausing) {
15863         SendToICS(ics_prefix);
15864         SendToICS("backward\n");
15865     } else {
15866         BackwardInner(currentMove - 1);
15867     }
15868 }
15869
15870 void
15871 ToStartEvent ()
15872 {
15873     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
15874         /* to optimize, we temporarily turn off analysis mode while we undo
15875          * all the moves. Otherwise we get analysis output after each undo.
15876          */
15877         if (first.analysisSupport) {
15878           SendToProgram("exit\nforce\n", &first);
15879           first.analyzing = FALSE;
15880         }
15881     }
15882
15883     if (gameMode == IcsExamining && !pausing) {
15884         SendToICS(ics_prefix);
15885         SendToICS("backward 999999\n");
15886     } else {
15887         BackwardInner(backwardMostMove);
15888     }
15889
15890     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
15891         /* we have fed all the moves, so reactivate analysis mode */
15892         SendToProgram("analyze\n", &first);
15893         first.analyzing = TRUE;
15894         /*first.maybeThinking = TRUE;*/
15895         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
15896     }
15897 }
15898
15899 void
15900 ToNrEvent (int to)
15901 {
15902   if (gameMode == PlayFromGameFile && !pausing) PauseEvent();
15903   if (to >= forwardMostMove) to = forwardMostMove;
15904   if (to <= backwardMostMove) to = backwardMostMove;
15905   if (to < currentMove) {
15906     BackwardInner(to);
15907   } else {
15908     ForwardInner(to);
15909   }
15910 }
15911
15912 void
15913 RevertEvent (Boolean annotate)
15914 {
15915     if(PopTail(annotate)) { // [HGM] vari: restore old game tail
15916         return;
15917     }
15918     if (gameMode != IcsExamining) {
15919         DisplayError(_("You are not examining a game"), 0);
15920         return;
15921     }
15922     if (pausing) {
15923         DisplayError(_("You can't revert while pausing"), 0);
15924         return;
15925     }
15926     SendToICS(ics_prefix);
15927     SendToICS("revert\n");
15928 }
15929
15930 void
15931 RetractMoveEvent ()
15932 {
15933     switch (gameMode) {
15934       case MachinePlaysWhite:
15935       case MachinePlaysBlack:
15936         if (WhiteOnMove(forwardMostMove) == (gameMode == MachinePlaysWhite)) {
15937             DisplayError(_("Wait until your turn,\nor select 'Move Now'."), 0);
15938             return;
15939         }
15940         if (forwardMostMove < 2) return;
15941         currentMove = forwardMostMove = forwardMostMove - 2;
15942         whiteTimeRemaining = timeRemaining[0][currentMove];
15943         blackTimeRemaining = timeRemaining[1][currentMove];
15944         DisplayBothClocks();
15945         DisplayMove(currentMove - 1);
15946         ClearHighlights();/*!! could figure this out*/
15947         DrawPosition(TRUE, boards[currentMove]); /* [AS] Changed to full redraw! */
15948         SendToProgram("remove\n", &first);
15949         /*first.maybeThinking = TRUE;*/ /* GNU Chess does not ponder here */
15950         break;
15951
15952       case BeginningOfGame:
15953       default:
15954         break;
15955
15956       case IcsPlayingWhite:
15957       case IcsPlayingBlack:
15958         if (WhiteOnMove(forwardMostMove) == (gameMode == IcsPlayingWhite)) {
15959             SendToICS(ics_prefix);
15960             SendToICS("takeback 2\n");
15961         } else {
15962             SendToICS(ics_prefix);
15963             SendToICS("takeback 1\n");
15964         }
15965         break;
15966     }
15967 }
15968
15969 void
15970 MoveNowEvent ()
15971 {
15972     ChessProgramState *cps;
15973
15974     switch (gameMode) {
15975       case MachinePlaysWhite:
15976         if (!WhiteOnMove(forwardMostMove)) {
15977             DisplayError(_("It is your turn"), 0);
15978             return;
15979         }
15980         cps = &first;
15981         break;
15982       case MachinePlaysBlack:
15983         if (WhiteOnMove(forwardMostMove)) {
15984             DisplayError(_("It is your turn"), 0);
15985             return;
15986         }
15987         cps = &first;
15988         break;
15989       case TwoMachinesPlay:
15990         if (WhiteOnMove(forwardMostMove) ==
15991             (first.twoMachinesColor[0] == 'w')) {
15992             cps = &first;
15993         } else {
15994             cps = &second;
15995         }
15996         break;
15997       case BeginningOfGame:
15998       default:
15999         return;
16000     }
16001     SendToProgram("?\n", cps);
16002 }
16003
16004 void
16005 TruncateGameEvent ()
16006 {
16007     EditGameEvent();
16008     if (gameMode != EditGame) return;
16009     TruncateGame();
16010 }
16011
16012 void
16013 TruncateGame ()
16014 {
16015     CleanupTail(); // [HGM] vari: only keep current variation if we explicitly truncate
16016     if (forwardMostMove > currentMove) {
16017         if (gameInfo.resultDetails != NULL) {
16018             free(gameInfo.resultDetails);
16019             gameInfo.resultDetails = NULL;
16020             gameInfo.result = GameUnfinished;
16021         }
16022         forwardMostMove = currentMove;
16023         HistorySet(parseList, backwardMostMove, forwardMostMove,
16024                    currentMove-1);
16025     }
16026 }
16027
16028 void
16029 HintEvent ()
16030 {
16031     if (appData.noChessProgram) return;
16032     switch (gameMode) {
16033       case MachinePlaysWhite:
16034         if (WhiteOnMove(forwardMostMove)) {
16035             DisplayError(_("Wait until your turn."), 0);
16036             return;
16037         }
16038         break;
16039       case BeginningOfGame:
16040       case MachinePlaysBlack:
16041         if (!WhiteOnMove(forwardMostMove)) {
16042             DisplayError(_("Wait until your turn."), 0);
16043             return;
16044         }
16045         break;
16046       default:
16047         DisplayError(_("No hint available"), 0);
16048         return;
16049     }
16050     SendToProgram("hint\n", &first);
16051     hintRequested = TRUE;
16052 }
16053
16054 int
16055 SaveSelected (FILE *g, int dummy, char *dummy2)
16056 {
16057     ListGame * lg = (ListGame *) gameList.head;
16058     int nItem, cnt=0;
16059     FILE *f;
16060
16061     if( !(f = GameFile()) || ((ListGame *) gameList.tailPred)->number <= 0 ) {
16062         DisplayError(_("Game list not loaded or empty"), 0);
16063         return 0;
16064     }
16065
16066     creatingBook = TRUE; // suppresses stuff during load game
16067
16068     /* Get list size */
16069     for (nItem = 1; nItem <= ((ListGame *) gameList.tailPred)->number; nItem++){
16070         if(lg->position >= 0) { // selected?
16071             LoadGame(f, nItem, "", TRUE);
16072             SaveGamePGN2(g); // leaves g open
16073             cnt++; DoEvents();
16074         }
16075         lg = (ListGame *) lg->node.succ;
16076     }
16077
16078     fclose(g);
16079     creatingBook = FALSE;
16080
16081     return cnt;
16082 }
16083
16084 void
16085 CreateBookEvent ()
16086 {
16087     ListGame * lg = (ListGame *) gameList.head;
16088     FILE *f, *g;
16089     int nItem;
16090     static int secondTime = FALSE;
16091
16092     if( !(f = GameFile()) || ((ListGame *) gameList.tailPred)->number <= 0 ) {
16093         DisplayError(_("Game list not loaded or empty"), 0);
16094         return;
16095     }
16096
16097     if(!secondTime && (g = fopen(appData.polyglotBook, "r"))) {
16098         fclose(g);
16099         secondTime++;
16100         DisplayNote(_("Book file exists! Try again for overwrite."));
16101         return;
16102     }
16103
16104     creatingBook = TRUE;
16105     secondTime = FALSE;
16106
16107     /* Get list size */
16108     for (nItem = 1; nItem <= ((ListGame *) gameList.tailPred)->number; nItem++){
16109         if(lg->position >= 0) {
16110             LoadGame(f, nItem, "", TRUE);
16111             AddGameToBook(TRUE);
16112             DoEvents();
16113         }
16114         lg = (ListGame *) lg->node.succ;
16115     }
16116
16117     creatingBook = FALSE;
16118     FlushBook();
16119 }
16120
16121 void
16122 BookEvent ()
16123 {
16124     if (appData.noChessProgram) return;
16125     switch (gameMode) {
16126       case MachinePlaysWhite:
16127         if (WhiteOnMove(forwardMostMove)) {
16128             DisplayError(_("Wait until your turn."), 0);
16129             return;
16130         }
16131         break;
16132       case BeginningOfGame:
16133       case MachinePlaysBlack:
16134         if (!WhiteOnMove(forwardMostMove)) {
16135             DisplayError(_("Wait until your turn."), 0);
16136             return;
16137         }
16138         break;
16139       case EditPosition:
16140         EditPositionDone(TRUE);
16141         break;
16142       case TwoMachinesPlay:
16143         return;
16144       default:
16145         break;
16146     }
16147     SendToProgram("bk\n", &first);
16148     bookOutput[0] = NULLCHAR;
16149     bookRequested = TRUE;
16150 }
16151
16152 void
16153 AboutGameEvent ()
16154 {
16155     char *tags = PGNTags(&gameInfo);
16156     TagsPopUp(tags, CmailMsg());
16157     free(tags);
16158 }
16159
16160 /* end button procedures */
16161
16162 void
16163 PrintPosition (FILE *fp, int move)
16164 {
16165     int i, j;
16166
16167     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
16168         for (j = BOARD_LEFT; j < BOARD_RGHT; j++) {
16169             char c = PieceToChar(boards[move][i][j]);
16170             fputc(c == 'x' ? '.' : c, fp);
16171             fputc(j == BOARD_RGHT - 1 ? '\n' : ' ', fp);
16172         }
16173     }
16174     if ((gameMode == EditPosition) ? !blackPlaysFirst : (move % 2 == 0))
16175       fprintf(fp, "white to play\n");
16176     else
16177       fprintf(fp, "black to play\n");
16178 }
16179
16180 void
16181 PrintOpponents (FILE *fp)
16182 {
16183     if (gameInfo.white != NULL) {
16184         fprintf(fp, "\t%s vs. %s\n", gameInfo.white, gameInfo.black);
16185     } else {
16186         fprintf(fp, "\n");
16187     }
16188 }
16189
16190 /* Find last component of program's own name, using some heuristics */
16191 void
16192 TidyProgramName (char *prog, char *host, char buf[MSG_SIZ])
16193 {
16194     char *p, *q, c;
16195     int local = (strcmp(host, "localhost") == 0);
16196     while (!local && (p = strchr(prog, ';')) != NULL) {
16197         p++;
16198         while (*p == ' ') p++;
16199         prog = p;
16200     }
16201     if (*prog == '"' || *prog == '\'') {
16202         q = strchr(prog + 1, *prog);
16203     } else {
16204         q = strchr(prog, ' ');
16205     }
16206     if (q == NULL) q = prog + strlen(prog);
16207     p = q;
16208     while (p >= prog && *p != '/' && *p != '\\') p--;
16209     p++;
16210     if(p == prog && *p == '"') p++;
16211     c = *q; *q = 0;
16212     if (q - p >= 4 && StrCaseCmp(q - 4, ".exe") == 0) *q = c, q -= 4; else *q = c;
16213     memcpy(buf, p, q - p);
16214     buf[q - p] = NULLCHAR;
16215     if (!local) {
16216         strcat(buf, "@");
16217         strcat(buf, host);
16218     }
16219 }
16220
16221 char *
16222 TimeControlTagValue ()
16223 {
16224     char buf[MSG_SIZ];
16225     if (!appData.clockMode) {
16226       safeStrCpy(buf, "-", sizeof(buf)/sizeof(buf[0]));
16227     } else if (movesPerSession > 0) {
16228       snprintf(buf, MSG_SIZ, "%d/%ld", movesPerSession, timeControl/1000);
16229     } else if (timeIncrement == 0) {
16230       snprintf(buf, MSG_SIZ, "%ld", timeControl/1000);
16231     } else {
16232       snprintf(buf, MSG_SIZ, "%ld+%ld", timeControl/1000, timeIncrement/1000);
16233     }
16234     return StrSave(buf);
16235 }
16236
16237 void
16238 SetGameInfo ()
16239 {
16240     /* This routine is used only for certain modes */
16241     VariantClass v = gameInfo.variant;
16242     ChessMove r = GameUnfinished;
16243     char *p = NULL;
16244
16245     if(keepInfo) return;
16246
16247     if(gameMode == EditGame) { // [HGM] vari: do not erase result on EditGame
16248         r = gameInfo.result;
16249         p = gameInfo.resultDetails;
16250         gameInfo.resultDetails = NULL;
16251     }
16252     ClearGameInfo(&gameInfo);
16253     gameInfo.variant = v;
16254
16255     switch (gameMode) {
16256       case MachinePlaysWhite:
16257         gameInfo.event = StrSave( appData.pgnEventHeader );
16258         gameInfo.site = StrSave(HostName());
16259         gameInfo.date = PGNDate();
16260         gameInfo.round = StrSave("-");
16261         gameInfo.white = StrSave(first.tidy);
16262         gameInfo.black = StrSave(UserName());
16263         gameInfo.timeControl = TimeControlTagValue();
16264         break;
16265
16266       case MachinePlaysBlack:
16267         gameInfo.event = StrSave( appData.pgnEventHeader );
16268         gameInfo.site = StrSave(HostName());
16269         gameInfo.date = PGNDate();
16270         gameInfo.round = StrSave("-");
16271         gameInfo.white = StrSave(UserName());
16272         gameInfo.black = StrSave(first.tidy);
16273         gameInfo.timeControl = TimeControlTagValue();
16274         break;
16275
16276       case TwoMachinesPlay:
16277         gameInfo.event = StrSave( appData.pgnEventHeader );
16278         gameInfo.site = StrSave(HostName());
16279         gameInfo.date = PGNDate();
16280         if (roundNr > 0) {
16281             char buf[MSG_SIZ];
16282             snprintf(buf, MSG_SIZ, "%d", roundNr);
16283             gameInfo.round = StrSave(buf);
16284         } else {
16285             gameInfo.round = StrSave("-");
16286         }
16287         if (first.twoMachinesColor[0] == 'w') {
16288             gameInfo.white = StrSave(appData.pgnName[0][0] ? appData.pgnName[0] : first.tidy);
16289             gameInfo.black = StrSave(appData.pgnName[1][0] ? appData.pgnName[1] : second.tidy);
16290         } else {
16291             gameInfo.white = StrSave(appData.pgnName[1][0] ? appData.pgnName[1] : second.tidy);
16292             gameInfo.black = StrSave(appData.pgnName[0][0] ? appData.pgnName[0] : first.tidy);
16293         }
16294         gameInfo.timeControl = TimeControlTagValue();
16295         break;
16296
16297       case EditGame:
16298         gameInfo.event = StrSave("Edited game");
16299         gameInfo.site = StrSave(HostName());
16300         gameInfo.date = PGNDate();
16301         gameInfo.round = StrSave("-");
16302         gameInfo.white = StrSave("-");
16303         gameInfo.black = StrSave("-");
16304         gameInfo.result = r;
16305         gameInfo.resultDetails = p;
16306         break;
16307
16308       case EditPosition:
16309         gameInfo.event = StrSave("Edited position");
16310         gameInfo.site = StrSave(HostName());
16311         gameInfo.date = PGNDate();
16312         gameInfo.round = StrSave("-");
16313         gameInfo.white = StrSave("-");
16314         gameInfo.black = StrSave("-");
16315         break;
16316
16317       case IcsPlayingWhite:
16318       case IcsPlayingBlack:
16319       case IcsObserving:
16320       case IcsExamining:
16321         break;
16322
16323       case PlayFromGameFile:
16324         gameInfo.event = StrSave("Game from non-PGN file");
16325         gameInfo.site = StrSave(HostName());
16326         gameInfo.date = PGNDate();
16327         gameInfo.round = StrSave("-");
16328         gameInfo.white = StrSave("?");
16329         gameInfo.black = StrSave("?");
16330         break;
16331
16332       default:
16333         break;
16334     }
16335 }
16336
16337 void
16338 ReplaceComment (int index, char *text)
16339 {
16340     int len;
16341     char *p;
16342     float score;
16343
16344     if(index && sscanf(text, "%f/%d", &score, &len) == 2 &&
16345        pvInfoList[index-1].depth == len &&
16346        fabs(pvInfoList[index-1].score - score*100.) < 0.5 &&
16347        (p = strchr(text, '\n'))) text = p; // [HGM] strip off first line with PV info, if any
16348     while (*text == '\n') text++;
16349     len = strlen(text);
16350     while (len > 0 && text[len - 1] == '\n') len--;
16351
16352     if (commentList[index] != NULL)
16353       free(commentList[index]);
16354
16355     if (len == 0) {
16356         commentList[index] = NULL;
16357         return;
16358     }
16359   if( *text == '{' && strchr(text, '}') || // [HGM] braces: if certainy malformed, put braces
16360       *text == '[' && strchr(text, ']') || // otherwise hope the user knows what he is doing
16361       *text == '(' && strchr(text, ')')) { // (perhaps check if this parses as comment-only?)
16362     commentList[index] = (char *) malloc(len + 2);
16363     strncpy(commentList[index], text, len);
16364     commentList[index][len] = '\n';
16365     commentList[index][len + 1] = NULLCHAR;
16366   } else {
16367     // [HGM] braces: if text does not start with known OK delimiter, put braces around it.
16368     char *p;
16369     commentList[index] = (char *) malloc(len + 7);
16370     safeStrCpy(commentList[index], "{\n", 3);
16371     safeStrCpy(commentList[index]+2, text, len+1);
16372     commentList[index][len+2] = NULLCHAR;
16373     while(p = strchr(commentList[index], '}')) *p = ')'; // kill all } to make it one comment
16374     strcat(commentList[index], "\n}\n");
16375   }
16376 }
16377
16378 void
16379 CrushCRs (char *text)
16380 {
16381   char *p = text;
16382   char *q = text;
16383   char ch;
16384
16385   do {
16386     ch = *p++;
16387     if (ch == '\r') continue;
16388     *q++ = ch;
16389   } while (ch != '\0');
16390 }
16391
16392 void
16393 AppendComment (int index, char *text, Boolean addBraces)
16394 /* addBraces  tells if we should add {} */
16395 {
16396     int oldlen, len;
16397     char *old;
16398
16399 if(appData.debugMode) fprintf(debugFP, "Append: in='%s' %d\n", text, addBraces);
16400     if(addBraces == 3) addBraces = 0; else // force appending literally
16401     text = GetInfoFromComment( index, text ); /* [HGM] PV time: strip PV info from comment */
16402
16403     CrushCRs(text);
16404     while (*text == '\n') text++;
16405     len = strlen(text);
16406     while (len > 0 && text[len - 1] == '\n') len--;
16407     text[len] = NULLCHAR;
16408
16409     if (len == 0) return;
16410
16411     if (commentList[index] != NULL) {
16412       Boolean addClosingBrace = addBraces;
16413         old = commentList[index];
16414         oldlen = strlen(old);
16415         while(commentList[index][oldlen-1] ==  '\n')
16416           commentList[index][--oldlen] = NULLCHAR;
16417         commentList[index] = (char *) malloc(oldlen + len + 6); // might waste 4
16418         safeStrCpy(commentList[index], old, oldlen + len + 6);
16419         free(old);
16420         // [HGM] braces: join "{A\n}\n" + "{\nB}" as "{A\nB\n}"
16421         if(commentList[index][oldlen-1] == '}' && (text[0] == '{' || addBraces == TRUE)) {
16422           if(addBraces == TRUE) addBraces = FALSE; else { text++; len--; }
16423           while (*text == '\n') { text++; len--; }
16424           commentList[index][--oldlen] = NULLCHAR;
16425       }
16426         if(addBraces) strcat(commentList[index], addBraces == 2 ? "\n(" : "\n{\n");
16427         else          strcat(commentList[index], "\n");
16428         strcat(commentList[index], text);
16429         if(addClosingBrace) strcat(commentList[index], addClosingBrace == 2 ? ")\n" : "\n}\n");
16430         else          strcat(commentList[index], "\n");
16431     } else {
16432         commentList[index] = (char *) malloc(len + 6); // perhaps wastes 4...
16433         if(addBraces)
16434           safeStrCpy(commentList[index], addBraces == 2 ? "(" : "{\n", 3);
16435         else commentList[index][0] = NULLCHAR;
16436         strcat(commentList[index], text);
16437         strcat(commentList[index], addBraces == 2 ? ")\n" : "\n");
16438         if(addBraces == TRUE) strcat(commentList[index], "}\n");
16439     }
16440 }
16441
16442 static char *
16443 FindStr (char * text, char * sub_text)
16444 {
16445     char * result = strstr( text, sub_text );
16446
16447     if( result != NULL ) {
16448         result += strlen( sub_text );
16449     }
16450
16451     return result;
16452 }
16453
16454 /* [AS] Try to extract PV info from PGN comment */
16455 /* [HGM] PV time: and then remove it, to prevent it appearing twice */
16456 char *
16457 GetInfoFromComment (int index, char * text)
16458 {
16459     char * sep = text, *p;
16460
16461     if( text != NULL && index > 0 ) {
16462         int score = 0;
16463         int depth = 0;
16464         int time = -1, sec = 0, deci;
16465         char * s_eval = FindStr( text, "[%eval " );
16466         char * s_emt = FindStr( text, "[%emt " );
16467 #if 0
16468         if( s_eval != NULL || s_emt != NULL ) {
16469 #else
16470         if(0) { // [HGM] this code is not finished, and could actually be detrimental
16471 #endif
16472             /* New style */
16473             char delim;
16474
16475             if( s_eval != NULL ) {
16476                 if( sscanf( s_eval, "%d,%d%c", &score, &depth, &delim ) != 3 ) {
16477                     return text;
16478                 }
16479
16480                 if( delim != ']' ) {
16481                     return text;
16482                 }
16483             }
16484
16485             if( s_emt != NULL ) {
16486             }
16487                 return text;
16488         }
16489         else {
16490             /* We expect something like: [+|-]nnn.nn/dd */
16491             int score_lo = 0;
16492
16493             if(*text != '{') return text; // [HGM] braces: must be normal comment
16494
16495             sep = strchr( text, '/' );
16496             if( sep == NULL || sep < (text+4) ) {
16497                 return text;
16498             }
16499
16500             p = text;
16501             if(!strncmp(p+1, "final score ", 12)) p += 12, index++; else
16502             if(p[1] == '(') { // comment starts with PV
16503                p = strchr(p, ')'); // locate end of PV
16504                if(p == NULL || sep < p+5) return text;
16505                // at this point we have something like "{(.*) +0.23/6 ..."
16506                p = text; while(*++p != ')') p[-1] = *p; p[-1] = ')';
16507                *p = '\n'; while(*p == ' ' || *p == '\n') p++; *--p = '{';
16508                // we now moved the brace to behind the PV: "(.*) {+0.23/6 ..."
16509             }
16510             time = -1; sec = -1; deci = -1;
16511             if( sscanf( p+1, "%d.%d/%d %d:%d", &score, &score_lo, &depth, &time, &sec ) != 5 &&
16512                 sscanf( p+1, "%d.%d/%d %d.%d", &score, &score_lo, &depth, &time, &deci ) != 5 &&
16513                 sscanf( p+1, "%d.%d/%d %d", &score, &score_lo, &depth, &time ) != 4 &&
16514                 sscanf( p+1, "%d.%d/%d", &score, &score_lo, &depth ) != 3   ) {
16515                 return text;
16516             }
16517
16518             if( score_lo < 0 || score_lo >= 100 ) {
16519                 return text;
16520             }
16521
16522             if(sec >= 0) time = 600*time + 10*sec; else
16523             if(deci >= 0) time = 10*time + deci; else time *= 10; // deci-sec
16524
16525             score = score > 0 || !score & p[1] != '-' ? score*100 + score_lo : score*100 - score_lo;
16526
16527             /* [HGM] PV time: now locate end of PV info */
16528             while( *++sep >= '0' && *sep <= '9'); // strip depth
16529             if(time >= 0)
16530             while( *++sep >= '0' && *sep <= '9' || *sep == '\n'); // strip time
16531             if(sec >= 0)
16532             while( *++sep >= '0' && *sep <= '9'); // strip seconds
16533             if(deci >= 0)
16534             while( *++sep >= '0' && *sep <= '9'); // strip fractional seconds
16535             while(*sep == ' ' || *sep == '\n' || *sep == '\r') sep++;
16536         }
16537
16538         if( depth <= 0 ) {
16539             return text;
16540         }
16541
16542         if( time < 0 ) {
16543             time = -1;
16544         }
16545
16546         pvInfoList[index-1].depth = depth;
16547         pvInfoList[index-1].score = score;
16548         pvInfoList[index-1].time  = 10*time; // centi-sec
16549         if(*sep == '}') *sep = 0; else *--sep = '{';
16550         if(p != text) { while(*p++ = *sep++); sep = text; } // squeeze out space between PV and comment, and return both
16551     }
16552     return sep;
16553 }
16554
16555 void
16556 SendToProgram (char *message, ChessProgramState *cps)
16557 {
16558     int count, outCount, error;
16559     char buf[MSG_SIZ];
16560
16561     if (cps->pr == NoProc) return;
16562     Attention(cps);
16563
16564     if (appData.debugMode) {
16565         TimeMark now;
16566         GetTimeMark(&now);
16567         fprintf(debugFP, "%ld >%-6s: %s",
16568                 SubtractTimeMarks(&now, &programStartTime),
16569                 cps->which, message);
16570         if(serverFP)
16571             fprintf(serverFP, "%ld >%-6s: %s",
16572                 SubtractTimeMarks(&now, &programStartTime),
16573                 cps->which, message), fflush(serverFP);
16574     }
16575
16576     count = strlen(message);
16577     outCount = OutputToProcess(cps->pr, message, count, &error);
16578     if (outCount < count && !exiting
16579                          && !endingGame) { /* [HGM] crash: to not hang GameEnds() writing to deceased engines */
16580       if(!cps->initDone) return; // [HGM] should not generate fatal error during engine load
16581       snprintf(buf, MSG_SIZ, _("Error writing to %s chess program"), _(cps->which));
16582         if(gameInfo.resultDetails==NULL) { /* [HGM] crash: if game in progress, give reason for abort */
16583             if((signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
16584                 snprintf(buf, MSG_SIZ, _("%s program exits in draw position (%s)"), _(cps->which), cps->program);
16585                 if(matchMode && appData.tourneyFile[0]) { cps->pr = NoProc; GameEnds(GameIsDrawn, buf, GE_XBOARD); return; }
16586                 gameInfo.result = GameIsDrawn; /* [HGM] accept exit as draw claim */
16587             } else {
16588                 ChessMove res = cps->twoMachinesColor[0]=='w' ? BlackWins : WhiteWins;
16589                 if(matchMode && appData.tourneyFile[0]) { cps->pr = NoProc; GameEnds(res, buf, GE_XBOARD); return; }
16590                 gameInfo.result = res;
16591             }
16592             gameInfo.resultDetails = StrSave(buf);
16593         }
16594         if(matchMode && appData.tourneyFile[0]) { cps->pr = NoProc; return; }
16595         if(!cps->userError || !appData.popupExitMessage) DisplayFatalError(buf, error, 1); else errorExitStatus = 1;
16596     }
16597 }
16598
16599 void
16600 ReceiveFromProgram (InputSourceRef isr, VOIDSTAR closure, char *message, int count, int error)
16601 {
16602     char *end_str;
16603     char buf[MSG_SIZ];
16604     ChessProgramState *cps = (ChessProgramState *)closure;
16605
16606     if (isr != cps->isr) return; /* Killed intentionally */
16607     if (count <= 0) {
16608         if (count == 0) {
16609             RemoveInputSource(cps->isr);
16610             snprintf(buf, MSG_SIZ, _("Error: %s chess program (%s) exited unexpectedly"),
16611                     _(cps->which), cps->program);
16612             if(LoadError(cps->userError ? NULL : buf, cps)) return; // [HGM] should not generate fatal error during engine load
16613             if(gameInfo.resultDetails==NULL) { /* [HGM] crash: if game in progress, give reason for abort */
16614                 if((signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
16615                     snprintf(buf, MSG_SIZ, _("%s program exits in draw position (%s)"), _(cps->which), cps->program);
16616                     if(matchMode && appData.tourneyFile[0]) { cps->pr = NoProc; GameEnds(GameIsDrawn, buf, GE_XBOARD); return; }
16617                     gameInfo.result = GameIsDrawn; /* [HGM] accept exit as draw claim */
16618                 } else {
16619                     ChessMove res = cps->twoMachinesColor[0]=='w' ? BlackWins : WhiteWins;
16620                     if(matchMode && appData.tourneyFile[0]) { cps->pr = NoProc; GameEnds(res, buf, GE_XBOARD); return; }
16621                     gameInfo.result = res;
16622                 }
16623                 gameInfo.resultDetails = StrSave(buf);
16624             }
16625             if(matchMode && appData.tourneyFile[0]) { cps->pr = NoProc; return; }
16626             if(!cps->userError || !appData.popupExitMessage) DisplayFatalError(buf, 0, 1); else errorExitStatus = 1;
16627         } else {
16628             snprintf(buf, MSG_SIZ, _("Error reading from %s chess program (%s)"),
16629                     _(cps->which), cps->program);
16630             RemoveInputSource(cps->isr);
16631
16632             /* [AS] Program is misbehaving badly... kill it */
16633             if( count == -2 ) {
16634                 DestroyChildProcess( cps->pr, 9 );
16635                 cps->pr = NoProc;
16636             }
16637
16638             if(!cps->userError || !appData.popupExitMessage) DisplayFatalError(buf, error, 1); else errorExitStatus = 1;
16639         }
16640         return;
16641     }
16642
16643     if ((end_str = strchr(message, '\r')) != NULL)
16644       *end_str = NULLCHAR;
16645     if ((end_str = strchr(message, '\n')) != NULL)
16646       *end_str = NULLCHAR;
16647
16648     if (appData.debugMode) {
16649         TimeMark now; int print = 1;
16650         char *quote = ""; char c; int i;
16651
16652         if(appData.engineComments != 1) { /* [HGM] debug: decide if protocol-violating output is written */
16653                 char start = message[0];
16654                 if(start >='A' && start <= 'Z') start += 'a' - 'A'; // be tolerant to capitalizing
16655                 if(sscanf(message, "%d%c%d%d%d", &i, &c, &i, &i, &i) != 5 &&
16656                    sscanf(message, "move %c", &c)!=1  && sscanf(message, "offer%c", &c)!=1 &&
16657                    sscanf(message, "resign%c", &c)!=1 && sscanf(message, "feature %c", &c)!=1 &&
16658                    sscanf(message, "error %c", &c)!=1 && sscanf(message, "illegal %c", &c)!=1 &&
16659                    sscanf(message, "tell%c", &c)!=1   && sscanf(message, "0-1 %c", &c)!=1 &&
16660                    sscanf(message, "1-0 %c", &c)!=1   && sscanf(message, "1/2-1/2 %c", &c)!=1 &&
16661                    sscanf(message, "setboard %c", &c)!=1   && sscanf(message, "setup %c", &c)!=1 &&
16662                    sscanf(message, "hint: %c", &c)!=1 &&
16663                    sscanf(message, "pong %c", &c)!=1   && start != '#') {
16664                     quote = appData.engineComments == 2 ? "# " : "### NON-COMPLIANT! ### ";
16665                     print = (appData.engineComments >= 2);
16666                 }
16667                 message[0] = start; // restore original message
16668         }
16669         if(print) {
16670                 GetTimeMark(&now);
16671                 fprintf(debugFP, "%ld <%-6s: %s%s\n",
16672                         SubtractTimeMarks(&now, &programStartTime), cps->which,
16673                         quote,
16674                         message);
16675                 if(serverFP)
16676                     fprintf(serverFP, "%ld <%-6s: %s%s\n",
16677                         SubtractTimeMarks(&now, &programStartTime), cps->which,
16678                         quote,
16679                         message), fflush(serverFP);
16680         }
16681     }
16682
16683     /* [DM] if icsEngineAnalyze is active we block all whisper and kibitz output, because nobody want to see this */
16684     if (appData.icsEngineAnalyze) {
16685         if (strstr(message, "whisper") != NULL ||
16686              strstr(message, "kibitz") != NULL ||
16687             strstr(message, "tellics") != NULL) return;
16688     }
16689
16690     HandleMachineMove(message, cps);
16691 }
16692
16693
16694 void
16695 SendTimeControl (ChessProgramState *cps, int mps, long tc, int inc, int sd, int st)
16696 {
16697     char buf[MSG_SIZ];
16698     int seconds;
16699
16700     if( timeControl_2 > 0 ) {
16701         if( (gameMode == MachinePlaysBlack) || (gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b') ) {
16702             tc = timeControl_2;
16703         }
16704     }
16705     tc  /= cps->timeOdds; /* [HGM] time odds: apply before telling engine */
16706     inc /= cps->timeOdds;
16707     st  /= cps->timeOdds;
16708
16709     seconds = (tc / 1000) % 60; /* [HGM] displaced to after applying odds */
16710
16711     if (st > 0) {
16712       /* Set exact time per move, normally using st command */
16713       if (cps->stKludge) {
16714         /* GNU Chess 4 has no st command; uses level in a nonstandard way */
16715         seconds = st % 60;
16716         if (seconds == 0) {
16717           snprintf(buf, MSG_SIZ, "level 1 %d\n", st/60);
16718         } else {
16719           snprintf(buf, MSG_SIZ, "level 1 %d:%02d\n", st/60, seconds);
16720         }
16721       } else {
16722         snprintf(buf, MSG_SIZ, "st %d\n", st);
16723       }
16724     } else {
16725       /* Set conventional or incremental time control, using level command */
16726       if (seconds == 0) {
16727         /* Note old gnuchess bug -- minutes:seconds used to not work.
16728            Fixed in later versions, but still avoid :seconds
16729            when seconds is 0. */
16730         snprintf(buf, MSG_SIZ, "level %d %ld %g\n", mps, tc/60000, inc/1000.);
16731       } else {
16732         snprintf(buf, MSG_SIZ, "level %d %ld:%02d %g\n", mps, tc/60000,
16733                  seconds, inc/1000.);
16734       }
16735     }
16736     SendToProgram(buf, cps);
16737
16738     /* Orthoganally (except for GNU Chess 4), limit time to st seconds */
16739     /* Orthogonally, limit search to given depth */
16740     if (sd > 0) {
16741       if (cps->sdKludge) {
16742         snprintf(buf, MSG_SIZ, "depth\n%d\n", sd);
16743       } else {
16744         snprintf(buf, MSG_SIZ, "sd %d\n", sd);
16745       }
16746       SendToProgram(buf, cps);
16747     }
16748
16749     if(cps->nps >= 0) { /* [HGM] nps */
16750         if(cps->supportsNPS == FALSE)
16751           cps->nps = -1; // don't use if engine explicitly says not supported!
16752         else {
16753           snprintf(buf, MSG_SIZ, "nps %d\n", cps->nps);
16754           SendToProgram(buf, cps);
16755         }
16756     }
16757 }
16758
16759 ChessProgramState *
16760 WhitePlayer ()
16761 /* [HGM] return pointer to 'first' or 'second', depending on who plays white */
16762 {
16763     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b' ||
16764        gameMode == BeginningOfGame || gameMode == MachinePlaysBlack)
16765         return &second;
16766     return &first;
16767 }
16768
16769 void
16770 SendTimeRemaining (ChessProgramState *cps, int machineWhite)
16771 {
16772     char message[MSG_SIZ];
16773     long time, otime;
16774
16775     /* Note: this routine must be called when the clocks are stopped
16776        or when they have *just* been set or switched; otherwise
16777        it will be off by the time since the current tick started.
16778     */
16779     if (machineWhite) {
16780         time = whiteTimeRemaining / 10;
16781         otime = blackTimeRemaining / 10;
16782     } else {
16783         time = blackTimeRemaining / 10;
16784         otime = whiteTimeRemaining / 10;
16785     }
16786     /* [HGM] translate opponent's time by time-odds factor */
16787     otime = (otime * cps->other->timeOdds) / cps->timeOdds;
16788
16789     if (time <= 0) time = 1;
16790     if (otime <= 0) otime = 1;
16791
16792     snprintf(message, MSG_SIZ, "time %ld\n", time);
16793     SendToProgram(message, cps);
16794
16795     snprintf(message, MSG_SIZ, "otim %ld\n", otime);
16796     SendToProgram(message, cps);
16797 }
16798
16799 char *
16800 EngineDefinedVariant (ChessProgramState *cps, int n)
16801 {   // return name of n-th unknown variant that engine supports
16802     static char buf[MSG_SIZ];
16803     char *p, *s = cps->variants;
16804     if(!s) return NULL;
16805     do { // parse string from variants feature
16806       VariantClass v;
16807         p = strchr(s, ',');
16808         if(p) *p = NULLCHAR;
16809       v = StringToVariant(s);
16810       if(v == VariantNormal && strcmp(s, "normal") && !strstr(s, "_normal")) v = VariantUnknown; // garbage is recognized as normal
16811         if(v == VariantUnknown) { // non-standard variant in list of engine-supported variants
16812             if(!strcmp(s, "tenjiku") || !strcmp(s, "dai") || !strcmp(s, "dada") || // ignore Alien-Edition variants
16813                !strcmp(s, "maka") || !strcmp(s, "tai") || !strcmp(s, "kyoku") ||
16814                !strcmp(s, "checkers") || !strcmp(s, "go") || !strcmp(s, "reversi") ||
16815                !strcmp(s, "dark") || !strcmp(s, "alien") || !strcmp(s, "multi") || !strcmp(s, "amazons") ) n++;
16816             if(--n < 0) safeStrCpy(buf, s, MSG_SIZ);
16817         }
16818         if(p) *p++ = ',';
16819         if(n < 0) return buf;
16820     } while(s = p);
16821     return NULL;
16822 }
16823
16824 int
16825 BoolFeature (char **p, char *name, int *loc, ChessProgramState *cps)
16826 {
16827   char buf[MSG_SIZ];
16828   int len = strlen(name);
16829   int val;
16830
16831   if (strncmp((*p), name, len) == 0 && (*p)[len] == '=') {
16832     (*p) += len + 1;
16833     sscanf(*p, "%d", &val);
16834     *loc = (val != 0);
16835     while (**p && **p != ' ')
16836       (*p)++;
16837     snprintf(buf, MSG_SIZ, "accepted %s\n", name);
16838     SendToProgram(buf, cps);
16839     return TRUE;
16840   }
16841   return FALSE;
16842 }
16843
16844 int
16845 IntFeature (char **p, char *name, int *loc, ChessProgramState *cps)
16846 {
16847   char buf[MSG_SIZ];
16848   int len = strlen(name);
16849   if (strncmp((*p), name, len) == 0 && (*p)[len] == '=') {
16850     (*p) += len + 1;
16851     sscanf(*p, "%d", loc);
16852     while (**p && **p != ' ') (*p)++;
16853     snprintf(buf, MSG_SIZ, "accepted %s\n", name);
16854     SendToProgram(buf, cps);
16855     return TRUE;
16856   }
16857   return FALSE;
16858 }
16859
16860 int
16861 StringFeature (char **p, char *name, char **loc, ChessProgramState *cps)
16862 {
16863   char buf[MSG_SIZ];
16864   int len = strlen(name);
16865   if (strncmp((*p), name, len) == 0
16866       && (*p)[len] == '=' && (*p)[len+1] == '\"') {
16867     (*p) += len + 2;
16868     ASSIGN(*loc, *p); // kludge alert: assign rest of line just to be sure allocation is large enough so that sscanf below always fits
16869     sscanf(*p, "%[^\"]", *loc);
16870     while (**p && **p != '\"') (*p)++;
16871     if (**p == '\"') (*p)++;
16872     snprintf(buf, MSG_SIZ, "accepted %s\n", name);
16873     SendToProgram(buf, cps);
16874     return TRUE;
16875   }
16876   return FALSE;
16877 }
16878
16879 int
16880 ParseOption (Option *opt, ChessProgramState *cps)
16881 // [HGM] options: process the string that defines an engine option, and determine
16882 // name, type, default value, and allowed value range
16883 {
16884         char *p, *q, buf[MSG_SIZ];
16885         int n, min = (-1)<<31, max = 1<<31, def;
16886
16887         if(p = strstr(opt->name, " -spin ")) {
16888             if((n = sscanf(p, " -spin %d %d %d", &def, &min, &max)) < 3 ) return FALSE;
16889             if(max < min) max = min; // enforce consistency
16890             if(def < min) def = min;
16891             if(def > max) def = max;
16892             opt->value = def;
16893             opt->min = min;
16894             opt->max = max;
16895             opt->type = Spin;
16896         } else if((p = strstr(opt->name, " -slider "))) {
16897             // for now -slider is a synonym for -spin, to already provide compatibility with future polyglots
16898             if((n = sscanf(p, " -slider %d %d %d", &def, &min, &max)) < 3 ) return FALSE;
16899             if(max < min) max = min; // enforce consistency
16900             if(def < min) def = min;
16901             if(def > max) def = max;
16902             opt->value = def;
16903             opt->min = min;
16904             opt->max = max;
16905             opt->type = Spin; // Slider;
16906         } else if((p = strstr(opt->name, " -string "))) {
16907             opt->textValue = p+9;
16908             opt->type = TextBox;
16909         } else if((p = strstr(opt->name, " -file "))) {
16910             // for now -file is a synonym for -string, to already provide compatibility with future polyglots
16911             opt->textValue = p+7;
16912             opt->type = FileName; // FileName;
16913         } else if((p = strstr(opt->name, " -path "))) {
16914             // for now -file is a synonym for -string, to already provide compatibility with future polyglots
16915             opt->textValue = p+7;
16916             opt->type = PathName; // PathName;
16917         } else if(p = strstr(opt->name, " -check ")) {
16918             if(sscanf(p, " -check %d", &def) < 1) return FALSE;
16919             opt->value = (def != 0);
16920             opt->type = CheckBox;
16921         } else if(p = strstr(opt->name, " -combo ")) {
16922             opt->textValue = (char*) (opt->choice = &cps->comboList[cps->comboCnt]); // cheat with pointer type
16923             cps->comboList[cps->comboCnt++] = q = p+8; // holds possible choices
16924             if(*q == '*') cps->comboList[cps->comboCnt-1]++;
16925             opt->value = n = 0;
16926             while(q = StrStr(q, " /// ")) {
16927                 n++; *q = 0;    // count choices, and null-terminate each of them
16928                 q += 5;
16929                 if(*q == '*') { // remember default, which is marked with * prefix
16930                     q++;
16931                     opt->value = n;
16932                 }
16933                 cps->comboList[cps->comboCnt++] = q;
16934             }
16935             cps->comboList[cps->comboCnt++] = NULL;
16936             opt->max = n + 1;
16937             opt->type = ComboBox;
16938         } else if(p = strstr(opt->name, " -button")) {
16939             opt->type = Button;
16940         } else if(p = strstr(opt->name, " -save")) {
16941             opt->type = SaveButton;
16942         } else return FALSE;
16943         *p = 0; // terminate option name
16944         // now look if the command-line options define a setting for this engine option.
16945         if(cps->optionSettings && cps->optionSettings[0])
16946             p = strstr(cps->optionSettings, opt->name); else p = NULL;
16947         if(p && (p == cps->optionSettings || p[-1] == ',')) {
16948           snprintf(buf, MSG_SIZ, "option %s", p);
16949                 if(p = strstr(buf, ",")) *p = 0;
16950                 if(q = strchr(buf, '=')) switch(opt->type) {
16951                     case ComboBox:
16952                         for(n=0; n<opt->max; n++)
16953                             if(!strcmp(((char**)opt->textValue)[n], q+1)) opt->value = n;
16954                         break;
16955                     case TextBox:
16956                         safeStrCpy(opt->textValue, q+1, MSG_SIZ - (opt->textValue - opt->name));
16957                         break;
16958                     case Spin:
16959                     case CheckBox:
16960                         opt->value = atoi(q+1);
16961                     default:
16962                         break;
16963                 }
16964                 strcat(buf, "\n");
16965                 SendToProgram(buf, cps);
16966         }
16967         return TRUE;
16968 }
16969
16970 void
16971 FeatureDone (ChessProgramState *cps, int val)
16972 {
16973   DelayedEventCallback cb = GetDelayedEvent();
16974   if ((cb == InitBackEnd3 && cps == &first) ||
16975       (cb == SettingsMenuIfReady && cps == &second) ||
16976       (cb == LoadEngine) ||
16977       (cb == TwoMachinesEventIfReady)) {
16978     CancelDelayedEvent();
16979     ScheduleDelayedEvent(cb, val ? 1 : 3600000);
16980   }
16981   cps->initDone = val;
16982   if(val) cps->reload = FALSE;
16983 }
16984
16985 /* Parse feature command from engine */
16986 void
16987 ParseFeatures (char *args, ChessProgramState *cps)
16988 {
16989   char *p = args;
16990   char *q = NULL;
16991   int val;
16992   char buf[MSG_SIZ];
16993
16994   for (;;) {
16995     while (*p == ' ') p++;
16996     if (*p == NULLCHAR) return;
16997
16998     if (BoolFeature(&p, "setboard", &cps->useSetboard, cps)) continue;
16999     if (BoolFeature(&p, "xedit", &cps->extendedEdit, cps)) continue;
17000     if (BoolFeature(&p, "time", &cps->sendTime, cps)) continue;
17001     if (BoolFeature(&p, "draw", &cps->sendDrawOffers, cps)) continue;
17002     if (BoolFeature(&p, "sigint", &cps->useSigint, cps)) continue;
17003     if (BoolFeature(&p, "sigterm", &cps->useSigterm, cps)) continue;
17004     if (BoolFeature(&p, "reuse", &val, cps)) {
17005       /* Engine can disable reuse, but can't enable it if user said no */
17006       if (!val) cps->reuse = FALSE;
17007       continue;
17008     }
17009     if (BoolFeature(&p, "analyze", &cps->analysisSupport, cps)) continue;
17010     if (StringFeature(&p, "myname", &cps->tidy, cps)) {
17011       if (gameMode == TwoMachinesPlay) {
17012         DisplayTwoMachinesTitle();
17013       } else {
17014         DisplayTitle("");
17015       }
17016       continue;
17017     }
17018     if (StringFeature(&p, "variants", &cps->variants, cps)) continue;
17019     if (BoolFeature(&p, "san", &cps->useSAN, cps)) continue;
17020     if (BoolFeature(&p, "ping", &cps->usePing, cps)) continue;
17021     if (BoolFeature(&p, "playother", &cps->usePlayother, cps)) continue;
17022     if (BoolFeature(&p, "colors", &cps->useColors, cps)) continue;
17023     if (BoolFeature(&p, "usermove", &cps->useUsermove, cps)) continue;
17024     if (BoolFeature(&p, "exclude", &cps->excludeMoves, cps)) continue;
17025     if (BoolFeature(&p, "ics", &cps->sendICS, cps)) continue;
17026     if (BoolFeature(&p, "name", &cps->sendName, cps)) continue;
17027     if (BoolFeature(&p, "pause", &cps->pause, cps)) continue; // [HGM] pause
17028     if (IntFeature(&p, "done", &val, cps)) {
17029       FeatureDone(cps, val);
17030       continue;
17031     }
17032     /* Added by Tord: */
17033     if (BoolFeature(&p, "fen960", &cps->useFEN960, cps)) continue;
17034     if (BoolFeature(&p, "oocastle", &cps->useOOCastle, cps)) continue;
17035     /* End of additions by Tord */
17036
17037     /* [HGM] added features: */
17038     if (BoolFeature(&p, "highlight", &cps->highlight, cps)) continue;
17039     if (BoolFeature(&p, "debug", &cps->debug, cps)) continue;
17040     if (BoolFeature(&p, "nps", &cps->supportsNPS, cps)) continue;
17041     if (IntFeature(&p, "level", &cps->maxNrOfSessions, cps)) continue;
17042     if (BoolFeature(&p, "memory", &cps->memSize, cps)) continue;
17043     if (BoolFeature(&p, "smp", &cps->maxCores, cps)) continue;
17044     if (StringFeature(&p, "egt", &cps->egtFormats, cps)) continue;
17045     if (StringFeature(&p, "option", &q, cps)) { // read to freshly allocated temp buffer first
17046         if(cps->reload) { FREE(q); q = NULL; continue; } // we are reloading because of xreuse
17047         FREE(cps->option[cps->nrOptions].name);
17048         cps->option[cps->nrOptions].name = q; q = NULL;
17049         if(!ParseOption(&(cps->option[cps->nrOptions++]), cps)) { // [HGM] options: add option feature
17050           snprintf(buf, MSG_SIZ, "rejected option %s\n", cps->option[--cps->nrOptions].name);
17051             SendToProgram(buf, cps);
17052             continue;
17053         }
17054         if(cps->nrOptions >= MAX_OPTIONS) {
17055             cps->nrOptions--;
17056             snprintf(buf, MSG_SIZ, _("%s engine has too many options\n"), _(cps->which));
17057             DisplayError(buf, 0);
17058         }
17059         continue;
17060     }
17061     /* End of additions by HGM */
17062
17063     /* unknown feature: complain and skip */
17064     q = p;
17065     while (*q && *q != '=') q++;
17066     snprintf(buf, MSG_SIZ,"rejected %.*s\n", (int)(q-p), p);
17067     SendToProgram(buf, cps);
17068     p = q;
17069     if (*p == '=') {
17070       p++;
17071       if (*p == '\"') {
17072         p++;
17073         while (*p && *p != '\"') p++;
17074         if (*p == '\"') p++;
17075       } else {
17076         while (*p && *p != ' ') p++;
17077       }
17078     }
17079   }
17080
17081 }
17082
17083 void
17084 PeriodicUpdatesEvent (int newState)
17085 {
17086     if (newState == appData.periodicUpdates)
17087       return;
17088
17089     appData.periodicUpdates=newState;
17090
17091     /* Display type changes, so update it now */
17092 //    DisplayAnalysis();
17093
17094     /* Get the ball rolling again... */
17095     if (newState) {
17096         AnalysisPeriodicEvent(1);
17097         StartAnalysisClock();
17098     }
17099 }
17100
17101 void
17102 PonderNextMoveEvent (int newState)
17103 {
17104     if (newState == appData.ponderNextMove) return;
17105     if (gameMode == EditPosition) EditPositionDone(TRUE);
17106     if (newState) {
17107         SendToProgram("hard\n", &first);
17108         if (gameMode == TwoMachinesPlay) {
17109             SendToProgram("hard\n", &second);
17110         }
17111     } else {
17112         SendToProgram("easy\n", &first);
17113         thinkOutput[0] = NULLCHAR;
17114         if (gameMode == TwoMachinesPlay) {
17115             SendToProgram("easy\n", &second);
17116         }
17117     }
17118     appData.ponderNextMove = newState;
17119 }
17120
17121 void
17122 NewSettingEvent (int option, int *feature, char *command, int value)
17123 {
17124     char buf[MSG_SIZ];
17125
17126     if (gameMode == EditPosition) EditPositionDone(TRUE);
17127     snprintf(buf, MSG_SIZ,"%s%s %d\n", (option ? "option ": ""), command, value);
17128     if(feature == NULL || *feature) SendToProgram(buf, &first);
17129     if (gameMode == TwoMachinesPlay) {
17130         if(feature == NULL || feature[(int*)&second - (int*)&first]) SendToProgram(buf, &second);
17131     }
17132 }
17133
17134 void
17135 ShowThinkingEvent ()
17136 // [HGM] thinking: this routine is now also called from "Options -> Engine..." popup
17137 {
17138     static int oldState = 2; // kludge alert! Neither true nor fals, so first time oldState is always updated
17139     int newState = appData.showThinking
17140         // [HGM] thinking: other features now need thinking output as well
17141         || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp();
17142
17143     if (oldState == newState) return;
17144     oldState = newState;
17145     if (gameMode == EditPosition) EditPositionDone(TRUE);
17146     if (oldState) {
17147         SendToProgram("post\n", &first);
17148         if (gameMode == TwoMachinesPlay) {
17149             SendToProgram("post\n", &second);
17150         }
17151     } else {
17152         SendToProgram("nopost\n", &first);
17153         thinkOutput[0] = NULLCHAR;
17154         if (gameMode == TwoMachinesPlay) {
17155             SendToProgram("nopost\n", &second);
17156         }
17157     }
17158 //    appData.showThinking = newState; // [HGM] thinking: responsible option should already have be changed when calling this routine!
17159 }
17160
17161 void
17162 AskQuestionEvent (char *title, char *question, char *replyPrefix, char *which)
17163 {
17164   ProcRef pr = (which[0] == '1') ? first.pr : second.pr;
17165   if (pr == NoProc) return;
17166   AskQuestion(title, question, replyPrefix, pr);
17167 }
17168
17169 void
17170 TypeInEvent (char firstChar)
17171 {
17172     if ((gameMode == BeginningOfGame && !appData.icsActive) ||
17173         gameMode == MachinePlaysWhite || gameMode == MachinePlaysBlack ||
17174         gameMode == AnalyzeMode || gameMode == EditGame ||
17175         gameMode == EditPosition || gameMode == IcsExamining ||
17176         gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack ||
17177         isdigit(firstChar) && // [HGM] movenum: allow typing in of move nr in 'passive' modes
17178                 ( gameMode == AnalyzeFile || gameMode == PlayFromGameFile ||
17179                   gameMode == IcsObserving || gameMode == TwoMachinesPlay    ) ||
17180         gameMode == Training) PopUpMoveDialog(firstChar);
17181 }
17182
17183 void
17184 TypeInDoneEvent (char *move)
17185 {
17186         Board board;
17187         int n, fromX, fromY, toX, toY;
17188         char promoChar;
17189         ChessMove moveType;
17190
17191         // [HGM] FENedit
17192         if(gameMode == EditPosition && ParseFEN(board, &n, move, TRUE) ) {
17193                 EditPositionPasteFEN(move);
17194                 return;
17195         }
17196         // [HGM] movenum: allow move number to be typed in any mode
17197         if(sscanf(move, "%d", &n) == 1 && n != 0 ) {
17198           ToNrEvent(2*n-1);
17199           return;
17200         }
17201         // undocumented kludge: allow command-line option to be typed in!
17202         // (potentially fatal, and does not implement the effect of the option.)
17203         // should only be used for options that are values on which future decisions will be made,
17204         // and definitely not on options that would be used during initialization.
17205         if(strstr(move, "!!! -") == move) {
17206             ParseArgsFromString(move+4);
17207             return;
17208         }
17209
17210       if (gameMode != EditGame && currentMove != forwardMostMove &&
17211         gameMode != Training) {
17212         DisplayMoveError(_("Displayed move is not current"));
17213       } else {
17214         int ok = ParseOneMove(move, gameMode == EditPosition ? blackPlaysFirst : currentMove,
17215           &moveType, &fromX, &fromY, &toX, &toY, &promoChar);
17216         if(!ok && move[0] >= 'a') { move[0] += 'A' - 'a'; ok = 2; } // [HGM] try also capitalized
17217         if (ok==1 || ok && ParseOneMove(move, gameMode == EditPosition ? blackPlaysFirst : currentMove,
17218           &moveType, &fromX, &fromY, &toX, &toY, &promoChar)) {
17219           UserMoveEvent(fromX, fromY, toX, toY, promoChar);
17220         } else {
17221           DisplayMoveError(_("Could not parse move"));
17222         }
17223       }
17224 }
17225
17226 void
17227 DisplayMove (int moveNumber)
17228 {
17229     char message[MSG_SIZ];
17230     char res[MSG_SIZ];
17231     char cpThinkOutput[MSG_SIZ];
17232
17233     if(appData.noGUI) return; // [HGM] fast: suppress display of moves
17234
17235     if (moveNumber == forwardMostMove - 1 ||
17236         gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
17237
17238         safeStrCpy(cpThinkOutput, thinkOutput, sizeof(cpThinkOutput)/sizeof(cpThinkOutput[0]));
17239
17240         if (strchr(cpThinkOutput, '\n')) {
17241             *strchr(cpThinkOutput, '\n') = NULLCHAR;
17242         }
17243     } else {
17244         *cpThinkOutput = NULLCHAR;
17245     }
17246
17247     /* [AS] Hide thinking from human user */
17248     if( appData.hideThinkingFromHuman && gameMode != TwoMachinesPlay ) {
17249         *cpThinkOutput = NULLCHAR;
17250         if( thinkOutput[0] != NULLCHAR ) {
17251             int i;
17252
17253             for( i=0; i<=hiddenThinkOutputState; i++ ) {
17254                 cpThinkOutput[i] = '.';
17255             }
17256             cpThinkOutput[i] = NULLCHAR;
17257             hiddenThinkOutputState = (hiddenThinkOutputState + 1) % 3;
17258         }
17259     }
17260
17261     if (moveNumber == forwardMostMove - 1 &&
17262         gameInfo.resultDetails != NULL) {
17263         if (gameInfo.resultDetails[0] == NULLCHAR) {
17264           snprintf(res, MSG_SIZ, " %s", PGNResult(gameInfo.result));
17265         } else {
17266           snprintf(res, MSG_SIZ, " {%s} %s",
17267                     T_(gameInfo.resultDetails), PGNResult(gameInfo.result));
17268         }
17269     } else {
17270         res[0] = NULLCHAR;
17271     }
17272
17273     if (moveNumber < 0 || parseList[moveNumber][0] == NULLCHAR) {
17274         DisplayMessage(res, cpThinkOutput);
17275     } else {
17276       snprintf(message, MSG_SIZ, "%d.%s%s%s", moveNumber / 2 + 1,
17277                 WhiteOnMove(moveNumber) ? " " : ".. ",
17278                 parseList[moveNumber], res);
17279         DisplayMessage(message, cpThinkOutput);
17280     }
17281 }
17282
17283 void
17284 DisplayComment (int moveNumber, char *text)
17285 {
17286     char title[MSG_SIZ];
17287
17288     if (moveNumber < 0 || parseList[moveNumber][0] == NULLCHAR) {
17289       safeStrCpy(title, "Comment", sizeof(title)/sizeof(title[0]));
17290     } else {
17291       snprintf(title,MSG_SIZ, "Comment on %d.%s%s", moveNumber / 2 + 1,
17292               WhiteOnMove(moveNumber) ? " " : ".. ",
17293               parseList[moveNumber]);
17294     }
17295     if (text != NULL && (appData.autoDisplayComment || commentUp))
17296         CommentPopUp(title, text);
17297 }
17298
17299 /* This routine sends a ^C interrupt to gnuchess, to awaken it if it
17300  * might be busy thinking or pondering.  It can be omitted if your
17301  * gnuchess is configured to stop thinking immediately on any user
17302  * input.  However, that gnuchess feature depends on the FIONREAD
17303  * ioctl, which does not work properly on some flavors of Unix.
17304  */
17305 void
17306 Attention (ChessProgramState *cps)
17307 {
17308 #if ATTENTION
17309     if (!cps->useSigint) return;
17310     if (appData.noChessProgram || (cps->pr == NoProc)) return;
17311     switch (gameMode) {
17312       case MachinePlaysWhite:
17313       case MachinePlaysBlack:
17314       case TwoMachinesPlay:
17315       case IcsPlayingWhite:
17316       case IcsPlayingBlack:
17317       case AnalyzeMode:
17318       case AnalyzeFile:
17319         /* Skip if we know it isn't thinking */
17320         if (!cps->maybeThinking) return;
17321         if (appData.debugMode)
17322           fprintf(debugFP, "Interrupting %s\n", cps->which);
17323         InterruptChildProcess(cps->pr);
17324         cps->maybeThinking = FALSE;
17325         break;
17326       default:
17327         break;
17328     }
17329 #endif /*ATTENTION*/
17330 }
17331
17332 int
17333 CheckFlags ()
17334 {
17335     if (whiteTimeRemaining <= 0) {
17336         if (!whiteFlag) {
17337             whiteFlag = TRUE;
17338             if (appData.icsActive) {
17339                 if (appData.autoCallFlag &&
17340                     gameMode == IcsPlayingBlack && !blackFlag) {
17341                   SendToICS(ics_prefix);
17342                   SendToICS("flag\n");
17343                 }
17344             } else {
17345                 if (blackFlag) {
17346                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Both flags fell"));
17347                 } else {
17348                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("White's flag fell"));
17349                     if (appData.autoCallFlag) {
17350                         GameEnds(BlackWins, "Black wins on time", GE_XBOARD);
17351                         return TRUE;
17352                     }
17353                 }
17354             }
17355         }
17356     }
17357     if (blackTimeRemaining <= 0) {
17358         if (!blackFlag) {
17359             blackFlag = TRUE;
17360             if (appData.icsActive) {
17361                 if (appData.autoCallFlag &&
17362                     gameMode == IcsPlayingWhite && !whiteFlag) {
17363                   SendToICS(ics_prefix);
17364                   SendToICS("flag\n");
17365                 }
17366             } else {
17367                 if (whiteFlag) {
17368                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Both flags fell"));
17369                 } else {
17370                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Black's flag fell"));
17371                     if (appData.autoCallFlag) {
17372                         GameEnds(WhiteWins, "White wins on time", GE_XBOARD);
17373                         return TRUE;
17374                     }
17375                 }
17376             }
17377         }
17378     }
17379     return FALSE;
17380 }
17381
17382 void
17383 CheckTimeControl ()
17384 {
17385     if (!appData.clockMode || appData.icsActive || searchTime || // [HGM] st: no inc in st mode
17386         gameMode == PlayFromGameFile || forwardMostMove == 0) return;
17387
17388     /*
17389      * add time to clocks when time control is achieved ([HGM] now also used for increment)
17390      */
17391     if ( !WhiteOnMove(forwardMostMove) ) {
17392         /* White made time control */
17393         lastWhite -= whiteTimeRemaining; // [HGM] contains start time, socalculate thinking time
17394         whiteTimeRemaining += GetTimeQuota((forwardMostMove-whiteStartMove-1)/2, lastWhite, whiteTC)
17395         /* [HGM] time odds: correct new time quota for time odds! */
17396                                             / WhitePlayer()->timeOdds;
17397         lastBlack = blackTimeRemaining; // [HGM] leave absolute time (after quota), so next switch we can us it to calculate thinking time
17398     } else {
17399         lastBlack -= blackTimeRemaining;
17400         /* Black made time control */
17401         blackTimeRemaining += GetTimeQuota((forwardMostMove-blackStartMove-1)/2, lastBlack, blackTC)
17402                                             / WhitePlayer()->other->timeOdds;
17403         lastWhite = whiteTimeRemaining;
17404     }
17405 }
17406
17407 void
17408 DisplayBothClocks ()
17409 {
17410     int wom = gameMode == EditPosition ?
17411       !blackPlaysFirst : WhiteOnMove(currentMove);
17412     DisplayWhiteClock(whiteTimeRemaining, wom);
17413     DisplayBlackClock(blackTimeRemaining, !wom);
17414 }
17415
17416
17417 /* Timekeeping seems to be a portability nightmare.  I think everyone
17418    has ftime(), but I'm really not sure, so I'm including some ifdefs
17419    to use other calls if you don't.  Clocks will be less accurate if
17420    you have neither ftime nor gettimeofday.
17421 */
17422
17423 /* VS 2008 requires the #include outside of the function */
17424 #if !HAVE_GETTIMEOFDAY && HAVE_FTIME
17425 #include <sys/timeb.h>
17426 #endif
17427
17428 /* Get the current time as a TimeMark */
17429 void
17430 GetTimeMark (TimeMark *tm)
17431 {
17432 #if HAVE_GETTIMEOFDAY
17433
17434     struct timeval timeVal;
17435     struct timezone timeZone;
17436
17437     gettimeofday(&timeVal, &timeZone);
17438     tm->sec = (long) timeVal.tv_sec;
17439     tm->ms = (int) (timeVal.tv_usec / 1000L);
17440
17441 #else /*!HAVE_GETTIMEOFDAY*/
17442 #if HAVE_FTIME
17443
17444 // include <sys/timeb.h> / moved to just above start of function
17445     struct timeb timeB;
17446
17447     ftime(&timeB);
17448     tm->sec = (long) timeB.time;
17449     tm->ms = (int) timeB.millitm;
17450
17451 #else /*!HAVE_FTIME && !HAVE_GETTIMEOFDAY*/
17452     tm->sec = (long) time(NULL);
17453     tm->ms = 0;
17454 #endif
17455 #endif
17456 }
17457
17458 /* Return the difference in milliseconds between two
17459    time marks.  We assume the difference will fit in a long!
17460 */
17461 long
17462 SubtractTimeMarks (TimeMark *tm2, TimeMark *tm1)
17463 {
17464     return 1000L*(tm2->sec - tm1->sec) +
17465            (long) (tm2->ms - tm1->ms);
17466 }
17467
17468
17469 /*
17470  * Code to manage the game clocks.
17471  *
17472  * In tournament play, black starts the clock and then white makes a move.
17473  * We give the human user a slight advantage if he is playing white---the
17474  * clocks don't run until he makes his first move, so it takes zero time.
17475  * Also, we don't account for network lag, so we could get out of sync
17476  * with GNU Chess's clock -- but then, referees are always right.
17477  */
17478
17479 static TimeMark tickStartTM;
17480 static long intendedTickLength;
17481
17482 long
17483 NextTickLength (long timeRemaining)
17484 {
17485     long nominalTickLength, nextTickLength;
17486
17487     if (timeRemaining > 0L && timeRemaining <= 10000L)
17488       nominalTickLength = 100L;
17489     else
17490       nominalTickLength = 1000L;
17491     nextTickLength = timeRemaining % nominalTickLength;
17492     if (nextTickLength <= 0) nextTickLength += nominalTickLength;
17493
17494     return nextTickLength;
17495 }
17496
17497 /* Adjust clock one minute up or down */
17498 void
17499 AdjustClock (Boolean which, int dir)
17500 {
17501     if(appData.autoCallFlag) { DisplayError(_("Clock adjustment not allowed in auto-flag mode"), 0); return; }
17502     if(which) blackTimeRemaining += 60000*dir;
17503     else      whiteTimeRemaining += 60000*dir;
17504     DisplayBothClocks();
17505     adjustedClock = TRUE;
17506 }
17507
17508 /* Stop clocks and reset to a fresh time control */
17509 void
17510 ResetClocks ()
17511 {
17512     (void) StopClockTimer();
17513     if (appData.icsActive) {
17514         whiteTimeRemaining = blackTimeRemaining = 0;
17515     } else if (searchTime) {
17516         whiteTimeRemaining = 1000*searchTime / WhitePlayer()->timeOdds;
17517         blackTimeRemaining = 1000*searchTime / WhitePlayer()->other->timeOdds;
17518     } else { /* [HGM] correct new time quote for time odds */
17519         whiteTC = blackTC = fullTimeControlString;
17520         whiteTimeRemaining = GetTimeQuota(-1, 0, whiteTC) / WhitePlayer()->timeOdds;
17521         blackTimeRemaining = GetTimeQuota(-1, 0, blackTC) / WhitePlayer()->other->timeOdds;
17522     }
17523     if (whiteFlag || blackFlag) {
17524         DisplayTitle("");
17525         whiteFlag = blackFlag = FALSE;
17526     }
17527     lastWhite = lastBlack = whiteStartMove = blackStartMove = 0;
17528     DisplayBothClocks();
17529     adjustedClock = FALSE;
17530 }
17531
17532 #define FUDGE 25 /* 25ms = 1/40 sec; should be plenty even for 50 Hz clocks */
17533
17534 /* Decrement running clock by amount of time that has passed */
17535 void
17536 DecrementClocks ()
17537 {
17538     long timeRemaining;
17539     long lastTickLength, fudge;
17540     TimeMark now;
17541
17542     if (!appData.clockMode) return;
17543     if (gameMode==AnalyzeMode || gameMode == AnalyzeFile) return;
17544
17545     GetTimeMark(&now);
17546
17547     lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
17548
17549     /* Fudge if we woke up a little too soon */
17550     fudge = intendedTickLength - lastTickLength;
17551     if (fudge < 0 || fudge > FUDGE) fudge = 0;
17552
17553     if (WhiteOnMove(forwardMostMove)) {
17554         if(whiteNPS >= 0) lastTickLength = 0;
17555         timeRemaining = whiteTimeRemaining -= lastTickLength;
17556         if(timeRemaining < 0 && !appData.icsActive) {
17557             GetTimeQuota((forwardMostMove-whiteStartMove-1)/2, 0, whiteTC); // sets suddenDeath & nextSession;
17558             if(suddenDeath) { // [HGM] if we run out of a non-last incremental session, go to the next
17559                 whiteStartMove = forwardMostMove; whiteTC = nextSession;
17560                 lastWhite= timeRemaining = whiteTimeRemaining += GetTimeQuota(-1, 0, whiteTC);
17561             }
17562         }
17563         DisplayWhiteClock(whiteTimeRemaining - fudge,
17564                           WhiteOnMove(currentMove < forwardMostMove ? currentMove : forwardMostMove));
17565     } else {
17566         if(blackNPS >= 0) lastTickLength = 0;
17567         timeRemaining = blackTimeRemaining -= lastTickLength;
17568         if(timeRemaining < 0 && !appData.icsActive) { // [HGM] if we run out of a non-last incremental session, go to the next
17569             GetTimeQuota((forwardMostMove-blackStartMove-1)/2, 0, blackTC);
17570             if(suddenDeath) {
17571                 blackStartMove = forwardMostMove;
17572                 lastBlack = timeRemaining = blackTimeRemaining += GetTimeQuota(-1, 0, blackTC=nextSession);
17573             }
17574         }
17575         DisplayBlackClock(blackTimeRemaining - fudge,
17576                           !WhiteOnMove(currentMove < forwardMostMove ? currentMove : forwardMostMove));
17577     }
17578     if (CheckFlags()) return;
17579
17580     if(twoBoards) { // count down secondary board's clocks as well
17581         activePartnerTime -= lastTickLength;
17582         partnerUp = 1;
17583         if(activePartner == 'W')
17584             DisplayWhiteClock(activePartnerTime, TRUE); // the counting clock is always the highlighted one!
17585         else
17586             DisplayBlackClock(activePartnerTime, TRUE);
17587         partnerUp = 0;
17588     }
17589
17590     tickStartTM = now;
17591     intendedTickLength = NextTickLength(timeRemaining - fudge) + fudge;
17592     StartClockTimer(intendedTickLength);
17593
17594     /* if the time remaining has fallen below the alarm threshold, sound the
17595      * alarm. if the alarm has sounded and (due to a takeback or time control
17596      * with increment) the time remaining has increased to a level above the
17597      * threshold, reset the alarm so it can sound again.
17598      */
17599
17600     if (appData.icsActive && appData.icsAlarm) {
17601
17602         /* make sure we are dealing with the user's clock */
17603         if (!( ((gameMode == IcsPlayingWhite) && WhiteOnMove(currentMove)) ||
17604                ((gameMode == IcsPlayingBlack) && !WhiteOnMove(currentMove))
17605            )) return;
17606
17607         if (alarmSounded && (timeRemaining > appData.icsAlarmTime)) {
17608             alarmSounded = FALSE;
17609         } else if (!alarmSounded && (timeRemaining <= appData.icsAlarmTime)) {
17610             PlayAlarmSound();
17611             alarmSounded = TRUE;
17612         }
17613     }
17614 }
17615
17616
17617 /* A player has just moved, so stop the previously running
17618    clock and (if in clock mode) start the other one.
17619    We redisplay both clocks in case we're in ICS mode, because
17620    ICS gives us an update to both clocks after every move.
17621    Note that this routine is called *after* forwardMostMove
17622    is updated, so the last fractional tick must be subtracted
17623    from the color that is *not* on move now.
17624 */
17625 void
17626 SwitchClocks (int newMoveNr)
17627 {
17628     long lastTickLength;
17629     TimeMark now;
17630     int flagged = FALSE;
17631
17632     GetTimeMark(&now);
17633
17634     if (StopClockTimer() && appData.clockMode) {
17635         lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
17636         if (!WhiteOnMove(forwardMostMove)) {
17637             if(blackNPS >= 0) lastTickLength = 0;
17638             blackTimeRemaining -= lastTickLength;
17639            /* [HGM] PGNtime: save time for PGN file if engine did not give it */
17640 //         if(pvInfoList[forwardMostMove].time == -1)
17641                  pvInfoList[forwardMostMove].time =               // use GUI time
17642                       (timeRemaining[1][forwardMostMove-1] - blackTimeRemaining)/10;
17643         } else {
17644            if(whiteNPS >= 0) lastTickLength = 0;
17645            whiteTimeRemaining -= lastTickLength;
17646            /* [HGM] PGNtime: save time for PGN file if engine did not give it */
17647 //         if(pvInfoList[forwardMostMove].time == -1)
17648                  pvInfoList[forwardMostMove].time =
17649                       (timeRemaining[0][forwardMostMove-1] - whiteTimeRemaining)/10;
17650         }
17651         flagged = CheckFlags();
17652     }
17653     forwardMostMove = newMoveNr; // [HGM] race: change stm when no timer interrupt scheduled
17654     CheckTimeControl();
17655
17656     if (flagged || !appData.clockMode) return;
17657
17658     switch (gameMode) {
17659       case MachinePlaysBlack:
17660       case MachinePlaysWhite:
17661       case BeginningOfGame:
17662         if (pausing) return;
17663         break;
17664
17665       case EditGame:
17666       case PlayFromGameFile:
17667       case IcsExamining:
17668         return;
17669
17670       default:
17671         break;
17672     }
17673
17674     if (searchTime) { // [HGM] st: set clock of player that has to move to max time
17675         if(WhiteOnMove(forwardMostMove))
17676              whiteTimeRemaining = 1000*searchTime / WhitePlayer()->timeOdds;
17677         else blackTimeRemaining = 1000*searchTime / WhitePlayer()->other->timeOdds;
17678     }
17679
17680     tickStartTM = now;
17681     intendedTickLength = NextTickLength(WhiteOnMove(forwardMostMove) ?
17682       whiteTimeRemaining : blackTimeRemaining);
17683     StartClockTimer(intendedTickLength);
17684 }
17685
17686
17687 /* Stop both clocks */
17688 void
17689 StopClocks ()
17690 {
17691     long lastTickLength;
17692     TimeMark now;
17693
17694     if (!StopClockTimer()) return;
17695     if (!appData.clockMode) return;
17696
17697     GetTimeMark(&now);
17698
17699     lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
17700     if (WhiteOnMove(forwardMostMove)) {
17701         if(whiteNPS >= 0) lastTickLength = 0;
17702         whiteTimeRemaining -= lastTickLength;
17703         DisplayWhiteClock(whiteTimeRemaining, WhiteOnMove(currentMove));
17704     } else {
17705         if(blackNPS >= 0) lastTickLength = 0;
17706         blackTimeRemaining -= lastTickLength;
17707         DisplayBlackClock(blackTimeRemaining, !WhiteOnMove(currentMove));
17708     }
17709     CheckFlags();
17710 }
17711
17712 /* Start clock of player on move.  Time may have been reset, so
17713    if clock is already running, stop and restart it. */
17714 void
17715 StartClocks ()
17716 {
17717     (void) StopClockTimer(); /* in case it was running already */
17718     DisplayBothClocks();
17719     if (CheckFlags()) return;
17720
17721     if (!appData.clockMode) return;
17722     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) return;
17723
17724     GetTimeMark(&tickStartTM);
17725     intendedTickLength = NextTickLength(WhiteOnMove(forwardMostMove) ?
17726       whiteTimeRemaining : blackTimeRemaining);
17727
17728    /* [HGM] nps: figure out nps factors, by determining which engine plays white and/or black once and for all */
17729     whiteNPS = blackNPS = -1;
17730     if(gameMode == MachinePlaysWhite || gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'w'
17731        || appData.zippyPlay && gameMode == IcsPlayingBlack) // first (perhaps only) engine has white
17732         whiteNPS = first.nps;
17733     if(gameMode == MachinePlaysBlack || gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b'
17734        || appData.zippyPlay && gameMode == IcsPlayingWhite) // first (perhaps only) engine has black
17735         blackNPS = first.nps;
17736     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b') // second only used in Two-Machines mode
17737         whiteNPS = second.nps;
17738     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'w')
17739         blackNPS = second.nps;
17740     if(appData.debugMode) fprintf(debugFP, "nps: w=%d, b=%d\n", whiteNPS, blackNPS);
17741
17742     StartClockTimer(intendedTickLength);
17743 }
17744
17745 char *
17746 TimeString (long ms)
17747 {
17748     long second, minute, hour, day;
17749     char *sign = "";
17750     static char buf[32];
17751
17752     if (ms > 0 && ms <= 9900) {
17753       /* convert milliseconds to tenths, rounding up */
17754       double tenths = floor( ((double)(ms + 99L)) / 100.00 );
17755
17756       snprintf(buf,sizeof(buf)/sizeof(buf[0]), " %03.1f ", tenths/10.0);
17757       return buf;
17758     }
17759
17760     /* convert milliseconds to seconds, rounding up */
17761     /* use floating point to avoid strangeness of integer division
17762        with negative dividends on many machines */
17763     second = (long) floor(((double) (ms + 999L)) / 1000.0);
17764
17765     if (second < 0) {
17766         sign = "-";
17767         second = -second;
17768     }
17769
17770     day = second / (60 * 60 * 24);
17771     second = second % (60 * 60 * 24);
17772     hour = second / (60 * 60);
17773     second = second % (60 * 60);
17774     minute = second / 60;
17775     second = second % 60;
17776
17777     if (day > 0)
17778       snprintf(buf, sizeof(buf)/sizeof(buf[0]), " %s%ld:%02ld:%02ld:%02ld ",
17779               sign, day, hour, minute, second);
17780     else if (hour > 0)
17781       snprintf(buf, sizeof(buf)/sizeof(buf[0]), " %s%ld:%02ld:%02ld ", sign, hour, minute, second);
17782     else
17783       snprintf(buf, sizeof(buf)/sizeof(buf[0]), " %s%2ld:%02ld ", sign, minute, second);
17784
17785     return buf;
17786 }
17787
17788
17789 /*
17790  * This is necessary because some C libraries aren't ANSI C compliant yet.
17791  */
17792 char *
17793 StrStr (char *string, char *match)
17794 {
17795     int i, length;
17796
17797     length = strlen(match);
17798
17799     for (i = strlen(string) - length; i >= 0; i--, string++)
17800       if (!strncmp(match, string, length))
17801         return string;
17802
17803     return NULL;
17804 }
17805
17806 char *
17807 StrCaseStr (char *string, char *match)
17808 {
17809     int i, j, length;
17810
17811     length = strlen(match);
17812
17813     for (i = strlen(string) - length; i >= 0; i--, string++) {
17814         for (j = 0; j < length; j++) {
17815             if (ToLower(match[j]) != ToLower(string[j]))
17816               break;
17817         }
17818         if (j == length) return string;
17819     }
17820
17821     return NULL;
17822 }
17823
17824 #ifndef _amigados
17825 int
17826 StrCaseCmp (char *s1, char *s2)
17827 {
17828     char c1, c2;
17829
17830     for (;;) {
17831         c1 = ToLower(*s1++);
17832         c2 = ToLower(*s2++);
17833         if (c1 > c2) return 1;
17834         if (c1 < c2) return -1;
17835         if (c1 == NULLCHAR) return 0;
17836     }
17837 }
17838
17839
17840 int
17841 ToLower (int c)
17842 {
17843     return isupper(c) ? tolower(c) : c;
17844 }
17845
17846
17847 int
17848 ToUpper (int c)
17849 {
17850     return islower(c) ? toupper(c) : c;
17851 }
17852 #endif /* !_amigados    */
17853
17854 char *
17855 StrSave (char *s)
17856 {
17857   char *ret;
17858
17859   if ((ret = (char *) malloc(strlen(s) + 1)))
17860     {
17861       safeStrCpy(ret, s, strlen(s)+1);
17862     }
17863   return ret;
17864 }
17865
17866 char *
17867 StrSavePtr (char *s, char **savePtr)
17868 {
17869     if (*savePtr) {
17870         free(*savePtr);
17871     }
17872     if ((*savePtr = (char *) malloc(strlen(s) + 1))) {
17873       safeStrCpy(*savePtr, s, strlen(s)+1);
17874     }
17875     return(*savePtr);
17876 }
17877
17878 char *
17879 PGNDate ()
17880 {
17881     time_t clock;
17882     struct tm *tm;
17883     char buf[MSG_SIZ];
17884
17885     clock = time((time_t *)NULL);
17886     tm = localtime(&clock);
17887     snprintf(buf, MSG_SIZ, "%04d.%02d.%02d",
17888             tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday);
17889     return StrSave(buf);
17890 }
17891
17892
17893 char *
17894 PositionToFEN (int move, char *overrideCastling, int moveCounts)
17895 {
17896     int i, j, fromX, fromY, toX, toY;
17897     int whiteToPlay;
17898     char buf[MSG_SIZ];
17899     char *p, *q;
17900     int emptycount;
17901     ChessSquare piece;
17902
17903     whiteToPlay = (gameMode == EditPosition) ?
17904       !blackPlaysFirst : (move % 2 == 0);
17905     p = buf;
17906
17907     /* Piece placement data */
17908     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
17909         if(MSG_SIZ - (p - buf) < BOARD_RGHT - BOARD_LEFT + 20) { *p = 0; return StrSave(buf); }
17910         emptycount = 0;
17911         for (j = BOARD_LEFT; j < BOARD_RGHT; j++) {
17912             if (boards[move][i][j] == EmptySquare) {
17913                 emptycount++;
17914             } else { ChessSquare piece = boards[move][i][j];
17915                 if (emptycount > 0) {
17916                     if(emptycount<10) /* [HGM] can be >= 10 */
17917                         *p++ = '0' + emptycount;
17918                     else { *p++ = '0' + emptycount/10; *p++ = '0' + emptycount%10; }
17919                     emptycount = 0;
17920                 }
17921                 if(PieceToChar(piece) == '+') {
17922                     /* [HGM] write promoted pieces as '+<unpromoted>' (Shogi) */
17923                     *p++ = '+';
17924                     piece = (ChessSquare)(CHUDEMOTED piece);
17925                 }
17926                 *p++ = (piece == DarkSquare ? '*' : PieceToChar(piece));
17927                 if(*p = PieceSuffix(piece)) p++;
17928                 if(p[-1] == '~') {
17929                     /* [HGM] flag promoted pieces as '<promoted>~' (Crazyhouse) */
17930                     p[-1] = PieceToChar((ChessSquare)(CHUDEMOTED piece));
17931                     *p++ = '~';
17932                 }
17933             }
17934         }
17935         if (emptycount > 0) {
17936             if(emptycount<10) /* [HGM] can be >= 10 */
17937                 *p++ = '0' + emptycount;
17938             else { *p++ = '0' + emptycount/10; *p++ = '0' + emptycount%10; }
17939             emptycount = 0;
17940         }
17941         *p++ = '/';
17942     }
17943     *(p - 1) = ' ';
17944
17945     /* [HGM] print Crazyhouse or Shogi holdings */
17946     if( gameInfo.holdingsWidth ) {
17947         *(p-1) = '['; /* if we wanted to support BFEN, this could be '/' */
17948         q = p;
17949         for(i=0; i<gameInfo.holdingsSize; i++) { /* white holdings */
17950             piece = boards[move][i][BOARD_WIDTH-1];
17951             if( piece != EmptySquare )
17952               for(j=0; j<(int) boards[move][i][BOARD_WIDTH-2]; j++)
17953                   *p++ = PieceToChar(piece);
17954         }
17955         for(i=0; i<gameInfo.holdingsSize; i++) { /* black holdings */
17956             piece = boards[move][BOARD_HEIGHT-i-1][0];
17957             if( piece != EmptySquare )
17958               for(j=0; j<(int) boards[move][BOARD_HEIGHT-i-1][1]; j++)
17959                   *p++ = PieceToChar(piece);
17960         }
17961
17962         if( q == p ) *p++ = '-';
17963         *p++ = ']';
17964         *p++ = ' ';
17965     }
17966
17967     /* Active color */
17968     *p++ = whiteToPlay ? 'w' : 'b';
17969     *p++ = ' ';
17970
17971   if(q = overrideCastling) { // [HGM] FRC: override castling & e.p fields for non-compliant engines
17972     while(*p++ = *q++); if(q != overrideCastling+1) p[-1] = ' '; else --p;
17973   } else {
17974   if(nrCastlingRights) {
17975      int handW=0, handB=0;
17976      if(gameInfo.variant == VariantSChess) { // for S-Chess, all virgin backrank pieces must be listed
17977         for(i=0; i<BOARD_HEIGHT; i++) handW += boards[move][i][BOARD_RGHT]; // count white held pieces
17978         for(i=0; i<BOARD_HEIGHT; i++) handB += boards[move][i][BOARD_LEFT-1]; // count black held pieces
17979      }
17980      q = p;
17981      if(appData.fischerCastling) {
17982         if(handW) { // in shuffle S-Chess simply dump all virgin pieces
17983            for(i=BOARD_RGHT-1; i>=BOARD_LEFT; i--)
17984                if(boards[move][VIRGIN][i] & VIRGIN_W) *p++ = i + AAA + 'A' - 'a';
17985         } else {
17986        /* [HGM] write directly from rights */
17987            if(boards[move][CASTLING][2] != NoRights &&
17988               boards[move][CASTLING][0] != NoRights   )
17989                 *p++ = boards[move][CASTLING][0] + AAA + 'A' - 'a';
17990            if(boards[move][CASTLING][2] != NoRights &&
17991               boards[move][CASTLING][1] != NoRights   )
17992                 *p++ = boards[move][CASTLING][1] + AAA + 'A' - 'a';
17993         }
17994         if(handB) {
17995            for(i=BOARD_RGHT-1; i>=BOARD_LEFT; i--)
17996                if(boards[move][VIRGIN][i] & VIRGIN_B) *p++ = i + AAA;
17997         } else {
17998            if(boards[move][CASTLING][5] != NoRights &&
17999               boards[move][CASTLING][3] != NoRights   )
18000                 *p++ = boards[move][CASTLING][3] + AAA;
18001            if(boards[move][CASTLING][5] != NoRights &&
18002               boards[move][CASTLING][4] != NoRights   )
18003                 *p++ = boards[move][CASTLING][4] + AAA;
18004         }
18005      } else {
18006
18007         /* [HGM] write true castling rights */
18008         if( nrCastlingRights == 6 ) {
18009             int q, k=0;
18010             if(boards[move][CASTLING][0] != NoRights &&
18011                boards[move][CASTLING][2] != NoRights  ) k = 1, *p++ = 'K';
18012             q = (boards[move][CASTLING][1] != NoRights &&
18013                  boards[move][CASTLING][2] != NoRights  );
18014             if(handW) { // for S-Chess with pieces in hand, list virgin pieces between K and Q
18015                 for(i=BOARD_RGHT-1-k; i>=BOARD_LEFT+q; i--)
18016                     if((boards[move][0][i] != WhiteKing || k+q == 0) &&
18017                         boards[move][VIRGIN][i] & VIRGIN_W) *p++ = i + AAA + 'A' - 'a';
18018             }
18019             if(q) *p++ = 'Q';
18020             k = 0;
18021             if(boards[move][CASTLING][3] != NoRights &&
18022                boards[move][CASTLING][5] != NoRights  ) k = 1, *p++ = 'k';
18023             q = (boards[move][CASTLING][4] != NoRights &&
18024                  boards[move][CASTLING][5] != NoRights  );
18025             if(handB) {
18026                 for(i=BOARD_RGHT-1-k; i>=BOARD_LEFT+q; i--)
18027                     if((boards[move][BOARD_HEIGHT-1][i] != BlackKing || k+q == 0) &&
18028                         boards[move][VIRGIN][i] & VIRGIN_B) *p++ = i + AAA;
18029             }
18030             if(q) *p++ = 'q';
18031         }
18032      }
18033      if (q == p) *p++ = '-'; /* No castling rights */
18034      *p++ = ' ';
18035   }
18036
18037   if(gameInfo.variant != VariantShogi    && gameInfo.variant != VariantXiangqi &&
18038      gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier &&
18039      gameInfo.variant != VariantMakruk   && gameInfo.variant != VariantASEAN ) {
18040     /* En passant target square */
18041     if (move > backwardMostMove) {
18042         fromX = moveList[move - 1][0] - AAA;
18043         fromY = moveList[move - 1][1] - ONE;
18044         toX = moveList[move - 1][2] - AAA;
18045         toY = moveList[move - 1][3] - ONE;
18046         if (fromY == (whiteToPlay ? BOARD_HEIGHT-2 : 1) &&
18047             toY == (whiteToPlay ? BOARD_HEIGHT-4 : 3) &&
18048             boards[move][toY][toX] == (whiteToPlay ? BlackPawn : WhitePawn) &&
18049             fromX == toX) {
18050             /* 2-square pawn move just happened */
18051             *p++ = toX + AAA;
18052             *p++ = whiteToPlay ? '6'+BOARD_HEIGHT-8 : '3';
18053         } else {
18054             *p++ = '-';
18055         }
18056     } else if(move == backwardMostMove) {
18057         // [HGM] perhaps we should always do it like this, and forget the above?
18058         if((signed char)boards[move][EP_STATUS] >= 0) {
18059             *p++ = boards[move][EP_STATUS] + AAA;
18060             *p++ = whiteToPlay ? '6'+BOARD_HEIGHT-8 : '3';
18061         } else {
18062             *p++ = '-';
18063         }
18064     } else {
18065         *p++ = '-';
18066     }
18067     *p++ = ' ';
18068   }
18069   }
18070
18071     if(moveCounts)
18072     {   int i = 0, j=move;
18073
18074         /* [HGM] find reversible plies */
18075         if (appData.debugMode) { int k;
18076             fprintf(debugFP, "write FEN 50-move: %d %d %d\n", initialRulePlies, forwardMostMove, backwardMostMove);
18077             for(k=backwardMostMove; k<=forwardMostMove; k++)
18078                 fprintf(debugFP, "e%d. p=%d\n", k, (signed char)boards[k][EP_STATUS]);
18079
18080         }
18081
18082         while(j > backwardMostMove && (signed char)boards[j][EP_STATUS] <= EP_NONE) j--,i++;
18083         if( j == backwardMostMove ) i += initialRulePlies;
18084         sprintf(p, "%d ", i);
18085         p += i>=100 ? 4 : i >= 10 ? 3 : 2;
18086
18087         /* Fullmove number */
18088         sprintf(p, "%d", (move / 2) + 1);
18089     } else *--p = NULLCHAR;
18090
18091     return StrSave(buf);
18092 }
18093
18094 Boolean
18095 ParseFEN (Board board, int *blackPlaysFirst, char *fen, Boolean autoSize)
18096 {
18097     int i, j, k, w=0, subst=0, shuffle=0, wKingRank = -1, bKingRank = -1;
18098     char *p, c;
18099     int emptycount, virgin[BOARD_FILES];
18100     ChessSquare piece, king = (gameInfo.variant == VariantKnightmate ? WhiteUnicorn : WhiteKing);
18101
18102     p = fen;
18103
18104     /* Piece placement data */
18105     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
18106         j = 0;
18107         for (;;) {
18108             if (*p == '/' || *p == ' ' || *p == '[' ) {
18109                 if(j > w) w = j;
18110                 emptycount = gameInfo.boardWidth - j;
18111                 while (emptycount--)
18112                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
18113                 if (*p == '/') p++;
18114                 else if(autoSize) { // we stumbled unexpectedly into end of board
18115                     for(k=i; k<BOARD_HEIGHT; k++) { // too few ranks; shift towards bottom
18116                         for(j=0; j<BOARD_WIDTH; j++) board[k-i][j] = board[k][j];
18117                     }
18118                     appData.NrRanks = gameInfo.boardHeight - i; i=0;
18119                 }
18120                 break;
18121 #if(BOARD_FILES >= 10)*0
18122             } else if(*p=='x' || *p=='X') { /* [HGM] X means 10 */
18123                 p++; emptycount=10;
18124                 if (j + emptycount > gameInfo.boardWidth) return FALSE;
18125                 while (emptycount--)
18126                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
18127 #endif
18128             } else if (*p == '*') {
18129                 board[i][(j++)+gameInfo.holdingsWidth] = DarkSquare; p++;
18130             } else if (isdigit(*p)) {
18131                 emptycount = *p++ - '0';
18132                 while(isdigit(*p)) emptycount = 10*emptycount + *p++ - '0'; /* [HGM] allow > 9 */
18133                 if (j + emptycount > gameInfo.boardWidth) return FALSE;
18134                 while (emptycount--)
18135                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
18136             } else if (*p == '<') {
18137                 if(i == BOARD_HEIGHT-1) shuffle = 1;
18138                 else if (i != 0 || !shuffle) return FALSE;
18139                 p++;
18140             } else if (shuffle && *p == '>') {
18141                 p++; // for now ignore closing shuffle range, and assume rank-end
18142             } else if (*p == '?') {
18143                 if (j >= gameInfo.boardWidth) return FALSE;
18144                 if (i != 0  && i != BOARD_HEIGHT-1) return FALSE; // only on back-rank
18145                 board[i][(j++)+gameInfo.holdingsWidth] = ClearBoard; p++; subst++; // placeHolder
18146             } else if (*p == '+' || isalpha(*p)) {
18147                 char *q, *s = SUFFIXES;
18148                 if (j >= gameInfo.boardWidth) return FALSE;
18149                 if(*p=='+') {
18150                     char c = *++p;
18151                     if(q = strchr(s, p[1])) p++;
18152                     piece = CharToPiece(c + (q ? 64*(q - s + 1) : 0));
18153                     if(piece == EmptySquare) return FALSE; /* unknown piece */
18154                     piece = (ChessSquare) (CHUPROMOTED piece ); p++;
18155                     if(PieceToChar(piece) != '+') return FALSE; /* unpromotable piece */
18156                 } else {
18157                     char c = *p++;
18158                     if(q = strchr(s, *p)) p++;
18159                     piece = CharToPiece(c + (q ? 64*(q - s + 1) : 0));
18160                 }
18161
18162                 if(piece==EmptySquare) return FALSE; /* unknown piece */
18163                 if(*p == '~') { /* [HGM] make it a promoted piece for Crazyhouse */
18164                     piece = (ChessSquare) (PROMOTED piece);
18165                     if(PieceToChar(piece) != '~') return FALSE; /* cannot be a promoted piece */
18166                     p++;
18167                 }
18168                 board[i][(j++)+gameInfo.holdingsWidth] = piece;
18169                 if(piece == king) wKingRank = i;
18170                 if(piece == WHITE_TO_BLACK king) bKingRank = i;
18171             } else {
18172                 return FALSE;
18173             }
18174         }
18175     }
18176     while (*p == '/' || *p == ' ') p++;
18177
18178     if(autoSize) appData.NrFiles = w, InitPosition(TRUE);
18179
18180     /* [HGM] by default clear Crazyhouse holdings, if present */
18181     if(gameInfo.holdingsWidth) {
18182        for(i=0; i<BOARD_HEIGHT; i++) {
18183            board[i][0]             = EmptySquare; /* black holdings */
18184            board[i][BOARD_WIDTH-1] = EmptySquare; /* white holdings */
18185            board[i][1]             = (ChessSquare) 0; /* black counts */
18186            board[i][BOARD_WIDTH-2] = (ChessSquare) 0; /* white counts */
18187        }
18188     }
18189
18190     /* [HGM] look for Crazyhouse holdings here */
18191     while(*p==' ') p++;
18192     if( gameInfo.holdingsWidth && p[-1] == '/' || *p == '[') {
18193         int swap=0, wcnt=0, bcnt=0;
18194         if(*p == '[') p++;
18195         if(*p == '<') swap++, p++;
18196         if(*p == '-' ) p++; /* empty holdings */ else {
18197             if( !gameInfo.holdingsWidth ) return FALSE; /* no room to put holdings! */
18198             /* if we would allow FEN reading to set board size, we would   */
18199             /* have to add holdings and shift the board read so far here   */
18200             while( (piece = CharToPiece(*p) ) != EmptySquare ) {
18201                 p++;
18202                 if((int) piece >= (int) BlackPawn ) {
18203                     i = (int)piece - (int)BlackPawn;
18204                     i = PieceToNumber((ChessSquare)i);
18205                     if( i >= gameInfo.holdingsSize ) return FALSE;
18206                     board[BOARD_HEIGHT-1-i][0] = piece; /* black holdings */
18207                     board[BOARD_HEIGHT-1-i][1]++;       /* black counts   */
18208                     bcnt++;
18209                 } else {
18210                     i = (int)piece - (int)WhitePawn;
18211                     i = PieceToNumber((ChessSquare)i);
18212                     if( i >= gameInfo.holdingsSize ) return FALSE;
18213                     board[i][BOARD_WIDTH-1] = piece;    /* white holdings */
18214                     board[i][BOARD_WIDTH-2]++;          /* black holdings */
18215                     wcnt++;
18216                 }
18217             }
18218             if(subst) { // substitute back-rank question marks by holdings pieces
18219                 for(j=BOARD_LEFT; j<BOARD_RGHT; j++) {
18220                     int k, m, n = bcnt + 1;
18221                     if(board[0][j] == ClearBoard) {
18222                         if(!wcnt) return FALSE;
18223                         n = rand() % wcnt;
18224                         for(k=0, m=n; k<gameInfo.holdingsSize; k++) if((m -= board[k][BOARD_WIDTH-2]) < 0) {
18225                             board[0][j] = board[k][BOARD_WIDTH-1]; wcnt--;
18226                             if(--board[k][BOARD_WIDTH-2] == 0) board[k][BOARD_WIDTH-1] = EmptySquare;
18227                             break;
18228                         }
18229                     }
18230                     if(board[BOARD_HEIGHT-1][j] == ClearBoard) {
18231                         if(!bcnt) return FALSE;
18232                         if(n >= bcnt) n = rand() % bcnt; // use same randomization for black and white if possible
18233                         for(k=0, m=n; k<gameInfo.holdingsSize; k++) if((n -= board[BOARD_HEIGHT-1-k][1]) < 0) {
18234                             board[BOARD_HEIGHT-1][j] = board[BOARD_HEIGHT-1-k][0]; bcnt--;
18235                             if(--board[BOARD_HEIGHT-1-k][1] == 0) board[BOARD_HEIGHT-1-k][0] = EmptySquare;
18236                             break;
18237                         }
18238                     }
18239                 }
18240                 subst = 0;
18241             }
18242         }
18243         if(*p == ']') p++;
18244     }
18245
18246     if(subst) return FALSE; // substitution requested, but no holdings
18247
18248     while(*p == ' ') p++;
18249
18250     /* Active color */
18251     c = *p++;
18252     if(appData.colorNickNames) {
18253       if( c == appData.colorNickNames[0] ) c = 'w'; else
18254       if( c == appData.colorNickNames[1] ) c = 'b';
18255     }
18256     switch (c) {
18257       case 'w':
18258         *blackPlaysFirst = FALSE;
18259         break;
18260       case 'b':
18261         *blackPlaysFirst = TRUE;
18262         break;
18263       default:
18264         return FALSE;
18265     }
18266
18267     /* [HGM] We NO LONGER ignore the rest of the FEN notation */
18268     /* return the extra info in global variiables             */
18269
18270     while(*p==' ') p++;
18271
18272     if(!isdigit(*p) && *p != '-') { // we seem to have castling rights. Make sure they are on the rank the King actually is.
18273         if(wKingRank >= 0) for(i=0; i<3; i++) castlingRank[i] = wKingRank;
18274         if(bKingRank >= 0) for(i=3; i<6; i++) castlingRank[i] = bKingRank;
18275     }
18276
18277     /* set defaults in case FEN is incomplete */
18278     board[EP_STATUS] = EP_UNKNOWN;
18279     for(i=0; i<nrCastlingRights; i++ ) {
18280         board[CASTLING][i] =
18281             appData.fischerCastling ? NoRights : initialRights[i];
18282     }   /* assume possible unless obviously impossible */
18283     if(initialRights[0]!=NoRights && board[castlingRank[0]][initialRights[0]] != WhiteRook) board[CASTLING][0] = NoRights;
18284     if(initialRights[1]!=NoRights && board[castlingRank[1]][initialRights[1]] != WhiteRook) board[CASTLING][1] = NoRights;
18285     if(initialRights[2]!=NoRights && board[castlingRank[2]][initialRights[2]] != WhiteUnicorn
18286                                   && board[castlingRank[2]][initialRights[2]] != WhiteKing) board[CASTLING][2] = NoRights;
18287     if(initialRights[3]!=NoRights && board[castlingRank[3]][initialRights[3]] != BlackRook) board[CASTLING][3] = NoRights;
18288     if(initialRights[4]!=NoRights && board[castlingRank[4]][initialRights[4]] != BlackRook) board[CASTLING][4] = NoRights;
18289     if(initialRights[5]!=NoRights && board[castlingRank[5]][initialRights[5]] != BlackUnicorn
18290                                   && board[castlingRank[5]][initialRights[5]] != BlackKing) board[CASTLING][5] = NoRights;
18291     FENrulePlies = 0;
18292
18293     if(nrCastlingRights) {
18294       int fischer = 0;
18295       if(gameInfo.variant == VariantSChess) for(i=0; i<BOARD_FILES; i++) virgin[i] = 0;
18296       if(*p >= 'A' && *p <= 'Z' || *p >= 'a' && *p <= 'z' || *p=='-') {
18297           /* castling indicator present, so default becomes no castlings */
18298           for(i=0; i<nrCastlingRights; i++ ) {
18299                  board[CASTLING][i] = NoRights;
18300           }
18301       }
18302       while(*p=='K' || *p=='Q' || *p=='k' || *p=='q' || *p=='-' ||
18303              (appData.fischerCastling || gameInfo.variant == VariantSChess) &&
18304              ( *p >= 'a' && *p < 'a' + gameInfo.boardWidth) ||
18305              ( *p >= 'A' && *p < 'A' + gameInfo.boardWidth)   ) {
18306         int c = *p++, whiteKingFile=NoRights, blackKingFile=NoRights;
18307
18308         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) {
18309             if(board[castlingRank[5]][i] == BlackKing) blackKingFile = i;
18310             if(board[castlingRank[2]][i] == WhiteKing) whiteKingFile = i;
18311         }
18312         if(gameInfo.variant == VariantTwoKings || gameInfo.variant == VariantKnightmate)
18313             whiteKingFile = blackKingFile = BOARD_WIDTH >> 1; // for these variant scanning fails
18314         if(whiteKingFile == NoRights || board[castlingRank[2]][whiteKingFile] != WhiteUnicorn
18315                                      && board[castlingRank[2]][whiteKingFile] != WhiteKing) whiteKingFile = NoRights;
18316         if(blackKingFile == NoRights || board[castlingRank[5]][blackKingFile] != BlackUnicorn
18317                                      && board[castlingRank[5]][blackKingFile] != BlackKing) blackKingFile = NoRights;
18318         switch(c) {
18319           case'K':
18320               for(i=BOARD_RGHT-1; board[castlingRank[2]][i]!=WhiteRook && i>whiteKingFile; i--);
18321               board[CASTLING][0] = i != whiteKingFile ? i : NoRights;
18322               board[CASTLING][2] = whiteKingFile;
18323               if(board[CASTLING][0] != NoRights) virgin[board[CASTLING][0]] |= VIRGIN_W;
18324               if(board[CASTLING][2] != NoRights) virgin[board[CASTLING][2]] |= VIRGIN_W;
18325               if(whiteKingFile != BOARD_WIDTH>>1|| i != BOARD_RGHT-1) fischer = 1;
18326               break;
18327           case'Q':
18328               for(i=BOARD_LEFT;  i<BOARD_RGHT && board[castlingRank[2]][i]!=WhiteRook && i<whiteKingFile; i++);
18329               board[CASTLING][1] = i != whiteKingFile ? i : NoRights;
18330               board[CASTLING][2] = whiteKingFile;
18331               if(board[CASTLING][1] != NoRights) virgin[board[CASTLING][1]] |= VIRGIN_W;
18332               if(board[CASTLING][2] != NoRights) virgin[board[CASTLING][2]] |= VIRGIN_W;
18333               if(whiteKingFile != BOARD_WIDTH>>1|| i != BOARD_LEFT) fischer = 1;
18334               break;
18335           case'k':
18336               for(i=BOARD_RGHT-1; board[castlingRank[5]][i]!=BlackRook && i>blackKingFile; i--);
18337               board[CASTLING][3] = i != blackKingFile ? i : NoRights;
18338               board[CASTLING][5] = blackKingFile;
18339               if(board[CASTLING][3] != NoRights) virgin[board[CASTLING][3]] |= VIRGIN_B;
18340               if(board[CASTLING][5] != NoRights) virgin[board[CASTLING][5]] |= VIRGIN_B;
18341               if(blackKingFile != BOARD_WIDTH>>1|| i != BOARD_RGHT-1) fischer = 1;
18342               break;
18343           case'q':
18344               for(i=BOARD_LEFT; i<BOARD_RGHT && board[castlingRank[5]][i]!=BlackRook && i<blackKingFile; i++);
18345               board[CASTLING][4] = i != blackKingFile ? i : NoRights;
18346               board[CASTLING][5] = blackKingFile;
18347               if(board[CASTLING][4] != NoRights) virgin[board[CASTLING][4]] |= VIRGIN_B;
18348               if(board[CASTLING][5] != NoRights) virgin[board[CASTLING][5]] |= VIRGIN_B;
18349               if(blackKingFile != BOARD_WIDTH>>1|| i != BOARD_LEFT) fischer = 1;
18350           case '-':
18351               break;
18352           default: /* FRC castlings */
18353               if(c >= 'a') { /* black rights */
18354                   if(gameInfo.variant == VariantSChess) { virgin[c-AAA] |= VIRGIN_B; break; } // in S-Chess castlings are always kq, so just virginity
18355                   for(i=BOARD_LEFT; i<BOARD_RGHT; i++)
18356                     if(board[BOARD_HEIGHT-1][i] == BlackKing) break;
18357                   if(i == BOARD_RGHT) break;
18358                   board[CASTLING][5] = i;
18359                   c -= AAA;
18360                   if(board[BOARD_HEIGHT-1][c] <  BlackPawn ||
18361                      board[BOARD_HEIGHT-1][c] >= BlackKing   ) break;
18362                   if(c > i)
18363                       board[CASTLING][3] = c;
18364                   else
18365                       board[CASTLING][4] = c;
18366               } else { /* white rights */
18367                   if(gameInfo.variant == VariantSChess) { virgin[c-AAA-'A'+'a'] |= VIRGIN_W; break; } // in S-Chess castlings are always KQ
18368                   for(i=BOARD_LEFT; i<BOARD_RGHT; i++)
18369                     if(board[0][i] == WhiteKing) break;
18370                   if(i == BOARD_RGHT) break;
18371                   board[CASTLING][2] = i;
18372                   c -= AAA - 'a' + 'A';
18373                   if(board[0][c] >= WhiteKing) break;
18374                   if(c > i)
18375                       board[CASTLING][0] = c;
18376                   else
18377                       board[CASTLING][1] = c;
18378               }
18379         }
18380       }
18381       for(i=0; i<nrCastlingRights; i++)
18382         if(board[CASTLING][i] != NoRights) initialRights[i] = board[CASTLING][i];
18383       if(gameInfo.variant == VariantSChess)
18384         for(i=0; i<BOARD_FILES; i++) board[VIRGIN][i] = shuffle ? VIRGIN_W | VIRGIN_B : virgin[i]; // when shuffling assume all virgin
18385       if(fischer && shuffle) appData.fischerCastling = TRUE;
18386     if (appData.debugMode) {
18387         fprintf(debugFP, "FEN castling rights:");
18388         for(i=0; i<nrCastlingRights; i++)
18389         fprintf(debugFP, " %d", board[CASTLING][i]);
18390         fprintf(debugFP, "\n");
18391     }
18392
18393       while(*p==' ') p++;
18394     }
18395
18396     if(shuffle) SetUpShuffle(board, appData.defaultFrcPosition);
18397
18398     /* read e.p. field in games that know e.p. capture */
18399     if(gameInfo.variant != VariantShogi    && gameInfo.variant != VariantXiangqi &&
18400        gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier &&
18401        gameInfo.variant != VariantMakruk && gameInfo.variant != VariantASEAN ) {
18402       if(*p=='-') {
18403         p++; board[EP_STATUS] = EP_NONE;
18404       } else {
18405          char c = *p++ - AAA;
18406
18407          if(c < BOARD_LEFT || c >= BOARD_RGHT) return TRUE;
18408          if(*p >= '0' && *p <='9') p++;
18409          board[EP_STATUS] = c;
18410       }
18411     }
18412
18413
18414     if(sscanf(p, "%d", &i) == 1) {
18415         FENrulePlies = i; /* 50-move ply counter */
18416         /* (The move number is still ignored)    */
18417     }
18418
18419     return TRUE;
18420 }
18421
18422 void
18423 EditPositionPasteFEN (char *fen)
18424 {
18425   if (fen != NULL) {
18426     Board initial_position;
18427
18428     if (!ParseFEN(initial_position, &blackPlaysFirst, fen, TRUE)) {
18429       DisplayError(_("Bad FEN position in clipboard"), 0);
18430       return ;
18431     } else {
18432       int savedBlackPlaysFirst = blackPlaysFirst;
18433       EditPositionEvent();
18434       blackPlaysFirst = savedBlackPlaysFirst;
18435       CopyBoard(boards[0], initial_position);
18436       initialRulePlies = FENrulePlies; /* [HGM] copy FEN attributes as well */
18437       EditPositionDone(FALSE); // [HGM] fake: do not fake rights if we had FEN
18438       DisplayBothClocks();
18439       DrawPosition(FALSE, boards[currentMove]);
18440     }
18441   }
18442 }
18443
18444 static char cseq[12] = "\\   ";
18445
18446 Boolean
18447 set_cont_sequence (char *new_seq)
18448 {
18449     int len;
18450     Boolean ret;
18451
18452     // handle bad attempts to set the sequence
18453         if (!new_seq)
18454                 return 0; // acceptable error - no debug
18455
18456     len = strlen(new_seq);
18457     ret = (len > 0) && (len < sizeof(cseq));
18458     if (ret)
18459       safeStrCpy(cseq, new_seq, sizeof(cseq)/sizeof(cseq[0]));
18460     else if (appData.debugMode)
18461       fprintf(debugFP, "Invalid continuation sequence \"%s\"  (maximum length is: %u)\n", new_seq, (unsigned) sizeof(cseq)-1);
18462     return ret;
18463 }
18464
18465 /*
18466     reformat a source message so words don't cross the width boundary.  internal
18467     newlines are not removed.  returns the wrapped size (no null character unless
18468     included in source message).  If dest is NULL, only calculate the size required
18469     for the dest buffer.  lp argument indicats line position upon entry, and it's
18470     passed back upon exit.
18471 */
18472 int
18473 wrap (char *dest, char *src, int count, int width, int *lp)
18474 {
18475     int len, i, ansi, cseq_len, line, old_line, old_i, old_len, clen;
18476
18477     cseq_len = strlen(cseq);
18478     old_line = line = *lp;
18479     ansi = len = clen = 0;
18480
18481     for (i=0; i < count; i++)
18482     {
18483         if (src[i] == '\033')
18484             ansi = 1;
18485
18486         // if we hit the width, back up
18487         if (!ansi && (line >= width) && src[i] != '\n' && src[i] != ' ')
18488         {
18489             // store i & len in case the word is too long
18490             old_i = i, old_len = len;
18491
18492             // find the end of the last word
18493             while (i && src[i] != ' ' && src[i] != '\n')
18494             {
18495                 i--;
18496                 len--;
18497             }
18498
18499             // word too long?  restore i & len before splitting it
18500             if ((old_i-i+clen) >= width)
18501             {
18502                 i = old_i;
18503                 len = old_len;
18504             }
18505
18506             // extra space?
18507             if (i && src[i-1] == ' ')
18508                 len--;
18509
18510             if (src[i] != ' ' && src[i] != '\n')
18511             {
18512                 i--;
18513                 if (len)
18514                     len--;
18515             }
18516
18517             // now append the newline and continuation sequence
18518             if (dest)
18519                 dest[len] = '\n';
18520             len++;
18521             if (dest)
18522                 strncpy(dest+len, cseq, cseq_len);
18523             len += cseq_len;
18524             line = cseq_len;
18525             clen = cseq_len;
18526             continue;
18527         }
18528
18529         if (dest)
18530             dest[len] = src[i];
18531         len++;
18532         if (!ansi)
18533             line++;
18534         if (src[i] == '\n')
18535             line = 0;
18536         if (src[i] == 'm')
18537             ansi = 0;
18538     }
18539     if (dest && appData.debugMode)
18540     {
18541         fprintf(debugFP, "wrap(count:%d,width:%d,line:%d,len:%d,*lp:%d,src: ",
18542             count, width, line, len, *lp);
18543         show_bytes(debugFP, src, count);
18544         fprintf(debugFP, "\ndest: ");
18545         show_bytes(debugFP, dest, len);
18546         fprintf(debugFP, "\n");
18547     }
18548     *lp = dest ? line : old_line;
18549
18550     return len;
18551 }
18552
18553 // [HGM] vari: routines for shelving variations
18554 Boolean modeRestore = FALSE;
18555
18556 void
18557 PushInner (int firstMove, int lastMove)
18558 {
18559         int i, j, nrMoves = lastMove - firstMove;
18560
18561         // push current tail of game on stack
18562         savedResult[storedGames] = gameInfo.result;
18563         savedDetails[storedGames] = gameInfo.resultDetails;
18564         gameInfo.resultDetails = NULL;
18565         savedFirst[storedGames] = firstMove;
18566         savedLast [storedGames] = lastMove;
18567         savedFramePtr[storedGames] = framePtr;
18568         framePtr -= nrMoves; // reserve space for the boards
18569         for(i=nrMoves; i>=1; i--) { // copy boards to stack, working downwards, in case of overlap
18570             CopyBoard(boards[framePtr+i], boards[firstMove+i]);
18571             for(j=0; j<MOVE_LEN; j++)
18572                 moveList[framePtr+i][j] = moveList[firstMove+i-1][j];
18573             for(j=0; j<2*MOVE_LEN; j++)
18574                 parseList[framePtr+i][j] = parseList[firstMove+i-1][j];
18575             timeRemaining[0][framePtr+i] = timeRemaining[0][firstMove+i];
18576             timeRemaining[1][framePtr+i] = timeRemaining[1][firstMove+i];
18577             pvInfoList[framePtr+i] = pvInfoList[firstMove+i-1];
18578             pvInfoList[firstMove+i-1].depth = 0;
18579             commentList[framePtr+i] = commentList[firstMove+i];
18580             commentList[firstMove+i] = NULL;
18581         }
18582
18583         storedGames++;
18584         forwardMostMove = firstMove; // truncate game so we can start variation
18585 }
18586
18587 void
18588 PushTail (int firstMove, int lastMove)
18589 {
18590         if(appData.icsActive) { // only in local mode
18591                 forwardMostMove = currentMove; // mimic old ICS behavior
18592                 return;
18593         }
18594         if(storedGames >= MAX_VARIATIONS-2) return; // leave one for PV-walk
18595
18596         PushInner(firstMove, lastMove);
18597         if(storedGames == 1) GreyRevert(FALSE);
18598         if(gameMode == PlayFromGameFile) gameMode = EditGame, modeRestore = TRUE;
18599 }
18600
18601 void
18602 PopInner (Boolean annotate)
18603 {
18604         int i, j, nrMoves;
18605         char buf[8000], moveBuf[20];
18606
18607         ToNrEvent(savedFirst[storedGames-1]); // sets currentMove
18608         storedGames--; // do this after ToNrEvent, to make sure HistorySet will refresh entire game after PopInner returns
18609         nrMoves = savedLast[storedGames] - currentMove;
18610         if(annotate) {
18611                 int cnt = 10;
18612                 if(!WhiteOnMove(currentMove))
18613                   snprintf(buf, sizeof(buf)/sizeof(buf[0]),"(%d...", (currentMove+2)>>1);
18614                 else safeStrCpy(buf, "(", sizeof(buf)/sizeof(buf[0]));
18615                 for(i=currentMove; i<forwardMostMove; i++) {
18616                         if(WhiteOnMove(i))
18617                           snprintf(moveBuf, sizeof(moveBuf)/sizeof(moveBuf[0]), " %d. %s", (i+2)>>1, SavePart(parseList[i]));
18618                         else snprintf(moveBuf, sizeof(moveBuf)/sizeof(moveBuf[0])," %s", SavePart(parseList[i]));
18619                         strcat(buf, moveBuf);
18620                         if(commentList[i]) { strcat(buf, " "); strcat(buf, commentList[i]); }
18621                         if(!--cnt) { strcat(buf, "\n"); cnt = 10; }
18622                 }
18623                 strcat(buf, ")");
18624         }
18625         for(i=1; i<=nrMoves; i++) { // copy last variation back
18626             CopyBoard(boards[currentMove+i], boards[framePtr+i]);
18627             for(j=0; j<MOVE_LEN; j++)
18628                 moveList[currentMove+i-1][j] = moveList[framePtr+i][j];
18629             for(j=0; j<2*MOVE_LEN; j++)
18630                 parseList[currentMove+i-1][j] = parseList[framePtr+i][j];
18631             timeRemaining[0][currentMove+i] = timeRemaining[0][framePtr+i];
18632             timeRemaining[1][currentMove+i] = timeRemaining[1][framePtr+i];
18633             pvInfoList[currentMove+i-1] = pvInfoList[framePtr+i];
18634             if(commentList[currentMove+i]) free(commentList[currentMove+i]);
18635             commentList[currentMove+i] = commentList[framePtr+i];
18636             commentList[framePtr+i] = NULL;
18637         }
18638         if(annotate) AppendComment(currentMove+1, buf, FALSE);
18639         framePtr = savedFramePtr[storedGames];
18640         gameInfo.result = savedResult[storedGames];
18641         if(gameInfo.resultDetails != NULL) {
18642             free(gameInfo.resultDetails);
18643       }
18644         gameInfo.resultDetails = savedDetails[storedGames];
18645         forwardMostMove = currentMove + nrMoves;
18646 }
18647
18648 Boolean
18649 PopTail (Boolean annotate)
18650 {
18651         if(appData.icsActive) return FALSE; // only in local mode
18652         if(!storedGames) return FALSE; // sanity
18653         CommentPopDown(); // make sure no stale variation comments to the destroyed line can remain open
18654
18655         PopInner(annotate);
18656         if(currentMove < forwardMostMove) ForwardEvent(); else
18657         HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
18658
18659         if(storedGames == 0) { GreyRevert(TRUE); if(modeRestore) modeRestore = FALSE, gameMode = PlayFromGameFile; }
18660         return TRUE;
18661 }
18662
18663 void
18664 CleanupTail ()
18665 {       // remove all shelved variations
18666         int i;
18667         for(i=0; i<storedGames; i++) {
18668             if(savedDetails[i])
18669                 free(savedDetails[i]);
18670             savedDetails[i] = NULL;
18671         }
18672         for(i=framePtr; i<MAX_MOVES; i++) {
18673                 if(commentList[i]) free(commentList[i]);
18674                 commentList[i] = NULL;
18675         }
18676         framePtr = MAX_MOVES-1;
18677         storedGames = 0;
18678 }
18679
18680 void
18681 LoadVariation (int index, char *text)
18682 {       // [HGM] vari: shelve previous line and load new variation, parsed from text around text[index]
18683         char *p = text, *start = NULL, *end = NULL, wait = NULLCHAR;
18684         int level = 0, move;
18685
18686         if(gameMode != EditGame && gameMode != AnalyzeMode && gameMode != PlayFromGameFile) return;
18687         // first find outermost bracketing variation
18688         while(*p) { // hope I got this right... Non-nesting {} and [] can screen each other and nesting ()
18689             if(!wait) { // while inside [] pr {}, ignore everyting except matching closing ]}
18690                 if(*p == '{') wait = '}'; else
18691                 if(*p == '[') wait = ']'; else
18692                 if(*p == '(' && level++ == 0 && p-text < index) start = p+1;
18693                 if(*p == ')' && level > 0 && --level == 0 && p-text > index && end == NULL) end = p-1;
18694             }
18695             if(*p == wait) wait = NULLCHAR; // closing ]} found
18696             p++;
18697         }
18698         if(!start || !end) return; // no variation found, or syntax error in PGN: ignore click
18699         if(appData.debugMode) fprintf(debugFP, "at move %d load variation '%s'\n", currentMove, start);
18700         end[1] = NULLCHAR; // clip off comment beyond variation
18701         ToNrEvent(currentMove-1);
18702         PushTail(currentMove, forwardMostMove); // shelve main variation. This truncates game
18703         // kludge: use ParsePV() to append variation to game
18704         move = currentMove;
18705         ParsePV(start, TRUE, TRUE);
18706         forwardMostMove = endPV; endPV = -1; currentMove = move; // cleanup what ParsePV did
18707         ClearPremoveHighlights();
18708         CommentPopDown();
18709         ToNrEvent(currentMove+1);
18710 }
18711
18712 void
18713 LoadTheme ()
18714 {
18715     char *p, *q, buf[MSG_SIZ];
18716     if(engineLine && engineLine[0]) { // a theme was selected from the listbox
18717         snprintf(buf, MSG_SIZ, "-theme %s", engineLine);
18718         ParseArgsFromString(buf);
18719         ActivateTheme(TRUE); // also redo colors
18720         return;
18721     }
18722     p = nickName;
18723     if(*p && !strchr(p, '"')) // theme name specified and well-formed; add settings to theme list
18724     {
18725         int len;
18726         q = appData.themeNames;
18727         snprintf(buf, MSG_SIZ, "\"%s\"", nickName);
18728       if(appData.useBitmaps) {
18729         snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), " -ubt true -lbtf \"%s\" -dbtf \"%s\" -lbtm %d -dbtm %d",
18730                 appData.liteBackTextureFile, appData.darkBackTextureFile,
18731                 appData.liteBackTextureMode,
18732                 appData.darkBackTextureMode );
18733       } else {
18734         snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), " -ubt false -lsc %s -dsc %s",
18735                 Col2Text(2),   // lightSquareColor
18736                 Col2Text(3) ); // darkSquareColor
18737       }
18738       if(appData.useBorder) {
18739         snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), " -ub true -border \"%s\"",
18740                 appData.border);
18741       } else {
18742         snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), " -ub false");
18743       }
18744       if(appData.useFont) {
18745         snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), " -upf true -pf \"%s\" -fptc \"%s\" -fpfcw %s -fpbcb %s",
18746                 appData.renderPiecesWithFont,
18747                 appData.fontToPieceTable,
18748                 Col2Text(9),    // appData.fontBackColorWhite
18749                 Col2Text(10) ); // appData.fontForeColorBlack
18750       } else {
18751         snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), " -upf false -pid \"%s\"",
18752                 appData.pieceDirectory);
18753         if(!appData.pieceDirectory[0])
18754           snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), " -wpc %s -bpc %s",
18755                 Col2Text(0),   // whitePieceColor
18756                 Col2Text(1) ); // blackPieceColor
18757       }
18758       snprintf(buf+strlen(buf), MSG_SIZ-strlen(buf), " -hsc %s -phc %s\n",
18759                 Col2Text(4),   // highlightSquareColor
18760                 Col2Text(5) ); // premoveHighlightColor
18761         appData.themeNames = malloc(len = strlen(q) + strlen(buf) + 1);
18762         if(insert != q) insert[-1] = NULLCHAR;
18763         snprintf(appData.themeNames, len, "%s\n%s%s", q, buf, insert);
18764         if(q)   free(q);
18765     }
18766     ActivateTheme(FALSE);
18767 }