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 Free Software Foundation, Inc.
   9  *
  10  * Enhancements Copyright 2005 Alessandro Scotti
  11  *
  12  * The following terms apply to Digital Equipment Corporation's copyright
  13  * interest in XBoard:
  14  * ------------------------------------------------------------------------
  15  * All Rights Reserved
  16  *
  17  * Permission to use, copy, modify, and distribute this software and its
  18  * documentation for any purpose and without fee is hereby granted,
  19  * provided that the above copyright notice appear in all copies and that
  20  * both that copyright notice and this permission notice appear in
  21  * supporting documentation, and that the name of Digital not be
  22  * used in advertising or publicity pertaining to distribution of the
  23  * software without specific, written prior permission.
  24  *
  25  * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  26  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  27  * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  28  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  29  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  30  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  31  * SOFTWARE.
  32  * ------------------------------------------------------------------------
  33  *
  34  * The following terms apply to the enhanced version of XBoard
  35  * distributed by the Free Software Foundation:
  36  * ------------------------------------------------------------------------
  37  *
  38  * GNU XBoard is free software: you can redistribute it and/or modify
  39  * it under the terms of the GNU General Public License as published by
  40  * the Free Software Foundation, either version 3 of the License, or (at
  41  * your option) any later version.
  42  *
  43  * GNU XBoard is distributed in the hope that it will be useful, but
  44  * WITHOUT ANY WARRANTY; without even the implied warranty of
  45  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  46  * General Public License for more details.
  47  *
  48  * You should have received a copy of the GNU General Public License
  49  * along with this program. If not, see http://www.gnu.org/licenses/.  *
  50  *
  51  *------------------------------------------------------------------------
  52  ** See the file ChangeLog for a revision history.  */
  53
  54 /* [AS] Also useful here for debugging */
  55 #ifdef WIN32
  56 #include <windows.h>
  57
  58 #define DoSleep( n ) if( (n) != 0 ) Sleep( (n) );
  59
  60 #else
  61
  62 #define DoSleep( n ) if( (n) >= 0) sleep(n)
  63
  64 #endif
  65
  66 #include "config.h"
  67
  68 #include <assert.h>
  69 #include <stdio.h>
  70 #include <ctype.h>
  71 #include <errno.h>
  72 #include <sys/types.h>
  73 #include <sys/stat.h>
  74 #include <math.h>
  75 #include <ctype.h>
  76
  77 #if STDC_HEADERS
  78 # include <stdlib.h>
  79 # include <string.h>
  80 # include <stdarg.h>
  81 #else /* not STDC_HEADERS */
  82 # if HAVE_STRING_H
  83 #  include <string.h>
  84 # else /* not HAVE_STRING_H */
  85 #  include <strings.h>
  86 # endif /* not HAVE_STRING_H */
  87 #endif /* not STDC_HEADERS */
  88
  89 #if HAVE_SYS_FCNTL_H
  90 # include <sys/fcntl.h>
  91 #else /* not HAVE_SYS_FCNTL_H */
  92 # if HAVE_FCNTL_H
  93 #  include <fcntl.h>
  94 # endif /* HAVE_FCNTL_H */
  95 #endif /* not HAVE_SYS_FCNTL_H */
  96
  97 #if TIME_WITH_SYS_TIME
  98 # include <sys/time.h>
  99 # include <time.h>
 100 #else
 101 # if HAVE_SYS_TIME_H
 102 #  include <sys/time.h>
 103 # else
 104 #  include <time.h>
 105 # endif
 106 #endif
 107
 108 #if defined(_amigados) && !defined(__GNUC__)
 109 struct timezone {
 110     int tz_minuteswest;
 111     int tz_dsttime;
 112 };
 113 extern int gettimeofday(struct timeval *, struct timezone *);
 114 #endif
 115
 116 #if HAVE_UNISTD_H
 117 # include <unistd.h>
 118 #endif
 119
 120 #include "common.h"
 121 #include "frontend.h"
 122 #include "backend.h"
 123 #include "parser.h"
 124 #include "moves.h"
 125 #if ZIPPY
 126 # include "zippy.h"
 127 #endif
 128 #include "backendz.h"
 129 #include "gettext.h"
 130
 131 #ifdef ENABLE_NLS
 132 # define _(s) gettext (s)
 133 # define N_(s) gettext_noop (s)
 134 #else
 135 # define _(s) (s)
 136 # define N_(s) s
 137 #endif
 138
 139
 140 /* A point in time */
 141 typedef struct {
 142     long sec;  /* Assuming this is >= 32 bits */
 143     int ms;    /* Assuming this is >= 16 bits */
 144 } TimeMark;
 145
 146 int establish P((void));
 147 void read_from_player P((InputSourceRef isr, VOIDSTAR closure,
 148                          char *buf, int count, int error));
 149 void read_from_ics P((InputSourceRef isr, VOIDSTAR closure,
 150                       char *buf, int count, int error));
 151 void ics_printf P((char *format, ...));
 152 void SendToICS P((char *s));
 153 void SendToICSDelayed P((char *s, long msdelay));
 154 void SendMoveToICS P((ChessMove moveType, int fromX, int fromY,
 155                       int toX, int toY));
 156 void HandleMachineMove P((char *message, ChessProgramState *cps));
 157 int AutoPlayOneMove P((void));
 158 int LoadGameOneMove P((ChessMove readAhead));
 159 int LoadGameFromFile P((char *filename, int n, char *title, int useList));
 160 int LoadPositionFromFile P((char *filename, int n, char *title));
 161 int SavePositionToFile P((char *filename));
 162 void ApplyMove P((int fromX, int fromY, int toX, int toY, int promoChar,
 163                                                                                 Board board));
 164 void MakeMove P((int fromX, int fromY, int toX, int toY, int promoChar));
 165 void ShowMove P((int fromX, int fromY, int toX, int toY));
 166 int FinishMove P((ChessMove moveType, int fromX, int fromY, int toX, int toY,
 167                    /*char*/int promoChar));
 168 void BackwardInner P((int target));
 169 void ForwardInner P((int target));
 170 int Adjudicate P((ChessProgramState *cps));
 171 void GameEnds P((ChessMove result, char *resultDetails, int whosays));
 172 void EditPositionDone P((Boolean fakeRights));
 173 void PrintOpponents P((FILE *fp));
 174 void PrintPosition P((FILE *fp, int move));
 175 void StartChessProgram P((ChessProgramState *cps));
 176 void SendToProgram P((char *message, ChessProgramState *cps));
 177 void SendMoveToProgram P((int moveNum, ChessProgramState *cps));
 178 void ReceiveFromProgram P((InputSourceRef isr, VOIDSTAR closure,
 179                            char *buf, int count, int error));
 180 void SendTimeControl P((ChessProgramState *cps,
 181                         int mps, long tc, int inc, int sd, int st));
 182 char *TimeControlTagValue P((void));
 183 void Attention P((ChessProgramState *cps));
 184 void FeedMovesToProgram P((ChessProgramState *cps, int upto));
 185 void ResurrectChessProgram P((void));
 186 void DisplayComment P((int moveNumber, char *text));
 187 void DisplayMove P((int moveNumber));
 188
 189 void ParseGameHistory P((char *game));
 190 void ParseBoard12 P((char *string));
 191 void KeepAlive P((void));
 192 void StartClocks P((void));
 193 void SwitchClocks P((int nr));
 194 void StopClocks P((void));
 195 void ResetClocks P((void));
 196 char *PGNDate P((void));
 197 void SetGameInfo P((void));
 198 Boolean ParseFEN P((Board board, int *blackPlaysFirst, char *fen));
 199 int RegisterMove P((void));
 200 void MakeRegisteredMove P((void));
 201 void TruncateGame P((void));
 202 int looking_at P((char *, int *, char *));
 203 void CopyPlayerNameIntoFileName P((char **, char *));
 204 char *SavePart P((char *));
 205 int SaveGameOldStyle P((FILE *));
 206 int SaveGamePGN P((FILE *));
 207 void GetTimeMark P((TimeMark *));
 208 long SubtractTimeMarks P((TimeMark *, TimeMark *));
 209 int CheckFlags P((void));
 210 long NextTickLength P((long));
 211 void CheckTimeControl P((void));
 212 void show_bytes P((FILE *, char *, int));
 213 int string_to_rating P((char *str));
 214 void ParseFeatures P((char* args, ChessProgramState *cps));
 215 void InitBackEnd3 P((void));
 216 void FeatureDone P((ChessProgramState* cps, int val));
 217 void InitChessProgram P((ChessProgramState *cps, int setup));
 218 void OutputKibitz(int window, char *text);
 219 int PerpetualChase(int first, int last);
 220 int EngineOutputIsUp();
 221 void InitDrawingSizes(int x, int y);
 222
 223 #ifdef WIN32
 224        extern void ConsoleCreate();
 225 #endif
 226
 227 ChessProgramState *WhitePlayer();
 228 void InsertIntoMemo P((int which, char *text)); // [HGM] kibitz: in engineo.c
 229 int VerifyDisplayMode P(());
 230
 231 char *GetInfoFromComment( int, char * ); // [HGM] PV time: returns stripped comment
 232 void InitEngineUCI( const char * iniDir, ChessProgramState * cps ); // [HGM] moved here from winboard.c
 233 char *ProbeBook P((int moveNr, char *book)); // [HGM] book: returns a book move
 234 char *SendMoveToBookUser P((int nr, ChessProgramState *cps, int initial)); // [HGM] book
 235 void ics_update_width P((int new_width));
 236 extern char installDir[MSG_SIZ];
 237
 238 extern int tinyLayout, smallLayout;
 239 ChessProgramStats programStats;
 240 char lastPV[2][2*MSG_SIZ]; /* [HGM] pv: last PV in thinking output of each engine */
 241 int endPV = -1;
 242 static int exiting = 0; /* [HGM] moved to top */
 243 static int setboardSpoiledMachineBlack = 0 /*, errorExitFlag = 0*/;
 244 int startedFromPositionFile = FALSE; Board filePosition;       /* [HGM] loadPos */
 245 Board partnerBoard;     /* [HGM] bughouse: for peeking at partner game          */
 246 int partnerHighlight[2];
 247 Boolean partnerBoardValid = 0;
 248 char partnerStatus[MSG_SIZ];
 249 Boolean partnerUp;
 250 Boolean originalFlip;
 251 Boolean twoBoards = 0;
 252 char endingGame = 0;    /* [HGM] crash: flag to prevent recursion of GameEnds() */
 253 int whiteNPS, blackNPS; /* [HGM] nps: for easily making clocks aware of NPS     */
 254 VariantClass currentlyInitializedVariant; /* [HGM] variantswitch */
 255 int lastIndex = 0;      /* [HGM] autoinc: last game/position used in match mode */
 256 Boolean connectionAlive;/* [HGM] alive: ICS connection status from probing      */
 257 int opponentKibitzes;
 258 int lastSavedGame; /* [HGM] save: ID of game */
 259 char chatPartner[MAX_CHAT][MSG_SIZ]; /* [HGM] chat: list of chatting partners */
 260 extern int chatCount;
 261 int chattingPartner;
 262 char marker[BOARD_RANKS][BOARD_FILES]; /* [HGM] marks for target squares */
 263
 264 /* States for ics_getting_history */
 265 #define H_FALSE 0
 266 #define H_REQUESTED 1
 267 #define H_GOT_REQ_HEADER 2
 268 #define H_GOT_UNREQ_HEADER 3
 269 #define H_GETTING_MOVES 4
 270 #define H_GOT_UNWANTED_HEADER 5
 271
 272 /* whosays values for GameEnds */
 273 #define GE_ICS 0
 274 #define GE_ENGINE 1
 275 #define GE_PLAYER 2
 276 #define GE_FILE 3
 277 #define GE_XBOARD 4
 278 #define GE_ENGINE1 5
 279 #define GE_ENGINE2 6
 280
 281 /* Maximum number of games in a cmail message */
 282 #define CMAIL_MAX_GAMES 20
 283
 284 /* Different types of move when calling RegisterMove */
 285 #define CMAIL_MOVE   0
 286 #define CMAIL_RESIGN 1
 287 #define CMAIL_DRAW   2
 288 #define CMAIL_ACCEPT 3
 289
 290 /* Different types of result to remember for each game */
 291 #define CMAIL_NOT_RESULT 0
 292 #define CMAIL_OLD_RESULT 1
 293 #define CMAIL_NEW_RESULT 2
 294
 295 /* Telnet protocol constants */
 296 #define TN_WILL 0373
 297 #define TN_WONT 0374
 298 #define TN_DO   0375
 299 #define TN_DONT 0376
 300 #define TN_IAC  0377
 301 #define TN_ECHO 0001
 302 #define TN_SGA  0003
 303 #define TN_PORT 23
 304
 305 /* [AS] */
 306 static char * safeStrCpy( char * dst, const char * src, size_t count )
 307 {
 308     assert( dst != NULL );
 309     assert( src != NULL );
 310     assert( count > 0 );
 311
 312     strncpy( dst, src, count );
 313     dst[ count-1 ] = '\0';
 314     return dst;
 315 }
 316
 317 /* Some compiler can't cast u64 to double
 318  * This function do the job for us:
 319
 320  * We use the highest bit for cast, this only
 321  * works if the highest bit is not
 322  * in use (This should not happen)
 323  *
 324  * We used this for all compiler
 325  */
 326 double
 327 u64ToDouble(u64 value)
 328 {
 329   double r;
 330   u64 tmp = value & u64Const(0x7fffffffffffffff);
 331   r = (double)(s64)tmp;
 332   if (value & u64Const(0x8000000000000000))
 333        r +=  9.2233720368547758080e18; /* 2^63 */
 334  return r;
 335 }
 336
 337 /* Fake up flags for now, as we aren't keeping track of castling
 338    availability yet. [HGM] Change of logic: the flag now only
 339    indicates the type of castlings allowed by the rule of the game.
 340    The actual rights themselves are maintained in the array
 341    castlingRights, as part of the game history, and are not probed
 342    by this function.
 343  */
 344 int
 345 PosFlags(index)
 346 {
 347   int flags = F_ALL_CASTLE_OK;
 348   if ((index % 2) == 0) flags |= F_WHITE_ON_MOVE;
 349   switch (gameInfo.variant) {
 350   case VariantSuicide:
 351     flags &= ~F_ALL_CASTLE_OK;
 352   case VariantGiveaway:         // [HGM] moved this case label one down: seems Giveaway does have castling on ICC!
 353     flags |= F_IGNORE_CHECK;
 354   case VariantLosers:
 355     flags |= F_MANDATORY_CAPTURE; //[HGM] losers: sets flag so TestLegality rejects non-capts if capts exist
 356     break;
 357   case VariantAtomic:
 358     flags |= F_IGNORE_CHECK | F_ATOMIC_CAPTURE;
 359     break;
 360   case VariantKriegspiel:
 361     flags |= F_KRIEGSPIEL_CAPTURE;
 362     break;
 363   case VariantCapaRandom:
 364   case VariantFischeRandom:
 365     flags |= F_FRC_TYPE_CASTLING; /* [HGM] enable this through flag */
 366   case VariantNoCastle:
 367   case VariantShatranj:
 368   case VariantCourier:
 369   case VariantMakruk:
 370     flags &= ~F_ALL_CASTLE_OK;
 371     break;
 372   default:
 373     break;
 374   }
 375   return flags;
 376 }
 377
 378 FILE *gameFileFP, *debugFP;
 379
 380 /*
 381     [AS] Note: sometimes, the sscanf() function is used to parse the input
 382     into a fixed-size buffer. Because of this, we must be prepared to
 383     receive strings as long as the size of the input buffer, which is currently
 384     set to 4K for Windows and 8K for the rest.
 385     So, we must either allocate sufficiently large buffers here, or
 386     reduce the size of the input buffer in the input reading part.
 387 */
 388
 389 char cmailMove[CMAIL_MAX_GAMES][MOVE_LEN], cmailMsg[MSG_SIZ];
 390 char bookOutput[MSG_SIZ*10], thinkOutput[MSG_SIZ*10], lastHint[MSG_SIZ];
 391 char thinkOutput1[MSG_SIZ*10];
 392
 393 ChessProgramState first, second;
 394
 395 /* premove variables */
 396 int premoveToX = 0;
 397 int premoveToY = 0;
 398 int premoveFromX = 0;
 399 int premoveFromY = 0;
 400 int premovePromoChar = 0;
 401 int gotPremove = 0;
 402 Boolean alarmSounded;
 403 /* end premove variables */
 404
 405 char *ics_prefix = "$";
 406 int ics_type = ICS_GENERIC;
 407
 408 int currentMove = 0, forwardMostMove = 0, backwardMostMove = 0;
 409 int pauseExamForwardMostMove = 0;
 410 int nCmailGames = 0, nCmailResults = 0, nCmailMovesRegistered = 0;
 411 int cmailMoveRegistered[CMAIL_MAX_GAMES], cmailResult[CMAIL_MAX_GAMES];
 412 int cmailMsgLoaded = FALSE, cmailMailedMove = FALSE;
 413 int cmailOldMove = -1, firstMove = TRUE, flipView = FALSE;
 414 int blackPlaysFirst = FALSE, startedFromSetupPosition = FALSE;
 415 int searchTime = 0, pausing = FALSE, pauseExamInvalid = FALSE;
 416 int whiteFlag = FALSE, blackFlag = FALSE;
 417 int userOfferedDraw = FALSE;
 418 int ics_user_moved = 0, ics_gamenum = -1, ics_getting_history = H_FALSE;
 419 int matchMode = FALSE, hintRequested = FALSE, bookRequested = FALSE;
 420 int cmailMoveType[CMAIL_MAX_GAMES];
 421 long ics_clock_paused = 0;
 422 ProcRef icsPR = NoProc, cmailPR = NoProc;
 423 InputSourceRef telnetISR = NULL, fromUserISR = NULL, cmailISR = NULL;
 424 GameMode gameMode = BeginningOfGame;
 425 char moveList[MAX_MOVES][MOVE_LEN], parseList[MAX_MOVES][MOVE_LEN * 2];
 426 char *commentList[MAX_MOVES], *cmailCommentList[CMAIL_MAX_GAMES];
 427 ChessProgramStats_Move pvInfoList[MAX_MOVES]; /* [AS] Info about engine thinking */
 428 int hiddenThinkOutputState = 0; /* [AS] */
 429 int adjudicateLossThreshold = 0; /* [AS] Automatic adjudication */
 430 int adjudicateLossPlies = 6;
 431 char white_holding[64], black_holding[64];
 432 TimeMark lastNodeCountTime;
 433 long lastNodeCount=0;
 434 int have_sent_ICS_logon = 0;
 435 int movesPerSession;
 436 long whiteTimeRemaining, blackTimeRemaining, timeControl, timeIncrement;
 437 long timeControl_2; /* [AS] Allow separate time controls */
 438 char *fullTimeControlString = NULL; /* [HGM] secondary TC: merge of MPS, TC and inc */
 439 long timeRemaining[2][MAX_MOVES];
 440 int matchGame = 0;
 441 TimeMark programStartTime;
 442 char ics_handle[MSG_SIZ];
 443 int have_set_title = 0;
 444
 445 /* animateTraining preserves the state of appData.animate
 446  * when Training mode is activated. This allows the
 447  * response to be animated when appData.animate == TRUE and
 448  * appData.animateDragging == TRUE.
 449  */
 450 Boolean animateTraining;
 451
 452 GameInfo gameInfo;
 453
 454 AppData appData;
 455
 456 Board boards[MAX_MOVES];
 457 /* [HGM] Following 7 needed for accurate legality tests: */
 458 signed char  castlingRank[BOARD_FILES]; // and corresponding ranks
 459 signed char  initialRights[BOARD_FILES];
 460 int   nrCastlingRights; // For TwoKings, or to implement castling-unknown status
 461 int   initialRulePlies, FENrulePlies;
 462 FILE  *serverMoves = NULL; // next two for broadcasting (/serverMoves option)
 463 int loadFlag = 0;
 464 int shuffleOpenings;
 465 int mute; // mute all sounds
 466
 467 // [HGM] vari: next 12 to save and restore variations
 468 #define MAX_VARIATIONS 10
 469 int framePtr = MAX_MOVES-1; // points to free stack entry
 470 int storedGames = 0;
 471 int savedFirst[MAX_VARIATIONS];
 472 int savedLast[MAX_VARIATIONS];
 473 int savedFramePtr[MAX_VARIATIONS];
 474 char *savedDetails[MAX_VARIATIONS];
 475 ChessMove savedResult[MAX_VARIATIONS];
 476
 477 void PushTail P((int firstMove, int lastMove));
 478 Boolean PopTail P((Boolean annotate));
 479 void CleanupTail P((void));
 480
 481 ChessSquare  FIDEArray[2][BOARD_FILES] = {
 482     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 483         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 484     { BlackRook, BlackKnight, BlackBishop, BlackQueen,
 485         BlackKing, BlackBishop, BlackKnight, BlackRook }
 486 };
 487
 488 ChessSquare twoKingsArray[2][BOARD_FILES] = {
 489     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 490         WhiteKing, WhiteKing, WhiteKnight, WhiteRook },
 491     { BlackRook, BlackKnight, BlackBishop, BlackQueen,
 492         BlackKing, BlackKing, BlackKnight, BlackRook }
 493 };
 494
 495 ChessSquare  KnightmateArray[2][BOARD_FILES] = {
 496     { WhiteRook, WhiteMan, WhiteBishop, WhiteQueen,
 497         WhiteUnicorn, WhiteBishop, WhiteMan, WhiteRook },
 498     { BlackRook, BlackMan, BlackBishop, BlackQueen,
 499         BlackUnicorn, BlackBishop, BlackMan, BlackRook }
 500 };
 501
 502 ChessSquare fairyArray[2][BOARD_FILES] = { /* [HGM] Queen side differs from King side */
 503     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 504         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 505     { BlackLance, BlackAlfil, BlackMarshall, BlackAngel,
 506         BlackKing, BlackMarshall, BlackAlfil, BlackLance }
 507 };
 508
 509 ChessSquare ShatranjArray[2][BOARD_FILES] = { /* [HGM] (movGen knows about Shatranj Q and P) */
 510     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteKing,
 511         WhiteFerz, WhiteAlfil, WhiteKnight, WhiteRook },
 512     { BlackRook, BlackKnight, BlackAlfil, BlackKing,
 513         BlackFerz, BlackAlfil, BlackKnight, BlackRook }
 514 };
 515
 516 ChessSquare makrukArray[2][BOARD_FILES] = { /* [HGM] (movGen knows about Shatranj Q and P) */
 517     { WhiteRook, WhiteKnight, WhiteMan, WhiteKing,
 518         WhiteFerz, WhiteMan, WhiteKnight, WhiteRook },
 519     { BlackRook, BlackKnight, BlackMan, BlackFerz,
 520         BlackKing, BlackMan, BlackKnight, BlackRook }
 521 };
 522
 523
 524 #if (BOARD_FILES>=10)
 525 ChessSquare ShogiArray[2][BOARD_FILES] = {
 526     { WhiteQueen, WhiteKnight, WhiteFerz, WhiteWazir,
 527         WhiteKing, WhiteWazir, WhiteFerz, WhiteKnight, WhiteQueen },
 528     { BlackQueen, BlackKnight, BlackFerz, BlackWazir,
 529         BlackKing, BlackWazir, BlackFerz, BlackKnight, BlackQueen }
 530 };
 531
 532 ChessSquare XiangqiArray[2][BOARD_FILES] = {
 533     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteFerz,
 534         WhiteWazir, WhiteFerz, WhiteAlfil, WhiteKnight, WhiteRook },
 535     { BlackRook, BlackKnight, BlackAlfil, BlackFerz,
 536         BlackWazir, BlackFerz, BlackAlfil, BlackKnight, BlackRook }
 537 };
 538
 539 ChessSquare CapablancaArray[2][BOARD_FILES] = {
 540     { WhiteRook, WhiteKnight, WhiteAngel, WhiteBishop, WhiteQueen,
 541         WhiteKing, WhiteBishop, WhiteMarshall, WhiteKnight, WhiteRook },
 542     { BlackRook, BlackKnight, BlackAngel, BlackBishop, BlackQueen,
 543         BlackKing, BlackBishop, BlackMarshall, BlackKnight, BlackRook }
 544 };
 545
 546 ChessSquare GreatArray[2][BOARD_FILES] = {
 547     { WhiteDragon, WhiteKnight, WhiteAlfil, WhiteGrasshopper, WhiteKing,
 548         WhiteSilver, WhiteCardinal, WhiteAlfil, WhiteKnight, WhiteDragon },
 549     { BlackDragon, BlackKnight, BlackAlfil, BlackGrasshopper, BlackKing,
 550         BlackSilver, BlackCardinal, BlackAlfil, BlackKnight, BlackDragon },
 551 };
 552
 553 ChessSquare JanusArray[2][BOARD_FILES] = {
 554     { WhiteRook, WhiteAngel, WhiteKnight, WhiteBishop, WhiteKing,
 555         WhiteQueen, WhiteBishop, WhiteKnight, WhiteAngel, WhiteRook },
 556     { BlackRook, BlackAngel, BlackKnight, BlackBishop, BlackKing,
 557         BlackQueen, BlackBishop, BlackKnight, BlackAngel, BlackRook }
 558 };
 559
 560 #ifdef GOTHIC
 561 ChessSquare GothicArray[2][BOARD_FILES] = {
 562     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen, WhiteMarshall,
 563         WhiteKing, WhiteAngel, WhiteBishop, WhiteKnight, WhiteRook },
 564     { BlackRook, BlackKnight, BlackBishop, BlackQueen, BlackMarshall,
 565         BlackKing, BlackAngel, BlackBishop, BlackKnight, BlackRook }
 566 };
 567 #else // !GOTHIC
 568 #define GothicArray CapablancaArray
 569 #endif // !GOTHIC
 570
 571 #ifdef FALCON
 572 ChessSquare FalconArray[2][BOARD_FILES] = {
 573     { WhiteRook, WhiteKnight, WhiteBishop, WhiteLance, WhiteQueen,
 574         WhiteKing, WhiteLance, WhiteBishop, WhiteKnight, WhiteRook },
 575     { BlackRook, BlackKnight, BlackBishop, BlackLance, BlackQueen,
 576         BlackKing, BlackLance, BlackBishop, BlackKnight, BlackRook }
 577 };
 578 #else // !FALCON
 579 #define FalconArray CapablancaArray
 580 #endif // !FALCON
 581
 582 #else // !(BOARD_FILES>=10)
 583 #define XiangqiPosition FIDEArray
 584 #define CapablancaArray FIDEArray
 585 #define GothicArray FIDEArray
 586 #define GreatArray FIDEArray
 587 #endif // !(BOARD_FILES>=10)
 588
 589 #if (BOARD_FILES>=12)
 590 ChessSquare CourierArray[2][BOARD_FILES] = {
 591     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteBishop, WhiteMan, WhiteKing,
 592         WhiteFerz, WhiteWazir, WhiteBishop, WhiteAlfil, WhiteKnight, WhiteRook },
 593     { BlackRook, BlackKnight, BlackAlfil, BlackBishop, BlackMan, BlackKing,
 594         BlackFerz, BlackWazir, BlackBishop, BlackAlfil, BlackKnight, BlackRook }
 595 };
 596 #else // !(BOARD_FILES>=12)
 597 #define CourierArray CapablancaArray
 598 #endif // !(BOARD_FILES>=12)
 599
 600
 601 Board initialPosition;
 602
 603
 604 /* Convert str to a rating. Checks for special cases of "----",
 605
 606    "++++", etc. Also strips ()'s */
 607 int
 608 string_to_rating(str)
 609   char *str;
 610 {
 611   while(*str && !isdigit(*str)) ++str;
 612   if (!*str)
 613     return 0;   /* One of the special "no rating" cases */
 614   else
 615     return atoi(str);
 616 }
 617
 618 void
 619 ClearProgramStats()
 620 {
 621     /* Init programStats */
 622     programStats.movelist[0] = 0;
 623     programStats.depth = 0;
 624     programStats.nr_moves = 0;
 625     programStats.moves_left = 0;
 626     programStats.nodes = 0;
 627     programStats.time = -1;        // [HGM] PGNtime: make invalid to recognize engine output
 628     programStats.score = 0;
 629     programStats.got_only_move = 0;
 630     programStats.got_fail = 0;
 631     programStats.line_is_book = 0;
 632 }
 633
 634 void
 635 InitBackEnd1()
 636 {
 637     int matched, min, sec;
 638
 639     ShowThinkingEvent(); // [HGM] thinking: make sure post/nopost state is set according to options
 640
 641     GetTimeMark(&programStartTime);
 642     srandom((programStartTime.ms + 1000*programStartTime.sec)*0x1001001); // [HGM] book: makes sure random is unpredictabe to msec level
 643
 644     ClearProgramStats();
 645     programStats.ok_to_send = 1;
 646     programStats.seen_stat = 0;
 647
 648     /*
 649      * Initialize game list
 650      */
 651     ListNew(&gameList);
 652
 653
 654     /*
 655      * Internet chess server status
 656      */
 657     if (appData.icsActive) {
 658         appData.matchMode = FALSE;
 659         appData.matchGames = 0;
 660 #if ZIPPY
 661         appData.noChessProgram = !appData.zippyPlay;
 662 #else
 663         appData.zippyPlay = FALSE;
 664         appData.zippyTalk = FALSE;
 665         appData.noChessProgram = TRUE;
 666 #endif
 667         if (*appData.icsHelper != NULLCHAR) {
 668             appData.useTelnet = TRUE;
 669             appData.telnetProgram = appData.icsHelper;
 670         }
 671     } else {
 672         appData.zippyTalk = appData.zippyPlay = FALSE;
 673     }
 674
 675     /* [AS] Initialize pv info list [HGM] and game state */
 676     {
 677         int i, j;
 678
 679         for( i=0; i<=framePtr; i++ ) {
 680             pvInfoList[i].depth = -1;
 681             boards[i][EP_STATUS] = EP_NONE;
 682             for( j=0; j<BOARD_FILES-2; j++ ) boards[i][CASTLING][j] = NoRights;
 683         }
 684     }
 685
 686     /*
 687      * Parse timeControl resource
 688      */
 689     if (!ParseTimeControl(appData.timeControl, appData.timeIncrement,
 690                           appData.movesPerSession)) {
 691         char buf[MSG_SIZ];
 692         snprintf(buf, sizeof(buf), _("bad timeControl option %s"), appData.timeControl);
 693         DisplayFatalError(buf, 0, 2);
 694     }
 695
 696     /*
 697      * Parse searchTime resource
 698      */
 699     if (*appData.searchTime != NULLCHAR) {
 700         matched = sscanf(appData.searchTime, "%d:%d", &min, &sec);
 701         if (matched == 1) {
 702             searchTime = min * 60;
 703         } else if (matched == 2) {
 704             searchTime = min * 60 + sec;
 705         } else {
 706             char buf[MSG_SIZ];
 707             snprintf(buf, sizeof(buf), _("bad searchTime option %s"), appData.searchTime);
 708             DisplayFatalError(buf, 0, 2);
 709         }
 710     }
 711
 712     /* [AS] Adjudication threshold */
 713     adjudicateLossThreshold = appData.adjudicateLossThreshold;
 714
 715     first.which = "first";
 716     second.which = "second";
 717     first.maybeThinking = second.maybeThinking = FALSE;
 718     first.pr = second.pr = NoProc;
 719     first.isr = second.isr = NULL;
 720     first.sendTime = second.sendTime = 2;
 721     first.sendDrawOffers = 1;
 722     if (appData.firstPlaysBlack) {
 723         first.twoMachinesColor = "black\n";
 724         second.twoMachinesColor = "white\n";
 725     } else {
 726         first.twoMachinesColor = "white\n";
 727         second.twoMachinesColor = "black\n";
 728     }
 729     first.program = appData.firstChessProgram;
 730     second.program = appData.secondChessProgram;
 731     first.host = appData.firstHost;
 732     second.host = appData.secondHost;
 733     first.dir = appData.firstDirectory;
 734     second.dir = appData.secondDirectory;
 735     first.other = &second;
 736     second.other = &first;
 737     first.initString = appData.initString;
 738     second.initString = appData.secondInitString;
 739     first.computerString = appData.firstComputerString;
 740     second.computerString = appData.secondComputerString;
 741     first.useSigint = second.useSigint = TRUE;
 742     first.useSigterm = second.useSigterm = TRUE;
 743     first.reuse = appData.reuseFirst;
 744     second.reuse = appData.reuseSecond;
 745     first.nps = appData.firstNPS;   // [HGM] nps: copy nodes per second
 746     second.nps = appData.secondNPS;
 747     first.useSetboard = second.useSetboard = FALSE;
 748     first.useSAN = second.useSAN = FALSE;
 749     first.usePing = second.usePing = FALSE;
 750     first.lastPing = second.lastPing = 0;
 751     first.lastPong = second.lastPong = 0;
 752     first.usePlayother = second.usePlayother = FALSE;
 753     first.useColors = second.useColors = TRUE;
 754     first.useUsermove = second.useUsermove = FALSE;
 755     first.sendICS = second.sendICS = FALSE;
 756     first.sendName = second.sendName = appData.icsActive;
 757     first.sdKludge = second.sdKludge = FALSE;
 758     first.stKludge = second.stKludge = FALSE;
 759     TidyProgramName(first.program, first.host, first.tidy);
 760     TidyProgramName(second.program, second.host, second.tidy);
 761     first.matchWins = second.matchWins = 0;
 762     strcpy(first.variants, appData.variant);
 763     strcpy(second.variants, appData.variant);
 764     first.analysisSupport = second.analysisSupport = 2; /* detect */
 765     first.analyzing = second.analyzing = FALSE;
 766     first.initDone = second.initDone = FALSE;
 767
 768     /* New features added by Tord: */
 769     first.useFEN960 = FALSE; second.useFEN960 = FALSE;
 770     first.useOOCastle = TRUE; second.useOOCastle = TRUE;
 771     /* End of new features added by Tord. */
 772     first.fenOverride  = appData.fenOverride1;
 773     second.fenOverride = appData.fenOverride2;
 774
 775     /* [HGM] time odds: set factor for each machine */
 776     first.timeOdds  = appData.firstTimeOdds;
 777     second.timeOdds = appData.secondTimeOdds;
 778     { float norm = 1;
 779         if(appData.timeOddsMode) {
 780             norm = first.timeOdds;
 781             if(norm > second.timeOdds) norm = second.timeOdds;
 782         }
 783         first.timeOdds /= norm;
 784         second.timeOdds /= norm;
 785     }
 786
 787     /* [HGM] secondary TC: how to handle sessions that do not fit in 'level'*/
 788     first.accumulateTC = appData.firstAccumulateTC;
 789     second.accumulateTC = appData.secondAccumulateTC;
 790     first.maxNrOfSessions = second.maxNrOfSessions = 1;
 791
 792     /* [HGM] debug */
 793     first.debug = second.debug = FALSE;
 794     first.supportsNPS = second.supportsNPS = UNKNOWN;
 795
 796     /* [HGM] options */
 797     first.optionSettings  = appData.firstOptions;
 798     second.optionSettings = appData.secondOptions;
 799
 800     first.scoreIsAbsolute = appData.firstScoreIsAbsolute; /* [AS] */
 801     second.scoreIsAbsolute = appData.secondScoreIsAbsolute; /* [AS] */
 802     first.isUCI = appData.firstIsUCI; /* [AS] */
 803     second.isUCI = appData.secondIsUCI; /* [AS] */
 804     first.hasOwnBookUCI = appData.firstHasOwnBookUCI; /* [AS] */
 805     second.hasOwnBookUCI = appData.secondHasOwnBookUCI; /* [AS] */
 806
 807     if (appData.firstProtocolVersion > PROTOVER ||
 808         appData.firstProtocolVersion < 1) {
 809       char buf[MSG_SIZ];
 810       sprintf(buf, _("protocol version %d not supported"),
 811               appData.firstProtocolVersion);
 812       DisplayFatalError(buf, 0, 2);
 813     } else {
 814       first.protocolVersion = appData.firstProtocolVersion;
 815     }
 816
 817     if (appData.secondProtocolVersion > PROTOVER ||
 818         appData.secondProtocolVersion < 1) {
 819       char buf[MSG_SIZ];
 820       sprintf(buf, _("protocol version %d not supported"),
 821               appData.secondProtocolVersion);
 822       DisplayFatalError(buf, 0, 2);
 823     } else {
 824       second.protocolVersion = appData.secondProtocolVersion;
 825     }
 826
 827     if (appData.icsActive) {
 828         appData.clockMode = TRUE;  /* changes dynamically in ICS mode */
 829 //    } else if (*appData.searchTime != NULLCHAR || appData.noChessProgram) {
 830     } else if (appData.noChessProgram) { // [HGM] st: searchTime mode now also is clockMode
 831         appData.clockMode = FALSE;
 832         first.sendTime = second.sendTime = 0;
 833     }
 834
 835 #if ZIPPY
 836     /* Override some settings from environment variables, for backward
 837        compatibility.  Unfortunately it's not feasible to have the env
 838        vars just set defaults, at least in xboard.  Ugh.
 839     */
 840     if (appData.icsActive && (appData.zippyPlay || appData.zippyTalk)) {
 841       ZippyInit();
 842     }
 843 #endif
 844
 845     if (appData.noChessProgram) {
 846         programVersion = (char*) malloc(5 + strlen(PACKAGE_STRING));
 847         sprintf(programVersion, "%s", PACKAGE_STRING);
 848     } else {
 849       /* [HGM] tidy: use tidy name, in stead of full pathname (which was probably a bug due to / vs \ ) */
 850       programVersion = (char*) malloc(8 + strlen(PACKAGE_STRING) + strlen(first.tidy));
 851       sprintf(programVersion, "%s + %s", PACKAGE_STRING, first.tidy);
 852     }
 853
 854     if (!appData.icsActive) {
 855       char buf[MSG_SIZ];
 856       /* Check for variants that are supported only in ICS mode,
 857          or not at all.  Some that are accepted here nevertheless
 858          have bugs; see comments below.
 859       */
 860       VariantClass variant = StringToVariant(appData.variant);
 861       switch (variant) {
 862       case VariantBughouse:     /* need four players and two boards */
 863       case VariantKriegspiel:   /* need to hide pieces and move details */
 864       /* case VariantFischeRandom: (Fabien: moved below) */
 865         sprintf(buf, _("Variant %s supported only in ICS mode"), appData.variant);
 866         DisplayFatalError(buf, 0, 2);
 867         return;
 868
 869       case VariantUnknown:
 870       case VariantLoadable:
 871       case Variant29:
 872       case Variant30:
 873       case Variant31:
 874       case Variant32:
 875       case Variant33:
 876       case Variant34:
 877       case Variant35:
 878       case Variant36:
 879       default:
 880         sprintf(buf, _("Unknown variant name %s"), appData.variant);
 881         DisplayFatalError(buf, 0, 2);
 882         return;
 883
 884       case VariantXiangqi:    /* [HGM] repetition rules not implemented */
 885       case VariantFairy:      /* [HGM] TestLegality definitely off! */
 886       case VariantGothic:     /* [HGM] should work */
 887       case VariantCapablanca: /* [HGM] should work */
 888       case VariantCourier:    /* [HGM] initial forced moves not implemented */
 889       case VariantShogi:      /* [HGM] drops not tested for legality */
 890       case VariantKnightmate: /* [HGM] should work */
 891       case VariantCylinder:   /* [HGM] untested */
 892       case VariantFalcon:     /* [HGM] untested */
 893       case VariantCrazyhouse: /* holdings not shown, ([HGM] fixed that!)
 894                                  offboard interposition not understood */
 895       case VariantNormal:     /* definitely works! */
 896       case VariantWildCastle: /* pieces not automatically shuffled */
 897       case VariantNoCastle:   /* pieces not automatically shuffled */
 898       case VariantFischeRandom: /* [HGM] works and shuffles pieces */
 899       case VariantLosers:     /* should work except for win condition,
 900                                  and doesn't know captures are mandatory */
 901       case VariantSuicide:    /* should work except for win condition,
 902                                  and doesn't know captures are mandatory */
 903       case VariantGiveaway:   /* should work except for win condition,
 904                                  and doesn't know captures are mandatory */
 905       case VariantTwoKings:   /* should work */
 906       case VariantAtomic:     /* should work except for win condition */
 907       case Variant3Check:     /* should work except for win condition */
 908       case VariantShatranj:   /* should work except for all win conditions */
 909       case VariantMakruk:     /* should work except for daw countdown */
 910       case VariantBerolina:   /* might work if TestLegality is off */
 911       case VariantCapaRandom: /* should work */
 912       case VariantJanus:      /* should work */
 913       case VariantSuper:      /* experimental */
 914       case VariantGreat:      /* experimental, requires legality testing to be off */
 915         break;
 916       }
 917     }
 918
 919     InitEngineUCI( installDir, &first );  // [HGM] moved here from winboard.c, to make available in xboard
 920     InitEngineUCI( installDir, &second );
 921 }
 922
 923 int NextIntegerFromString( char ** str, long * value )
 924 {
 925     int result = -1;
 926     char * s = *str;
 927
 928     while( *s == ' ' || *s == '\t' ) {
 929         s++;
 930     }
 931
 932     *value = 0;
 933
 934     if( *s >= '0' && *s <= '9' ) {
 935         while( *s >= '0' && *s <= '9' ) {
 936             *value = *value * 10 + (*s - '0');
 937             s++;
 938         }
 939
 940         result = 0;
 941     }
 942
 943     *str = s;
 944
 945     return result;
 946 }
 947
 948 int NextTimeControlFromString( char ** str, long * value )
 949 {
 950     long temp;
 951     int result = NextIntegerFromString( str, &temp );
 952
 953     if( result == 0 ) {
 954         *value = temp * 60; /* Minutes */
 955         if( **str == ':' ) {
 956             (*str)++;
 957             result = NextIntegerFromString( str, &temp );
 958             *value += temp; /* Seconds */
 959         }
 960     }
 961
 962     return result;
 963 }
 964
 965 int NextSessionFromString( char ** str, int *moves, long * tc, long *inc)
 966 {   /* [HGM] routine added to read '+moves/time' for secondary time control */
 967     int result = -1; long temp, temp2;
 968
 969     if(**str != '+') return -1; // old params remain in force!
 970     (*str)++;
 971     if( NextTimeControlFromString( str, &temp ) ) return -1;
 972
 973     if(**str != '/') {
 974         /* time only: incremental or sudden-death time control */
 975         if(**str == '+') { /* increment follows; read it */
 976             (*str)++;
 977             if(result = NextIntegerFromString( str, &temp2)) return -1;
 978             *inc = temp2 * 1000;
 979         } else *inc = 0;
 980         *moves = 0; *tc = temp * 1000;
 981         return 0;
 982     } else if(temp % 60 != 0) return -1;     /* moves was given as min:sec */
 983
 984     (*str)++; /* classical time control */
 985     result = NextTimeControlFromString( str, &temp2);
 986     if(result == 0) {
 987         *moves = temp/60;
 988         *tc    = temp2 * 1000;
 989         *inc   = 0;
 990     }
 991     return result;
 992 }
 993
 994 int GetTimeQuota(int movenr)
 995 {   /* [HGM] get time to add from the multi-session time-control string */
 996     int moves=1; /* kludge to force reading of first session */
 997     long time, increment;
 998     char *s = fullTimeControlString;
 999
1000     if(appData.debugMode) fprintf(debugFP, "TC string = '%s'\n", fullTimeControlString);
1001     do {
1002         if(moves) NextSessionFromString(&s, &moves, &time, &increment);
1003         if(appData.debugMode) fprintf(debugFP, "mps=%d tc=%d inc=%d\n", moves, (int) time, (int) increment);
1004         if(movenr == -1) return time;    /* last move before new session     */
1005         if(!moves) return increment;     /* current session is incremental   */
1006         if(movenr >= 0) movenr -= moves; /* we already finished this session */
1007     } while(movenr >= -1);               /* try again for next session       */
1008
1009     return 0; // no new time quota on this move
1010 }
1011
1012 int
1013 ParseTimeControl(tc, ti, mps)
1014      char *tc;
1015      int ti;
1016      int mps;
1017 {
1018   long tc1;
1019   long tc2;
1020   char buf[MSG_SIZ];
1021
1022   if(ti >= 0 && !strchr(tc, '+') && !strchr(tc, '/') ) mps = 0;
1023   if(ti > 0) {
1024     if(mps)
1025       sprintf(buf, "+%d/%s+%d", mps, tc, ti);
1026     else sprintf(buf, "+%s+%d", tc, ti);
1027   } else {
1028     if(mps)
1029              sprintf(buf, "+%d/%s", mps, tc);
1030     else sprintf(buf, "+%s", tc);
1031   }
1032   fullTimeControlString = StrSave(buf);
1033
1034   if( NextTimeControlFromString( &tc, &tc1 ) != 0 ) {
1035     return FALSE;
1036   }
1037
1038   if( *tc == '/' ) {
1039     /* Parse second time control */
1040     tc++;
1041
1042     if( NextTimeControlFromString( &tc, &tc2 ) != 0 ) {
1043       return FALSE;
1044     }
1045
1046     if( tc2 == 0 ) {
1047       return FALSE;
1048     }
1049
1050     timeControl_2 = tc2 * 1000;
1051   }
1052   else {
1053     timeControl_2 = 0;
1054   }
1055
1056   if( tc1 == 0 ) {
1057     return FALSE;
1058   }
1059
1060   timeControl = tc1 * 1000;
1061
1062   if (ti >= 0) {
1063     timeIncrement = ti * 1000;  /* convert to ms */
1064     movesPerSession = 0;
1065   } else {
1066     timeIncrement = 0;
1067     movesPerSession = mps;
1068   }
1069   return TRUE;
1070 }
1071
1072 void
1073 InitBackEnd2()
1074 {
1075     if (appData.debugMode) {
1076         fprintf(debugFP, "%s\n", programVersion);
1077     }
1078
1079     set_cont_sequence(appData.wrapContSeq);
1080     if (appData.matchGames > 0) {
1081         appData.matchMode = TRUE;
1082     } else if (appData.matchMode) {
1083         appData.matchGames = 1;
1084     }
1085     if(appData.matchMode && appData.sameColorGames > 0) /* [HGM] alternate: overrule matchGames */
1086         appData.matchGames = appData.sameColorGames;
1087     if(appData.rewindIndex > 1) { /* [HGM] autoinc: rewind implies auto-increment and overrules given index */
1088         if(appData.loadPositionIndex >= 0) appData.loadPositionIndex = -1;
1089         if(appData.loadGameIndex >= 0) appData.loadGameIndex = -1;
1090     }
1091     Reset(TRUE, FALSE);
1092     if (appData.noChessProgram || first.protocolVersion == 1) {
1093       InitBackEnd3();
1094     } else {
1095       /* kludge: allow timeout for initial "feature" commands */
1096       FreezeUI();
1097       DisplayMessage("", _("Starting chess program"));
1098       ScheduleDelayedEvent(InitBackEnd3, FEATURE_TIMEOUT);
1099     }
1100 }
1101
1102 void
1103 InitBackEnd3 P((void))
1104 {
1105     GameMode initialMode;
1106     char buf[MSG_SIZ];
1107     int err;
1108
1109     InitChessProgram(&first, startedFromSetupPosition);
1110
1111     if(!appData.noChessProgram) {  /* [HGM] tidy: redo program version to use name from myname feature */
1112         free(programVersion);
1113         programVersion = (char*) malloc(8 + strlen(PACKAGE_STRING) + strlen(first.tidy));
1114         sprintf(programVersion, "%s + %s", PACKAGE_STRING, first.tidy);
1115     }
1116
1117     if (appData.icsActive) {
1118 #ifdef WIN32
1119         /* [DM] Make a console window if needed [HGM] merged ifs */
1120         ConsoleCreate();
1121 #endif
1122         err = establish();
1123         if (err != 0) {
1124             if (*appData.icsCommPort != NULLCHAR) {
1125                 sprintf(buf, _("Could not open comm port %s"),
1126                         appData.icsCommPort);
1127             } else {
1128                 snprintf(buf, sizeof(buf), _("Could not connect to host %s, port %s"),
1129                         appData.icsHost, appData.icsPort);
1130             }
1131             DisplayFatalError(buf, err, 1);
1132             return;
1133         }
1134         SetICSMode();
1135         telnetISR =
1136           AddInputSource(icsPR, FALSE, read_from_ics, &telnetISR);
1137         fromUserISR =
1138           AddInputSource(NoProc, FALSE, read_from_player, &fromUserISR);
1139         if(appData.keepAlive) // [HGM] alive: schedule sending of dummy 'date' command
1140             ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
1141     } else if (appData.noChessProgram) {
1142         SetNCPMode();
1143     } else {
1144         SetGNUMode();
1145     }
1146
1147     if (*appData.cmailGameName != NULLCHAR) {
1148         SetCmailMode();
1149         OpenLoopback(&cmailPR);
1150         cmailISR =
1151           AddInputSource(cmailPR, FALSE, CmailSigHandlerCallBack, &cmailISR);
1152     }
1153
1154     ThawUI();
1155     DisplayMessage("", "");
1156     if (StrCaseCmp(appData.initialMode, "") == 0) {
1157       initialMode = BeginningOfGame;
1158     } else if (StrCaseCmp(appData.initialMode, "TwoMachines") == 0) {
1159       initialMode = TwoMachinesPlay;
1160     } else if (StrCaseCmp(appData.initialMode, "AnalyzeFile") == 0) {
1161       initialMode = AnalyzeFile;
1162     } else if (StrCaseCmp(appData.initialMode, "Analysis") == 0) {
1163       initialMode = AnalyzeMode;
1164     } else if (StrCaseCmp(appData.initialMode, "MachineWhite") == 0) {
1165       initialMode = MachinePlaysWhite;
1166     } else if (StrCaseCmp(appData.initialMode, "MachineBlack") == 0) {
1167       initialMode = MachinePlaysBlack;
1168     } else if (StrCaseCmp(appData.initialMode, "EditGame") == 0) {
1169       initialMode = EditGame;
1170     } else if (StrCaseCmp(appData.initialMode, "EditPosition") == 0) {
1171       initialMode = EditPosition;
1172     } else if (StrCaseCmp(appData.initialMode, "Training") == 0) {
1173       initialMode = Training;
1174     } else {
1175       sprintf(buf, _("Unknown initialMode %s"), appData.initialMode);
1176       DisplayFatalError(buf, 0, 2);
1177       return;
1178     }
1179
1180     if (appData.matchMode) {
1181         /* Set up machine vs. machine match */
1182         if (appData.noChessProgram) {
1183             DisplayFatalError(_("Can't have a match with no chess programs"),
1184                               0, 2);
1185             return;
1186         }
1187         matchMode = TRUE;
1188         matchGame = 1;
1189         if (*appData.loadGameFile != NULLCHAR) {
1190             int index = appData.loadGameIndex; // [HGM] autoinc
1191             if(index<0) lastIndex = index = 1;
1192             if (!LoadGameFromFile(appData.loadGameFile,
1193                                   index,
1194                                   appData.loadGameFile, FALSE)) {
1195                 DisplayFatalError(_("Bad game file"), 0, 1);
1196                 return;
1197             }
1198         } else if (*appData.loadPositionFile != NULLCHAR) {
1199             int index = appData.loadPositionIndex; // [HGM] autoinc
1200             if(index<0) lastIndex = index = 1;
1201             if (!LoadPositionFromFile(appData.loadPositionFile,
1202                                       index,
1203                                       appData.loadPositionFile)) {
1204                 DisplayFatalError(_("Bad position file"), 0, 1);
1205                 return;
1206             }
1207         }
1208         TwoMachinesEvent();
1209     } else if (*appData.cmailGameName != NULLCHAR) {
1210         /* Set up cmail mode */
1211         ReloadCmailMsgEvent(TRUE);
1212     } else {
1213         /* Set up other modes */
1214         if (initialMode == AnalyzeFile) {
1215           if (*appData.loadGameFile == NULLCHAR) {
1216             DisplayFatalError(_("AnalyzeFile mode requires a game file"), 0, 1);
1217             return;
1218           }
1219         }
1220         if (*appData.loadGameFile != NULLCHAR) {
1221             (void) LoadGameFromFile(appData.loadGameFile,
1222                                     appData.loadGameIndex,
1223                                     appData.loadGameFile, TRUE);
1224         } else if (*appData.loadPositionFile != NULLCHAR) {
1225             (void) LoadPositionFromFile(appData.loadPositionFile,
1226                                         appData.loadPositionIndex,
1227                                         appData.loadPositionFile);
1228             /* [HGM] try to make self-starting even after FEN load */
1229             /* to allow automatic setup of fairy variants with wtm */
1230             if(initialMode == BeginningOfGame && !blackPlaysFirst) {
1231                 gameMode = BeginningOfGame;
1232                 setboardSpoiledMachineBlack = 1;
1233             }
1234             /* [HGM] loadPos: make that every new game uses the setup */
1235             /* from file as long as we do not switch variant          */
1236             if(!blackPlaysFirst) {
1237                 startedFromPositionFile = TRUE;
1238                 CopyBoard(filePosition, boards[0]);
1239             }
1240         }
1241         if (initialMode == AnalyzeMode) {
1242           if (appData.noChessProgram) {
1243             DisplayFatalError(_("Analysis mode requires a chess engine"), 0, 2);
1244             return;
1245           }
1246           if (appData.icsActive) {
1247             DisplayFatalError(_("Analysis mode does not work with ICS mode"),0,2);
1248             return;
1249           }
1250           AnalyzeModeEvent();
1251         } else if (initialMode == AnalyzeFile) {
1252           appData.showThinking = TRUE; // [HGM] thinking: moved out of ShowThinkingEvent
1253           ShowThinkingEvent();
1254           AnalyzeFileEvent();
1255           AnalysisPeriodicEvent(1);
1256         } else if (initialMode == MachinePlaysWhite) {
1257           if (appData.noChessProgram) {
1258             DisplayFatalError(_("MachineWhite mode requires a chess engine"),
1259                               0, 2);
1260             return;
1261           }
1262           if (appData.icsActive) {
1263             DisplayFatalError(_("MachineWhite mode does not work with ICS mode"),
1264                               0, 2);
1265             return;
1266           }
1267           MachineWhiteEvent();
1268         } else if (initialMode == MachinePlaysBlack) {
1269           if (appData.noChessProgram) {
1270             DisplayFatalError(_("MachineBlack mode requires a chess engine"),
1271                               0, 2);
1272             return;
1273           }
1274           if (appData.icsActive) {
1275             DisplayFatalError(_("MachineBlack mode does not work with ICS mode"),
1276                               0, 2);
1277             return;
1278           }
1279           MachineBlackEvent();
1280         } else if (initialMode == TwoMachinesPlay) {
1281           if (appData.noChessProgram) {
1282             DisplayFatalError(_("TwoMachines mode requires a chess engine"),
1283                               0, 2);
1284             return;
1285           }
1286           if (appData.icsActive) {
1287             DisplayFatalError(_("TwoMachines mode does not work with ICS mode"),
1288                               0, 2);
1289             return;
1290           }
1291           TwoMachinesEvent();
1292         } else if (initialMode == EditGame) {
1293           EditGameEvent();
1294         } else if (initialMode == EditPosition) {
1295           EditPositionEvent();
1296         } else if (initialMode == Training) {
1297           if (*appData.loadGameFile == NULLCHAR) {
1298             DisplayFatalError(_("Training mode requires a game file"), 0, 2);
1299             return;
1300           }
1301           TrainingEvent();
1302         }
1303     }
1304 }
1305
1306 /*
1307  * Establish will establish a contact to a remote host.port.
1308  * Sets icsPR to a ProcRef for a process (or pseudo-process)
1309  *  used to talk to the host.
1310  * Returns 0 if okay, error code if not.
1311  */
1312 int
1313 establish()
1314 {
1315     char buf[MSG_SIZ];
1316
1317     if (*appData.icsCommPort != NULLCHAR) {
1318         /* Talk to the host through a serial comm port */
1319         return OpenCommPort(appData.icsCommPort, &icsPR);
1320
1321     } else if (*appData.gateway != NULLCHAR) {
1322         if (*appData.remoteShell == NULLCHAR) {
1323             /* Use the rcmd protocol to run telnet program on a gateway host */
1324             snprintf(buf, sizeof(buf), "%s %s %s",
1325                     appData.telnetProgram, appData.icsHost, appData.icsPort);
1326             return OpenRcmd(appData.gateway, appData.remoteUser, buf, &icsPR);
1327
1328         } else {
1329             /* Use the rsh program to run telnet program on a gateway host */
1330             if (*appData.remoteUser == NULLCHAR) {
1331                 snprintf(buf, sizeof(buf), "%s %s %s %s %s", appData.remoteShell,
1332                         appData.gateway, appData.telnetProgram,
1333                         appData.icsHost, appData.icsPort);
1334             } else {
1335                 snprintf(buf, sizeof(buf), "%s %s -l %s %s %s %s",
1336                         appData.remoteShell, appData.gateway,
1337                         appData.remoteUser, appData.telnetProgram,
1338                         appData.icsHost, appData.icsPort);
1339             }
1340             return StartChildProcess(buf, "", &icsPR);
1341
1342         }
1343     } else if (appData.useTelnet) {
1344         return OpenTelnet(appData.icsHost, appData.icsPort, &icsPR);
1345
1346     } else {
1347         /* TCP socket interface differs somewhat between
1348            Unix and NT; handle details in the front end.
1349            */
1350         return OpenTCP(appData.icsHost, appData.icsPort, &icsPR);
1351     }
1352 }
1353
1354 void EscapeExpand(char *p, char *q)
1355 {       // [HGM] initstring: routine to shape up string arguments
1356         while(*p++ = *q++) if(p[-1] == '\\')
1357             switch(*q++) {
1358                 case 'n': p[-1] = '\n'; break;
1359                 case 'r': p[-1] = '\r'; break;
1360                 case 't': p[-1] = '\t'; break;
1361                 case '\\': p[-1] = '\\'; break;
1362                 case 0: *p = 0; return;
1363                 default: p[-1] = q[-1]; break;
1364             }
1365 }
1366
1367 void
1368 show_bytes(fp, buf, count)
1369      FILE *fp;
1370      char *buf;
1371      int count;
1372 {
1373     while (count--) {
1374         if (*buf < 040 || *(unsigned char *) buf > 0177) {
1375             fprintf(fp, "\\%03o", *buf & 0xff);
1376         } else {
1377             putc(*buf, fp);
1378         }
1379         buf++;
1380     }
1381     fflush(fp);
1382 }
1383
1384 /* Returns an errno value */
1385 int
1386 OutputMaybeTelnet(pr, message, count, outError)
1387      ProcRef pr;
1388      char *message;
1389      int count;
1390      int *outError;
1391 {
1392     char buf[8192], *p, *q, *buflim;
1393     int left, newcount, outcount;
1394
1395     if (*appData.icsCommPort != NULLCHAR || appData.useTelnet ||
1396         *appData.gateway != NULLCHAR) {
1397         if (appData.debugMode) {
1398             fprintf(debugFP, ">ICS: ");
1399             show_bytes(debugFP, message, count);
1400             fprintf(debugFP, "\n");
1401         }
1402         return OutputToProcess(pr, message, count, outError);
1403     }
1404
1405     buflim = &buf[sizeof(buf)-1]; /* allow 1 byte for expanding last char */
1406     p = message;
1407     q = buf;
1408     left = count;
1409     newcount = 0;
1410     while (left) {
1411         if (q >= buflim) {
1412             if (appData.debugMode) {
1413                 fprintf(debugFP, ">ICS: ");
1414                 show_bytes(debugFP, buf, newcount);
1415                 fprintf(debugFP, "\n");
1416             }
1417             outcount = OutputToProcess(pr, buf, newcount, outError);
1418             if (outcount < newcount) return -1; /* to be sure */
1419             q = buf;
1420             newcount = 0;
1421         }
1422         if (*p == '\n') {
1423             *q++ = '\r';
1424             newcount++;
1425         } else if (((unsigned char) *p) == TN_IAC) {
1426             *q++ = (char) TN_IAC;
1427             newcount ++;
1428         }
1429         *q++ = *p++;
1430         newcount++;
1431         left--;
1432     }
1433     if (appData.debugMode) {
1434         fprintf(debugFP, ">ICS: ");
1435         show_bytes(debugFP, buf, newcount);
1436         fprintf(debugFP, "\n");
1437     }
1438     outcount = OutputToProcess(pr, buf, newcount, outError);
1439     if (outcount < newcount) return -1; /* to be sure */
1440     return count;
1441 }
1442
1443 void
1444 read_from_player(isr, closure, message, count, error)
1445      InputSourceRef isr;
1446      VOIDSTAR closure;
1447      char *message;
1448      int count;
1449      int error;
1450 {
1451     int outError, outCount;
1452     static int gotEof = 0;
1453
1454     /* Pass data read from player on to ICS */
1455     if (count > 0) {
1456         gotEof = 0;
1457         outCount = OutputMaybeTelnet(icsPR, message, count, &outError);
1458         if (outCount < count) {
1459             DisplayFatalError(_("Error writing to ICS"), outError, 1);
1460         }
1461     } else if (count < 0) {
1462         RemoveInputSource(isr);
1463         DisplayFatalError(_("Error reading from keyboard"), error, 1);
1464     } else if (gotEof++ > 0) {
1465         RemoveInputSource(isr);
1466         DisplayFatalError(_("Got end of file from keyboard"), 0, 0);
1467     }
1468 }
1469
1470 void
1471 KeepAlive()
1472 {   // [HGM] alive: periodically send dummy (date) command to ICS to prevent time-out
1473     if(!connectionAlive) DisplayFatalError("No response from ICS", 0, 1);
1474     connectionAlive = FALSE; // only sticks if no response to 'date' command.
1475     SendToICS("date\n");
1476     if(appData.keepAlive) ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
1477 }
1478
1479 /* added routine for printf style output to ics */
1480 void ics_printf(char *format, ...)
1481 {
1482     char buffer[MSG_SIZ];
1483     va_list args;
1484
1485     va_start(args, format);
1486     vsnprintf(buffer, sizeof(buffer), format, args);
1487     buffer[sizeof(buffer)-1] = '\0';
1488     SendToICS(buffer);
1489     va_end(args);
1490 }
1491
1492 void
1493 SendToICS(s)
1494      char *s;
1495 {
1496     int count, outCount, outError;
1497
1498     if (icsPR == NULL) return;
1499
1500     count = strlen(s);
1501     outCount = OutputMaybeTelnet(icsPR, s, count, &outError);
1502     if (outCount < count) {
1503         DisplayFatalError(_("Error writing to ICS"), outError, 1);
1504     }
1505 }
1506
1507 /* This is used for sending logon scripts to the ICS. Sending
1508    without a delay causes problems when using timestamp on ICC
1509    (at least on my machine). */
1510 void
1511 SendToICSDelayed(s,msdelay)
1512      char *s;
1513      long msdelay;
1514 {
1515     int count, outCount, outError;
1516
1517     if (icsPR == NULL) return;
1518
1519     count = strlen(s);
1520     if (appData.debugMode) {
1521         fprintf(debugFP, ">ICS: ");
1522         show_bytes(debugFP, s, count);
1523         fprintf(debugFP, "\n");
1524     }
1525     outCount = OutputToProcessDelayed(icsPR, s, count, &outError,
1526                                       msdelay);
1527     if (outCount < count) {
1528         DisplayFatalError(_("Error writing to ICS"), outError, 1);
1529     }
1530 }
1531
1532
1533 /* Remove all highlighting escape sequences in s
1534    Also deletes any suffix starting with '('
1535    */
1536 char *
1537 StripHighlightAndTitle(s)
1538      char *s;
1539 {
1540     static char retbuf[MSG_SIZ];
1541     char *p = retbuf;
1542
1543     while (*s != NULLCHAR) {
1544         while (*s == '\033') {
1545             while (*s != NULLCHAR && !isalpha(*s)) s++;
1546             if (*s != NULLCHAR) s++;
1547         }
1548         while (*s != NULLCHAR && *s != '\033') {
1549             if (*s == '(' || *s == '[') {
1550                 *p = NULLCHAR;
1551                 return retbuf;
1552             }
1553             *p++ = *s++;
1554         }
1555     }
1556     *p = NULLCHAR;
1557     return retbuf;
1558 }
1559
1560 /* Remove all highlighting escape sequences in s */
1561 char *
1562 StripHighlight(s)
1563      char *s;
1564 {
1565     static char retbuf[MSG_SIZ];
1566     char *p = retbuf;
1567
1568     while (*s != NULLCHAR) {
1569         while (*s == '\033') {
1570             while (*s != NULLCHAR && !isalpha(*s)) s++;
1571             if (*s != NULLCHAR) s++;
1572         }
1573         while (*s != NULLCHAR && *s != '\033') {
1574             *p++ = *s++;
1575         }
1576     }
1577     *p = NULLCHAR;
1578     return retbuf;
1579 }
1580
1581 char *variantNames[] = VARIANT_NAMES;
1582 char *
1583 VariantName(v)
1584      VariantClass v;
1585 {
1586     return variantNames[v];
1587 }
1588
1589
1590 /* Identify a variant from the strings the chess servers use or the
1591    PGN Variant tag names we use. */
1592 VariantClass
1593 StringToVariant(e)
1594      char *e;
1595 {
1596     char *p;
1597     int wnum = -1;
1598     VariantClass v = VariantNormal;
1599     int i, found = FALSE;
1600     char buf[MSG_SIZ];
1601
1602     if (!e) return v;
1603
1604     /* [HGM] skip over optional board-size prefixes */
1605     if( sscanf(e, "%dx%d_", &i, &i) == 2 ||
1606         sscanf(e, "%dx%d+%d_", &i, &i, &i) == 3 ) {
1607         while( *e++ != '_');
1608     }
1609
1610     if(StrCaseStr(e, "misc/")) { // [HGM] on FICS, misc/shogi is not shogi
1611         v = VariantNormal;
1612         found = TRUE;
1613     } else
1614     for (i=0; i<sizeof(variantNames)/sizeof(char*); i++) {
1615       if (StrCaseStr(e, variantNames[i])) {
1616         v = (VariantClass) i;
1617         found = TRUE;
1618         break;
1619       }
1620     }
1621
1622     if (!found) {
1623       if ((StrCaseStr(e, "fischer") && StrCaseStr(e, "random"))
1624           || StrCaseStr(e, "wild/fr")
1625           || StrCaseStr(e, "frc") || StrCaseStr(e, "960")) {
1626         v = VariantFischeRandom;
1627       } else if ((i = 4, p = StrCaseStr(e, "wild")) ||
1628                  (i = 1, p = StrCaseStr(e, "w"))) {
1629         p += i;
1630         while (*p && (isspace(*p) || *p == '(' || *p == '/')) p++;
1631         if (isdigit(*p)) {
1632           wnum = atoi(p);
1633         } else {
1634           wnum = -1;
1635         }
1636         switch (wnum) {
1637         case 0: /* FICS only, actually */
1638         case 1:
1639           /* Castling legal even if K starts on d-file */
1640           v = VariantWildCastle;
1641           break;
1642         case 2:
1643         case 3:
1644         case 4:
1645           /* Castling illegal even if K & R happen to start in
1646              normal positions. */
1647           v = VariantNoCastle;
1648           break;
1649         case 5:
1650         case 7:
1651         case 8:
1652         case 10:
1653         case 11:
1654         case 12:
1655         case 13:
1656         case 14:
1657         case 15:
1658         case 18:
1659         case 19:
1660           /* Castling legal iff K & R start in normal positions */
1661           v = VariantNormal;
1662           break;
1663         case 6:
1664         case 20:
1665         case 21:
1666           /* Special wilds for position setup; unclear what to do here */
1667           v = VariantLoadable;
1668           break;
1669         case 9:
1670           /* Bizarre ICC game */
1671           v = VariantTwoKings;
1672           break;
1673         case 16:
1674           v = VariantKriegspiel;
1675           break;
1676         case 17:
1677           v = VariantLosers;
1678           break;
1679         case 22:
1680           v = VariantFischeRandom;
1681           break;
1682         case 23:
1683           v = VariantCrazyhouse;
1684           break;
1685         case 24:
1686           v = VariantBughouse;
1687           break;
1688         case 25:
1689           v = Variant3Check;
1690           break;
1691         case 26:
1692           /* Not quite the same as FICS suicide! */
1693           v = VariantGiveaway;
1694           break;
1695         case 27:
1696           v = VariantAtomic;
1697           break;
1698         case 28:
1699           v = VariantShatranj;
1700           break;
1701
1702         /* Temporary names for future ICC types.  The name *will* change in
1703            the next xboard/WinBoard release after ICC defines it. */
1704         case 29:
1705           v = Variant29;
1706           break;
1707         case 30:
1708           v = Variant30;
1709           break;
1710         case 31:
1711           v = Variant31;
1712           break;
1713         case 32:
1714           v = Variant32;
1715           break;
1716         case 33:
1717           v = Variant33;
1718           break;
1719         case 34:
1720           v = Variant34;
1721           break;
1722         case 35:
1723           v = Variant35;
1724           break;
1725         case 36:
1726           v = Variant36;
1727           break;
1728         case 37:
1729           v = VariantShogi;
1730           break;
1731         case 38:
1732           v = VariantXiangqi;
1733           break;
1734         case 39:
1735           v = VariantCourier;
1736           break;
1737         case 40:
1738           v = VariantGothic;
1739           break;
1740         case 41:
1741           v = VariantCapablanca;
1742           break;
1743         case 42:
1744           v = VariantKnightmate;
1745           break;
1746         case 43:
1747           v = VariantFairy;
1748           break;
1749         case 44:
1750           v = VariantCylinder;
1751           break;
1752         case 45:
1753           v = VariantFalcon;
1754           break;
1755         case 46:
1756           v = VariantCapaRandom;
1757           break;
1758         case 47:
1759           v = VariantBerolina;
1760           break;
1761         case 48:
1762           v = VariantJanus;
1763           break;
1764         case 49:
1765           v = VariantSuper;
1766           break;
1767         case 50:
1768           v = VariantGreat;
1769           break;
1770         case -1:
1771           /* Found "wild" or "w" in the string but no number;
1772              must assume it's normal chess. */
1773           v = VariantNormal;
1774           break;
1775         default:
1776           sprintf(buf, _("Unknown wild type %d"), wnum);
1777           DisplayError(buf, 0);
1778           v = VariantUnknown;
1779           break;
1780         }
1781       }
1782     }
1783     if (appData.debugMode) {
1784       fprintf(debugFP, _("recognized '%s' (%d) as variant %s\n"),
1785               e, wnum, VariantName(v));
1786     }
1787     return v;
1788 }
1789
1790 static int leftover_start = 0, leftover_len = 0;
1791 char star_match[STAR_MATCH_N][MSG_SIZ];
1792
1793 /* Test whether pattern is present at &buf[*index]; if so, return TRUE,
1794    advance *index beyond it, and set leftover_start to the new value of
1795    *index; else return FALSE.  If pattern contains the character '*', it
1796    matches any sequence of characters not containing '\r', '\n', or the
1797    character following the '*' (if any), and the matched sequence(s) are
1798    copied into star_match.
1799    */
1800 int
1801 looking_at(buf, index, pattern)
1802      char *buf;
1803      int *index;
1804      char *pattern;
1805 {
1806     char *bufp = &buf[*index], *patternp = pattern;
1807     int star_count = 0;
1808     char *matchp = star_match[0];
1809
1810     for (;;) {
1811         if (*patternp == NULLCHAR) {
1812             *index = leftover_start = bufp - buf;
1813             *matchp = NULLCHAR;
1814             return TRUE;
1815         }
1816         if (*bufp == NULLCHAR) return FALSE;
1817         if (*patternp == '*') {
1818             if (*bufp == *(patternp + 1)) {
1819                 *matchp = NULLCHAR;
1820                 matchp = star_match[++star_count];
1821                 patternp += 2;
1822                 bufp++;
1823                 continue;
1824             } else if (*bufp == '\n' || *bufp == '\r') {
1825                 patternp++;
1826                 if (*patternp == NULLCHAR)
1827                   continue;
1828                 else
1829                   return FALSE;
1830             } else {
1831                 *matchp++ = *bufp++;
1832                 continue;
1833             }
1834         }
1835         if (*patternp != *bufp) return FALSE;
1836         patternp++;
1837         bufp++;
1838     }
1839 }
1840
1841 void
1842 SendToPlayer(data, length)
1843      char *data;
1844      int length;
1845 {
1846     int error, outCount;
1847     outCount = OutputToProcess(NoProc, data, length, &error);
1848     if (outCount < length) {
1849         DisplayFatalError(_("Error writing to display"), error, 1);
1850     }
1851 }
1852
1853 void
1854 PackHolding(packed, holding)
1855      char packed[];
1856      char *holding;
1857 {
1858     char *p = holding;
1859     char *q = packed;
1860     int runlength = 0;
1861     int curr = 9999;
1862     do {
1863         if (*p == curr) {
1864             runlength++;
1865         } else {
1866             switch (runlength) {
1867               case 0:
1868                 break;
1869               case 1:
1870                 *q++ = curr;
1871                 break;
1872               case 2:
1873                 *q++ = curr;
1874                 *q++ = curr;
1875                 break;
1876               default:
1877                 sprintf(q, "%d", runlength);
1878                 while (*q) q++;
1879                 *q++ = curr;
1880                 break;
1881             }
1882             runlength = 1;
1883             curr = *p;
1884         }
1885     } while (*p++);
1886     *q = NULLCHAR;
1887 }
1888
1889 /* Telnet protocol requests from the front end */
1890 void
1891 TelnetRequest(ddww, option)
1892      unsigned char ddww, option;
1893 {
1894     unsigned char msg[3];
1895     int outCount, outError;
1896
1897     if (*appData.icsCommPort != NULLCHAR || appData.useTelnet) return;
1898
1899     if (appData.debugMode) {
1900         char buf1[8], buf2[8], *ddwwStr, *optionStr;
1901         switch (ddww) {
1902           case TN_DO:
1903             ddwwStr = "DO";
1904             break;
1905           case TN_DONT:
1906             ddwwStr = "DONT";
1907             break;
1908           case TN_WILL:
1909             ddwwStr = "WILL";
1910             break;
1911           case TN_WONT:
1912             ddwwStr = "WONT";
1913             break;
1914           default:
1915             ddwwStr = buf1;
1916             sprintf(buf1, "%d", ddww);
1917             break;
1918         }
1919         switch (option) {
1920           case TN_ECHO:
1921             optionStr = "ECHO";
1922             break;
1923           default:
1924             optionStr = buf2;
1925             sprintf(buf2, "%d", option);
1926             break;
1927         }
1928         fprintf(debugFP, ">%s %s ", ddwwStr, optionStr);
1929     }
1930     msg[0] = TN_IAC;
1931     msg[1] = ddww;
1932     msg[2] = option;
1933     outCount = OutputToProcess(icsPR, (char *)msg, 3, &outError);
1934     if (outCount < 3) {
1935         DisplayFatalError(_("Error writing to ICS"), outError, 1);
1936     }
1937 }
1938
1939 void
1940 DoEcho()
1941 {
1942     if (!appData.icsActive) return;
1943     TelnetRequest(TN_DO, TN_ECHO);
1944 }
1945
1946 void
1947 DontEcho()
1948 {
1949     if (!appData.icsActive) return;
1950     TelnetRequest(TN_DONT, TN_ECHO);
1951 }
1952
1953 void
1954 CopyHoldings(Board board, char *holdings, ChessSquare lowestPiece)
1955 {
1956     /* put the holdings sent to us by the server on the board holdings area */
1957     int i, j, holdingsColumn, holdingsStartRow, direction, countsColumn;
1958     char p;
1959     ChessSquare piece;
1960
1961     if(gameInfo.holdingsWidth < 2)  return;
1962     if(gameInfo.variant != VariantBughouse && board[HOLDINGS_SET])
1963         return; // prevent overwriting by pre-board holdings
1964
1965     if( (int)lowestPiece >= BlackPawn ) {
1966         holdingsColumn = 0;
1967         countsColumn = 1;
1968         holdingsStartRow = BOARD_HEIGHT-1;
1969         direction = -1;
1970     } else {
1971         holdingsColumn = BOARD_WIDTH-1;
1972         countsColumn = BOARD_WIDTH-2;
1973         holdingsStartRow = 0;
1974         direction = 1;
1975     }
1976
1977     for(i=0; i<BOARD_HEIGHT; i++) { /* clear holdings */
1978         board[i][holdingsColumn] = EmptySquare;
1979         board[i][countsColumn]   = (ChessSquare) 0;
1980     }
1981     while( (p=*holdings++) != NULLCHAR ) {
1982         piece = CharToPiece( ToUpper(p) );
1983         if(piece == EmptySquare) continue;
1984         /*j = (int) piece - (int) WhitePawn;*/
1985         j = PieceToNumber(piece);
1986         if(j >= gameInfo.holdingsSize) continue; /* ignore pieces that do not fit */
1987         if(j < 0) continue;               /* should not happen */
1988         piece = (ChessSquare) ( (int)piece + (int)lowestPiece );
1989         board[holdingsStartRow+j*direction][holdingsColumn] = piece;
1990         board[holdingsStartRow+j*direction][countsColumn]++;
1991     }
1992 }
1993
1994
1995 void
1996 VariantSwitch(Board board, VariantClass newVariant)
1997 {
1998    int newHoldingsWidth, newWidth = 8, newHeight = 8, i, j;
1999    static Board oldBoard;
2000
2001    startedFromPositionFile = FALSE;
2002    if(gameInfo.variant == newVariant) return;
2003
2004    /* [HGM] This routine is called each time an assignment is made to
2005     * gameInfo.variant during a game, to make sure the board sizes
2006     * are set to match the new variant. If that means adding or deleting
2007     * holdings, we shift the playing board accordingly
2008     * This kludge is needed because in ICS observe mode, we get boards
2009     * of an ongoing game without knowing the variant, and learn about the
2010     * latter only later. This can be because of the move list we requested,
2011     * in which case the game history is refilled from the beginning anyway,
2012     * but also when receiving holdings of a crazyhouse game. In the latter
2013     * case we want to add those holdings to the already received position.
2014     */
2015
2016
2017    if (appData.debugMode) {
2018      fprintf(debugFP, "Switch board from %s to %s\n",
2019              VariantName(gameInfo.variant), VariantName(newVariant));
2020      setbuf(debugFP, NULL);
2021    }
2022    shuffleOpenings = 0;       /* [HGM] shuffle */
2023    gameInfo.holdingsSize = 5; /* [HGM] prepare holdings */
2024    switch(newVariant)
2025      {
2026      case VariantShogi:
2027        newWidth = 9;  newHeight = 9;
2028        gameInfo.holdingsSize = 7;
2029      case VariantBughouse:
2030      case VariantCrazyhouse:
2031        newHoldingsWidth = 2; break;
2032      case VariantGreat:
2033        newWidth = 10;
2034      case VariantSuper:
2035        newHoldingsWidth = 2;
2036        gameInfo.holdingsSize = 8;
2037        break;
2038      case VariantGothic:
2039      case VariantCapablanca:
2040      case VariantCapaRandom:
2041        newWidth = 10;
2042      default:
2043        newHoldingsWidth = gameInfo.holdingsSize = 0;
2044      };
2045
2046    if(newWidth  != gameInfo.boardWidth  ||
2047       newHeight != gameInfo.boardHeight ||
2048       newHoldingsWidth != gameInfo.holdingsWidth ) {
2049
2050      /* shift position to new playing area, if needed */
2051      if(newHoldingsWidth > gameInfo.holdingsWidth) {
2052        for(i=0; i<BOARD_HEIGHT; i++)
2053          for(j=BOARD_RGHT-1; j>=BOARD_LEFT; j--)
2054            board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
2055              board[i][j];
2056        for(i=0; i<newHeight; i++) {
2057          board[i][0] = board[i][newWidth+2*newHoldingsWidth-1] = EmptySquare;
2058          board[i][1] = board[i][newWidth+2*newHoldingsWidth-2] = (ChessSquare) 0;
2059        }
2060      } else if(newHoldingsWidth < gameInfo.holdingsWidth) {
2061        for(i=0; i<BOARD_HEIGHT; i++)
2062          for(j=BOARD_LEFT; j<BOARD_RGHT; j++)
2063            board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
2064              board[i][j];
2065      }
2066      gameInfo.boardWidth  = newWidth;
2067      gameInfo.boardHeight = newHeight;
2068      gameInfo.holdingsWidth = newHoldingsWidth;
2069      gameInfo.variant = newVariant;
2070      InitDrawingSizes(-2, 0);
2071    } else gameInfo.variant = newVariant;
2072    CopyBoard(oldBoard, board);   // remember correctly formatted board
2073      InitPosition(FALSE);          /* this sets up board[0], but also other stuff        */
2074    DrawPosition(TRUE, currentMove ? boards[currentMove] : oldBoard);
2075 }
2076
2077 static int loggedOn = FALSE;
2078
2079 /*-- Game start info cache: --*/
2080 int gs_gamenum;
2081 char gs_kind[MSG_SIZ];
2082 static char player1Name[128] = "";
2083 static char player2Name[128] = "";
2084 static char cont_seq[] = "\n\\   ";
2085 static int player1Rating = -1;
2086 static int player2Rating = -1;
2087 /*----------------------------*/
2088
2089 ColorClass curColor = ColorNormal;
2090 int suppressKibitz = 0;
2091
2092 // [HGM] seekgraph
2093 Boolean soughtPending = FALSE;
2094 Boolean seekGraphUp;
2095 #define MAX_SEEK_ADS 200
2096 #define SQUARE 0x80
2097 char *seekAdList[MAX_SEEK_ADS];
2098 int ratingList[MAX_SEEK_ADS], xList[MAX_SEEK_ADS], yList[MAX_SEEK_ADS], seekNrList[MAX_SEEK_ADS], zList[MAX_SEEK_ADS];
2099 float tcList[MAX_SEEK_ADS];
2100 char colorList[MAX_SEEK_ADS];
2101 int nrOfSeekAds = 0;
2102 int minRating = 1010, maxRating = 2800;
2103 int hMargin = 10, vMargin = 20, h, w;
2104 extern int squareSize, lineGap;
2105
2106 void
2107 PlotSeekAd(int i)
2108 {
2109         int x, y, color = 0, r = ratingList[i]; float tc = tcList[i];
2110         xList[i] = yList[i] = -100; // outside graph, so cannot be clicked
2111         if(r < minRating+100 && r >=0 ) r = minRating+100;
2112         if(r > maxRating) r = maxRating;
2113         if(tc < 1.) tc = 1.;
2114         if(tc > 95.) tc = 95.;
2115         x = (w-hMargin-squareSize/8-7)* log(tc)/log(95.) + hMargin;
2116         y = ((double)r - minRating)/(maxRating - minRating)
2117             * (h-vMargin-squareSize/8-1) + vMargin;
2118         if(ratingList[i] < 0) y = vMargin + squareSize/4;
2119         if(strstr(seekAdList[i], " u ")) color = 1;
2120         if(!strstr(seekAdList[i], "lightning") && // for now all wilds same color
2121            !strstr(seekAdList[i], "bullet") &&
2122            !strstr(seekAdList[i], "blitz") &&
2123            !strstr(seekAdList[i], "standard") ) color = 2;
2124         if(strstr(seekAdList[i], "(C) ")) color |= SQUARE; // plot computer seeks as squares
2125         DrawSeekDot(xList[i]=x+3*(color&~SQUARE), yList[i]=h-1-y, colorList[i]=color);
2126 }
2127
2128 void
2129 AddAd(char *handle, char *rating, int base, int inc,  char rated, char *type, int nr, Boolean plot)
2130 {
2131         char buf[MSG_SIZ], *ext = "";
2132         VariantClass v = StringToVariant(type);
2133         if(strstr(type, "wild")) {
2134             ext = type + 4; // append wild number
2135             if(v == VariantFischeRandom) type = "chess960"; else
2136             if(v == VariantLoadable) type = "setup"; else
2137             type = VariantName(v);
2138         }
2139         sprintf(buf, "%s (%s) %d %d %c %s%s", handle, rating, base, inc, rated, type, ext);
2140         if(nrOfSeekAds < MAX_SEEK_ADS-1) {
2141             if(seekAdList[nrOfSeekAds]) free(seekAdList[nrOfSeekAds]);
2142             ratingList[nrOfSeekAds] = -1; // for if seeker has no rating
2143             sscanf(rating, "%d", &ratingList[nrOfSeekAds]);
2144             tcList[nrOfSeekAds] = base + (2./3.)*inc;
2145             seekNrList[nrOfSeekAds] = nr;
2146             zList[nrOfSeekAds] = 0;
2147             seekAdList[nrOfSeekAds++] = StrSave(buf);
2148             if(plot) PlotSeekAd(nrOfSeekAds-1);
2149         }
2150 }
2151
2152 void
2153 EraseSeekDot(int i)
2154 {
2155     int x = xList[i], y = yList[i], d=squareSize/4, k;
2156     DrawSeekBackground(x-squareSize/8, y-squareSize/8, x+squareSize/8+1, y+squareSize/8+1);
2157     if(x < hMargin+d) DrawSeekAxis(hMargin, y-squareSize/8, hMargin, y+squareSize/8+1);
2158     // now replot every dot that overlapped
2159     for(k=0; k<nrOfSeekAds; k++) if(k != i) {
2160         int xx = xList[k], yy = yList[k];
2161         if(xx <= x+d && xx > x-d && yy <= y+d && yy > y-d)
2162             DrawSeekDot(xx, yy, colorList[k]);
2163     }
2164 }
2165
2166 void
2167 RemoveSeekAd(int nr)
2168 {
2169         int i;
2170         for(i=0; i<nrOfSeekAds; i++) if(seekNrList[i] == nr) {
2171             EraseSeekDot(i);
2172             if(seekAdList[i]) free(seekAdList[i]);
2173             seekAdList[i] = seekAdList[--nrOfSeekAds];
2174             seekNrList[i] = seekNrList[nrOfSeekAds];
2175             ratingList[i] = ratingList[nrOfSeekAds];
2176             colorList[i]  = colorList[nrOfSeekAds];
2177             tcList[i] = tcList[nrOfSeekAds];
2178             xList[i]  = xList[nrOfSeekAds];
2179             yList[i]  = yList[nrOfSeekAds];
2180             zList[i]  = zList[nrOfSeekAds];
2181             seekAdList[nrOfSeekAds] = NULL;
2182             break;
2183         }
2184 }
2185
2186 Boolean
2187 MatchSoughtLine(char *line)
2188 {
2189     char handle[MSG_SIZ], rating[MSG_SIZ], type[MSG_SIZ];
2190     int nr, base, inc, u=0; char dummy;
2191
2192     if(sscanf(line, "%d %s %s %d %d rated %s", &nr, rating, handle, &base, &inc, type) == 6 ||
2193        sscanf(line, "%d %s %s %s %d %d rated %c", &nr, rating, handle, type, &base, &inc, &dummy) == 7 ||
2194        (u=1) &&
2195        (sscanf(line, "%d %s %s %d %d unrated %s", &nr, rating, handle, &base, &inc, type) == 6 ||
2196         sscanf(line, "%d %s %s %s %d %d unrated %c", &nr, rating, handle, type, &base, &inc, &dummy) == 7)  ) {
2197         // match: compact and save the line
2198         AddAd(handle, rating, base, inc, u ? 'u' : 'r', type, nr, FALSE);
2199         return TRUE;
2200     }
2201     return FALSE;
2202 }
2203
2204 int
2205 DrawSeekGraph()
2206 {
2207     if(!seekGraphUp) return FALSE;
2208     int i;
2209     h = BOARD_HEIGHT * (squareSize + lineGap) + lineGap;
2210     w = BOARD_WIDTH  * (squareSize + lineGap) + lineGap;
2211
2212     DrawSeekBackground(0, 0, w, h);
2213     DrawSeekAxis(hMargin, h-1-vMargin, w-5, h-1-vMargin);
2214     DrawSeekAxis(hMargin, h-1-vMargin, hMargin, 5);
2215     for(i=0; i<4000; i+= 100) if(i>=minRating && i<maxRating) {
2216         int yy =((double)i - minRating)/(maxRating - minRating)*(h-vMargin-squareSize/8-1) + vMargin;
2217         yy = h-1-yy;
2218         DrawSeekAxis(hMargin+5*(i%500==0), yy, hMargin-5, yy); // rating ticks
2219         if(i%500 == 0) {
2220             char buf[MSG_SIZ];
2221             sprintf(buf, "%d", i);
2222             DrawSeekText(buf, hMargin+squareSize/8+7, yy);
2223         }
2224     }
2225     DrawSeekText("unrated", hMargin+squareSize/8+7, h-1-vMargin-squareSize/4);
2226     for(i=1; i<100; i+=(i<10?1:5)) {
2227         int xx = (w-hMargin-squareSize/8-7)* log((double)i)/log(95.) + hMargin;
2228         DrawSeekAxis(xx, h-1-vMargin, xx, h-6-vMargin-3*(i%10==0)); // TC ticks
2229         if(i<=5 || (i>40 ? i%20 : i%10) == 0) {
2230             char buf[MSG_SIZ];
2231             sprintf(buf, "%d", i);
2232             DrawSeekText(buf, xx-2-3*(i>9), h-1-vMargin/2);
2233         }
2234     }
2235     for(i=0; i<nrOfSeekAds; i++) PlotSeekAd(i);
2236     return TRUE;
2237 }
2238
2239 int SeekGraphClick(ClickType click, int x, int y, int moving)
2240 {
2241     static int lastDown = 0, displayed = 0, lastSecond;
2242     if(!seekGraphUp) { // initiate cration of seek graph by requesting seek-ad list
2243         if(click == Release || moving) return FALSE;
2244         nrOfSeekAds = 0;
2245         soughtPending = TRUE;
2246         SendToICS(ics_prefix);
2247         SendToICS("sought\n"); // should this be "sought all"?
2248     } else { // issue challenge based on clicked ad
2249         int dist = 10000; int i, closest = 0, second = 0;
2250         for(i=0; i<nrOfSeekAds; i++) {
2251             int d = (x-xList[i])*(x-xList[i]) +  (y-yList[i])*(y-yList[i]) + zList[i];
2252             if(d < dist) { dist = d; closest = i; }
2253             second += (d - zList[i] < 120); // count in-range ads
2254             if(click == Press && moving != 1 && zList[i]>0) zList[i] *= 0.8; // age priority
2255         }
2256         if(dist < 120) {
2257             char buf[MSG_SIZ];
2258             second = (second > 1);
2259             if(displayed != closest || second != lastSecond) {
2260                 DisplayMessage(second ? "!" : "", seekAdList[closest]);
2261                 lastSecond = second; displayed = closest;
2262             }
2263             if(click == Press) {
2264                 if(moving == 2) zList[closest] = 100; // right-click; push to back on press
2265                 lastDown = closest;
2266                 return TRUE;
2267             } // on press 'hit', only show info
2268             if(moving == 2) return TRUE; // ignore right up-clicks on dot
2269             sprintf(buf, "play %d\n", seekNrList[closest]);
2270             SendToICS(ics_prefix);
2271             SendToICS(buf);
2272             return TRUE; // let incoming board of started game pop down the graph
2273         } else if(click == Release) { // release 'miss' is ignored
2274             zList[lastDown] = 100; // make future selection of the rejected ad more difficult
2275             if(moving == 2) { // right up-click
2276                 nrOfSeekAds = 0; // refresh graph
2277                 soughtPending = TRUE;
2278                 SendToICS(ics_prefix);
2279                 SendToICS("sought\n"); // should this be "sought all"?
2280             }
2281             return TRUE;
2282         } else if(moving) { if(displayed >= 0) DisplayMessage("", ""); displayed = -1; return TRUE; }
2283         // press miss or release hit 'pop down' seek graph
2284         seekGraphUp = FALSE;
2285         DrawPosition(TRUE, NULL);
2286     }
2287     return TRUE;
2288 }
2289
2290 void
2291 read_from_ics(isr, closure, data, count, error)
2292      InputSourceRef isr;
2293      VOIDSTAR closure;
2294      char *data;
2295      int count;
2296      int error;
2297 {
2298 #define BUF_SIZE (16*1024) /* overflowed at 8K with "inchannel 1" on FICS? */
2299 #define STARTED_NONE 0
2300 #define STARTED_MOVES 1
2301 #define STARTED_BOARD 2
2302 #define STARTED_OBSERVE 3
2303 #define STARTED_HOLDINGS 4
2304 #define STARTED_CHATTER 5
2305 #define STARTED_COMMENT 6
2306 #define STARTED_MOVES_NOHIDE 7
2307
2308     static int started = STARTED_NONE;
2309     static char parse[20000];
2310     static int parse_pos = 0;
2311     static char buf[BUF_SIZE + 1];
2312     static int firstTime = TRUE, intfSet = FALSE;
2313     static ColorClass prevColor = ColorNormal;
2314     static int savingComment = FALSE;
2315     static int cmatch = 0; // continuation sequence match
2316     char *bp;
2317     char str[500];
2318     int i, oldi;
2319     int buf_len;
2320     int next_out;
2321     int tkind;
2322     int backup;    /* [DM] For zippy color lines */
2323     char *p;
2324     char talker[MSG_SIZ]; // [HGM] chat
2325     int channel;
2326
2327     connectionAlive = TRUE; // [HGM] alive: I think, therefore I am...
2328
2329     if (appData.debugMode) {
2330       if (!error) {
2331         fprintf(debugFP, "<ICS: ");
2332         show_bytes(debugFP, data, count);
2333         fprintf(debugFP, "\n");
2334       }
2335     }
2336
2337     if (appData.debugMode) { int f = forwardMostMove;
2338         fprintf(debugFP, "ics input %d, castling = %d %d %d %d %d %d\n", f,
2339                 boards[f][CASTLING][0],boards[f][CASTLING][1],boards[f][CASTLING][2],
2340                 boards[f][CASTLING][3],boards[f][CASTLING][4],boards[f][CASTLING][5]);
2341     }
2342     if (count > 0) {
2343         /* If last read ended with a partial line that we couldn't parse,
2344            prepend it to the new read and try again. */
2345         if (leftover_len > 0) {
2346             for (i=0; i<leftover_len; i++)
2347               buf[i] = buf[leftover_start + i];
2348         }
2349
2350     /* copy new characters into the buffer */
2351     bp = buf + leftover_len;
2352     buf_len=leftover_len;
2353     for (i=0; i<count; i++)
2354     {
2355         // ignore these
2356         if (data[i] == '\r')
2357             continue;
2358
2359         // join lines split by ICS?
2360         if (!appData.noJoin)
2361         {
2362             /*
2363                 Joining just consists of finding matches against the
2364                 continuation sequence, and discarding that sequence
2365                 if found instead of copying it.  So, until a match
2366                 fails, there's nothing to do since it might be the
2367                 complete sequence, and thus, something we don't want
2368                 copied.
2369             */
2370             if (data[i] == cont_seq[cmatch])
2371             {
2372                 cmatch++;
2373                 if (cmatch == strlen(cont_seq))
2374                 {
2375                     cmatch = 0; // complete match.  just reset the counter
2376
2377                     /*
2378                         it's possible for the ICS to not include the space
2379                         at the end of the last word, making our [correct]
2380                         join operation fuse two separate words.  the server
2381                         does this when the space occurs at the width setting.
2382                     */
2383                     if (!buf_len || buf[buf_len-1] != ' ')
2384                     {
2385                         *bp++ = ' ';
2386                         buf_len++;
2387                     }
2388                 }
2389                 continue;
2390             }
2391             else if (cmatch)
2392             {
2393                 /*
2394                     match failed, so we have to copy what matched before
2395                     falling through and copying this character.  In reality,
2396                     this will only ever be just the newline character, but
2397                     it doesn't hurt to be precise.
2398                 */
2399                 strncpy(bp, cont_seq, cmatch);
2400                 bp += cmatch;
2401                 buf_len += cmatch;
2402                 cmatch = 0;
2403             }
2404         }
2405
2406         // copy this char
2407         *bp++ = data[i];
2408         buf_len++;
2409     }
2410
2411         buf[buf_len] = NULLCHAR;
2412 //      next_out = leftover_len; // [HGM] should we set this to 0, and not print it in advance?
2413         next_out = 0;
2414         leftover_start = 0;
2415
2416         i = 0;
2417         while (i < buf_len) {
2418             /* Deal with part of the TELNET option negotiation
2419                protocol.  We refuse to do anything beyond the
2420                defaults, except that we allow the WILL ECHO option,
2421                which ICS uses to turn off password echoing when we are
2422                directly connected to it.  We reject this option
2423                if localLineEditing mode is on (always on in xboard)
2424                and we are talking to port 23, which might be a real
2425                telnet server that will try to keep WILL ECHO on permanently.
2426              */
2427             if (buf_len - i >= 3 && (unsigned char) buf[i] == TN_IAC) {
2428                 static int remoteEchoOption = FALSE; /* telnet ECHO option */
2429                 unsigned char option;
2430                 oldi = i;
2431                 switch ((unsigned char) buf[++i]) {
2432                   case TN_WILL:
2433                     if (appData.debugMode)
2434                       fprintf(debugFP, "\n<WILL ");
2435                     switch (option = (unsigned char) buf[++i]) {
2436                       case TN_ECHO:
2437                         if (appData.debugMode)
2438                           fprintf(debugFP, "ECHO ");
2439                         /* Reply only if this is a change, according
2440                            to the protocol rules. */
2441                         if (remoteEchoOption) break;
2442                         if (appData.localLineEditing &&
2443                             atoi(appData.icsPort) == TN_PORT) {
2444                             TelnetRequest(TN_DONT, TN_ECHO);
2445                         } else {
2446                             EchoOff();
2447                             TelnetRequest(TN_DO, TN_ECHO);
2448                             remoteEchoOption = TRUE;
2449                         }
2450                         break;
2451                       default:
2452                         if (appData.debugMode)
2453                           fprintf(debugFP, "%d ", option);
2454                         /* Whatever this is, we don't want it. */
2455                         TelnetRequest(TN_DONT, option);
2456                         break;
2457                     }
2458                     break;
2459                   case TN_WONT:
2460                     if (appData.debugMode)
2461                       fprintf(debugFP, "\n<WONT ");
2462                     switch (option = (unsigned char) buf[++i]) {
2463                       case TN_ECHO:
2464                         if (appData.debugMode)
2465                           fprintf(debugFP, "ECHO ");
2466                         /* Reply only if this is a change, according
2467                            to the protocol rules. */
2468                         if (!remoteEchoOption) break;
2469                         EchoOn();
2470                         TelnetRequest(TN_DONT, TN_ECHO);
2471                         remoteEchoOption = FALSE;
2472                         break;
2473                       default:
2474                         if (appData.debugMode)
2475                           fprintf(debugFP, "%d ", (unsigned char) option);
2476                         /* Whatever this is, it must already be turned
2477                            off, because we never agree to turn on
2478                            anything non-default, so according to the
2479                            protocol rules, we don't reply. */
2480                         break;
2481                     }
2482                     break;
2483                   case TN_DO:
2484                     if (appData.debugMode)
2485                       fprintf(debugFP, "\n<DO ");
2486                     switch (option = (unsigned char) buf[++i]) {
2487                       default:
2488                         /* Whatever this is, we refuse to do it. */
2489                         if (appData.debugMode)
2490                           fprintf(debugFP, "%d ", option);
2491                         TelnetRequest(TN_WONT, option);
2492                         break;
2493                     }
2494                     break;
2495                   case TN_DONT:
2496                     if (appData.debugMode)
2497                       fprintf(debugFP, "\n<DONT ");
2498                     switch (option = (unsigned char) buf[++i]) {
2499                       default:
2500                         if (appData.debugMode)
2501                           fprintf(debugFP, "%d ", option);
2502                         /* Whatever this is, we are already not doing
2503                            it, because we never agree to do anything
2504                            non-default, so according to the protocol
2505                            rules, we don't reply. */
2506                         break;
2507                     }
2508                     break;
2509                   case TN_IAC:
2510                     if (appData.debugMode)
2511                       fprintf(debugFP, "\n<IAC ");
2512                     /* Doubled IAC; pass it through */
2513                     i--;
2514                     break;
2515                   default:
2516                     if (appData.debugMode)
2517                       fprintf(debugFP, "\n<%d ", (unsigned char) buf[i]);
2518                     /* Drop all other telnet commands on the floor */
2519                     break;
2520                 }
2521                 if (oldi > next_out)
2522                   SendToPlayer(&buf[next_out], oldi - next_out);
2523                 if (++i > next_out)
2524                   next_out = i;
2525                 continue;
2526             }
2527
2528             /* OK, this at least will *usually* work */
2529             if (!loggedOn && looking_at(buf, &i, "ics%")) {
2530                 loggedOn = TRUE;
2531             }
2532
2533             if (loggedOn && !intfSet) {
2534                 if (ics_type == ICS_ICC) {
2535                   sprintf(str,
2536                           "/set-quietly interface %s\n/set-quietly style 12\n",
2537                           programVersion);
2538                   if(appData.seekGraph && appData.autoRefresh) // [HGM] seekgraph
2539                       strcat(str, "/set-2 51 1\n/set seek 1\n");
2540                 } else if (ics_type == ICS_CHESSNET) {
2541                   sprintf(str, "/style 12\n");
2542                 } else {
2543                   strcpy(str, "alias $ @\n$set interface ");
2544                   strcat(str, programVersion);
2545                   strcat(str, "\n$iset startpos 1\n$iset ms 1\n");
2546                   if(appData.seekGraph && appData.autoRefresh) // [HGM] seekgraph
2547                       strcat(str, "$iset seekremove 1\n$set seek 1\n");
2548 #ifdef WIN32
2549                   strcat(str, "$iset nohighlight 1\n");
2550 #endif
2551                   strcat(str, "$iset lock 1\n$style 12\n");
2552                 }
2553                 SendToICS(str);
2554                 NotifyFrontendLogin();
2555                 intfSet = TRUE;
2556             }
2557
2558             if (started == STARTED_COMMENT) {
2559                 /* Accumulate characters in comment */
2560                 parse[parse_pos++] = buf[i];
2561                 if (buf[i] == '\n') {
2562                     parse[parse_pos] = NULLCHAR;
2563                     if(chattingPartner>=0) {
2564                         char mess[MSG_SIZ];
2565                         sprintf(mess, "%s%s", talker, parse);
2566                         OutputChatMessage(chattingPartner, mess);
2567                         chattingPartner = -1;
2568                         next_out = i+1; // [HGM] suppress printing in ICS window
2569                     } else
2570                     if(!suppressKibitz) // [HGM] kibitz
2571                         AppendComment(forwardMostMove, StripHighlight(parse), TRUE);
2572                     else { // [HGM kibitz: divert memorized engine kibitz to engine-output window
2573                         int nrDigit = 0, nrAlph = 0, j;
2574                         if(parse_pos > MSG_SIZ - 30) // defuse unreasonably long input
2575                         { parse_pos = MSG_SIZ-30; parse[parse_pos - 1] = '\n'; }
2576                         parse[parse_pos] = NULLCHAR;
2577                         // try to be smart: if it does not look like search info, it should go to
2578                         // ICS interaction window after all, not to engine-output window.
2579                         for(j=0; j<parse_pos; j++) { // count letters and digits
2580                             nrDigit += (parse[j] >= '0' && parse[j] <= '9');
2581                             nrAlph  += (parse[j] >= 'a' && parse[j] <= 'z');
2582                             nrAlph  += (parse[j] >= 'A' && parse[j] <= 'Z');
2583                         }
2584                         if(nrAlph < 9*nrDigit) { // if more than 10% digit we assume search info
2585                             int depth=0; float score;
2586                             if(sscanf(parse, "!!! %f/%d", &score, &depth) == 2 && depth>0) {
2587                                 // [HGM] kibitz: save kibitzed opponent info for PGN and eval graph
2588                                 pvInfoList[forwardMostMove-1].depth = depth;
2589                                 pvInfoList[forwardMostMove-1].score = 100*score;
2590                             }
2591                             OutputKibitz(suppressKibitz, parse);
2592                         } else {
2593                             char tmp[MSG_SIZ];
2594                             sprintf(tmp, _("your opponent kibitzes: %s"), parse);
2595                             SendToPlayer(tmp, strlen(tmp));
2596                         }
2597                         next_out = i+1; // [HGM] suppress printing in ICS window
2598                     }
2599                     started = STARTED_NONE;
2600                 } else {
2601                     /* Don't match patterns against characters in comment */
2602                     i++;
2603                     continue;
2604                 }
2605             }
2606             if (started == STARTED_CHATTER) {
2607                 if (buf[i] != '\n') {
2608                     /* Don't match patterns against characters in chatter */
2609                     i++;
2610                     continue;
2611                 }
2612                 started = STARTED_NONE;
2613                 if(suppressKibitz) next_out = i+1;
2614             }
2615
2616             /* Kludge to deal with rcmd protocol */
2617             if (firstTime && looking_at(buf, &i, "\001*")) {
2618                 DisplayFatalError(&buf[1], 0, 1);
2619                 continue;
2620             } else {
2621                 firstTime = FALSE;
2622             }
2623
2624             if (!loggedOn && looking_at(buf, &i, "chessclub.com")) {
2625                 ics_type = ICS_ICC;
2626                 ics_prefix = "/";
2627                 if (appData.debugMode)
2628                   fprintf(debugFP, "ics_type %d\n", ics_type);
2629                 continue;
2630             }
2631             if (!loggedOn && looking_at(buf, &i, "freechess.org")) {
2632                 ics_type = ICS_FICS;
2633                 ics_prefix = "$";
2634                 if (appData.debugMode)
2635                   fprintf(debugFP, "ics_type %d\n", ics_type);
2636                 continue;
2637             }
2638             if (!loggedOn && looking_at(buf, &i, "chess.net")) {
2639                 ics_type = ICS_CHESSNET;
2640                 ics_prefix = "/";
2641                 if (appData.debugMode)
2642                   fprintf(debugFP, "ics_type %d\n", ics_type);
2643                 continue;
2644             }
2645
2646             if (!loggedOn &&
2647                 (looking_at(buf, &i, "\"*\" is *a registered name") ||
2648                  looking_at(buf, &i, "Logging you in as \"*\"") ||
2649                  looking_at(buf, &i, "will be \"*\""))) {
2650               strcpy(ics_handle, star_match[0]);
2651               continue;
2652             }
2653
2654             if (loggedOn && !have_set_title && ics_handle[0] != NULLCHAR) {
2655               char buf[MSG_SIZ];
2656               snprintf(buf, sizeof(buf), "%s@%s", ics_handle, appData.icsHost);
2657               DisplayIcsInteractionTitle(buf);
2658               have_set_title = TRUE;
2659             }
2660
2661             /* skip finger notes */
2662             if (started == STARTED_NONE &&
2663                 ((buf[i] == ' ' && isdigit(buf[i+1])) ||
2664                  (buf[i] == '1' && buf[i+1] == '0')) &&
2665                 buf[i+2] == ':' && buf[i+3] == ' ') {
2666               started = STARTED_CHATTER;
2667               i += 3;
2668               continue;
2669             }
2670
2671             oldi = i;
2672             // [HGM] seekgraph: recognize sought lines and end-of-sought message
2673             if(appData.seekGraph) {
2674                 if(soughtPending && MatchSoughtLine(buf+i)) {
2675                     i = strstr(buf+i, "rated") - buf;
2676                     if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
2677                     next_out = leftover_start = i;
2678                     started = STARTED_CHATTER;
2679                     suppressKibitz = TRUE;
2680                     continue;
2681                 }
2682                 if((gameMode == IcsIdle || gameMode == BeginningOfGame)
2683                         && looking_at(buf, &i, "* ads displayed")) {
2684                     soughtPending = FALSE;
2685                     seekGraphUp = TRUE;
2686                     DrawSeekGraph();
2687                     continue;
2688                 }
2689                 if(appData.autoRefresh) {
2690                     if(looking_at(buf, &i, "* (*) seeking * * * * *\"play *\" to respond)\n")) {
2691                         int s = (ics_type == ICS_ICC); // ICC format differs
2692                         if(seekGraphUp)
2693                         AddAd(star_match[0], star_match[1], atoi(star_match[2+s]), atoi(star_match[3+s]),
2694                               star_match[4+s][0], star_match[5-3*s], atoi(star_match[7]), TRUE);
2695                         looking_at(buf, &i, "*% "); // eat prompt
2696                         if(oldi > 0 && buf[oldi-1] == '\n') oldi--; // suppress preceding LF, if any
2697                         if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
2698                         next_out = i; // suppress
2699                         continue;
2700                     }
2701                     if(looking_at(buf, &i, "\nAds removed: *\n") || looking_at(buf, &i, "\031(51 * *\031)")) {
2702                         char *p = star_match[0];
2703                         while(*p) {
2704                             if(seekGraphUp) RemoveSeekAd(atoi(p));
2705                             while(*p && *p++ != ' '); // next
2706                         }
2707                         looking_at(buf, &i, "*% "); // eat prompt
2708                         if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
2709                         next_out = i;
2710                         continue;
2711                     }
2712                 }
2713             }
2714
2715             /* skip formula vars */
2716             if (started == STARTED_NONE &&
2717                 buf[i] == 'f' && isdigit(buf[i+1]) && buf[i+2] == ':') {
2718               started = STARTED_CHATTER;
2719               i += 3;
2720               continue;
2721             }
2722
2723             // [HGM] kibitz: try to recognize opponent engine-score kibitzes, to divert them to engine-output window
2724             if (appData.autoKibitz && started == STARTED_NONE &&
2725                 !appData.icsEngineAnalyze &&                     // [HGM] [DM] ICS analyze
2726                 (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack || gameMode == IcsObserving)) {
2727                 if((looking_at(buf, &i, "* kibitzes: ") || looking_at(buf, &i, "* whispers: ")) &&
2728                    (StrStr(star_match[0], gameInfo.white) == star_match[0] ||
2729                     StrStr(star_match[0], gameInfo.black) == star_match[0]   )) { // kibitz of self or opponent
2730                         suppressKibitz = TRUE;
2731                         if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
2732                         next_out = i;
2733                         if((StrStr(star_match[0], gameInfo.white) == star_match[0]
2734                                 && (gameMode == IcsPlayingWhite)) ||
2735                            (StrStr(star_match[0], gameInfo.black) == star_match[0]
2736                                 && (gameMode == IcsPlayingBlack))   ) // opponent kibitz
2737                             started = STARTED_CHATTER; // own kibitz we simply discard
2738                         else {
2739                             started = STARTED_COMMENT; // make sure it will be collected in parse[]
2740                             parse_pos = 0; parse[0] = NULLCHAR;
2741                             savingComment = TRUE;
2742                             suppressKibitz = gameMode != IcsObserving ? 2 :
2743                                 (StrStr(star_match[0], gameInfo.white) == NULL) + 1;
2744                         }
2745                         continue;
2746                 } else
2747                 if((looking_at(buf, &i, "\nkibitzed to *\n") || looking_at(buf, &i, "kibitzed to *\n") ||
2748                     looking_at(buf, &i, "\n(kibitzed to *\n") || looking_at(buf, &i, "(kibitzed to *\n"))
2749                          && atoi(star_match[0])) {
2750                     // suppress the acknowledgements of our own autoKibitz
2751                     char *p;
2752                     if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
2753                     if(p = strchr(star_match[0], ' ')) p[1] = NULLCHAR; // clip off "players)" on FICS
2754                     SendToPlayer(star_match[0], strlen(star_match[0]));
2755                     if(looking_at(buf, &i, "*% ")) // eat prompt
2756                         suppressKibitz = FALSE;
2757                     next_out = i;
2758                     continue;
2759                 }
2760             } // [HGM] kibitz: end of patch
2761
2762             // [HGM] chat: intercept tells by users for which we have an open chat window
2763             channel = -1;
2764             if(started == STARTED_NONE && (looking_at(buf, &i, "* tells you:") || looking_at(buf, &i, "* says:") ||
2765                                            looking_at(buf, &i, "* whispers:") ||
2766                                            looking_at(buf, &i, "* kibitzes:") ||
2767                                            looking_at(buf, &i, "* shouts:") ||
2768                                            looking_at(buf, &i, "* c-shouts:") ||
2769                                            looking_at(buf, &i, "--> * ") ||
2770                                            looking_at(buf, &i, "*(*):") && (sscanf(star_match[1], "%d", &channel),1) ||
2771                                            looking_at(buf, &i, "*(*)(*):") && (sscanf(star_match[2], "%d", &channel),1) ||
2772                                            looking_at(buf, &i, "*(*)(*)(*):") && (sscanf(star_match[3], "%d", &channel),1) ||
2773                                            looking_at(buf, &i, "*(*)(*)(*)(*):") && sscanf(star_match[4], "%d", &channel) == 1 )) {
2774                 int p;
2775                 sscanf(star_match[0], "%[^(]", talker+1); // strip (C) or (U) off ICS handle
2776                 chattingPartner = -1;
2777
2778                 if(channel >= 0) // channel broadcast; look if there is a chatbox for this channel
2779                 for(p=0; p<MAX_CHAT; p++) {
2780                     if(channel == atoi(chatPartner[p])) {
2781                     talker[0] = '['; strcat(talker, "] ");
2782                     Colorize(channel == 1 ? ColorChannel1 : ColorChannel, FALSE);
2783                     chattingPartner = p; break;
2784                     }
2785                 } else
2786                 if(buf[i-3] == 'e') // kibitz; look if there is a KIBITZ chatbox
2787                 for(p=0; p<MAX_CHAT; p++) {
2788                     if(!strcmp("kibitzes", chatPartner[p])) {
2789                         talker[0] = '['; strcat(talker, "] ");
2790                         chattingPartner = p; break;
2791                     }
2792                 } else
2793                 if(buf[i-3] == 'r') // whisper; look if there is a WHISPER chatbox
2794                 for(p=0; p<MAX_CHAT; p++) {
2795                     if(!strcmp("whispers", chatPartner[p])) {
2796                         talker[0] = '['; strcat(talker, "] ");
2797                         chattingPartner = p; break;
2798                     }
2799                 } else
2800                 if(buf[i-3] == 't' || buf[oldi+2] == '>') {// shout, c-shout or it; look if there is a 'shouts' chatbox
2801                   if(buf[i-8] == '-' && buf[i-3] == 't')
2802                   for(p=0; p<MAX_CHAT; p++) { // c-shout; check if dedicatesd c-shout box exists
2803                     if(!strcmp("c-shouts", chatPartner[p])) {
2804                         talker[0] = '('; strcat(talker, ") "); Colorize(ColorSShout, FALSE);
2805                         chattingPartner = p; break;
2806                     }
2807                   }
2808                   if(chattingPartner < 0)
2809                   for(p=0; p<MAX_CHAT; p++) {
2810                     if(!strcmp("shouts", chatPartner[p])) {
2811                         if(buf[oldi+2] == '>') { talker[0] = '<'; strcat(talker, "> "); Colorize(ColorShout, FALSE); }
2812                         else if(buf[i-8] == '-') { talker[0] = '('; strcat(talker, ") "); Colorize(ColorSShout, FALSE); }
2813                         else { talker[0] = '['; strcat(talker, "] "); Colorize(ColorShout, FALSE); }
2814                         chattingPartner = p; break;
2815                     }
2816                   }
2817                 }
2818                 if(chattingPartner<0) // if not, look if there is a chatbox for this indivdual
2819                 for(p=0; p<MAX_CHAT; p++) if(!StrCaseCmp(talker+1, chatPartner[p])) {
2820                     talker[0] = 0; Colorize(ColorTell, FALSE);
2821                     chattingPartner = p; break;
2822                 }
2823                 if(chattingPartner<0) i = oldi; else {
2824                     Colorize(curColor, TRUE); // undo the bogus colorations we just made to trigger the souds
2825                     if(oldi > 0 && buf[oldi-1] == '\n') oldi--;
2826                     if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
2827                     started = STARTED_COMMENT;
2828                     parse_pos = 0; parse[0] = NULLCHAR;
2829                     savingComment = 3 + chattingPartner; // counts as TRUE
2830                     suppressKibitz = TRUE;
2831                     continue;
2832                 }
2833             } // [HGM] chat: end of patch
2834
2835             if (appData.zippyTalk || appData.zippyPlay) {
2836                 /* [DM] Backup address for color zippy lines */
2837                 backup = i;
2838 #if ZIPPY
2839        #ifdef WIN32
2840                if (loggedOn == TRUE)
2841                        if (ZippyControl(buf, &backup) || ZippyConverse(buf, &backup) ||
2842                           (appData.zippyPlay && ZippyMatch(buf, &backup)));
2843        #else
2844                 if (ZippyControl(buf, &i) ||
2845                     ZippyConverse(buf, &i) ||
2846                     (appData.zippyPlay && ZippyMatch(buf, &i))) {
2847                       loggedOn = TRUE;
2848                       if (!appData.colorize) continue;
2849                 }
2850        #endif
2851 #endif
2852             } // [DM] 'else { ' deleted
2853                 if (
2854                     /* Regular tells and says */
2855                     (tkind = 1, looking_at(buf, &i, "* tells you: ")) ||
2856                     looking_at(buf, &i, "* (your partner) tells you: ") ||
2857                     looking_at(buf, &i, "* says: ") ||
2858                     /* Don't color "message" or "messages" output */
2859                     (tkind = 5, looking_at(buf, &i, "*. * (*:*): ")) ||
2860                     looking_at(buf, &i, "*. * at *:*: ") ||
2861                     looking_at(buf, &i, "--* (*:*): ") ||
2862                     /* Message notifications (same color as tells) */
2863                     looking_at(buf, &i, "* has left a message ") ||
2864                     looking_at(buf, &i, "* just sent you a message:\n") ||
2865                     /* Whispers and kibitzes */
2866                     (tkind = 2, looking_at(buf, &i, "* whispers: ")) ||
2867                     looking_at(buf, &i, "* kibitzes: ") ||
2868                     /* Channel tells */
2869                     (tkind = 3, looking_at(buf, &i, "*(*: "))) {
2870
2871                   if (tkind == 1 && strchr(star_match[0], ':')) {
2872                       /* Avoid "tells you:" spoofs in channels */
2873                      tkind = 3;
2874                   }
2875                   if (star_match[0][0] == NULLCHAR ||
2876                       strchr(star_match[0], ' ') ||
2877                       (tkind == 3 && strchr(star_match[1], ' '))) {
2878                     /* Reject bogus matches */
2879                     i = oldi;
2880                   } else {
2881                     if (appData.colorize) {
2882                       if (oldi > next_out) {
2883                         SendToPlayer(&buf[next_out], oldi - next_out);
2884                         next_out = oldi;
2885                       }
2886                       switch (tkind) {
2887                       case 1:
2888                         Colorize(ColorTell, FALSE);
2889                         curColor = ColorTell;
2890                         break;
2891                       case 2:
2892                         Colorize(ColorKibitz, FALSE);
2893                         curColor = ColorKibitz;
2894                         break;
2895                       case 3:
2896                         p = strrchr(star_match[1], '(');
2897                         if (p == NULL) {
2898                           p = star_match[1];
2899                         } else {
2900                           p++;
2901                         }
2902                         if (atoi(p) == 1) {
2903                           Colorize(ColorChannel1, FALSE);
2904                           curColor = ColorChannel1;
2905                         } else {
2906                           Colorize(ColorChannel, FALSE);
2907                           curColor = ColorChannel;
2908                         }
2909                         break;
2910                       case 5:
2911                         curColor = ColorNormal;
2912                         break;
2913                       }
2914                     }
2915                     if (started == STARTED_NONE && appData.autoComment &&
2916                         (gameMode == IcsObserving ||
2917                          gameMode == IcsPlayingWhite ||
2918                          gameMode == IcsPlayingBlack)) {
2919                       parse_pos = i - oldi;
2920                       memcpy(parse, &buf[oldi], parse_pos);
2921                       parse[parse_pos] = NULLCHAR;
2922                       started = STARTED_COMMENT;
2923                       savingComment = TRUE;
2924                     } else {
2925                       started = STARTED_CHATTER;
2926                       savingComment = FALSE;
2927                     }
2928                     loggedOn = TRUE;
2929                     continue;
2930                   }
2931                 }
2932
2933                 if (looking_at(buf, &i, "* s-shouts: ") ||
2934                     looking_at(buf, &i, "* c-shouts: ")) {
2935                     if (appData.colorize) {
2936                         if (oldi > next_out) {
2937                             SendToPlayer(&buf[next_out], oldi - next_out);
2938                             next_out = oldi;
2939                         }
2940                         Colorize(ColorSShout, FALSE);
2941                         curColor = ColorSShout;
2942                     }
2943                     loggedOn = TRUE;
2944                     started = STARTED_CHATTER;
2945                     continue;
2946                 }
2947
2948                 if (looking_at(buf, &i, "--->")) {
2949                     loggedOn = TRUE;
2950                     continue;
2951                 }
2952
2953                 if (looking_at(buf, &i, "* shouts: ") ||
2954                     looking_at(buf, &i, "--> ")) {
2955                     if (appData.colorize) {
2956                         if (oldi > next_out) {
2957                             SendToPlayer(&buf[next_out], oldi - next_out);
2958                             next_out = oldi;
2959                         }
2960                         Colorize(ColorShout, FALSE);
2961                         curColor = ColorShout;
2962                     }
2963                     loggedOn = TRUE;
2964                     started = STARTED_CHATTER;
2965                     continue;
2966                 }
2967
2968                 if (looking_at( buf, &i, "Challenge:")) {
2969                     if (appData.colorize) {
2970                         if (oldi > next_out) {
2971                             SendToPlayer(&buf[next_out], oldi - next_out);
2972                             next_out = oldi;
2973                         }
2974                         Colorize(ColorChallenge, FALSE);
2975                         curColor = ColorChallenge;
2976                     }
2977                     loggedOn = TRUE;
2978                     continue;
2979                 }
2980
2981                 if (looking_at(buf, &i, "* offers you") ||
2982                     looking_at(buf, &i, "* offers to be") ||
2983                     looking_at(buf, &i, "* would like to") ||
2984                     looking_at(buf, &i, "* requests to") ||
2985                     looking_at(buf, &i, "Your opponent offers") ||
2986                     looking_at(buf, &i, "Your opponent requests")) {
2987
2988                     if (appData.colorize) {
2989                         if (oldi > next_out) {
2990                             SendToPlayer(&buf[next_out], oldi - next_out);
2991                             next_out = oldi;
2992                         }
2993                         Colorize(ColorRequest, FALSE);
2994                         curColor = ColorRequest;
2995                     }
2996                     continue;
2997                 }
2998
2999                 if (looking_at(buf, &i, "* (*) seeking")) {
3000                     if (appData.colorize) {
3001                         if (oldi > next_out) {
3002                             SendToPlayer(&buf[next_out], oldi - next_out);
3003                             next_out = oldi;
3004                         }
3005                         Colorize(ColorSeek, FALSE);
3006                         curColor = ColorSeek;
3007                     }
3008                     continue;
3009             }
3010
3011             if (looking_at(buf, &i, "\\   ")) {
3012                 if (prevColor != ColorNormal) {
3013                     if (oldi > next_out) {
3014                         SendToPlayer(&buf[next_out], oldi - next_out);
3015                         next_out = oldi;
3016                     }
3017                     Colorize(prevColor, TRUE);
3018                     curColor = prevColor;
3019                 }
3020                 if (savingComment) {
3021                     parse_pos = i - oldi;
3022                     memcpy(parse, &buf[oldi], parse_pos);
3023                     parse[parse_pos] = NULLCHAR;
3024                     started = STARTED_COMMENT;
3025                     if(savingComment >= 3) // [HGM] chat: continuation of line for chat box
3026                         chattingPartner = savingComment - 3; // kludge to remember the box
3027                 } else {
3028                     started = STARTED_CHATTER;
3029                 }
3030                 continue;
3031             }
3032
3033             if (looking_at(buf, &i, "Black Strength :") ||
3034                 looking_at(buf, &i, "<<< style 10 board >>>") ||
3035                 looking_at(buf, &i, "<10>") ||
3036                 looking_at(buf, &i, "#@#")) {
3037                 /* Wrong board style */
3038                 loggedOn = TRUE;
3039                 SendToICS(ics_prefix);
3040                 SendToICS("set style 12\n");
3041                 SendToICS(ics_prefix);
3042                 SendToICS("refresh\n");
3043                 continue;
3044             }
3045
3046             if (!have_sent_ICS_logon && looking_at(buf, &i, "login:")) {
3047                 ICSInitScript();
3048                 have_sent_ICS_logon = 1;
3049                 continue;
3050             }
3051
3052             if (ics_getting_history != H_GETTING_MOVES /*smpos kludge*/ &&
3053                 (looking_at(buf, &i, "\n<12> ") ||
3054                  looking_at(buf, &i, "<12> "))) {
3055                 loggedOn = TRUE;
3056                 if (oldi > next_out) {
3057                     SendToPlayer(&buf[next_out], oldi - next_out);
3058                 }
3059                 next_out = i;
3060                 started = STARTED_BOARD;
3061                 parse_pos = 0;
3062                 continue;
3063             }
3064
3065             if ((started == STARTED_NONE && looking_at(buf, &i, "\n<b1> ")) ||
3066                 looking_at(buf, &i, "<b1> ")) {
3067                 if (oldi > next_out) {
3068                     SendToPlayer(&buf[next_out], oldi - next_out);
3069                 }
3070                 next_out = i;
3071                 started = STARTED_HOLDINGS;
3072                 parse_pos = 0;
3073                 continue;
3074             }
3075
3076             if (looking_at(buf, &i, "* *vs. * *--- *")) {
3077                 loggedOn = TRUE;
3078                 /* Header for a move list -- first line */
3079
3080                 switch (ics_getting_history) {
3081                   case H_FALSE:
3082                     switch (gameMode) {
3083                       case IcsIdle:
3084                       case BeginningOfGame:
3085                         /* User typed "moves" or "oldmoves" while we
3086                            were idle.  Pretend we asked for these
3087                            moves and soak them up so user can step
3088                            through them and/or save them.
3089                            */
3090                         Reset(FALSE, TRUE);
3091                         gameMode = IcsObserving;
3092                         ModeHighlight();
3093                         ics_gamenum = -1;
3094                         ics_getting_history = H_GOT_UNREQ_HEADER;
3095                         break;
3096                       case EditGame: /*?*/
3097                       case EditPosition: /*?*/
3098                         /* Should above feature work in these modes too? */
3099                         /* For now it doesn't */
3100                         ics_getting_history = H_GOT_UNWANTED_HEADER;
3101                         break;
3102                       default:
3103                         ics_getting_history = H_GOT_UNWANTED_HEADER;
3104                         break;
3105                     }
3106                     break;
3107                   case H_REQUESTED:
3108                     /* Is this the right one? */
3109                     if (gameInfo.white && gameInfo.black &&
3110                         strcmp(gameInfo.white, star_match[0]) == 0 &&
3111                         strcmp(gameInfo.black, star_match[2]) == 0) {
3112                         /* All is well */
3113                         ics_getting_history = H_GOT_REQ_HEADER;
3114                     }
3115                     break;
3116                   case H_GOT_REQ_HEADER:
3117                   case H_GOT_UNREQ_HEADER:
3118                   case H_GOT_UNWANTED_HEADER:
3119                   case H_GETTING_MOVES:
3120                     /* Should not happen */
3121                     DisplayError(_("Error gathering move list: two headers"), 0);
3122                     ics_getting_history = H_FALSE;
3123                     break;
3124                 }
3125
3126                 /* Save player ratings into gameInfo if needed */
3127                 if ((ics_getting_history == H_GOT_REQ_HEADER ||
3128                      ics_getting_history == H_GOT_UNREQ_HEADER) &&
3129                     (gameInfo.whiteRating == -1 ||
3130                      gameInfo.blackRating == -1)) {
3131
3132                     gameInfo.whiteRating = string_to_rating(star_match[1]);
3133                     gameInfo.blackRating = string_to_rating(star_match[3]);
3134                     if (appData.debugMode)
3135                       fprintf(debugFP, _("Ratings from header: W %d, B %d\n"),
3136                               gameInfo.whiteRating, gameInfo.blackRating);
3137                 }
3138                 continue;
3139             }
3140
3141             if (looking_at(buf, &i,
3142               "* * match, initial time: * minute*, increment: * second")) {
3143                 /* Header for a move list -- second line */
3144                 /* Initial board will follow if this is a wild game */
3145                 if (gameInfo.event != NULL) free(gameInfo.event);
3146                 sprintf(str, "ICS %s %s match", star_match[0], star_match[1]);
3147                 gameInfo.event = StrSave(str);
3148                 /* [HGM] we switched variant. Translate boards if needed. */
3149                 VariantSwitch(boards[currentMove], StringToVariant(gameInfo.event));
3150                 continue;
3151             }
3152
3153             if (looking_at(buf, &i, "Move  ")) {
3154                 /* Beginning of a move list */
3155                 switch (ics_getting_history) {
3156                   case H_FALSE:
3157                     /* Normally should not happen */
3158                     /* Maybe user hit reset while we were parsing */
3159                     break;
3160                   case H_REQUESTED:
3161                     /* Happens if we are ignoring a move list that is not
3162                      * the one we just requested.  Common if the user
3163                      * tries to observe two games without turning off
3164                      * getMoveList */
3165                     break;
3166                   case H_GETTING_MOVES:
3167                     /* Should not happen */
3168                     DisplayError(_("Error gathering move list: nested"), 0);
3169                     ics_getting_history = H_FALSE;
3170                     break;
3171                   case H_GOT_REQ_HEADER:
3172                     ics_getting_history = H_GETTING_MOVES;
3173                     started = STARTED_MOVES;
3174                     parse_pos = 0;
3175                     if (oldi > next_out) {
3176                         SendToPlayer(&buf[next_out], oldi - next_out);
3177                     }
3178                     break;
3179                   case H_GOT_UNREQ_HEADER:
3180                     ics_getting_history = H_GETTING_MOVES;
3181                     started = STARTED_MOVES_NOHIDE;
3182                     parse_pos = 0;
3183                     break;
3184                   case H_GOT_UNWANTED_HEADER:
3185                     ics_getting_history = H_FALSE;
3186                     break;
3187                 }
3188                 continue;
3189             }
3190
3191             if (looking_at(buf, &i, "% ") ||
3192                 ((started == STARTED_MOVES || started == STARTED_MOVES_NOHIDE)
3193                  && looking_at(buf, &i, "}*"))) { char *bookHit = NULL; // [HGM] book
3194                 if(ics_type == ICS_ICC && soughtPending) { // [HGM] seekgraph: on ICC sought-list has no termination line
3195                     soughtPending = FALSE;
3196                     seekGraphUp = TRUE;
3197                     DrawSeekGraph();
3198                 }
3199                 if(suppressKibitz) next_out = i;
3200                 savingComment = FALSE;
3201                 suppressKibitz = 0;
3202                 switch (started) {
3203                   case STARTED_MOVES:
3204                   case STARTED_MOVES_NOHIDE:
3205                     memcpy(&parse[parse_pos], &buf[oldi], i - oldi);
3206                     parse[parse_pos + i - oldi] = NULLCHAR;
3207                     ParseGameHistory(parse);
3208 #if ZIPPY
3209                     if (appData.zippyPlay && first.initDone) {
3210                         FeedMovesToProgram(&first, forwardMostMove);
3211                         if (gameMode == IcsPlayingWhite) {
3212                             if (WhiteOnMove(forwardMostMove)) {
3213                                 if (first.sendTime) {
3214                                   if (first.useColors) {
3215                                     SendToProgram("black\n", &first);
3216                                   }
3217                                   SendTimeRemaining(&first, TRUE);
3218                                 }
3219                                 if (first.useColors) {
3220                                   SendToProgram("white\n", &first); // [HGM] book: made sending of "go\n" book dependent
3221                                 }
3222                                 bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: probe book for initial pos
3223                                 first.maybeThinking = TRUE;
3224                             } else {
3225                                 if (first.usePlayother) {
3226                                   if (first.sendTime) {
3227                                     SendTimeRemaining(&first, TRUE);
3228                                   }
3229                                   SendToProgram("playother\n", &first);
3230                                   firstMove = FALSE;
3231                                 } else {
3232                                   firstMove = TRUE;
3233                                 }
3234                             }
3235                         } else if (gameMode == IcsPlayingBlack) {
3236                             if (!WhiteOnMove(forwardMostMove)) {
3237                                 if (first.sendTime) {
3238                                   if (first.useColors) {
3239                                     SendToProgram("white\n", &first);
3240                                   }
3241                                   SendTimeRemaining(&first, FALSE);
3242                                 }
3243                                 if (first.useColors) {
3244                                   SendToProgram("black\n", &first);
3245                                 }
3246                                 bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE);
3247                                 first.maybeThinking = TRUE;
3248                             } else {
3249                                 if (first.usePlayother) {
3250                                   if (first.sendTime) {
3251                                     SendTimeRemaining(&first, FALSE);
3252                                   }
3253                                   SendToProgram("playother\n", &first);
3254                                   firstMove = FALSE;
3255                                 } else {
3256                                   firstMove = TRUE;
3257                                 }
3258                             }
3259                         }
3260                     }
3261 #endif
3262                     if (gameMode == IcsObserving && ics_gamenum == -1) {
3263                         /* Moves came from oldmoves or moves command
3264                            while we weren't doing anything else.
3265                            */
3266                         currentMove = forwardMostMove;
3267                         ClearHighlights();/*!!could figure this out*/
3268                         flipView = appData.flipView;
3269                         DrawPosition(TRUE, boards[currentMove]);
3270                         DisplayBothClocks();
3271                         sprintf(str, "%s vs. %s",
3272                                 gameInfo.white, gameInfo.black);
3273                         DisplayTitle(str);
3274                         gameMode = IcsIdle;
3275                     } else {
3276                         /* Moves were history of an active game */
3277                         if (gameInfo.resultDetails != NULL) {
3278                             free(gameInfo.resultDetails);
3279                             gameInfo.resultDetails = NULL;
3280                         }
3281                     }
3282                     HistorySet(parseList, backwardMostMove,
3283                                forwardMostMove, currentMove-1);
3284                     DisplayMove(currentMove - 1);
3285                     if (started == STARTED_MOVES) next_out = i;
3286                     started = STARTED_NONE;
3287                     ics_getting_history = H_FALSE;
3288                     break;
3289
3290                   case STARTED_OBSERVE:
3291                     started = STARTED_NONE;
3292                     SendToICS(ics_prefix);
3293                     SendToICS("refresh\n");
3294                     break;
3295
3296                   default:
3297                     break;
3298                 }
3299                 if(bookHit) { // [HGM] book: simulate book reply
3300                     static char bookMove[MSG_SIZ]; // a bit generous?
3301
3302                     programStats.nodes = programStats.depth = programStats.time =
3303                     programStats.score = programStats.got_only_move = 0;
3304                     sprintf(programStats.movelist, "%s (xbook)", bookHit);
3305
3306                     strcpy(bookMove, "move ");
3307                     strcat(bookMove, bookHit);
3308                     HandleMachineMove(bookMove, &first);
3309                 }
3310                 continue;
3311             }
3312
3313             if ((started == STARTED_MOVES || started == STARTED_BOARD ||
3314                  started == STARTED_HOLDINGS ||
3315                  started == STARTED_MOVES_NOHIDE) && i >= leftover_len) {
3316                 /* Accumulate characters in move list or board */
3317                 parse[parse_pos++] = buf[i];
3318             }
3319
3320             /* Start of game messages.  Mostly we detect start of game
3321                when the first board image arrives.  On some versions
3322                of the ICS, though, we need to do a "refresh" after starting
3323                to observe in order to get the current board right away. */
3324             if (looking_at(buf, &i, "Adding game * to observation list")) {
3325                 started = STARTED_OBSERVE;
3326                 continue;
3327             }
3328
3329             /* Handle auto-observe */
3330             if (appData.autoObserve &&
3331                 (gameMode == IcsIdle || gameMode == BeginningOfGame) &&
3332                 looking_at(buf, &i, "Game notification: * (*) vs. * (*)")) {
3333                 char *player;
3334                 /* Choose the player that was highlighted, if any. */
3335                 if (star_match[0][0] == '\033' ||
3336                     star_match[1][0] != '\033') {
3337                     player = star_match[0];
3338                 } else {
3339                     player = star_match[2];
3340                 }
3341                 sprintf(str, "%sobserve %s\n",
3342                         ics_prefix, StripHighlightAndTitle(player));
3343                 SendToICS(str);
3344
3345                 /* Save ratings from notify string */
3346                 strcpy(player1Name, star_match[0]);
3347                 player1Rating = string_to_rating(star_match[1]);
3348                 strcpy(player2Name, star_match[2]);
3349                 player2Rating = string_to_rating(star_match[3]);
3350
3351                 if (appData.debugMode)
3352                   fprintf(debugFP,
3353                           "Ratings from 'Game notification:' %s %d, %s %d\n",
3354                           player1Name, player1Rating,
3355                           player2Name, player2Rating);
3356
3357                 continue;
3358             }
3359
3360             /* Deal with automatic examine mode after a game,
3361                and with IcsObserving -> IcsExamining transition */
3362             if (looking_at(buf, &i, "Entering examine mode for game *") ||
3363                 looking_at(buf, &i, "has made you an examiner of game *")) {
3364
3365                 int gamenum = atoi(star_match[0]);
3366                 if ((gameMode == IcsIdle || gameMode == IcsObserving) &&
3367                     gamenum == ics_gamenum) {
3368                     /* We were already playing or observing this game;
3369                        no need to refetch history */
3370                     gameMode = IcsExamining;
3371                     if (pausing) {
3372                         pauseExamForwardMostMove = forwardMostMove;
3373                     } else if (currentMove < forwardMostMove) {
3374                         ForwardInner(forwardMostMove);
3375                     }
3376                 } else {
3377                     /* I don't think this case really can happen */
3378                     SendToICS(ics_prefix);
3379                     SendToICS("refresh\n");
3380                 }
3381                 continue;
3382             }
3383
3384             /* Error messages */
3385 //          if (ics_user_moved) {
3386             if (1) { // [HGM] old way ignored error after move type in; ics_user_moved is not set then!
3387                 if (looking_at(buf, &i, "Illegal move") ||
3388                     looking_at(buf, &i, "Not a legal move") ||
3389                     looking_at(buf, &i, "Your king is in check") ||
3390                     looking_at(buf, &i, "It isn't your turn") ||
3391                     looking_at(buf, &i, "It is not your move")) {
3392                     /* Illegal move */
3393                     if (ics_user_moved && forwardMostMove > backwardMostMove) { // only backup if we already moved
3394                         currentMove = forwardMostMove-1;
3395                         DisplayMove(currentMove - 1); /* before DMError */
3396                         DrawPosition(FALSE, boards[currentMove]);
3397                         SwitchClocks(forwardMostMove-1); // [HGM] race
3398                         DisplayBothClocks();
3399                     }
3400                     DisplayMoveError(_("Illegal move (rejected by ICS)")); // [HGM] but always relay error msg
3401                     ics_user_moved = 0;
3402                     continue;
3403                 }
3404             }
3405
3406             if (looking_at(buf, &i, "still have time") ||
3407                 looking_at(buf, &i, "not out of time") ||
3408                 looking_at(buf, &i, "either player is out of time") ||
3409                 looking_at(buf, &i, "has timeseal; checking")) {
3410                 /* We must have called his flag a little too soon */
3411                 whiteFlag = blackFlag = FALSE;
3412                 continue;
3413             }
3414
3415             if (looking_at(buf, &i, "added * seconds to") ||
3416                 looking_at(buf, &i, "seconds were added to")) {
3417                 /* Update the clocks */
3418                 SendToICS(ics_prefix);
3419                 SendToICS("refresh\n");
3420                 continue;
3421             }
3422
3423             if (!ics_clock_paused && looking_at(buf, &i, "clock paused")) {
3424                 ics_clock_paused = TRUE;
3425                 StopClocks();
3426                 continue;
3427             }
3428
3429             if (ics_clock_paused && looking_at(buf, &i, "clock resumed")) {
3430                 ics_clock_paused = FALSE;
3431                 StartClocks();
3432                 continue;
3433             }
3434
3435             /* Grab player ratings from the Creating: message.
3436                Note we have to check for the special case when
3437                the ICS inserts things like [white] or [black]. */
3438             if (looking_at(buf, &i, "Creating: * (*)* * (*)") ||
3439                 looking_at(buf, &i, "Creating: * (*) [*] * (*)")) {
3440                 /* star_matches:
3441                    0    player 1 name (not necessarily white)
3442                    1    player 1 rating
3443                    2    empty, white, or black (IGNORED)
3444                    3    player 2 name (not necessarily black)
3445                    4    player 2 rating
3446
3447                    The names/ratings are sorted out when the game
3448                    actually starts (below).
3449                 */
3450                 strcpy(player1Name, StripHighlightAndTitle(star_match[0]));
3451                 player1Rating = string_to_rating(star_match[1]);
3452                 strcpy(player2Name, StripHighlightAndTitle(star_match[3]));
3453                 player2Rating = string_to_rating(star_match[4]);
3454
3455                 if (appData.debugMode)
3456                   fprintf(debugFP,
3457                           "Ratings from 'Creating:' %s %d, %s %d\n",
3458                           player1Name, player1Rating,
3459                           player2Name, player2Rating);
3460
3461                 continue;
3462             }
3463
3464             /* Improved generic start/end-of-game messages */
3465             if ((tkind=0, looking_at(buf, &i, "{Game * (* vs. *) *}*")) ||
3466                 (tkind=1, looking_at(buf, &i, "{Game * (*(*) vs. *(*)) *}*"))){
3467                 /* If tkind == 0: */
3468                 /* star_match[0] is the game number */
3469                 /*           [1] is the white player's name */
3470                 /*           [2] is the black player's name */
3471                 /* For end-of-game: */
3472                 /*           [3] is the reason for the game end */
3473                 /*           [4] is a PGN end game-token, preceded by " " */
3474                 /* For start-of-game: */
3475                 /*           [3] begins with "Creating" or "Continuing" */
3476                 /*           [4] is " *" or empty (don't care). */
3477                 int gamenum = atoi(star_match[0]);
3478                 char *whitename, *blackname, *why, *endtoken;
3479                 ChessMove endtype = (ChessMove) 0;
3480
3481                 if (tkind == 0) {
3482                   whitename = star_match[1];
3483                   blackname = star_match[2];
3484                   why = star_match[3];
3485                   endtoken = star_match[4];
3486                 } else {
3487                   whitename = star_match[1];
3488                   blackname = star_match[3];
3489                   why = star_match[5];
3490                   endtoken = star_match[6];
3491                 }
3492
3493                 /* Game start messages */
3494                 if (strncmp(why, "Creating ", 9) == 0 ||
3495                     strncmp(why, "Continuing ", 11) == 0) {
3496                     gs_gamenum = gamenum;
3497                     strcpy(gs_kind, strchr(why, ' ') + 1);
3498                     VariantSwitch(boards[currentMove], StringToVariant(gs_kind)); // [HGM] variantswitch: even before we get first board
3499 #if ZIPPY
3500                     if (appData.zippyPlay) {
3501                         ZippyGameStart(whitename, blackname);
3502                     }
3503 #endif /*ZIPPY*/
3504                     partnerBoardValid = FALSE; // [HGM] bughouse
3505                     continue;
3506                 }
3507
3508                 /* Game end messages */
3509                 if (gameMode == IcsIdle || gameMode == BeginningOfGame ||
3510                     ics_gamenum != gamenum) {
3511                     continue;
3512                 }
3513                 while (endtoken[0] == ' ') endtoken++;
3514                 switch (endtoken[0]) {
3515                   case '*':
3516                   default:
3517                     endtype = GameUnfinished;
3518                     break;
3519                   case '0':
3520                     endtype = BlackWins;
3521                     break;
3522                   case '1':
3523                     if (endtoken[1] == '/')
3524                       endtype = GameIsDrawn;
3525                     else
3526                       endtype = WhiteWins;
3527                     break;
3528                 }
3529                 GameEnds(endtype, why, GE_ICS);
3530 #if ZIPPY
3531                 if (appData.zippyPlay && first.initDone) {
3532                     ZippyGameEnd(endtype, why);
3533                     if (first.pr == NULL) {
3534                       /* Start the next process early so that we'll
3535                          be ready for the next challenge */
3536                       StartChessProgram(&first);
3537                     }
3538                     /* Send "new" early, in case this command takes
3539                        a long time to finish, so that we'll be ready
3540                        for the next challenge. */
3541                     gameInfo.variant = VariantNormal; // [HGM] variantswitch: suppress sending of 'variant'
3542                     Reset(TRUE, TRUE);
3543                 }
3544 #endif /*ZIPPY*/
3545                 if(appData.bgObserve && partnerBoardValid) DrawPosition(TRUE, partnerBoard);
3546                 continue;
3547             }
3548
3549             if (looking_at(buf, &i, "Removing game * from observation") ||
3550                 looking_at(buf, &i, "no longer observing game *") ||
3551                 looking_at(buf, &i, "Game * (*) has no examiners")) {
3552                 if (gameMode == IcsObserving &&
3553                     atoi(star_match[0]) == ics_gamenum)
3554                   {
3555                       /* icsEngineAnalyze */
3556                       if (appData.icsEngineAnalyze) {
3557                             ExitAnalyzeMode();
3558                             ModeHighlight();
3559                       }
3560                       StopClocks();
3561                       gameMode = IcsIdle;
3562                       ics_gamenum = -1;
3563                       ics_user_moved = FALSE;
3564                   }
3565                 continue;
3566             }
3567
3568             if (looking_at(buf, &i, "no longer examining game *")) {
3569                 if (gameMode == IcsExamining &&
3570                     atoi(star_match[0]) == ics_gamenum)
3571                   {
3572                       gameMode = IcsIdle;
3573                       ics_gamenum = -1;
3574                       ics_user_moved = FALSE;
3575                   }
3576                 continue;
3577             }
3578
3579             /* Advance leftover_start past any newlines we find,
3580                so only partial lines can get reparsed */
3581             if (looking_at(buf, &i, "\n")) {
3582                 prevColor = curColor;
3583                 if (curColor != ColorNormal) {
3584                     if (oldi > next_out) {
3585                         SendToPlayer(&buf[next_out], oldi - next_out);
3586                         next_out = oldi;
3587                     }
3588                     Colorize(ColorNormal, FALSE);
3589                     curColor = ColorNormal;
3590                 }
3591                 if (started == STARTED_BOARD) {
3592                     started = STARTED_NONE;
3593                     parse[parse_pos] = NULLCHAR;
3594                     ParseBoard12(parse);
3595                     ics_user_moved = 0;
3596
3597                     /* Send premove here */
3598                     if (appData.premove) {
3599                       char str[MSG_SIZ];
3600                       if (currentMove == 0 &&
3601                           gameMode == IcsPlayingWhite &&
3602                           appData.premoveWhite) {
3603                         sprintf(str, "%s\n", appData.premoveWhiteText);
3604                         if (appData.debugMode)
3605                           fprintf(debugFP, "Sending premove:\n");
3606                         SendToICS(str);
3607                       } else if (currentMove == 1 &&
3608                                  gameMode == IcsPlayingBlack &&
3609                                  appData.premoveBlack) {
3610                         sprintf(str, "%s\n", appData.premoveBlackText);
3611                         if (appData.debugMode)
3612                           fprintf(debugFP, "Sending premove:\n");
3613                         SendToICS(str);
3614                       } else if (gotPremove) {
3615                         gotPremove = 0;
3616                         ClearPremoveHighlights();
3617                         if (appData.debugMode)
3618                           fprintf(debugFP, "Sending premove:\n");
3619                           UserMoveEvent(premoveFromX, premoveFromY,
3620                                         premoveToX, premoveToY,
3621                                         premovePromoChar);
3622                       }
3623                     }
3624
3625                     /* Usually suppress following prompt */
3626                     if (!(forwardMostMove == 0 && gameMode == IcsExamining)) {
3627                         while(looking_at(buf, &i, "\n")); // [HGM] skip empty lines
3628                         if (looking_at(buf, &i, "*% ")) {
3629                             savingComment = FALSE;
3630                             suppressKibitz = 0;
3631                         }
3632                     }
3633                     next_out = i;
3634                 } else if (started == STARTED_HOLDINGS) {
3635                     int gamenum;
3636                     char new_piece[MSG_SIZ];
3637                     started = STARTED_NONE;
3638                     parse[parse_pos] = NULLCHAR;
3639                     if (appData.debugMode)
3640                       fprintf(debugFP, "Parsing holdings: %s, currentMove = %d\n",
3641                                                         parse, currentMove);
3642                     if (sscanf(parse, " game %d", &gamenum) == 1) {
3643                       if(gamenum == ics_gamenum) { // [HGM] bughouse: old code if part of foreground game
3644                         if (gameInfo.variant == VariantNormal) {
3645                           /* [HGM] We seem to switch variant during a game!
3646                            * Presumably no holdings were displayed, so we have
3647                            * to move the position two files to the right to
3648                            * create room for them!
3649                            */
3650                           VariantClass newVariant;
3651                           switch(gameInfo.boardWidth) { // base guess on board width
3652                                 case 9:  newVariant = VariantShogi; break;
3653                                 case 10: newVariant = VariantGreat; break;
3654                                 default: newVariant = VariantCrazyhouse; break;
3655                           }
3656                           VariantSwitch(boards[currentMove], newVariant); /* temp guess */
3657                           /* Get a move list just to see the header, which
3658                              will tell us whether this is really bug or zh */
3659                           if (ics_getting_history == H_FALSE) {
3660                             ics_getting_history = H_REQUESTED;
3661                             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3662                             SendToICS(str);
3663                           }
3664                         }
3665                         new_piece[0] = NULLCHAR;
3666                         sscanf(parse, "game %d white [%s black [%s <- %s",
3667                                &gamenum, white_holding, black_holding,
3668                                new_piece);
3669                         white_holding[strlen(white_holding)-1] = NULLCHAR;
3670                         black_holding[strlen(black_holding)-1] = NULLCHAR;
3671                         /* [HGM] copy holdings to board holdings area */
3672                         CopyHoldings(boards[forwardMostMove], white_holding, WhitePawn);
3673                         CopyHoldings(boards[forwardMostMove], black_holding, BlackPawn);
3674                         boards[forwardMostMove][HOLDINGS_SET] = 1; // flag holdings as set
3675 #if ZIPPY
3676                         if (appData.zippyPlay && first.initDone) {
3677                             ZippyHoldings(white_holding, black_holding,
3678                                           new_piece);
3679                         }
3680 #endif /*ZIPPY*/
3681                         if (tinyLayout || smallLayout) {
3682                             char wh[16], bh[16];
3683                             PackHolding(wh, white_holding);
3684                             PackHolding(bh, black_holding);
3685                             sprintf(str, "[%s-%s] %s-%s", wh, bh,
3686                                     gameInfo.white, gameInfo.black);
3687                         } else {
3688                             sprintf(str, "%s [%s] vs. %s [%s]",
3689                                     gameInfo.white, white_holding,
3690                                     gameInfo.black, black_holding);
3691                         }
3692                         if(!partnerUp) // [HGM] bughouse: when peeking at partner game we already know what he captured...
3693                         DrawPosition(FALSE, boards[currentMove]);
3694                         DisplayTitle(str);
3695                       } else if(appData.bgObserve) { // [HGM] bughouse: holdings of other game => background
3696                         sscanf(parse, "game %d white [%s black [%s <- %s",
3697                                &gamenum, white_holding, black_holding,
3698                                new_piece);
3699                         white_holding[strlen(white_holding)-1] = NULLCHAR;
3700                         black_holding[strlen(black_holding)-1] = NULLCHAR;
3701                         /* [HGM] copy holdings to partner-board holdings area */
3702                         CopyHoldings(partnerBoard, white_holding, WhitePawn);
3703                         CopyHoldings(partnerBoard, black_holding, BlackPawn);
3704                         if(twoBoards) { partnerUp = 1; flipView = !flipView; } // [HGM] dual: always draw
3705                         if(partnerUp) DrawPosition(FALSE, partnerBoard);
3706                         if(twoBoards) { partnerUp = 0; flipView = !flipView; }
3707                       }
3708                     }
3709                     /* Suppress following prompt */
3710                     if (looking_at(buf, &i, "*% ")) {
3711                         if(strchr(star_match[0], 7)) SendToPlayer("\007", 1); // Bell(); // FICS fuses bell for next board with prompt in zh captures
3712                         savingComment = FALSE;
3713                         suppressKibitz = 0;
3714                     }
3715                     next_out = i;
3716                 }
3717                 continue;
3718             }
3719
3720             i++;                /* skip unparsed character and loop back */
3721         }
3722
3723         if (started != STARTED_MOVES && started != STARTED_BOARD && !suppressKibitz && // [HGM] kibitz
3724 //          started != STARTED_HOLDINGS && i > next_out) { // [HGM] should we compare to leftover_start in stead of i?
3725 //          SendToPlayer(&buf[next_out], i - next_out);
3726             started != STARTED_HOLDINGS && leftover_start > next_out) {
3727             SendToPlayer(&buf[next_out], leftover_start - next_out);
3728             next_out = i;
3729         }
3730
3731         leftover_len = buf_len - leftover_start;
3732         /* if buffer ends with something we couldn't parse,
3733            reparse it after appending the next read */
3734
3735     } else if (count == 0) {
3736         RemoveInputSource(isr);
3737         DisplayFatalError(_("Connection closed by ICS"), 0, 0);
3738     } else {
3739         DisplayFatalError(_("Error reading from ICS"), error, 1);
3740     }
3741 }
3742
3743
3744 /* Board style 12 looks like this:
3745
3746    <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
3747
3748  * The "<12> " is stripped before it gets to this routine.  The two
3749  * trailing 0's (flip state and clock ticking) are later addition, and
3750  * some chess servers may not have them, or may have only the first.
3751  * Additional trailing fields may be added in the future.
3752  */
3753
3754 #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"
3755
3756 #define RELATION_OBSERVING_PLAYED    0
3757 #define RELATION_OBSERVING_STATIC   -2   /* examined, oldmoves, or smoves */
3758 #define RELATION_PLAYING_MYMOVE      1
3759 #define RELATION_PLAYING_NOTMYMOVE  -1
3760 #define RELATION_EXAMINING           2
3761 #define RELATION_ISOLATED_BOARD     -3
3762 #define RELATION_STARTING_POSITION  -4   /* FICS only */
3763
3764 void
3765 ParseBoard12(string)
3766      char *string;
3767 {
3768     GameMode newGameMode;
3769     int gamenum, newGame, newMove, relation, basetime, increment, ics_flip = 0, i;
3770     int j, k, n, moveNum, white_stren, black_stren, white_time, black_time, takeback;
3771     int double_push, castle_ws, castle_wl, castle_bs, castle_bl, irrev_count;
3772     char to_play, board_chars[200];
3773     char move_str[500], str[500], elapsed_time[500];
3774     char black[32], white[32];
3775     Board board;
3776     int prevMove = currentMove;
3777     int ticking = 2;
3778     ChessMove moveType;
3779     int fromX, fromY, toX, toY;
3780     char promoChar;
3781     int ranks=1, files=0; /* [HGM] ICS80: allow variable board size */
3782     char *bookHit = NULL; // [HGM] book
3783     Boolean weird = FALSE, reqFlag = FALSE;
3784
3785     fromX = fromY = toX = toY = -1;
3786
3787     newGame = FALSE;
3788
3789     if (appData.debugMode)
3790       fprintf(debugFP, _("Parsing board: %s\n"), string);
3791
3792     move_str[0] = NULLCHAR;
3793     elapsed_time[0] = NULLCHAR;
3794     {   /* [HGM] figure out how many ranks and files the board has, for ICS extension used by Capablanca server */
3795         int  i = 0, j;
3796         while(i < 199 && (string[i] != ' ' || string[i+2] != ' ')) {
3797             if(string[i] == ' ') { ranks++; files = 0; }
3798             else files++;
3799             if(!strchr(" -pnbrqkPNBRQK" , string[i])) weird = TRUE; // test for fairies
3800             i++;
3801         }
3802         for(j = 0; j <i; j++) board_chars[j] = string[j];
3803         board_chars[i] = '\0';
3804         string += i + 1;
3805     }
3806     n = sscanf(string, PATTERN, &to_play, &double_push,
3807                &castle_ws, &castle_wl, &castle_bs, &castle_bl, &irrev_count,
3808                &gamenum, white, black, &relation, &basetime, &increment,
3809                &white_stren, &black_stren, &white_time, &black_time,
3810                &moveNum, str, elapsed_time, move_str, &ics_flip,
3811                &ticking);
3812
3813     if (n < 21) {
3814         snprintf(str, sizeof(str), _("Failed to parse board string:\n\"%s\""), string);
3815         DisplayError(str, 0);
3816         return;
3817     }
3818
3819     /* Convert the move number to internal form */
3820     moveNum = (moveNum - 1) * 2;
3821     if (to_play == 'B') moveNum++;
3822     if (moveNum > framePtr) { // [HGM] vari: do not run into saved variations
3823       DisplayFatalError(_("Game too long; increase MAX_MOVES and recompile"),
3824                         0, 1);
3825       return;
3826     }
3827
3828     switch (relation) {
3829       case RELATION_OBSERVING_PLAYED:
3830       case RELATION_OBSERVING_STATIC:
3831         if (gamenum == -1) {
3832             /* Old ICC buglet */
3833             relation = RELATION_OBSERVING_STATIC;
3834         }
3835         newGameMode = IcsObserving;
3836         break;
3837       case RELATION_PLAYING_MYMOVE:
3838       case RELATION_PLAYING_NOTMYMOVE:
3839         newGameMode =
3840           ((relation == RELATION_PLAYING_MYMOVE) == (to_play == 'W')) ?
3841             IcsPlayingWhite : IcsPlayingBlack;
3842         break;
3843       case RELATION_EXAMINING:
3844         newGameMode = IcsExamining;
3845         break;
3846       case RELATION_ISOLATED_BOARD:
3847       default:
3848         /* Just display this board.  If user was doing something else,
3849            we will forget about it until the next board comes. */
3850         newGameMode = IcsIdle;
3851         break;
3852       case RELATION_STARTING_POSITION:
3853         newGameMode = gameMode;
3854         break;
3855     }
3856
3857     if((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack)
3858          && newGameMode == IcsObserving && gamenum != ics_gamenum && appData.bgObserve) {
3859       // [HGM] bughouse: don't act on alien boards while we play. Just parse the board and save it */
3860       char *toSqr;
3861       for (k = 0; k < ranks; k++) {
3862         for (j = 0; j < files; j++)
3863           board[k][j+gameInfo.holdingsWidth] = CharToPiece(board_chars[(ranks-1-k)*(files+1) + j]);
3864         if(gameInfo.holdingsWidth > 1) {
3865              board[k][0] = board[k][BOARD_WIDTH-1] = EmptySquare;
3866              board[k][1] = board[k][BOARD_WIDTH-2] = (ChessSquare) 0;;
3867         }
3868       }
3869       CopyBoard(partnerBoard, board);
3870       if(toSqr = strchr(str, '/')) { // extract highlights from long move
3871         partnerBoard[EP_STATUS-3] = toSqr[1] - AAA; // kludge: hide highlighting info in board
3872         partnerBoard[EP_STATUS-4] = toSqr[2] - ONE;
3873       } else partnerBoard[EP_STATUS-4] = partnerBoard[EP_STATUS-3] = -1;
3874       if(toSqr = strchr(str, '-')) {
3875         partnerBoard[EP_STATUS-1] = toSqr[1] - AAA;
3876         partnerBoard[EP_STATUS-2] = toSqr[2] - ONE;
3877       } else partnerBoard[EP_STATUS-1] = partnerBoard[EP_STATUS-2] = -1;
3878       if(appData.dualBoard && !twoBoards) { twoBoards = 1; InitDrawingSizes(-2,0); }
3879       if(twoBoards) { partnerUp = 1; flipView = !flipView; } // [HGM] dual
3880       if(partnerUp) DrawPosition(FALSE, partnerBoard);
3881       if(twoBoards) { partnerUp = 0; flipView = !flipView; } // [HGM] dual
3882       sprintf(partnerStatus, "W: %d:%02d B: %d:%02d (%d-%d) %c", white_time/60000, (white_time%60000)/1000,
3883                  (black_time/60000), (black_time%60000)/1000, white_stren, black_stren, to_play);
3884       DisplayMessage(partnerStatus, "");
3885         partnerBoardValid = TRUE;
3886       return;
3887     }
3888
3889     /* Modify behavior for initial board display on move listing
3890        of wild games.
3891        */
3892     switch (ics_getting_history) {
3893       case H_FALSE:
3894       case H_REQUESTED:
3895         break;
3896       case H_GOT_REQ_HEADER:
3897       case H_GOT_UNREQ_HEADER:
3898         /* This is the initial position of the current game */
3899         gamenum = ics_gamenum;
3900         moveNum = 0;            /* old ICS bug workaround */
3901         if (to_play == 'B') {
3902           startedFromSetupPosition = TRUE;
3903           blackPlaysFirst = TRUE;
3904           moveNum = 1;
3905           if (forwardMostMove == 0) forwardMostMove = 1;
3906           if (backwardMostMove == 0) backwardMostMove = 1;
3907           if (currentMove == 0) currentMove = 1;
3908         }
3909         newGameMode = gameMode;
3910         relation = RELATION_STARTING_POSITION; /* ICC needs this */
3911         break;
3912       case H_GOT_UNWANTED_HEADER:
3913         /* This is an initial board that we don't want */
3914         return;
3915       case H_GETTING_MOVES:
3916         /* Should not happen */
3917         DisplayError(_("Error gathering move list: extra board"), 0);
3918         ics_getting_history = H_FALSE;
3919         return;
3920     }
3921
3922    if (gameInfo.boardHeight != ranks || gameInfo.boardWidth != files ||
3923                                         weird && (int)gameInfo.variant <= (int)VariantShogi) {
3924      /* [HGM] We seem to have switched variant unexpectedly
3925       * Try to guess new variant from board size
3926       */
3927           VariantClass newVariant = VariantFairy; // if 8x8, but fairies present
3928           if(ranks == 8 && files == 10) newVariant = VariantCapablanca; else
3929           if(ranks == 10 && files == 9) newVariant = VariantXiangqi; else
3930           if(ranks == 8 && files == 12) newVariant = VariantCourier; else
3931           if(ranks == 9 && files == 9)  newVariant = VariantShogi; else
3932           if(!weird) newVariant = VariantNormal;
3933           VariantSwitch(boards[currentMove], newVariant); /* temp guess */
3934           /* Get a move list just to see the header, which
3935              will tell us whether this is really bug or zh */
3936           if (ics_getting_history == H_FALSE) {
3937             ics_getting_history = H_REQUESTED; reqFlag = TRUE;
3938             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3939             SendToICS(str);
3940           }
3941     }
3942
3943     /* Take action if this is the first board of a new game, or of a
3944        different game than is currently being displayed.  */
3945     if (gamenum != ics_gamenum || newGameMode != gameMode ||
3946         relation == RELATION_ISOLATED_BOARD) {
3947
3948         /* Forget the old game and get the history (if any) of the new one */
3949         if (gameMode != BeginningOfGame) {
3950           Reset(TRUE, TRUE);
3951         }
3952         newGame = TRUE;
3953         if (appData.autoRaiseBoard) BoardToTop();
3954         prevMove = -3;
3955         if (gamenum == -1) {
3956             newGameMode = IcsIdle;
3957         } else if ((moveNum > 0 || newGameMode == IcsObserving) && newGameMode != IcsIdle &&
3958                    appData.getMoveList && !reqFlag) {
3959             /* Need to get game history */
3960             ics_getting_history = H_REQUESTED;
3961             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3962             SendToICS(str);
3963         }
3964
3965         /* Initially flip the board to have black on the bottom if playing
3966            black or if the ICS flip flag is set, but let the user change
3967            it with the Flip View button. */
3968         flipView = appData.autoFlipView ?
3969           (newGameMode == IcsPlayingBlack) || ics_flip :
3970           appData.flipView;
3971
3972         /* Done with values from previous mode; copy in new ones */
3973         gameMode = newGameMode;
3974         ModeHighlight();
3975         ics_gamenum = gamenum;
3976         if (gamenum == gs_gamenum) {
3977             int klen = strlen(gs_kind);
3978             if (gs_kind[klen - 1] == '.') gs_kind[klen - 1] = NULLCHAR;
3979             sprintf(str, "ICS %s", gs_kind);
3980             gameInfo.event = StrSave(str);
3981         } else {
3982             gameInfo.event = StrSave("ICS game");
3983         }
3984         gameInfo.site = StrSave(appData.icsHost);
3985         gameInfo.date = PGNDate();
3986         gameInfo.round = StrSave("-");
3987         gameInfo.white = StrSave(white);
3988         gameInfo.black = StrSave(black);
3989         timeControl = basetime * 60 * 1000;
3990         timeControl_2 = 0;
3991         timeIncrement = increment * 1000;
3992         movesPerSession = 0;
3993         gameInfo.timeControl = TimeControlTagValue();
3994         VariantSwitch(boards[currentMove], StringToVariant(gameInfo.event) );
3995   if (appData.debugMode) {
3996     fprintf(debugFP, "ParseBoard says variant = '%s'\n", gameInfo.event);
3997     fprintf(debugFP, "recognized as %s\n", VariantName(gameInfo.variant));
3998     setbuf(debugFP, NULL);
3999   }
4000
4001         gameInfo.outOfBook = NULL;
4002
4003         /* Do we have the ratings? */
4004         if (strcmp(player1Name, white) == 0 &&
4005             strcmp(player2Name, black) == 0) {
4006             if (appData.debugMode)
4007               fprintf(debugFP, "Remembered ratings: W %d, B %d\n",
4008                       player1Rating, player2Rating);
4009             gameInfo.whiteRating = player1Rating;
4010             gameInfo.blackRating = player2Rating;
4011         } else if (strcmp(player2Name, white) == 0 &&
4012                    strcmp(player1Name, black) == 0) {
4013             if (appData.debugMode)
4014               fprintf(debugFP, "Remembered ratings: W %d, B %d\n",
4015                       player2Rating, player1Rating);
4016             gameInfo.whiteRating = player2Rating;
4017             gameInfo.blackRating = player1Rating;
4018         }
4019         player1Name[0] = player2Name[0] = NULLCHAR;
4020
4021         /* Silence shouts if requested */
4022         if (appData.quietPlay &&
4023             (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack)) {
4024             SendToICS(ics_prefix);
4025             SendToICS("set shout 0\n");
4026         }
4027     }
4028
4029     /* Deal with midgame name changes */
4030     if (!newGame) {
4031         if (!gameInfo.white || strcmp(gameInfo.white, white) != 0) {
4032             if (gameInfo.white) free(gameInfo.white);
4033             gameInfo.white = StrSave(white);
4034         }
4035         if (!gameInfo.black || strcmp(gameInfo.black, black) != 0) {
4036             if (gameInfo.black) free(gameInfo.black);
4037             gameInfo.black = StrSave(black);
4038         }
4039     }
4040
4041     /* Throw away game result if anything actually changes in examine mode */
4042     if (gameMode == IcsExamining && !newGame) {
4043         gameInfo.result = GameUnfinished;
4044         if (gameInfo.resultDetails != NULL) {
4045             free(gameInfo.resultDetails);
4046             gameInfo.resultDetails = NULL;
4047         }
4048     }
4049
4050     /* In pausing && IcsExamining mode, we ignore boards coming
4051        in if they are in a different variation than we are. */
4052     if (pauseExamInvalid) return;
4053     if (pausing && gameMode == IcsExamining) {
4054         if (moveNum <= pauseExamForwardMostMove) {
4055             pauseExamInvalid = TRUE;
4056             forwardMostMove = pauseExamForwardMostMove;
4057             return;
4058         }
4059     }
4060
4061   if (appData.debugMode) {
4062     fprintf(debugFP, "load %dx%d board\n", files, ranks);
4063   }
4064     /* Parse the board */
4065     for (k = 0; k < ranks; k++) {
4066       for (j = 0; j < files; j++)
4067         board[k][j+gameInfo.holdingsWidth] = CharToPiece(board_chars[(ranks-1-k)*(files+1) + j]);
4068       if(gameInfo.holdingsWidth > 1) {
4069            board[k][0] = board[k][BOARD_WIDTH-1] = EmptySquare;
4070            board[k][1] = board[k][BOARD_WIDTH-2] = (ChessSquare) 0;;
4071       }
4072     }
4073     CopyBoard(boards[moveNum], board);
4074     boards[moveNum][HOLDINGS_SET] = 0; // [HGM] indicate holdings not set
4075     if (moveNum == 0) {
4076         startedFromSetupPosition =
4077           !CompareBoards(board, initialPosition);
4078         if(startedFromSetupPosition)
4079             initialRulePlies = irrev_count; /* [HGM] 50-move counter offset */
4080     }
4081
4082     /* [HGM] Set castling rights. Take the outermost Rooks,
4083        to make it also work for FRC opening positions. Note that board12
4084        is really defective for later FRC positions, as it has no way to
4085        indicate which Rook can castle if they are on the same side of King.
4086        For the initial position we grant rights to the outermost Rooks,
4087        and remember thos rights, and we then copy them on positions
4088        later in an FRC game. This means WB might not recognize castlings with
4089        Rooks that have moved back to their original position as illegal,
4090        but in ICS mode that is not its job anyway.
4091     */
4092     if(moveNum == 0 || gameInfo.variant != VariantFischeRandom)
4093     { int i, j; ChessSquare wKing = WhiteKing, bKing = BlackKing;
4094
4095         for(i=BOARD_LEFT, j=NoRights; i<BOARD_RGHT; i++)
4096             if(board[0][i] == WhiteRook) j = i;
4097         initialRights[0] = boards[moveNum][CASTLING][0] = (castle_ws == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
4098         for(i=BOARD_RGHT-1, j=NoRights; i>=BOARD_LEFT; i--)
4099             if(board[0][i] == WhiteRook) j = i;
4100         initialRights[1] = boards[moveNum][CASTLING][1] = (castle_wl == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
4101         for(i=BOARD_LEFT, j=NoRights; i<BOARD_RGHT; i++)
4102             if(board[BOARD_HEIGHT-1][i] == BlackRook) j = i;
4103         initialRights[3] = boards[moveNum][CASTLING][3] = (castle_bs == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
4104         for(i=BOARD_RGHT-1, j=NoRights; i>=BOARD_LEFT; i--)
4105             if(board[BOARD_HEIGHT-1][i] == BlackRook) j = i;
4106         initialRights[4] = boards[moveNum][CASTLING][4] = (castle_bl == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
4107
4108         if(gameInfo.variant == VariantKnightmate) { wKing = WhiteUnicorn; bKing = BlackUnicorn; }
4109         for(k=BOARD_LEFT; k<BOARD_RGHT; k++)
4110             if(board[0][k] == wKing) initialRights[2] = boards[moveNum][CASTLING][2] = k;
4111         for(k=BOARD_LEFT; k<BOARD_RGHT; k++)
4112             if(board[BOARD_HEIGHT-1][k] == bKing)
4113                 initialRights[5] = boards[moveNum][CASTLING][5] = k;
4114         if(gameInfo.variant == VariantTwoKings) {
4115             // In TwoKings looking for a King does not work, so always give castling rights to a King on e1/e8
4116             if(board[0][4] == wKing) initialRights[2] = boards[moveNum][CASTLING][2] = 4;
4117             if(board[BOARD_HEIGHT-1][4] == bKing) initialRights[5] = boards[moveNum][CASTLING][5] = 4;
4118         }
4119     } else { int r;
4120         r = boards[moveNum][CASTLING][0] = initialRights[0];
4121         if(board[0][r] != WhiteRook) boards[moveNum][CASTLING][0] = NoRights;
4122         r = boards[moveNum][CASTLING][1] = initialRights[1];
4123         if(board[0][r] != WhiteRook) boards[moveNum][CASTLING][1] = NoRights;
4124         r = boards[moveNum][CASTLING][3] = initialRights[3];
4125         if(board[BOARD_HEIGHT-1][r] != BlackRook) boards[moveNum][CASTLING][3] = NoRights;
4126         r = boards[moveNum][CASTLING][4] = initialRights[4];
4127         if(board[BOARD_HEIGHT-1][r] != BlackRook) boards[moveNum][CASTLING][4] = NoRights;
4128         /* wildcastle kludge: always assume King has rights */
4129         r = boards[moveNum][CASTLING][2] = initialRights[2];
4130         r = boards[moveNum][CASTLING][5] = initialRights[5];
4131     }
4132     /* [HGM] e.p. rights. Assume that ICS sends file number here? */
4133     boards[moveNum][EP_STATUS] = double_push == -1 ? EP_NONE : double_push + BOARD_LEFT;
4134
4135
4136     if (ics_getting_history == H_GOT_REQ_HEADER ||
4137         ics_getting_history == H_GOT_UNREQ_HEADER) {
4138         /* This was an initial position from a move list, not
4139            the current position */
4140         return;
4141     }
4142
4143     /* Update currentMove and known move number limits */
4144     newMove = newGame || moveNum > forwardMostMove;
4145
4146     if (newGame) {
4147         forwardMostMove = backwardMostMove = currentMove = moveNum;
4148         if (gameMode == IcsExamining && moveNum == 0) {
4149           /* Workaround for ICS limitation: we are not told the wild
4150              type when starting to examine a game.  But if we ask for
4151              the move list, the move list header will tell us */
4152             ics_getting_history = H_REQUESTED;
4153             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
4154             SendToICS(str);
4155         }
4156     } else if (moveNum == forwardMostMove + 1 || moveNum == forwardMostMove
4157                || (moveNum < forwardMostMove && moveNum >= backwardMostMove)) {
4158 #if ZIPPY
4159         /* [DM] If we found takebacks during icsEngineAnalyze try send to engine */
4160         /* [HGM] applied this also to an engine that is silently watching        */
4161         if (appData.zippyPlay && moveNum < forwardMostMove && first.initDone &&
4162             (gameMode == IcsObserving || gameMode == IcsExamining) &&
4163             gameInfo.variant == currentlyInitializedVariant) {
4164           takeback = forwardMostMove - moveNum;
4165           for (i = 0; i < takeback; i++) {
4166             if (appData.debugMode) fprintf(debugFP, "take back move\n");
4167             SendToProgram("undo\n", &first);
4168           }
4169         }
4170 #endif
4171
4172         forwardMostMove = moveNum;
4173         if (!pausing || currentMove > forwardMostMove)
4174           currentMove = forwardMostMove;
4175     } else {
4176         /* New part of history that is not contiguous with old part */
4177         if (pausing && gameMode == IcsExamining) {
4178             pauseExamInvalid = TRUE;
4179             forwardMostMove = pauseExamForwardMostMove;
4180             return;
4181         }
4182         if (gameMode == IcsExamining && moveNum > 0 && appData.getMoveList) {
4183 #if ZIPPY
4184             if(appData.zippyPlay && forwardMostMove > 0 && first.initDone) {
4185                 // [HGM] when we will receive the move list we now request, it will be
4186                 // fed to the engine from the first move on. So if the engine is not
4187                 // in the initial position now, bring it there.
4188                 InitChessProgram(&first, 0);
4189             }
4190 #endif
4191             ics_getting_history = H_REQUESTED;
4192             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
4193             SendToICS(str);
4194         }
4195         forwardMostMove = backwardMostMove = currentMove = moveNum;
4196     }
4197
4198     /* Update the clocks */
4199     if (strchr(elapsed_time, '.')) {
4200       /* Time is in ms */
4201       timeRemaining[0][moveNum] = whiteTimeRemaining = white_time;
4202       timeRemaining[1][moveNum] = blackTimeRemaining = black_time;
4203     } else {
4204       /* Time is in seconds */
4205       timeRemaining[0][moveNum] = whiteTimeRemaining = white_time * 1000;
4206       timeRemaining[1][moveNum] = blackTimeRemaining = black_time * 1000;
4207     }
4208
4209
4210 #if ZIPPY
4211     if (appData.zippyPlay && newGame &&
4212         gameMode != IcsObserving && gameMode != IcsIdle &&
4213         gameMode != IcsExamining)
4214       ZippyFirstBoard(moveNum, basetime, increment);
4215 #endif
4216
4217     /* Put the move on the move list, first converting
4218        to canonical algebraic form. */
4219     if (moveNum > 0) {
4220   if (appData.debugMode) {
4221     if (appData.debugMode) { int f = forwardMostMove;
4222         fprintf(debugFP, "parseboard %d, castling = %d %d %d %d %d %d\n", f,
4223                 boards[f][CASTLING][0],boards[f][CASTLING][1],boards[f][CASTLING][2],
4224                 boards[f][CASTLING][3],boards[f][CASTLING][4],boards[f][CASTLING][5]);
4225     }
4226     fprintf(debugFP, "accepted move %s from ICS, parse it.\n", move_str);
4227     fprintf(debugFP, "moveNum = %d\n", moveNum);
4228     fprintf(debugFP, "board = %d-%d x %d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT);
4229     setbuf(debugFP, NULL);
4230   }
4231         if (moveNum <= backwardMostMove) {
4232             /* We don't know what the board looked like before
4233                this move.  Punt. */
4234             strcpy(parseList[moveNum - 1], move_str);
4235             strcat(parseList[moveNum - 1], " ");
4236             strcat(parseList[moveNum - 1], elapsed_time);
4237             moveList[moveNum - 1][0] = NULLCHAR;
4238         } else if (strcmp(move_str, "none") == 0) {
4239             // [HGM] long SAN: swapped order; test for 'none' before parsing move
4240             /* Again, we don't know what the board looked like;
4241                this is really the start of the game. */
4242             parseList[moveNum - 1][0] = NULLCHAR;
4243             moveList[moveNum - 1][0] = NULLCHAR;
4244             backwardMostMove = moveNum;
4245             startedFromSetupPosition = TRUE;
4246             fromX = fromY = toX = toY = -1;
4247         } else {
4248           // [HGM] long SAN: if legality-testing is off, disambiguation might not work or give wrong move.
4249           //                 So we parse the long-algebraic move string in stead of the SAN move
4250           int valid; char buf[MSG_SIZ], *prom;
4251
4252           // str looks something like "Q/a1-a2"; kill the slash
4253           if(str[1] == '/')
4254                 sprintf(buf, "%c%s", str[0], str+2);
4255           else  strcpy(buf, str); // might be castling
4256           if((prom = strstr(move_str, "=")) && !strstr(buf, "="))
4257                 strcat(buf, prom); // long move lacks promo specification!
4258           if(!appData.testLegality && move_str[1] != '@') { // drops never ambiguous (parser chokes on long form!)
4259                 if(appData.debugMode)
4260                         fprintf(debugFP, "replaced ICS move '%s' by '%s'\n", move_str, buf);
4261                 strcpy(move_str, buf);
4262           }
4263           valid = ParseOneMove(move_str, moveNum - 1, &moveType,
4264                                 &fromX, &fromY, &toX, &toY, &promoChar)
4265                || ParseOneMove(buf, moveNum - 1, &moveType,
4266                                 &fromX, &fromY, &toX, &toY, &promoChar);
4267           // end of long SAN patch
4268           if (valid) {
4269             (void) CoordsToAlgebraic(boards[moveNum - 1],
4270                                      PosFlags(moveNum - 1),
4271                                      fromY, fromX, toY, toX, promoChar,
4272                                      parseList[moveNum-1]);
4273             switch (MateTest(boards[moveNum], PosFlags(moveNum)) ) {
4274               case MT_NONE:
4275               case MT_STALEMATE:
4276               default:
4277                 break;
4278               case MT_CHECK:
4279                 if(gameInfo.variant != VariantShogi)
4280                     strcat(parseList[moveNum - 1], "+");
4281                 break;
4282               case MT_CHECKMATE:
4283               case MT_STAINMATE: // [HGM] xq: for notation stalemate that wins counts as checkmate
4284                 strcat(parseList[moveNum - 1], "#");
4285                 break;
4286             }
4287             strcat(parseList[moveNum - 1], " ");
4288             strcat(parseList[moveNum - 1], elapsed_time);
4289             /* currentMoveString is set as a side-effect of ParseOneMove */
4290             strcpy(moveList[moveNum - 1], currentMoveString);
4291             strcat(moveList[moveNum - 1], "\n");
4292           } else {
4293             /* Move from ICS was illegal!?  Punt. */
4294   if (appData.debugMode) {
4295     fprintf(debugFP, "Illegal move from ICS '%s'\n", move_str);
4296     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
4297   }
4298             strcpy(parseList[moveNum - 1], move_str);
4299             strcat(parseList[moveNum - 1], " ");
4300             strcat(parseList[moveNum - 1], elapsed_time);
4301             moveList[moveNum - 1][0] = NULLCHAR;
4302             fromX = fromY = toX = toY = -1;
4303           }
4304         }
4305   if (appData.debugMode) {
4306     fprintf(debugFP, "Move parsed to '%s'\n", parseList[moveNum - 1]);
4307     setbuf(debugFP, NULL);
4308   }
4309
4310 #if ZIPPY
4311         /* Send move to chess program (BEFORE animating it). */
4312         if (appData.zippyPlay && !newGame && newMove &&
4313            (!appData.getMoveList || backwardMostMove == 0) && first.initDone) {
4314
4315             if ((gameMode == IcsPlayingWhite && WhiteOnMove(moveNum)) ||
4316                 (gameMode == IcsPlayingBlack && !WhiteOnMove(moveNum))) {
4317                 if (moveList[moveNum - 1][0] == NULLCHAR) {
4318                     sprintf(str, _("Couldn't parse move \"%s\" from ICS"),
4319                             move_str);
4320                     DisplayError(str, 0);
4321                 } else {
4322                     if (first.sendTime) {
4323                         SendTimeRemaining(&first, gameMode == IcsPlayingWhite);
4324                     }
4325                     bookHit = SendMoveToBookUser(moveNum - 1, &first, FALSE); // [HGM] book
4326                     if (firstMove && !bookHit) {
4327                         firstMove = FALSE;
4328                         if (first.useColors) {
4329                           SendToProgram(gameMode == IcsPlayingWhite ?
4330                                         "white\ngo\n" :
4331                                         "black\ngo\n", &first);
4332                         } else {
4333                           SendToProgram("go\n", &first);
4334                         }
4335                         first.maybeThinking = TRUE;
4336                     }
4337                 }
4338             } else if (gameMode == IcsObserving || gameMode == IcsExamining) {
4339               if (moveList[moveNum - 1][0] == NULLCHAR) {
4340                 sprintf(str, _("Couldn't parse move \"%s\" from ICS"), move_str);
4341                 DisplayError(str, 0);
4342               } else {
4343                 if(gameInfo.variant == currentlyInitializedVariant) // [HGM] refrain sending moves engine can't understand!
4344                 SendMoveToProgram(moveNum - 1, &first);
4345               }
4346             }
4347         }
4348 #endif
4349     }
4350
4351     if (moveNum > 0 && !gotPremove && !appData.noGUI) {
4352         /* If move comes from a remote source, animate it.  If it
4353            isn't remote, it will have already been animated. */
4354         if (!pausing && !ics_user_moved && prevMove == moveNum - 1) {
4355             AnimateMove(boards[moveNum - 1], fromX, fromY, toX, toY);
4356         }
4357         if (!pausing && appData.highlightLastMove) {
4358             SetHighlights(fromX, fromY, toX, toY);
4359         }
4360     }
4361
4362     /* Start the clocks */
4363     whiteFlag = blackFlag = FALSE;
4364     appData.clockMode = !(basetime == 0 && increment == 0);
4365     if (ticking == 0) {
4366       ics_clock_paused = TRUE;
4367       StopClocks();
4368     } else if (ticking == 1) {
4369       ics_clock_paused = FALSE;
4370     }
4371     if (gameMode == IcsIdle ||
4372         relation == RELATION_OBSERVING_STATIC ||
4373         relation == RELATION_EXAMINING ||
4374         ics_clock_paused)
4375       DisplayBothClocks();
4376     else
4377       StartClocks();
4378
4379     /* Display opponents and material strengths */
4380     if (gameInfo.variant != VariantBughouse &&
4381         gameInfo.variant != VariantCrazyhouse && !appData.noGUI) {
4382         if (tinyLayout || smallLayout) {
4383             if(gameInfo.variant == VariantNormal)
4384                 sprintf(str, "%s(%d) %s(%d) {%d %d}",
4385                     gameInfo.white, white_stren, gameInfo.black, black_stren,
4386                     basetime, increment);
4387             else
4388                 sprintf(str, "%s(%d) %s(%d) {%d %d w%d}",
4389                     gameInfo.white, white_stren, gameInfo.black, black_stren,
4390                     basetime, increment, (int) gameInfo.variant);
4391         } else {
4392             if(gameInfo.variant == VariantNormal)
4393                 sprintf(str, "%s (%d) vs. %s (%d) {%d %d}",
4394                     gameInfo.white, white_stren, gameInfo.black, black_stren,
4395                     basetime, increment);
4396             else
4397                 sprintf(str, "%s (%d) vs. %s (%d) {%d %d %s}",
4398                     gameInfo.white, white_stren, gameInfo.black, black_stren,
4399                     basetime, increment, VariantName(gameInfo.variant));
4400         }
4401         DisplayTitle(str);
4402   if (appData.debugMode) {
4403     fprintf(debugFP, "Display title '%s, gameInfo.variant = %d'\n", str, gameInfo.variant);
4404   }
4405     }
4406
4407
4408     /* Display the board */
4409     if (!pausing && !appData.noGUI) {
4410
4411       if (appData.premove)
4412           if (!gotPremove ||
4413              ((gameMode == IcsPlayingWhite) && (WhiteOnMove(currentMove))) ||
4414              ((gameMode == IcsPlayingBlack) && (!WhiteOnMove(currentMove))))
4415               ClearPremoveHighlights();
4416
4417       j = seekGraphUp; seekGraphUp = FALSE; // [HGM] seekgraph: when we draw a board, it overwrites the seek graph
4418         if(partnerUp) { flipView = originalFlip; partnerUp = FALSE; j = TRUE; } // [HGM] bughouse: restore view
4419       DrawPosition(j, boards[currentMove]);
4420
4421       DisplayMove(moveNum - 1);
4422       if (appData.ringBellAfterMoves && /*!ics_user_moved*/ // [HGM] use absolute method to recognize own move
4423             !((gameMode == IcsPlayingWhite) && (!WhiteOnMove(moveNum)) ||
4424               (gameMode == IcsPlayingBlack) &&  (WhiteOnMove(moveNum))   ) ) {
4425         if(newMove) RingBell(); else PlayIcsUnfinishedSound();
4426       }
4427     }
4428
4429     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
4430 #if ZIPPY
4431     if(bookHit) { // [HGM] book: simulate book reply
4432         static char bookMove[MSG_SIZ]; // a bit generous?
4433
4434         programStats.nodes = programStats.depth = programStats.time =
4435         programStats.score = programStats.got_only_move = 0;
4436         sprintf(programStats.movelist, "%s (xbook)", bookHit);
4437
4438         strcpy(bookMove, "move ");
4439         strcat(bookMove, bookHit);
4440         HandleMachineMove(bookMove, &first);
4441     }
4442 #endif
4443 }
4444
4445 void
4446 GetMoveListEvent()
4447 {
4448     char buf[MSG_SIZ];
4449     if (appData.icsActive && gameMode != IcsIdle && ics_gamenum > 0) {
4450         ics_getting_history = H_REQUESTED;
4451         sprintf(buf, "%smoves %d\n", ics_prefix, ics_gamenum);
4452         SendToICS(buf);
4453     }
4454 }
4455
4456 void
4457 AnalysisPeriodicEvent(force)
4458      int force;
4459 {
4460     if (((programStats.ok_to_send == 0 || programStats.line_is_book)
4461          && !force) || !appData.periodicUpdates)
4462       return;
4463
4464     /* Send . command to Crafty to collect stats */
4465     SendToProgram(".\n", &first);
4466
4467     /* Don't send another until we get a response (this makes
4468        us stop sending to old Crafty's which don't understand
4469        the "." command (sending illegal cmds resets node count & time,
4470        which looks bad)) */
4471     programStats.ok_to_send = 0;
4472 }
4473
4474 void ics_update_width(new_width)
4475         int new_width;
4476 {
4477         ics_printf("set width %d\n", new_width);
4478 }
4479
4480 void
4481 SendMoveToProgram(moveNum, cps)
4482      int moveNum;
4483      ChessProgramState *cps;
4484 {
4485     char buf[MSG_SIZ];
4486
4487     if (cps->useUsermove) {
4488       SendToProgram("usermove ", cps);
4489     }
4490     if (cps->useSAN) {
4491       char *space;
4492       if ((space = strchr(parseList[moveNum], ' ')) != NULL) {
4493         int len = space - parseList[moveNum];
4494         memcpy(buf, parseList[moveNum], len);
4495         buf[len++] = '\n';
4496         buf[len] = NULLCHAR;
4497       } else {
4498         sprintf(buf, "%s\n", parseList[moveNum]);
4499       }
4500       SendToProgram(buf, cps);
4501     } else {
4502       if(cps->alphaRank) { /* [HGM] shogi: temporarily convert to shogi coordinates before sending */
4503         AlphaRank(moveList[moveNum], 4);
4504         SendToProgram(moveList[moveNum], cps);
4505         AlphaRank(moveList[moveNum], 4); // and back
4506       } else
4507       /* Added by Tord: Send castle moves in "O-O" in FRC games if required by
4508        * the engine. It would be nice to have a better way to identify castle
4509        * moves here. */
4510       if((gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom)
4511                                                                          && cps->useOOCastle) {
4512         int fromX = moveList[moveNum][0] - AAA;
4513         int fromY = moveList[moveNum][1] - ONE;
4514         int toX = moveList[moveNum][2] - AAA;
4515         int toY = moveList[moveNum][3] - ONE;
4516         if((boards[moveNum][fromY][fromX] == WhiteKing
4517             && boards[moveNum][toY][toX] == WhiteRook)
4518            || (boards[moveNum][fromY][fromX] == BlackKing
4519                && boards[moveNum][toY][toX] == BlackRook)) {
4520           if(toX > fromX) SendToProgram("O-O\n", cps);
4521           else SendToProgram("O-O-O\n", cps);
4522         }
4523         else SendToProgram(moveList[moveNum], cps);
4524       }
4525       else SendToProgram(moveList[moveNum], cps);
4526       /* End of additions by Tord */
4527     }
4528
4529     /* [HGM] setting up the opening has brought engine in force mode! */
4530     /*       Send 'go' if we are in a mode where machine should play. */
4531     if( (moveNum == 0 && setboardSpoiledMachineBlack && cps == &first) &&
4532         (gameMode == TwoMachinesPlay   ||
4533 #ifdef ZIPPY
4534          gameMode == IcsPlayingBlack     || gameMode == IcsPlayingWhite ||
4535 #endif
4536          gameMode == MachinePlaysBlack || gameMode == MachinePlaysWhite) ) {
4537         SendToProgram("go\n", cps);
4538   if (appData.debugMode) {
4539     fprintf(debugFP, "(extra)\n");
4540   }
4541     }
4542     setboardSpoiledMachineBlack = 0;
4543 }
4544
4545 void
4546 SendMoveToICS(moveType, fromX, fromY, toX, toY)
4547      ChessMove moveType;
4548      int fromX, fromY, toX, toY;
4549 {
4550     char user_move[MSG_SIZ];
4551
4552     switch (moveType) {
4553       default:
4554         sprintf(user_move, _("say Internal error; bad moveType %d (%d,%d-%d,%d)"),
4555                 (int)moveType, fromX, fromY, toX, toY);
4556         DisplayError(user_move + strlen("say "), 0);
4557         break;
4558       case WhiteKingSideCastle:
4559       case BlackKingSideCastle:
4560       case WhiteQueenSideCastleWild:
4561       case BlackQueenSideCastleWild:
4562       /* PUSH Fabien */
4563       case WhiteHSideCastleFR:
4564       case BlackHSideCastleFR:
4565       /* POP Fabien */
4566         sprintf(user_move, "o-o\n");
4567         break;
4568       case WhiteQueenSideCastle:
4569       case BlackQueenSideCastle:
4570       case WhiteKingSideCastleWild:
4571       case BlackKingSideCastleWild:
4572       /* PUSH Fabien */
4573       case WhiteASideCastleFR:
4574       case BlackASideCastleFR:
4575       /* POP Fabien */
4576         sprintf(user_move, "o-o-o\n");
4577         break;
4578       case WhitePromotionQueen:
4579       case BlackPromotionQueen:
4580       case WhitePromotionRook:
4581       case BlackPromotionRook:
4582       case WhitePromotionBishop:
4583       case BlackPromotionBishop:
4584       case WhitePromotionKnight:
4585       case BlackPromotionKnight:
4586       case WhitePromotionKing:
4587       case BlackPromotionKing:
4588       case WhitePromotionChancellor:
4589       case BlackPromotionChancellor:
4590       case WhitePromotionArchbishop:
4591       case BlackPromotionArchbishop:
4592         if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier || gameInfo.variant == VariantMakruk)
4593             sprintf(user_move, "%c%c%c%c=%c\n",
4594                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
4595                 PieceToChar(WhiteFerz));
4596         else if(gameInfo.variant == VariantGreat)
4597             sprintf(user_move, "%c%c%c%c=%c\n",
4598                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
4599                 PieceToChar(WhiteMan));
4600         else
4601             sprintf(user_move, "%c%c%c%c=%c\n",
4602                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
4603                 PieceToChar(PromoPiece(moveType)));
4604         break;
4605       case WhiteDrop:
4606       case BlackDrop:
4607         sprintf(user_move, "%c@%c%c\n",
4608                 ToUpper(PieceToChar((ChessSquare) fromX)),
4609                 AAA + toX, ONE + toY);
4610         break;
4611       case NormalMove:
4612       case WhiteCapturesEnPassant:
4613       case BlackCapturesEnPassant:
4614       case IllegalMove:  /* could be a variant we don't quite understand */
4615         sprintf(user_move, "%c%c%c%c\n",
4616                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY);
4617         break;
4618     }
4619     SendToICS(user_move);
4620     if(appData.keepAlive) // [HGM] alive: schedule sending of dummy 'date' command
4621         ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
4622 }
4623
4624 void
4625 UploadGameEvent()
4626 {   // [HGM] upload: send entire stored game to ICS as long-algebraic moves.
4627     int i, last = forwardMostMove; // make sure ICS reply cannot pre-empt us by clearing fmm
4628     static char *castlingStrings[4] = { "none", "kside", "qside", "both" };
4629     if(gameMode == IcsObserving || gameMode == IcsPlayingBlack || gameMode == IcsPlayingWhite) {
4630         DisplayError("You cannot do this while you are playing or observing", 0);
4631         return;
4632     }
4633     if(gameMode != IcsExamining) { // is this ever not the case?
4634         char buf[MSG_SIZ], *p, *fen, command[MSG_SIZ], bsetup = 0;
4635
4636         if(ics_type == ICS_ICC) { // on ICC match ourselves in applicable variant
4637             sprintf(command, "match %s", ics_handle);
4638         } else { // on FICS we must first go to general examine mode
4639             strcpy(command, "examine\nbsetup"); // and specify variant within it with bsetups
4640         }
4641         if(gameInfo.variant != VariantNormal) {
4642             // try figure out wild number, as xboard names are not always valid on ICS
4643             for(i=1; i<=36; i++) {
4644                 sprintf(buf, "wild/%d", i);
4645                 if(StringToVariant(buf) == gameInfo.variant) break;
4646             }
4647             if(i<=36 && ics_type == ICS_ICC) sprintf(buf, "%s w%d\n", command, i);
4648             else if(i == 22) sprintf(buf, "%s fr\n", command);
4649             else sprintf(buf, "%s %s\n", command, VariantName(gameInfo.variant));
4650         } else sprintf(buf, "%s\n", ics_type == ICS_ICC ? command : "examine\n"); // match yourself or examine
4651         SendToICS(ics_prefix);
4652         SendToICS(buf);
4653         if(startedFromSetupPosition || backwardMostMove != 0) {
4654           fen = PositionToFEN(backwardMostMove, NULL);
4655           if(ics_type == ICS_ICC) { // on ICC we can simply send a complete FEN to set everything
4656             sprintf(buf, "loadfen %s\n", fen);
4657             SendToICS(buf);
4658           } else { // FICS: everything has to set by separate bsetup commands
4659             p = strchr(fen, ' '); p[0] = NULLCHAR; // cut after board
4660             sprintf(buf, "bsetup fen %s\n", fen);
4661             SendToICS(buf);
4662             if(!WhiteOnMove(backwardMostMove)) {
4663                 SendToICS("bsetup tomove black\n");
4664             }
4665             i = (strchr(p+3, 'K') != NULL) + 2*(strchr(p+3, 'Q') != NULL);
4666             sprintf(buf, "bsetup wcastle %s\n", castlingStrings[i]);
4667             SendToICS(buf);
4668             i = (strchr(p+3, 'k') != NULL) + 2*(strchr(p+3, 'q') != NULL);
4669             sprintf(buf, "bsetup bcastle %s\n", castlingStrings[i]);
4670             SendToICS(buf);
4671             i = boards[backwardMostMove][EP_STATUS];
4672             if(i >= 0) { // set e.p.
4673                 sprintf(buf, "bsetup eppos %c\n", i+AAA);
4674                 SendToICS(buf);
4675             }
4676             bsetup++;
4677           }
4678         }
4679       if(bsetup || ics_type != ICS_ICC && gameInfo.variant != VariantNormal)
4680             SendToICS("bsetup done\n"); // switch to normal examining.
4681     }
4682     for(i = backwardMostMove; i<last; i++) {
4683         char buf[20];
4684         sprintf(buf, "%s\n", parseList[i]);
4685         SendToICS(buf);
4686     }
4687     SendToICS(ics_prefix);
4688     SendToICS(ics_type == ICS_ICC ? "tag result Game in progress\n" : "commit\n");
4689 }
4690
4691 void
4692 CoordsToComputerAlgebraic(rf, ff, rt, ft, promoChar, move)
4693      int rf, ff, rt, ft;
4694      char promoChar;
4695      char move[7];
4696 {
4697     if (rf == DROP_RANK) {
4698         sprintf(move, "%c@%c%c\n",
4699                 ToUpper(PieceToChar((ChessSquare) ff)), AAA + ft, ONE + rt);
4700     } else {
4701         if (promoChar == 'x' || promoChar == NULLCHAR) {
4702             sprintf(move, "%c%c%c%c\n",
4703                     AAA + ff, ONE + rf, AAA + ft, ONE + rt);
4704         } else {
4705             sprintf(move, "%c%c%c%c%c\n",
4706                     AAA + ff, ONE + rf, AAA + ft, ONE + rt, promoChar);
4707         }
4708     }
4709 }
4710
4711 void
4712 ProcessICSInitScript(f)
4713      FILE *f;
4714 {
4715     char buf[MSG_SIZ];
4716
4717     while (fgets(buf, MSG_SIZ, f)) {
4718         SendToICSDelayed(buf,(long)appData.msLoginDelay);
4719     }
4720
4721     fclose(f);
4722 }
4723
4724
4725 /* [HGM] Shogi move preprocessor: swap digits for letters, vice versa */
4726 void
4727 AlphaRank(char *move, int n)
4728 {
4729 //    char *p = move, c; int x, y;
4730
4731     if (appData.debugMode) {
4732         fprintf(debugFP, "alphaRank(%s,%d)\n", move, n);
4733     }
4734
4735     if(move[1]=='*' &&
4736        move[2]>='0' && move[2]<='9' &&
4737        move[3]>='a' && move[3]<='x'    ) {
4738         move[1] = '@';
4739         move[2] = BOARD_RGHT  -1 - (move[2]-'1') + AAA;
4740         move[3] = BOARD_HEIGHT-1 - (move[3]-'a') + ONE;
4741     } else
4742     if(move[0]>='0' && move[0]<='9' &&
4743        move[1]>='a' && move[1]<='x' &&
4744        move[2]>='0' && move[2]<='9' &&
4745        move[3]>='a' && move[3]<='x'    ) {
4746         /* input move, Shogi -> normal */
4747         move[0] = BOARD_RGHT  -1 - (move[0]-'1') + AAA;
4748         move[1] = BOARD_HEIGHT-1 - (move[1]-'a') + ONE;
4749         move[2] = BOARD_RGHT  -1 - (move[2]-'1') + AAA;
4750         move[3] = BOARD_HEIGHT-1 - (move[3]-'a') + ONE;
4751     } else
4752     if(move[1]=='@' &&
4753        move[3]>='0' && move[3]<='9' &&
4754        move[2]>='a' && move[2]<='x'    ) {
4755         move[1] = '*';
4756         move[2] = BOARD_RGHT - 1 - (move[2]-AAA) + '1';
4757         move[3] = BOARD_HEIGHT-1 - (move[3]-ONE) + 'a';
4758     } else
4759     if(
4760        move[0]>='a' && move[0]<='x' &&
4761        move[3]>='0' && move[3]<='9' &&
4762        move[2]>='a' && move[2]<='x'    ) {
4763          /* output move, normal -> Shogi */
4764         move[0] = BOARD_RGHT - 1 - (move[0]-AAA) + '1';
4765         move[1] = BOARD_HEIGHT-1 - (move[1]-ONE) + 'a';
4766         move[2] = BOARD_RGHT - 1 - (move[2]-AAA) + '1';
4767         move[3] = BOARD_HEIGHT-1 - (move[3]-ONE) + 'a';
4768         if(move[4] == PieceToChar(BlackQueen)) move[4] = '+';
4769     }
4770     if (appData.debugMode) {
4771         fprintf(debugFP, "   out = '%s'\n", move);
4772     }
4773 }
4774
4775 char yy_textstr[8000];
4776
4777 /* Parser for moves from gnuchess, ICS, or user typein box */
4778 Boolean
4779 ParseOneMove(move, moveNum, moveType, fromX, fromY, toX, toY, promoChar)
4780      char *move;
4781      int moveNum;
4782      ChessMove *moveType;
4783      int *fromX, *fromY, *toX, *toY;
4784      char *promoChar;
4785 {
4786     if (appData.debugMode) {
4787         fprintf(debugFP, "move to parse: %s\n", move);
4788     }
4789     *moveType = yylexstr(moveNum, move, yy_textstr, sizeof yy_textstr);
4790
4791     switch (*moveType) {
4792       case WhitePromotionChancellor:
4793       case BlackPromotionChancellor:
4794       case WhitePromotionArchbishop:
4795       case BlackPromotionArchbishop:
4796       case WhitePromotionQueen:
4797       case BlackPromotionQueen:
4798       case WhitePromotionRook:
4799       case BlackPromotionRook:
4800       case WhitePromotionBishop:
4801       case BlackPromotionBishop:
4802       case WhitePromotionKnight:
4803       case BlackPromotionKnight:
4804       case WhitePromotionKing:
4805       case BlackPromotionKing:
4806       case NormalMove:
4807       case WhiteCapturesEnPassant:
4808       case BlackCapturesEnPassant:
4809       case WhiteKingSideCastle:
4810       case WhiteQueenSideCastle:
4811       case BlackKingSideCastle:
4812       case BlackQueenSideCastle:
4813       case WhiteKingSideCastleWild:
4814       case WhiteQueenSideCastleWild:
4815       case BlackKingSideCastleWild:
4816       case BlackQueenSideCastleWild:
4817       /* Code added by Tord: */
4818       case WhiteHSideCastleFR:
4819       case WhiteASideCastleFR:
4820       case BlackHSideCastleFR:
4821       case BlackASideCastleFR:
4822       /* End of code added by Tord */
4823       case IllegalMove:         /* bug or odd chess variant */
4824         *fromX = currentMoveString[0] - AAA;
4825         *fromY = currentMoveString[1] - ONE;
4826         *toX = currentMoveString[2] - AAA;
4827         *toY = currentMoveString[3] - ONE;
4828         *promoChar = currentMoveString[4];
4829         if (*fromX < BOARD_LEFT || *fromX >= BOARD_RGHT || *fromY < 0 || *fromY >= BOARD_HEIGHT ||
4830             *toX < BOARD_LEFT || *toX >= BOARD_RGHT || *toY < 0 || *toY >= BOARD_HEIGHT) {
4831     if (appData.debugMode) {
4832         fprintf(debugFP, "Off-board move (%d,%d)-(%d,%d)%c, type = %d\n", *fromX, *fromY, *toX, *toY, *promoChar, *moveType);
4833     }
4834             *fromX = *fromY = *toX = *toY = 0;
4835             return FALSE;
4836         }
4837         if (appData.testLegality) {
4838           return (*moveType != IllegalMove);
4839         } else {
4840           return !(*fromX == *toX && *fromY == *toY) && boards[moveNum][*fromY][*fromX] != EmptySquare &&
4841                         WhiteOnMove(moveNum) == (boards[moveNum][*fromY][*fromX] < BlackPawn);
4842         }
4843
4844       case WhiteDrop:
4845       case BlackDrop:
4846         *fromX = *moveType == WhiteDrop ?
4847           (int) CharToPiece(ToUpper(currentMoveString[0])) :
4848           (int) CharToPiece(ToLower(currentMoveString[0]));
4849         *fromY = DROP_RANK;
4850         *toX = currentMoveString[2] - AAA;
4851         *toY = currentMoveString[3] - ONE;
4852         *promoChar = NULLCHAR;
4853         return TRUE;
4854
4855       case AmbiguousMove:
4856       case ImpossibleMove:
4857       case (ChessMove) 0:       /* end of file */
4858       case ElapsedTime:
4859       case Comment:
4860       case PGNTag:
4861       case NAG:
4862       case WhiteWins:
4863       case BlackWins:
4864       case GameIsDrawn:
4865       default:
4866     if (appData.debugMode) {
4867         fprintf(debugFP, "Impossible move %s, type = %d\n", currentMoveString, *moveType);
4868     }
4869         /* bug? */
4870         *fromX = *fromY = *toX = *toY = 0;
4871         *promoChar = NULLCHAR;
4872         return FALSE;
4873     }
4874 }
4875
4876
4877 void
4878 ParsePV(char *pv, Boolean storeComments)
4879 { // Parse a string of PV moves, and append to current game, behind forwardMostMove
4880   int fromX, fromY, toX, toY; char promoChar;
4881   ChessMove moveType;
4882   Boolean valid;
4883   int nr = 0;
4884
4885   endPV = forwardMostMove;
4886   do {
4887     while(*pv == ' ' || *pv == '\n' || *pv == '\t') pv++; // must still read away whitespace
4888     if(nr == 0 && !storeComments && *pv == '(') pv++; // first (ponder) move can be in parentheses
4889     valid = ParseOneMove(pv, endPV, &moveType, &fromX, &fromY, &toX, &toY, &promoChar);
4890 if(appData.debugMode){
4891 fprintf(debugFP,"parsePV: %d %c%c%c%c yy='%s'\nPV = '%s'\n", valid, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, yy_textstr, pv);
4892 }
4893     if(!valid && nr == 0 &&
4894        ParseOneMove(pv, endPV-1, &moveType, &fromX, &fromY, &toX, &toY, &promoChar)){
4895         nr++; moveType = Comment; // First move has been played; kludge to make sure we continue
4896         // Hande case where played move is different from leading PV move
4897         CopyBoard(boards[endPV+1], boards[endPV-1]); // tentatively unplay last game move
4898         CopyBoard(boards[endPV+2], boards[endPV-1]); // and play first move of PV
4899         ApplyMove(fromX, fromY, toX, toY, promoChar, boards[endPV+2]);
4900         if(!CompareBoards(boards[endPV], boards[endPV+2])) {
4901           endPV += 2; // if position different, keep this
4902           moveList[endPV-1][0] = fromX + AAA;
4903           moveList[endPV-1][1] = fromY + ONE;
4904           moveList[endPV-1][2] = toX + AAA;
4905           moveList[endPV-1][3] = toY + ONE;
4906           parseList[endPV-1][0] = NULLCHAR;
4907           strcpy(moveList[endPV-2], "_0_0"); // suppress premove highlight on takeback move
4908         }
4909       }
4910     pv = strstr(pv, yy_textstr) + strlen(yy_textstr); // skip what we parsed
4911     if(nr == 0 && !storeComments && *pv == ')') pv++; // closing parenthesis of ponder move;
4912     if(moveType == Comment && storeComments) AppendComment(endPV, yy_textstr, FALSE);
4913     if(moveType == Comment || moveType == NAG || moveType == ElapsedTime) {
4914         valid++; // allow comments in PV
4915         continue;
4916     }
4917     nr++;
4918     if(endPV+1 > framePtr) break; // no space, truncate
4919     if(!valid) break;
4920     endPV++;
4921     CopyBoard(boards[endPV], boards[endPV-1]);
4922     ApplyMove(fromX, fromY, toX, toY, promoChar, boards[endPV]);
4923     moveList[endPV-1][0] = fromX + AAA;
4924     moveList[endPV-1][1] = fromY + ONE;
4925     moveList[endPV-1][2] = toX + AAA;
4926     moveList[endPV-1][3] = toY + ONE;
4927     if(storeComments)
4928         CoordsToAlgebraic(boards[endPV - 1],
4929                              PosFlags(endPV - 1),
4930                              fromY, fromX, toY, toX, promoChar,
4931                              parseList[endPV - 1]);
4932     else
4933         parseList[endPV-1][0] = NULLCHAR;
4934   } while(valid);
4935   currentMove = endPV;
4936   if(currentMove == forwardMostMove) ClearPremoveHighlights(); else
4937   SetPremoveHighlights(moveList[currentMove-1][0]-AAA, moveList[currentMove-1][1]-ONE,
4938                        moveList[currentMove-1][2]-AAA, moveList[currentMove-1][3]-ONE);
4939   DrawPosition(TRUE, boards[currentMove]);
4940 }
4941
4942 static int lastX, lastY;
4943
4944 Boolean
4945 LoadMultiPV(int x, int y, char *buf, int index, int *start, int *end)
4946 {
4947         int startPV;
4948         char *p;
4949
4950         if(index < 0 || index >= strlen(buf)) return FALSE; // sanity
4951         lastX = x; lastY = y;
4952         while(index > 0 && buf[index-1] != '\n') index--; // beginning of line
4953         startPV = index;
4954         while(buf[index] != '\n') if(buf[index++] == '\t') startPV = index;
4955         if(index == startPV && (p = StrCaseStr(buf+index, "PV="))) startPV = p - buf + 3;
4956         index = startPV;
4957         do{ while(buf[index] && buf[index] != '\n') index++;
4958         } while(buf[index] == '\n' && buf[index+1] == '\\' && buf[index+2] == ' ' && index++); // join kibitzed PV continuation line
4959         buf[index] = 0;
4960         ParsePV(buf+startPV, FALSE);
4961         *start = startPV; *end = index-1;
4962         return TRUE;
4963 }
4964
4965 Boolean
4966 LoadPV(int x, int y)
4967 { // called on right mouse click to load PV
4968   int which = gameMode == TwoMachinesPlay && (WhiteOnMove(forwardMostMove) == (second.twoMachinesColor[0] == 'w'));
4969   lastX = x; lastY = y;
4970   ParsePV(lastPV[which], FALSE); // load the PV of the thinking engine in the boards array.
4971   return TRUE;
4972 }
4973
4974 void
4975 UnLoadPV()
4976 {
4977   if(endPV < 0) return;
4978   endPV = -1;
4979   currentMove = forwardMostMove;
4980   ClearPremoveHighlights();
4981   DrawPosition(TRUE, boards[currentMove]);
4982 }
4983
4984 void
4985 MovePV(int x, int y, int h)
4986 { // step through PV based on mouse coordinates (called on mouse move)
4987   int margin = h>>3, step = 0;
4988
4989   if(endPV < 0) return;
4990   // we must somehow check if right button is still down (might be released off board!)
4991   if(y < margin && (abs(x - lastX) > 6 || abs(y - lastY) > 6)) step = 1; else
4992   if(y > h - margin && (abs(x - lastX) > 6 || abs(y - lastY) > 6)) step = -1; else
4993   if( y > lastY + 6 ) step = -1; else if(y < lastY - 6) step = 1;
4994   if(!step) return;
4995   lastX = x; lastY = y;
4996   if(currentMove + step > endPV || currentMove + step < forwardMostMove) step = 0;
4997   currentMove += step;
4998   if(currentMove == forwardMostMove) ClearPremoveHighlights(); else
4999   SetPremoveHighlights(moveList[currentMove-1][0]-AAA, moveList[currentMove-1][1]-ONE,
5000                        moveList[currentMove-1][2]-AAA, moveList[currentMove-1][3]-ONE);
5001   DrawPosition(FALSE, boards[currentMove]);
5002 }
5003
5004
5005 // [HGM] shuffle: a general way to suffle opening setups, applicable to arbitrary variants.
5006 // All positions will have equal probability, but the current method will not provide a unique
5007 // numbering scheme for arrays that contain 3 or more pieces of the same kind.
5008 #define DARK 1
5009 #define LITE 2
5010 #define ANY 3
5011
5012 int squaresLeft[4];
5013 int piecesLeft[(int)BlackPawn];
5014 int seed, nrOfShuffles;
5015
5016 void GetPositionNumber()
5017 {       // sets global variable seed
5018         int i;
5019
5020         seed = appData.defaultFrcPosition;
5021         if(seed < 0) { // randomize based on time for negative FRC position numbers
5022                 for(i=0; i<50; i++) seed += random();
5023                 seed = random() ^ random() >> 8 ^ random() << 8;
5024                 if(seed<0) seed = -seed;
5025         }
5026 }
5027
5028 int put(Board board, int pieceType, int rank, int n, int shade)
5029 // put the piece on the (n-1)-th empty squares of the given shade
5030 {
5031         int i;
5032
5033         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) {
5034                 if( (((i-BOARD_LEFT)&1)+1) & shade && board[rank][i] == EmptySquare && n-- == 0) {
5035                         board[rank][i] = (ChessSquare) pieceType;
5036                         squaresLeft[((i-BOARD_LEFT)&1) + 1]--;
5037                         squaresLeft[ANY]--;
5038                         piecesLeft[pieceType]--;
5039                         return i;
5040                 }
5041         }
5042         return -1;
5043 }
5044
5045
5046 void AddOnePiece(Board board, int pieceType, int rank, int shade)
5047 // calculate where the next piece goes, (any empty square), and put it there
5048 {
5049         int i;
5050
5051         i = seed % squaresLeft[shade];
5052         nrOfShuffles *= squaresLeft[shade];
5053         seed /= squaresLeft[shade];
5054         put(board, pieceType, rank, i, shade);
5055 }
5056
5057 void AddTwoPieces(Board board, int pieceType, int rank)
5058 // calculate where the next 2 identical pieces go, (any empty square), and put it there
5059 {
5060         int i, n=squaresLeft[ANY], j=n-1, k;
5061
5062         k = n*(n-1)/2; // nr of possibilities, not counting permutations
5063         i = seed % k;  // pick one
5064         nrOfShuffles *= k;
5065         seed /= k;
5066         while(i >= j) i -= j--;
5067         j = n - 1 - j; i += j;
5068         put(board, pieceType, rank, j, ANY);
5069         put(board, pieceType, rank, i, ANY);
5070 }
5071
5072 void SetUpShuffle(Board board, int number)
5073 {
5074         int i, p, first=1;
5075
5076         GetPositionNumber(); nrOfShuffles = 1;
5077
5078         squaresLeft[DARK] = (BOARD_RGHT - BOARD_LEFT + 1)/2;
5079         squaresLeft[ANY]  = BOARD_RGHT - BOARD_LEFT;
5080         squaresLeft[LITE] = squaresLeft[ANY] - squaresLeft[DARK];
5081
5082         for(p = 0; p<=(int)WhiteKing; p++) piecesLeft[p] = 0;
5083
5084         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) { // count pieces and clear board
5085             p = (int) board[0][i];
5086             if(p < (int) BlackPawn) piecesLeft[p] ++;
5087             board[0][i] = EmptySquare;
5088         }
5089
5090         if(PosFlags(0) & F_ALL_CASTLE_OK) {
5091             // shuffles restricted to allow normal castling put KRR first
5092             if(piecesLeft[(int)WhiteKing]) // King goes rightish of middle
5093                 put(board, WhiteKing, 0, (gameInfo.boardWidth+1)/2, ANY);
5094             else if(piecesLeft[(int)WhiteUnicorn]) // in Knightmate Unicorn castles
5095                 put(board, WhiteUnicorn, 0, (gameInfo.boardWidth+1)/2, ANY);
5096             if(piecesLeft[(int)WhiteRook]) // First supply a Rook for K-side castling
5097                 put(board, WhiteRook, 0, gameInfo.boardWidth-2, ANY);
5098             if(piecesLeft[(int)WhiteRook]) // Then supply a Rook for Q-side castling
5099                 put(board, WhiteRook, 0, 0, ANY);
5100             // in variants with super-numerary Kings and Rooks, we leave these for the shuffle
5101         }
5102
5103         if(((BOARD_RGHT-BOARD_LEFT) & 1) == 0)
5104             // only for even boards make effort to put pairs of colorbound pieces on opposite colors
5105             for(p = (int) WhiteKing; p > (int) WhitePawn; p--) {
5106                 if(p != (int) WhiteBishop && p != (int) WhiteFerz && p != (int) WhiteAlfil) continue;
5107                 while(piecesLeft[p] >= 2) {
5108                     AddOnePiece(board, p, 0, LITE);
5109                     AddOnePiece(board, p, 0, DARK);
5110                 }
5111                 // Odd color-bound pieces are shuffled with the rest (to not run out of paired squares)
5112             }
5113
5114         for(p = (int) WhiteKing - 2; p > (int) WhitePawn; p--) {
5115             // Remaining pieces (non-colorbound, or odd color bound) can be put anywhere
5116             // but we leave King and Rooks for last, to possibly obey FRC restriction
5117             if(p == (int)WhiteRook) continue;
5118             while(piecesLeft[p] >= 2) AddTwoPieces(board, p, 0); // add in pairs, for not counting permutations
5119             if(piecesLeft[p]) AddOnePiece(board, p, 0, ANY);     // add the odd piece
5120         }
5121
5122         // now everything is placed, except perhaps King (Unicorn) and Rooks
5123
5124         if(PosFlags(0) & F_FRC_TYPE_CASTLING) {
5125             // Last King gets castling rights
5126             while(piecesLeft[(int)WhiteUnicorn]) {
5127                 i = put(board, WhiteUnicorn, 0, piecesLeft[(int)WhiteRook]/2, ANY);
5128                 initialRights[2]  = initialRights[5]  = board[CASTLING][2] = board[CASTLING][5] = i;
5129             }
5130
5131             while(piecesLeft[(int)WhiteKing]) {
5132                 i = put(board, WhiteKing, 0, piecesLeft[(int)WhiteRook]/2, ANY);
5133                 initialRights[2]  = initialRights[5]  = board[CASTLING][2] = board[CASTLING][5] = i;
5134             }
5135
5136
5137         } else {
5138             while(piecesLeft[(int)WhiteKing])    AddOnePiece(board, WhiteKing, 0, ANY);
5139             while(piecesLeft[(int)WhiteUnicorn]) AddOnePiece(board, WhiteUnicorn, 0, ANY);
5140         }
5141
5142         // Only Rooks can be left; simply place them all
5143         while(piecesLeft[(int)WhiteRook]) {
5144                 i = put(board, WhiteRook, 0, 0, ANY);
5145                 if(PosFlags(0) & F_FRC_TYPE_CASTLING) { // first and last Rook get FRC castling rights
5146                         if(first) {
5147                                 first=0;
5148                                 initialRights[1]  = initialRights[4]  = board[CASTLING][1] = board[CASTLING][4] = i;
5149                         }
5150                         initialRights[0]  = initialRights[3]  = board[CASTLING][0] = board[CASTLING][3] = i;
5151                 }
5152         }
5153         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) { // copy black from white
5154             board[BOARD_HEIGHT-1][i] =  (int) board[0][i] < BlackPawn ? WHITE_TO_BLACK board[0][i] : EmptySquare;
5155         }
5156
5157         if(number >= 0) appData.defaultFrcPosition %= nrOfShuffles; // normalize
5158 }
5159
5160 int SetCharTable( char *table, const char * map )
5161 /* [HGM] moved here from winboard.c because of its general usefulness */
5162 /*       Basically a safe strcpy that uses the last character as King */
5163 {
5164     int result = FALSE; int NrPieces;
5165
5166     if( map != NULL && (NrPieces=strlen(map)) <= (int) EmptySquare
5167                     && NrPieces >= 12 && !(NrPieces&1)) {
5168         int i; /* [HGM] Accept even length from 12 to 34 */
5169
5170         for( i=0; i<(int) EmptySquare; i++ ) table[i] = '.';
5171         for( i=0; i<NrPieces/2-1; i++ ) {
5172             table[i] = map[i];
5173             table[i + (int)BlackPawn - (int) WhitePawn] = map[i+NrPieces/2];
5174         }
5175         table[(int) WhiteKing]  = map[NrPieces/2-1];
5176         table[(int) BlackKing]  = map[NrPieces-1];
5177
5178         result = TRUE;
5179     }
5180
5181     return result;
5182 }
5183
5184 void Prelude(Board board)
5185 {       // [HGM] superchess: random selection of exo-pieces
5186         int i, j, k; ChessSquare p;
5187         static ChessSquare exoPieces[4] = { WhiteAngel, WhiteMarshall, WhiteSilver, WhiteLance };
5188
5189         GetPositionNumber(); // use FRC position number
5190
5191         if(appData.pieceToCharTable != NULL) { // select pieces to participate from given char table
5192             SetCharTable(pieceToChar, appData.pieceToCharTable);
5193             for(i=(int)WhiteQueen+1, j=0; i<(int)WhiteKing && j<4; i++)
5194                 if(PieceToChar((ChessSquare)i) != '.') exoPieces[j++] = (ChessSquare) i;
5195         }
5196
5197         j = seed%4;                 seed /= 4;
5198         p = board[0][BOARD_LEFT+j];   board[0][BOARD_LEFT+j] = EmptySquare; k = PieceToNumber(p);
5199         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
5200         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
5201         j = seed%3 + (seed%3 >= j); seed /= 3;
5202         p = board[0][BOARD_LEFT+j];   board[0][BOARD_LEFT+j] = EmptySquare; k = PieceToNumber(p);
5203         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
5204         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
5205         j = seed%3;                 seed /= 3;
5206         p = board[0][BOARD_LEFT+j+5]; board[0][BOARD_LEFT+j+5] = EmptySquare; k = PieceToNumber(p);
5207         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
5208         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
5209         j = seed%2 + (seed%2 >= j); seed /= 2;
5210         p = board[0][BOARD_LEFT+j+5]; board[0][BOARD_LEFT+j+5] = EmptySquare; k = PieceToNumber(p);
5211         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
5212         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
5213         j = seed%4; seed /= 4; put(board, exoPieces[3],    0, j, ANY);
5214         j = seed%3; seed /= 3; put(board, exoPieces[2],   0, j, ANY);
5215         j = seed%2; seed /= 2; put(board, exoPieces[1], 0, j, ANY);
5216         put(board, exoPieces[0],    0, 0, ANY);
5217         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) board[BOARD_HEIGHT-1][i] = WHITE_TO_BLACK board[0][i];
5218 }
5219
5220 void
5221 InitPosition(redraw)
5222      int redraw;
5223 {
5224     ChessSquare (* pieces)[BOARD_FILES];
5225     int i, j, pawnRow, overrule,
5226     oldx = gameInfo.boardWidth,
5227     oldy = gameInfo.boardHeight,
5228     oldh = gameInfo.holdingsWidth,
5229     oldv = gameInfo.variant;
5230
5231     if(appData.icsActive) shuffleOpenings = FALSE; // [HGM] shuffle: in ICS mode, only shuffle on ICS request
5232
5233     /* [AS] Initialize pv info list [HGM] and game status */
5234     {
5235         for( i=0; i<=framePtr; i++ ) { // [HGM] vari: spare saved variations
5236             pvInfoList[i].depth = 0;
5237             boards[i][EP_STATUS] = EP_NONE;
5238             for( j=0; j<BOARD_FILES-2; j++ ) boards[i][CASTLING][j] = NoRights;
5239         }
5240
5241         initialRulePlies = 0; /* 50-move counter start */
5242
5243         castlingRank[0] = castlingRank[1] = castlingRank[2] = 0;
5244         castlingRank[3] = castlingRank[4] = castlingRank[5] = BOARD_HEIGHT-1;
5245     }
5246
5247
5248     /* [HGM] logic here is completely changed. In stead of full positions */
5249     /* the initialized data only consist of the two backranks. The switch */
5250     /* selects which one we will use, which is than copied to the Board   */
5251     /* initialPosition, which for the rest is initialized by Pawns and    */
5252     /* empty squares. This initial position is then copied to boards[0],  */
5253     /* possibly after shuffling, so that it remains available.            */
5254
5255     gameInfo.holdingsWidth = 0; /* default board sizes */
5256     gameInfo.boardWidth    = 8;
5257     gameInfo.boardHeight   = 8;
5258     gameInfo.holdingsSize  = 0;
5259     nrCastlingRights = -1; /* [HGM] Kludge to indicate default should be used */
5260     for(i=0; i<BOARD_FILES-2; i++)
5261       initialPosition[CASTLING][i] = initialRights[i] = NoRights; /* but no rights yet */
5262     initialPosition[EP_STATUS] = EP_NONE;
5263     SetCharTable(pieceToChar, "PNBRQ...........Kpnbrq...........k");
5264
5265     switch (gameInfo.variant) {
5266     case VariantFischeRandom:
5267       shuffleOpenings = TRUE;
5268     default:
5269       pieces = FIDEArray;
5270       break;
5271     case VariantShatranj:
5272       pieces = ShatranjArray;
5273       nrCastlingRights = 0;
5274       SetCharTable(pieceToChar, "PN.R.QB...Kpn.r.qb...k");
5275       break;
5276     case VariantMakruk:
5277       pieces = makrukArray;
5278       nrCastlingRights = 0;
5279       startedFromSetupPosition = TRUE;
5280       SetCharTable(pieceToChar, "PN.R.M....SKpn.r.m....sk");
5281       break;
5282     case VariantTwoKings:
5283       pieces = twoKingsArray;
5284       break;
5285     case VariantCapaRandom:
5286       shuffleOpenings = TRUE;
5287     case VariantCapablanca:
5288       pieces = CapablancaArray;
5289       gameInfo.boardWidth = 10;
5290       SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
5291       break;
5292     case VariantGothic:
5293       pieces = GothicArray;
5294       gameInfo.boardWidth = 10;
5295       SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
5296       break;
5297     case VariantJanus:
5298       pieces = JanusArray;
5299       gameInfo.boardWidth = 10;
5300       SetCharTable(pieceToChar, "PNBRQ..JKpnbrq..jk");
5301       nrCastlingRights = 6;
5302         initialPosition[CASTLING][0] = initialRights[0] = BOARD_RGHT-1;
5303         initialPosition[CASTLING][1] = initialRights[1] = BOARD_LEFT;
5304         initialPosition[CASTLING][2] = initialRights[2] =(BOARD_WIDTH-1)>>1;
5305         initialPosition[CASTLING][3] = initialRights[3] = BOARD_RGHT-1;
5306         initialPosition[CASTLING][4] = initialRights[4] = BOARD_LEFT;
5307         initialPosition[CASTLING][5] = initialRights[5] =(BOARD_WIDTH-1)>>1;
5308       break;
5309     case VariantFalcon:
5310       pieces = FalconArray;
5311       gameInfo.boardWidth = 10;
5312       SetCharTable(pieceToChar, "PNBRQ.............FKpnbrq.............fk");
5313       break;
5314     case VariantXiangqi:
5315       pieces = XiangqiArray;
5316       gameInfo.boardWidth  = 9;
5317       gameInfo.boardHeight = 10;
5318       nrCastlingRights = 0;
5319       SetCharTable(pieceToChar, "PH.R.AE..K.C.ph.r.ae..k.c.");
5320       break;
5321     case VariantShogi:
5322       pieces = ShogiArray;
5323       gameInfo.boardWidth  = 9;
5324       gameInfo.boardHeight = 9;
5325       gameInfo.holdingsSize = 7;
5326       nrCastlingRights = 0;
5327       SetCharTable(pieceToChar, "PNBRLS...G.++++++Kpnbrls...g.++++++k");
5328       break;
5329     case VariantCourier:
5330       pieces = CourierArray;
5331       gameInfo.boardWidth  = 12;
5332       nrCastlingRights = 0;
5333       SetCharTable(pieceToChar, "PNBR.FE..WMKpnbr.fe..wmk");
5334       break;
5335     case VariantKnightmate:
5336       pieces = KnightmateArray;
5337       SetCharTable(pieceToChar, "P.BRQ.....M.........K.p.brq.....m.........k.");
5338       break;
5339     case VariantFairy:
5340       pieces = fairyArray;
5341       SetCharTable(pieceToChar, "PNBRQFEACWMOHIJGDVLSUKpnbrqfeacwmohijgdvlsuk");
5342       break;
5343     case VariantGreat:
5344       pieces = GreatArray;
5345       gameInfo.boardWidth = 10;
5346       SetCharTable(pieceToChar, "PN....E...S..HWGMKpn....e...s..hwgmk");
5347       gameInfo.holdingsSize = 8;
5348       break;
5349     case VariantSuper:
5350       pieces = FIDEArray;
5351       SetCharTable(pieceToChar, "PNBRQ..SE.......V.AKpnbrq..se.......v.ak");
5352       gameInfo.holdingsSize = 8;
5353       startedFromSetupPosition = TRUE;
5354       break;
5355     case VariantCrazyhouse:
5356     case VariantBughouse:
5357       pieces = FIDEArray;
5358       SetCharTable(pieceToChar, "PNBRQ.......~~~~Kpnbrq.......~~~~k");
5359       gameInfo.holdingsSize = 5;
5360       break;
5361     case VariantWildCastle:
5362       pieces = FIDEArray;
5363       /* !!?shuffle with kings guaranteed to be on d or e file */
5364       shuffleOpenings = 1;
5365       break;
5366     case VariantNoCastle:
5367       pieces = FIDEArray;
5368       nrCastlingRights = 0;
5369       /* !!?unconstrained back-rank shuffle */
5370       shuffleOpenings = 1;
5371       break;
5372     }
5373
5374     overrule = 0;
5375     if(appData.NrFiles >= 0) {
5376         if(gameInfo.boardWidth != appData.NrFiles) overrule++;
5377         gameInfo.boardWidth = appData.NrFiles;
5378     }
5379     if(appData.NrRanks >= 0) {
5380         gameInfo.boardHeight = appData.NrRanks;
5381     }
5382     if(appData.holdingsSize >= 0) {
5383         i = appData.holdingsSize;
5384         if(i > gameInfo.boardHeight) i = gameInfo.boardHeight;
5385         gameInfo.holdingsSize = i;
5386     }
5387     if(gameInfo.holdingsSize) gameInfo.holdingsWidth = 2;
5388     if(BOARD_HEIGHT > BOARD_RANKS || BOARD_WIDTH > BOARD_FILES)
5389         DisplayFatalError(_("Recompile to support this BOARD_RANKS or BOARD_FILES!"), 0, 2);
5390
5391     pawnRow = gameInfo.boardHeight - 7; /* seems to work in all common variants */
5392     if(pawnRow < 1) pawnRow = 1;
5393     if(gameInfo.variant == VariantMakruk) pawnRow = 2;
5394
5395     /* User pieceToChar list overrules defaults */
5396     if(appData.pieceToCharTable != NULL)
5397         SetCharTable(pieceToChar, appData.pieceToCharTable);
5398
5399     for( j=0; j<BOARD_WIDTH; j++ ) { ChessSquare s = EmptySquare;
5400
5401         if(j==BOARD_LEFT-1 || j==BOARD_RGHT)
5402             s = (ChessSquare) 0; /* account holding counts in guard band */
5403         for( i=0; i<BOARD_HEIGHT; i++ )
5404             initialPosition[i][j] = s;
5405
5406         if(j < BOARD_LEFT || j >= BOARD_RGHT || overrule) continue;
5407         initialPosition[0][j] = pieces[0][j-gameInfo.holdingsWidth];
5408         initialPosition[pawnRow][j] = WhitePawn;
5409         initialPosition[BOARD_HEIGHT-pawnRow-1][j] = BlackPawn;
5410         if(gameInfo.variant == VariantXiangqi) {
5411             if(j&1) {
5412                 initialPosition[pawnRow][j] =
5413                 initialPosition[BOARD_HEIGHT-pawnRow-1][j] = EmptySquare;
5414                 if(j==BOARD_LEFT+1 || j>=BOARD_RGHT-2) {
5415                    initialPosition[2][j] = WhiteCannon;
5416                    initialPosition[BOARD_HEIGHT-3][j] = BlackCannon;
5417                 }
5418             }
5419         }
5420         initialPosition[BOARD_HEIGHT-1][j] =  pieces[1][j-gameInfo.holdingsWidth];
5421     }
5422     if( (gameInfo.variant == VariantShogi) && !overrule ) {
5423
5424             j=BOARD_LEFT+1;
5425             initialPosition[1][j] = WhiteBishop;
5426             initialPosition[BOARD_HEIGHT-2][j] = BlackRook;
5427             j=BOARD_RGHT-2;
5428             initialPosition[1][j] = WhiteRook;
5429             initialPosition[BOARD_HEIGHT-2][j] = BlackBishop;
5430     }
5431
5432     if( nrCastlingRights == -1) {
5433         /* [HGM] Build normal castling rights (must be done after board sizing!) */
5434         /*       This sets default castling rights from none to normal corners   */
5435         /* Variants with other castling rights must set them themselves above    */
5436         nrCastlingRights = 6;
5437
5438         initialPosition[CASTLING][0] = initialRights[0] = BOARD_RGHT-1;
5439         initialPosition[CASTLING][1] = initialRights[1] = BOARD_LEFT;
5440         initialPosition[CASTLING][2] = initialRights[2] = BOARD_WIDTH>>1;
5441         initialPosition[CASTLING][3] = initialRights[3] = BOARD_RGHT-1;
5442         initialPosition[CASTLING][4] = initialRights[4] = BOARD_LEFT;
5443         initialPosition[CASTLING][5] = initialRights[5] = BOARD_WIDTH>>1;
5444      }
5445
5446      if(gameInfo.variant == VariantSuper) Prelude(initialPosition);
5447      if(gameInfo.variant == VariantGreat) { // promotion commoners
5448         initialPosition[PieceToNumber(WhiteMan)][BOARD_WIDTH-1] = WhiteMan;
5449         initialPosition[PieceToNumber(WhiteMan)][BOARD_WIDTH-2] = 9;
5450         initialPosition[BOARD_HEIGHT-1-PieceToNumber(WhiteMan)][0] = BlackMan;
5451         initialPosition[BOARD_HEIGHT-1-PieceToNumber(WhiteMan)][1] = 9;
5452      }
5453   if (appData.debugMode) {
5454     fprintf(debugFP, "shuffleOpenings = %d\n", shuffleOpenings);
5455   }
5456     if(shuffleOpenings) {
5457         SetUpShuffle(initialPosition, appData.defaultFrcPosition);
5458         startedFromSetupPosition = TRUE;
5459     }
5460     if(startedFromPositionFile) {
5461       /* [HGM] loadPos: use PositionFile for every new game */
5462       CopyBoard(initialPosition, filePosition);
5463       for(i=0; i<nrCastlingRights; i++)
5464           initialRights[i] = filePosition[CASTLING][i];
5465       startedFromSetupPosition = TRUE;
5466     }
5467
5468     CopyBoard(boards[0], initialPosition);
5469
5470     if(oldx != gameInfo.boardWidth ||
5471        oldy != gameInfo.boardHeight ||
5472        oldh != gameInfo.holdingsWidth
5473 #ifdef GOTHIC
5474        || oldv == VariantGothic ||        // For licensing popups
5475        gameInfo.variant == VariantGothic
5476 #endif
5477 #ifdef FALCON
5478        || oldv == VariantFalcon ||
5479        gameInfo.variant == VariantFalcon
5480 #endif
5481                                          )
5482             InitDrawingSizes(-2 ,0);
5483
5484     if (redraw)
5485       DrawPosition(TRUE, boards[currentMove]);
5486 }
5487
5488 void
5489 SendBoard(cps, moveNum)
5490      ChessProgramState *cps;
5491      int moveNum;
5492 {
5493     char message[MSG_SIZ];
5494
5495     if (cps->useSetboard) {
5496       char* fen = PositionToFEN(moveNum, cps->fenOverride);
5497       sprintf(message, "setboard %s\n", fen);
5498       SendToProgram(message, cps);
5499       free(fen);
5500
5501     } else {
5502       ChessSquare *bp;
5503       int i, j;
5504       /* Kludge to set black to move, avoiding the troublesome and now
5505        * deprecated "black" command.
5506        */
5507       if (!WhiteOnMove(moveNum)) SendToProgram("a2a3\n", cps);
5508
5509       SendToProgram("edit\n", cps);
5510       SendToProgram("#\n", cps);
5511       for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
5512         bp = &boards[moveNum][i][BOARD_LEFT];
5513         for (j = BOARD_LEFT; j < BOARD_RGHT; j++, bp++) {
5514           if ((int) *bp < (int) BlackPawn) {
5515             sprintf(message, "%c%c%c\n", PieceToChar(*bp),
5516                     AAA + j, ONE + i);
5517             if(message[0] == '+' || message[0] == '~') {
5518                 sprintf(message, "%c%c%c+\n",
5519                         PieceToChar((ChessSquare)(DEMOTED *bp)),
5520                         AAA + j, ONE + i);
5521             }
5522             if(cps->alphaRank) { /* [HGM] shogi: translate coords */
5523                 message[1] = BOARD_RGHT   - 1 - j + '1';
5524                 message[2] = BOARD_HEIGHT - 1 - i + 'a';
5525             }
5526             SendToProgram(message, cps);
5527           }
5528         }
5529       }
5530
5531       SendToProgram("c\n", cps);
5532       for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
5533         bp = &boards[moveNum][i][BOARD_LEFT];
5534         for (j = BOARD_LEFT; j < BOARD_RGHT; j++, bp++) {
5535           if (((int) *bp != (int) EmptySquare)
5536               && ((int) *bp >= (int) BlackPawn)) {
5537             sprintf(message, "%c%c%c\n", ToUpper(PieceToChar(*bp)),
5538                     AAA + j, ONE + i);
5539             if(message[0] == '+' || message[0] == '~') {
5540                 sprintf(message, "%c%c%c+\n",
5541                         PieceToChar((ChessSquare)(DEMOTED *bp)),
5542                         AAA + j, ONE + i);
5543             }
5544             if(cps->alphaRank) { /* [HGM] shogi: translate coords */
5545                 message[1] = BOARD_RGHT   - 1 - j + '1';
5546                 message[2] = BOARD_HEIGHT - 1 - i + 'a';
5547             }
5548             SendToProgram(message, cps);
5549           }
5550         }
5551       }
5552
5553       SendToProgram(".\n", cps);
5554     }
5555     setboardSpoiledMachineBlack = 0; /* [HGM] assume WB 4.2.7 already solves this after sending setboard */
5556 }
5557
5558 static int autoQueen; // [HGM] oneclick
5559
5560 int
5561 HasPromotionChoice(int fromX, int fromY, int toX, int toY, char *promoChoice)
5562 {
5563     /* [HGM] rewritten IsPromotion to only flag promotions that offer a choice */
5564     /* [HGM] add Shogi promotions */
5565     int promotionZoneSize=1, highestPromotingPiece = (int)WhitePawn;
5566     ChessSquare piece;
5567     ChessMove moveType;
5568     Boolean premove;
5569
5570     if(fromX < BOARD_LEFT || fromX >= BOARD_RGHT) return FALSE; // drop
5571     if(toX   < BOARD_LEFT || toX   >= BOARD_RGHT) return FALSE; // move into holdings
5572
5573     if(gameMode == EditPosition || gameInfo.variant == VariantXiangqi || // no promotions
5574       !(fromX >=0 && fromY >= 0 && toX >= 0 && toY >= 0) ) // invalid move
5575         return FALSE;
5576
5577     piece = boards[currentMove][fromY][fromX];
5578     if(gameInfo.variant == VariantShogi) {
5579         promotionZoneSize = 3;
5580         highestPromotingPiece = (int)WhiteFerz;
5581     } else if(gameInfo.variant == VariantMakruk) {
5582         promotionZoneSize = 3;
5583     }
5584
5585     // next weed out all moves that do not touch the promotion zone at all
5586     if((int)piece >= BlackPawn) {
5587         if(toY >= promotionZoneSize && fromY >= promotionZoneSize)
5588              return FALSE;
5589         highestPromotingPiece = WHITE_TO_BLACK highestPromotingPiece;
5590     } else {
5591         if(  toY < BOARD_HEIGHT - promotionZoneSize &&
5592            fromY < BOARD_HEIGHT - promotionZoneSize) return FALSE;
5593     }
5594
5595     if( (int)piece > highestPromotingPiece ) return FALSE; // non-promoting piece
5596
5597     // weed out mandatory Shogi promotions
5598     if(gameInfo.variant == VariantShogi) {
5599         if(piece >= BlackPawn) {
5600             if(toY == 0 && piece == BlackPawn ||
5601                toY == 0 && piece == BlackQueen ||
5602                toY <= 1 && piece == BlackKnight) {
5603                 *promoChoice = '+';
5604                 return FALSE;
5605             }
5606         } else {
5607             if(toY == BOARD_HEIGHT-1 && piece == WhitePawn ||
5608                toY == BOARD_HEIGHT-1 && piece == WhiteQueen ||
5609                toY >= BOARD_HEIGHT-2 && piece == WhiteKnight) {
5610                 *promoChoice = '+';
5611                 return FALSE;
5612             }
5613         }
5614     }
5615
5616     // weed out obviously illegal Pawn moves
5617     if(appData.testLegality  && (piece == WhitePawn || piece == BlackPawn) ) {
5618         if(toX > fromX+1 || toX < fromX-1) return FALSE; // wide
5619         if(piece == WhitePawn && toY != fromY+1) return FALSE; // deep
5620         if(piece == BlackPawn && toY != fromY-1) return FALSE; // deep
5621         if(fromX != toX && gameInfo.variant == VariantShogi) return FALSE;
5622         // note we are not allowed to test for valid (non-)capture, due to premove
5623     }
5624
5625     // we either have a choice what to promote to, or (in Shogi) whether to promote
5626     if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier || gameInfo.variant == VariantMakruk) {
5627         *promoChoice = PieceToChar(BlackFerz);  // no choice
5628         return FALSE;
5629     }
5630     if(autoQueen) { // predetermined
5631         if(gameInfo.variant == VariantSuicide || gameInfo.variant == VariantLosers)
5632              *promoChoice = PieceToChar(BlackKing); // in Suicide Q is the last thing we want
5633         else *promoChoice = PieceToChar(BlackQueen);
5634         return FALSE;
5635     }
5636
5637     // suppress promotion popup on illegal moves that are not premoves
5638     premove = gameMode == IcsPlayingWhite && !WhiteOnMove(currentMove) ||
5639               gameMode == IcsPlayingBlack &&  WhiteOnMove(currentMove);
5640     if(appData.testLegality && !premove) {
5641         moveType = LegalityTest(boards[currentMove], PosFlags(currentMove),
5642                         fromY, fromX, toY, toX, NULLCHAR);
5643         if(moveType != WhitePromotionQueen && moveType  != BlackPromotionQueen &&
5644            moveType != WhitePromotionKnight && moveType != BlackPromotionKnight)
5645             return FALSE;
5646     }
5647
5648     return TRUE;
5649 }
5650
5651 int
5652 InPalace(row, column)
5653      int row, column;
5654 {   /* [HGM] for Xiangqi */
5655     if( (row < 3 || row > BOARD_HEIGHT-4) &&
5656          column < (BOARD_WIDTH + 4)/2 &&
5657          column > (BOARD_WIDTH - 5)/2 ) return TRUE;
5658     return FALSE;
5659 }
5660
5661 int
5662 PieceForSquare (x, y)
5663      int x;
5664      int y;
5665 {
5666   if (x < 0 || x >= BOARD_WIDTH || y < 0 || y >= BOARD_HEIGHT)
5667      return -1;
5668   else
5669      return boards[currentMove][y][x];
5670 }
5671
5672 int
5673 OKToStartUserMove(x, y)
5674      int x, y;
5675 {
5676     ChessSquare from_piece;
5677     int white_piece;
5678
5679     if (matchMode) return FALSE;
5680     if (gameMode == EditPosition) return TRUE;
5681
5682     if (x >= 0 && y >= 0)
5683       from_piece = boards[currentMove][y][x];
5684     else
5685       from_piece = EmptySquare;
5686
5687     if (from_piece == EmptySquare) return FALSE;
5688
5689     white_piece = (int)from_piece >= (int)WhitePawn &&
5690       (int)from_piece < (int)BlackPawn; /* [HGM] can be > King! */
5691
5692     switch (gameMode) {
5693       case PlayFromGameFile:
5694       case AnalyzeFile:
5695       case TwoMachinesPlay:
5696       case EndOfGame:
5697         return FALSE;
5698
5699       case IcsObserving:
5700       case IcsIdle:
5701         return FALSE;
5702
5703       case MachinePlaysWhite:
5704       case IcsPlayingBlack:
5705         if (appData.zippyPlay) return FALSE;
5706         if (white_piece) {
5707             DisplayMoveError(_("You are playing Black"));
5708             return FALSE;
5709         }
5710         break;
5711
5712       case MachinePlaysBlack:
5713       case IcsPlayingWhite:
5714         if (appData.zippyPlay) return FALSE;
5715         if (!white_piece) {
5716             DisplayMoveError(_("You are playing White"));
5717             return FALSE;
5718         }
5719         break;
5720
5721       case EditGame:
5722         if (!white_piece && WhiteOnMove(currentMove)) {
5723             DisplayMoveError(_("It is White's turn"));
5724             return FALSE;
5725         }
5726         if (white_piece && !WhiteOnMove(currentMove)) {
5727             DisplayMoveError(_("It is Black's turn"));
5728             return FALSE;
5729         }
5730         if (cmailMsgLoaded && (currentMove < cmailOldMove)) {
5731             /* Editing correspondence game history */
5732             /* Could disallow this or prompt for confirmation */
5733             cmailOldMove = -1;
5734         }
5735         break;
5736
5737       case BeginningOfGame:
5738         if (appData.icsActive) return FALSE;
5739         if (!appData.noChessProgram) {
5740             if (!white_piece) {
5741                 DisplayMoveError(_("You are playing White"));
5742                 return FALSE;
5743             }
5744         }
5745         break;
5746
5747       case Training:
5748         if (!white_piece && WhiteOnMove(currentMove)) {
5749             DisplayMoveError(_("It is White's turn"));
5750             return FALSE;
5751         }
5752         if (white_piece && !WhiteOnMove(currentMove)) {
5753             DisplayMoveError(_("It is Black's turn"));
5754             return FALSE;
5755         }
5756         break;
5757
5758       default:
5759       case IcsExamining:
5760         break;
5761     }
5762     if (currentMove != forwardMostMove && gameMode != AnalyzeMode
5763         && gameMode != EditGame // [HGM] vari: treat as AnalyzeMode
5764         && gameMode != AnalyzeFile && gameMode != Training) {
5765         DisplayMoveError(_("Displayed position is not current"));
5766         return FALSE;
5767     }
5768     return TRUE;
5769 }
5770
5771 Boolean
5772 OnlyMove(int *x, int *y, Boolean captures) {
5773     DisambiguateClosure cl;
5774     if (appData.zippyPlay) return FALSE;
5775     switch(gameMode) {
5776       case MachinePlaysBlack:
5777       case IcsPlayingWhite:
5778       case BeginningOfGame:
5779         if(!WhiteOnMove(currentMove)) return FALSE;
5780         break;
5781       case MachinePlaysWhite:
5782       case IcsPlayingBlack:
5783         if(WhiteOnMove(currentMove)) return FALSE;
5784         break;
5785       default:
5786         return FALSE;
5787     }
5788     cl.pieceIn = EmptySquare;
5789     cl.rfIn = *y;
5790     cl.ffIn = *x;
5791     cl.rtIn = -1;
5792     cl.ftIn = -1;
5793     cl.promoCharIn = NULLCHAR;
5794     Disambiguate(boards[currentMove], PosFlags(currentMove), &cl);
5795     if( cl.kind == NormalMove ||
5796         cl.kind == AmbiguousMove && captures && cl.captures == 1 ||
5797         cl.kind == WhitePromotionQueen || cl.kind == BlackPromotionQueen ||
5798         cl.kind == WhitePromotionKnight || cl.kind == BlackPromotionKnight ||
5799         cl.kind == WhiteCapturesEnPassant || cl.kind == BlackCapturesEnPassant) {
5800       fromX = cl.ff;
5801       fromY = cl.rf;
5802       *x = cl.ft;
5803       *y = cl.rt;
5804       return TRUE;
5805     }
5806     if(cl.kind != ImpossibleMove) return FALSE;
5807     cl.pieceIn = EmptySquare;
5808     cl.rfIn = -1;
5809     cl.ffIn = -1;
5810     cl.rtIn = *y;
5811     cl.ftIn = *x;
5812     cl.promoCharIn = NULLCHAR;
5813     Disambiguate(boards[currentMove], PosFlags(currentMove), &cl);
5814     if( cl.kind == NormalMove ||
5815         cl.kind == AmbiguousMove && captures && cl.captures == 1 ||
5816         cl.kind == WhitePromotionQueen || cl.kind == BlackPromotionQueen ||
5817         cl.kind == WhitePromotionKnight || cl.kind == BlackPromotionKnight ||
5818         cl.kind == WhiteCapturesEnPassant || cl.kind == BlackCapturesEnPassant) {
5819       fromX = cl.ff;
5820       fromY = cl.rf;
5821       *x = cl.ft;
5822       *y = cl.rt;
5823       autoQueen = TRUE; // act as if autoQueen on when we click to-square
5824       return TRUE;
5825     }
5826     return FALSE;
5827 }
5828
5829 FILE *lastLoadGameFP = NULL, *lastLoadPositionFP = NULL;
5830 int lastLoadGameNumber = 0, lastLoadPositionNumber = 0;
5831 int lastLoadGameUseList = FALSE;
5832 char lastLoadGameTitle[MSG_SIZ], lastLoadPositionTitle[MSG_SIZ];
5833 ChessMove lastLoadGameStart = (ChessMove) 0;
5834
5835 ChessMove
5836 UserMoveTest(fromX, fromY, toX, toY, promoChar, captureOwn)
5837      int fromX, fromY, toX, toY;
5838      int promoChar;
5839      Boolean captureOwn;
5840 {
5841     ChessMove moveType;
5842     ChessSquare pdown, pup;
5843
5844     /* Check if the user is playing in turn.  This is complicated because we
5845        let the user "pick up" a piece before it is his turn.  So the piece he
5846        tried to pick up may have been captured by the time he puts it down!
5847        Therefore we use the color the user is supposed to be playing in this
5848        test, not the color of the piece that is currently on the starting
5849        square---except in EditGame mode, where the user is playing both
5850        sides; fortunately there the capture race can't happen.  (It can
5851        now happen in IcsExamining mode, but that's just too bad.  The user
5852        will get a somewhat confusing message in that case.)
5853        */
5854
5855     switch (gameMode) {
5856       case PlayFromGameFile:
5857       case AnalyzeFile:
5858       case TwoMachinesPlay:
5859       case EndOfGame:
5860       case IcsObserving:
5861       case IcsIdle:
5862         /* We switched into a game mode where moves are not accepted,
5863            perhaps while the mouse button was down. */
5864         return ImpossibleMove;
5865
5866       case MachinePlaysWhite:
5867         /* User is moving for Black */
5868         if (WhiteOnMove(currentMove)) {
5869             DisplayMoveError(_("It is White's turn"));
5870             return ImpossibleMove;
5871         }
5872         break;
5873
5874       case MachinePlaysBlack:
5875         /* User is moving for White */
5876         if (!WhiteOnMove(currentMove)) {
5877             DisplayMoveError(_("It is Black's turn"));
5878             return ImpossibleMove;
5879         }
5880         break;
5881
5882       case EditGame:
5883       case IcsExamining:
5884       case BeginningOfGame:
5885       case AnalyzeMode:
5886       case Training:
5887         if ((int) boards[currentMove][fromY][fromX] >= (int) BlackPawn &&
5888             (int) boards[currentMove][fromY][fromX] < (int) EmptySquare) {
5889             /* User is moving for Black */
5890             if (WhiteOnMove(currentMove)) {
5891                 DisplayMoveError(_("It is White's turn"));
5892                 return ImpossibleMove;
5893             }
5894         } else {
5895             /* User is moving for White */
5896             if (!WhiteOnMove(currentMove)) {
5897                 DisplayMoveError(_("It is Black's turn"));
5898                 return ImpossibleMove;
5899             }
5900         }
5901         break;
5902
5903       case IcsPlayingBlack:
5904         /* User is moving for Black */
5905         if (WhiteOnMove(currentMove)) {
5906             if (!appData.premove) {
5907                 DisplayMoveError(_("It is White's turn"));
5908             } else if (toX >= 0 && toY >= 0) {
5909                 premoveToX = toX;
5910                 premoveToY = toY;
5911                 premoveFromX = fromX;
5912                 premoveFromY = fromY;
5913                 premovePromoChar = promoChar;
5914                 gotPremove = 1;
5915                 if (appData.debugMode)
5916                     fprintf(debugFP, "Got premove: fromX %d,"
5917                             "fromY %d, toX %d, toY %d\n",
5918                             fromX, fromY, toX, toY);
5919             }
5920             return ImpossibleMove;
5921         }
5922         break;
5923
5924       case IcsPlayingWhite:
5925         /* User is moving for White */
5926         if (!WhiteOnMove(currentMove)) {
5927             if (!appData.premove) {
5928                 DisplayMoveError(_("It is Black's turn"));
5929             } else if (toX >= 0 && toY >= 0) {
5930                 premoveToX = toX;
5931                 premoveToY = toY;
5932                 premoveFromX = fromX;
5933                 premoveFromY = fromY;
5934                 premovePromoChar = promoChar;
5935                 gotPremove = 1;
5936                 if (appData.debugMode)
5937                     fprintf(debugFP, "Got premove: fromX %d,"
5938                             "fromY %d, toX %d, toY %d\n",
5939                             fromX, fromY, toX, toY);
5940             }
5941             return ImpossibleMove;
5942         }
5943         break;
5944
5945       default:
5946         break;
5947
5948       case EditPosition:
5949         /* EditPosition, empty square, or different color piece;
5950            click-click move is possible */
5951         if (toX == -2 || toY == -2) {
5952             boards[0][fromY][fromX] = EmptySquare;
5953             return AmbiguousMove;
5954         } else if (toX >= 0 && toY >= 0) {
5955             boards[0][toY][toX] = boards[0][fromY][fromX];
5956             if(fromX == BOARD_LEFT-2) { // handle 'moves' out of holdings
5957                 if(boards[0][fromY][0] != EmptySquare) {
5958                     if(boards[0][fromY][1]) boards[0][fromY][1]--;
5959                     if(boards[0][fromY][1] == 0)  boards[0][fromY][0] = EmptySquare;
5960                 }
5961             } else
5962             if(fromX == BOARD_RGHT+1) {
5963                 if(boards[0][fromY][BOARD_WIDTH-1] != EmptySquare) {
5964                     if(boards[0][fromY][BOARD_WIDTH-2]) boards[0][fromY][BOARD_WIDTH-2]--;
5965                     if(boards[0][fromY][BOARD_WIDTH-2] == 0)  boards[0][fromY][BOARD_WIDTH-1] = EmptySquare;
5966                 }
5967             } else
5968             boards[0][fromY][fromX] = EmptySquare;
5969             return AmbiguousMove;
5970         }
5971         return ImpossibleMove;
5972     }
5973
5974     if(toX < 0 || toY < 0) return ImpossibleMove;
5975     pdown = boards[currentMove][fromY][fromX];
5976     pup = boards[currentMove][toY][toX];
5977
5978     /* [HGM] If move started in holdings, it means a drop */
5979     if( fromX == BOARD_LEFT-2 || fromX == BOARD_RGHT+1) {
5980          if( pup != EmptySquare ) return ImpossibleMove;
5981          if(appData.testLegality) {
5982              /* it would be more logical if LegalityTest() also figured out
5983               * which drops are legal. For now we forbid pawns on back rank.
5984               * Shogi is on its own here...
5985               */
5986              if( (pdown == WhitePawn || pdown == BlackPawn) &&
5987                  (toY == 0 || toY == BOARD_HEIGHT -1 ) )
5988                  return(ImpossibleMove); /* no pawn drops on 1st/8th */
5989          }
5990          return WhiteDrop; /* Not needed to specify white or black yet */
5991     }
5992
5993     /* [HGM] always test for legality, to get promotion info */
5994     moveType = LegalityTest(boards[currentMove], PosFlags(currentMove),
5995                                          fromY, fromX, toY, toX, promoChar);
5996     /* [HGM] but possibly ignore an IllegalMove result */
5997     if (appData.testLegality) {
5998         if (moveType == IllegalMove || moveType == ImpossibleMove) {
5999             DisplayMoveError(_("Illegal move"));
6000             return ImpossibleMove;
6001         }
6002     }
6003
6004     return moveType;
6005     /* [HGM] <popupFix> in stead of calling FinishMove directly, this
6006        function is made into one that returns an OK move type if FinishMove
6007        should be called. This to give the calling driver routine the
6008        opportunity to finish the userMove input with a promotion popup,
6009        without bothering the user with this for invalid or illegal moves */
6010
6011 /*    FinishMove(moveType, fromX, fromY, toX, toY, promoChar); */
6012 }
6013
6014 /* Common tail of UserMoveEvent and DropMenuEvent */
6015 int
6016 FinishMove(moveType, fromX, fromY, toX, toY, promoChar)
6017      ChessMove moveType;
6018      int fromX, fromY, toX, toY;
6019      /*char*/int promoChar;
6020 {
6021     char *bookHit = 0;
6022
6023     if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) && promoChar != NULLCHAR) {
6024         // [HGM] superchess: suppress promotions to non-available piece
6025         int k = PieceToNumber(CharToPiece(ToUpper(promoChar)));
6026         if(WhiteOnMove(currentMove)) {
6027             if(!boards[currentMove][k][BOARD_WIDTH-2]) return 0;
6028         } else {
6029             if(!boards[currentMove][BOARD_HEIGHT-1-k][1]) return 0;
6030         }
6031     }
6032
6033     /* [HGM] <popupFix> kludge to avoid having to know the exact promotion
6034        move type in caller when we know the move is a legal promotion */
6035     if(moveType == NormalMove && promoChar)
6036         moveType = PromoCharToMoveType(WhiteOnMove(currentMove), promoChar);
6037
6038     /* [HGM] convert drag-and-drop piece drops to standard form */
6039     if( (fromX == BOARD_LEFT-2 || fromX == BOARD_RGHT+1) && fromY != DROP_RANK ){
6040          moveType = WhiteOnMove(currentMove) ? WhiteDrop : BlackDrop;
6041            if(appData.debugMode) fprintf(debugFP, "Drop move %d, curr=%d, x=%d,y=%d, p=%d\n",
6042                 moveType, currentMove, fromX, fromY, boards[currentMove][fromY][fromX]);
6043            // holdings might not be sent yet in ICS play; we have to figure out which piece belongs here
6044            if(fromX == 0) fromY = BOARD_HEIGHT-1 - fromY; // black holdings upside-down
6045            fromX = fromX ? WhitePawn : BlackPawn; // first piece type in selected holdings
6046            while(PieceToChar(fromX) == '.' || PieceToNumber(fromX) != fromY && fromX != (int) EmptySquare) fromX++;
6047          fromY = DROP_RANK;
6048     }
6049
6050     /* [HGM] <popupFix> The following if has been moved here from
6051        UserMoveEvent(). Because it seemed to belong here (why not allow
6052        piece drops in training games?), and because it can only be
6053        performed after it is known to what we promote. */
6054     if (gameMode == Training) {
6055       /* compare the move played on the board to the next move in the
6056        * game. If they match, display the move and the opponent's response.
6057        * If they don't match, display an error message.
6058        */
6059       int saveAnimate;
6060       Board testBoard;
6061       CopyBoard(testBoard, boards[currentMove]);
6062       ApplyMove(fromX, fromY, toX, toY, promoChar, testBoard);
6063
6064       if (CompareBoards(testBoard, boards[currentMove+1])) {
6065         ForwardInner(currentMove+1);
6066
6067         /* Autoplay the opponent's response.
6068          * if appData.animate was TRUE when Training mode was entered,
6069          * the response will be animated.
6070          */
6071         saveAnimate = appData.animate;
6072         appData.animate = animateTraining;
6073         ForwardInner(currentMove+1);
6074         appData.animate = saveAnimate;
6075
6076         /* check for the end of the game */
6077         if (currentMove >= forwardMostMove) {
6078           gameMode = PlayFromGameFile;
6079           ModeHighlight();
6080           SetTrainingModeOff();
6081           DisplayInformation(_("End of game"));
6082         }
6083       } else {
6084         DisplayError(_("Incorrect move"), 0);
6085       }
6086       return 1;
6087     }
6088
6089   /* Ok, now we know that the move is good, so we can kill
6090      the previous line in Analysis Mode */
6091   if ((gameMode == AnalyzeMode || gameMode == EditGame)
6092                                 && currentMove < forwardMostMove) {
6093     PushTail(currentMove, forwardMostMove); // [HGM] vari: save tail of game
6094   }
6095
6096   /* If we need the chess program but it's dead, restart it */
6097   ResurrectChessProgram();
6098
6099   /* A user move restarts a paused game*/
6100   if (pausing)
6101     PauseEvent();
6102
6103   thinkOutput[0] = NULLCHAR;
6104
6105   MakeMove(fromX, fromY, toX, toY, promoChar); /*updates forwardMostMove*/
6106
6107   if(Adjudicate(NULL)) return 1; // [HGM] adjudicate: take care of automtic game end
6108
6109   if (gameMode == BeginningOfGame) {
6110     if (appData.noChessProgram) {
6111       gameMode = EditGame;
6112       SetGameInfo();
6113     } else {
6114       char buf[MSG_SIZ];
6115       gameMode = MachinePlaysBlack;
6116       StartClocks();
6117       SetGameInfo();
6118       sprintf(buf, "%s vs. %s", gameInfo.white, gameInfo.black);
6119       DisplayTitle(buf);
6120       if (first.sendName) {
6121         sprintf(buf, "name %s\n", gameInfo.white);
6122         SendToProgram(buf, &first);
6123       }
6124       StartClocks();
6125     }
6126     ModeHighlight();
6127   }
6128
6129   /* Relay move to ICS or chess engine */
6130   if (appData.icsActive) {
6131     if (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack ||
6132         gameMode == IcsExamining) {
6133       if(userOfferedDraw && (signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
6134         SendToICS(ics_prefix); // [HGM] drawclaim: send caim and move on one line for FICS
6135         SendToICS("draw ");
6136         SendMoveToICS(moveType, fromX, fromY, toX, toY);
6137       }
6138       // also send plain move, in case ICS does not understand atomic claims
6139       SendMoveToICS(moveType, fromX, fromY, toX, toY);
6140       ics_user_moved = 1;
6141     }
6142   } else {
6143     if (first.sendTime && (gameMode == BeginningOfGame ||
6144                            gameMode == MachinePlaysWhite ||
6145                            gameMode == MachinePlaysBlack)) {
6146       SendTimeRemaining(&first, gameMode != MachinePlaysBlack);
6147     }
6148     if (gameMode != EditGame && gameMode != PlayFromGameFile) {
6149          // [HGM] book: if program might be playing, let it use book
6150         bookHit = SendMoveToBookUser(forwardMostMove-1, &first, FALSE);
6151         first.maybeThinking = TRUE;
6152     } else SendMoveToProgram(forwardMostMove-1, &first);
6153     if (currentMove == cmailOldMove + 1) {
6154       cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
6155     }
6156   }
6157
6158   ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6159
6160   switch (gameMode) {
6161   case EditGame:
6162     switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
6163     case MT_NONE:
6164     case MT_CHECK:
6165       break;
6166     case MT_CHECKMATE:
6167     case MT_STAINMATE:
6168       if (WhiteOnMove(currentMove)) {
6169         GameEnds(BlackWins, "Black mates", GE_PLAYER);
6170       } else {
6171         GameEnds(WhiteWins, "White mates", GE_PLAYER);
6172       }
6173       break;
6174     case MT_STALEMATE:
6175       GameEnds(GameIsDrawn, "Stalemate", GE_PLAYER);
6176       break;
6177     }
6178     break;
6179
6180   case MachinePlaysBlack:
6181   case MachinePlaysWhite:
6182     /* disable certain menu options while machine is thinking */
6183     SetMachineThinkingEnables();
6184     break;
6185
6186   default:
6187     break;
6188   }
6189
6190   userOfferedDraw = FALSE; // [HGM] drawclaim: after move made, and tested for claimable draw
6191
6192   if(bookHit) { // [HGM] book: simulate book reply
6193         static char bookMove[MSG_SIZ]; // a bit generous?
6194
6195         programStats.nodes = programStats.depth = programStats.time =
6196         programStats.score = programStats.got_only_move = 0;
6197         sprintf(programStats.movelist, "%s (xbook)", bookHit);
6198
6199         strcpy(bookMove, "move ");
6200         strcat(bookMove, bookHit);
6201         HandleMachineMove(bookMove, &first);
6202   }
6203   return 1;
6204 }
6205
6206 void
6207 UserMoveEvent(fromX, fromY, toX, toY, promoChar)
6208      int fromX, fromY, toX, toY;
6209      int promoChar;
6210 {
6211     /* [HGM] This routine was added to allow calling of its two logical
6212        parts from other modules in the old way. Before, UserMoveEvent()
6213        automatically called FinishMove() if the move was OK, and returned
6214        otherwise. I separated the two, in order to make it possible to
6215        slip a promotion popup in between. But that it always needs two
6216        calls, to the first part, (now called UserMoveTest() ), and to
6217        FinishMove if the first part succeeded. Calls that do not need
6218        to do anything in between, can call this routine the old way.
6219     */
6220     ChessMove moveType = UserMoveTest(fromX, fromY, toX, toY, promoChar, FALSE);
6221 if(appData.debugMode) fprintf(debugFP, "moveType 4 = %d, promochar = %x\n", moveType, promoChar);
6222     if(moveType == AmbiguousMove)
6223         DrawPosition(FALSE, boards[currentMove]);
6224     else if(moveType != ImpossibleMove && moveType != Comment)
6225         FinishMove(moveType, fromX, fromY, toX, toY, promoChar);
6226 }
6227
6228 void
6229 Mark(board, flags, kind, rf, ff, rt, ft, closure)
6230      Board board;
6231      int flags;
6232      ChessMove kind;
6233      int rf, ff, rt, ft;
6234      VOIDSTAR closure;
6235 {
6236     typedef char Markers[BOARD_RANKS][BOARD_FILES];
6237     Markers *m = (Markers *) closure;
6238     if(rf == fromY && ff == fromX)
6239         (*m)[rt][ft] = 1 + (board[rt][ft] != EmptySquare
6240                          || kind == WhiteCapturesEnPassant
6241                          || kind == BlackCapturesEnPassant);
6242     else if(flags & F_MANDATORY_CAPTURE && board[rt][ft] != EmptySquare) (*m)[rt][ft] = 3;
6243 }
6244
6245 void
6246 MarkTargetSquares(int clear)
6247 {
6248   int x, y;
6249   if(!appData.markers || !appData.highlightDragging ||
6250      !appData.testLegality || gameMode == EditPosition) return;
6251   if(clear) {
6252     for(x=0; x<BOARD_WIDTH; x++) for(y=0; y<BOARD_HEIGHT; y++) marker[y][x] = 0;
6253   } else {
6254     int capt = 0;
6255     GenLegal(boards[currentMove], PosFlags(currentMove), Mark, (void*) marker);
6256     if(PosFlags(0) & F_MANDATORY_CAPTURE) {
6257       for(x=0; x<BOARD_WIDTH; x++) for(y=0; y<BOARD_HEIGHT; y++) if(marker[y][x]>1) capt++;
6258       if(capt)
6259       for(x=0; x<BOARD_WIDTH; x++) for(y=0; y<BOARD_HEIGHT; y++) if(marker[y][x] == 1) marker[y][x] = 0;
6260     }
6261   }
6262   DrawPosition(TRUE, NULL);
6263 }
6264
6265 void LeftClick(ClickType clickType, int xPix, int yPix)
6266 {
6267     int x, y;
6268     Boolean saveAnimate;
6269     static int second = 0, promotionChoice = 0, dragging = 0;
6270     char promoChoice = NULLCHAR;
6271
6272     if(appData.seekGraph && appData.icsActive && loggedOn &&
6273         (gameMode == BeginningOfGame || gameMode == IcsIdle)) {
6274         SeekGraphClick(clickType, xPix, yPix, 0);
6275         return;
6276     }
6277
6278     if (clickType == Press) ErrorPopDown();
6279     MarkTargetSquares(1);
6280
6281     x = EventToSquare(xPix, BOARD_WIDTH);
6282     y = EventToSquare(yPix, BOARD_HEIGHT);
6283     if (!flipView && y >= 0) {
6284         y = BOARD_HEIGHT - 1 - y;
6285     }
6286     if (flipView && x >= 0) {
6287         x = BOARD_WIDTH - 1 - x;
6288     }
6289
6290     if(promotionChoice) { // we are waiting for a click to indicate promotion piece
6291         if(clickType == Release) return; // ignore upclick of click-click destination
6292         promotionChoice = FALSE; // only one chance: if click not OK it is interpreted as cancel
6293         if(appData.debugMode) fprintf(debugFP, "promotion click, x=%d, y=%d\n", x, y);
6294         if(gameInfo.holdingsWidth &&
6295                 (WhiteOnMove(currentMove)
6296                         ? x == BOARD_WIDTH-1 && y < gameInfo.holdingsSize && y > 0
6297                         : x == 0 && y >= BOARD_HEIGHT - gameInfo.holdingsSize && y < BOARD_HEIGHT-1) ) {
6298             // click in right holdings, for determining promotion piece
6299             ChessSquare p = boards[currentMove][y][x];
6300             if(appData.debugMode) fprintf(debugFP, "square contains %d\n", (int)p);
6301             if(p != EmptySquare) {
6302                 FinishMove(NormalMove, fromX, fromY, toX, toY, ToLower(PieceToChar(p)));
6303                 fromX = fromY = -1;
6304                 return;
6305             }
6306         }
6307         DrawPosition(FALSE, boards[currentMove]);
6308         return;
6309     }
6310
6311     /* [HGM] holdings: next 5 lines: ignore all clicks between board and holdings */
6312     if(clickType == Press
6313             && ( x == BOARD_LEFT-1 || x == BOARD_RGHT
6314               || x == BOARD_LEFT-2 && y < BOARD_HEIGHT-gameInfo.holdingsSize
6315               || x == BOARD_RGHT+1 && y >= gameInfo.holdingsSize) )
6316         return;
6317
6318     autoQueen = appData.alwaysPromoteToQueen;
6319
6320     if (fromX == -1) {
6321       if(!appData.oneClick || !OnlyMove(&x, &y, FALSE)) {
6322         if (clickType == Press) {
6323             /* First square */
6324             if (OKToStartUserMove(x, y)) {
6325                 fromX = x;
6326                 fromY = y;
6327                 second = 0;
6328                 MarkTargetSquares(0);
6329                 DragPieceBegin(xPix, yPix); dragging = 1;
6330                 if (appData.highlightDragging) {
6331                     SetHighlights(x, y, -1, -1);
6332                 }
6333             }
6334         } else if(dragging) { // [HGM] from-square must have been reset due to game end since last press
6335             DragPieceEnd(xPix, yPix); dragging = 0;
6336             DrawPosition(FALSE, NULL);
6337         }
6338         return;
6339       }
6340     }
6341
6342     /* fromX != -1 */
6343     if (clickType == Press && gameMode != EditPosition) {
6344         ChessSquare fromP;
6345         ChessSquare toP;
6346         int frc;
6347
6348         // ignore off-board to clicks
6349         if(y < 0 || x < 0) return;
6350
6351         /* Check if clicking again on the same color piece */
6352         fromP = boards[currentMove][fromY][fromX];
6353         toP = boards[currentMove][y][x];
6354         frc = gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom;
6355         if ((WhitePawn <= fromP && fromP <= WhiteKing &&
6356              WhitePawn <= toP && toP <= WhiteKing &&
6357              !(fromP == WhiteKing && toP == WhiteRook && frc) &&
6358              !(fromP == WhiteRook && toP == WhiteKing && frc)) ||
6359             (BlackPawn <= fromP && fromP <= BlackKing &&
6360              BlackPawn <= toP && toP <= BlackKing &&
6361              !(fromP == BlackRook && toP == BlackKing && frc) && // allow also RxK as FRC castling
6362              !(fromP == BlackKing && toP == BlackRook && frc))) {
6363             /* Clicked again on same color piece -- changed his mind */
6364             second = (x == fromX && y == fromY);
6365            if(!second || !OnlyMove(&x, &y, TRUE)) {
6366             if (appData.highlightDragging) {
6367                 SetHighlights(x, y, -1, -1);
6368             } else {
6369                 ClearHighlights();
6370             }
6371             if (OKToStartUserMove(x, y)) {
6372                 fromX = x;
6373                 fromY = y; dragging = 1;
6374                 MarkTargetSquares(0);
6375                 DragPieceBegin(xPix, yPix);
6376             }
6377             return;
6378            }
6379         }
6380         // ignore clicks on holdings
6381         if(x < BOARD_LEFT || x >= BOARD_RGHT) return;
6382     }
6383
6384     if (clickType == Release && x == fromX && y == fromY) {
6385         DragPieceEnd(xPix, yPix); dragging = 0;
6386         if (appData.animateDragging) {
6387             /* Undo animation damage if any */
6388             DrawPosition(FALSE, NULL);
6389         }
6390         if (second) {
6391             /* Second up/down in same square; just abort move */
6392             second = 0;
6393             fromX = fromY = -1;
6394             ClearHighlights();
6395             gotPremove = 0;
6396             ClearPremoveHighlights();
6397         } else {
6398             /* First upclick in same square; start click-click mode */
6399             SetHighlights(x, y, -1, -1);
6400         }
6401         return;
6402     }
6403
6404     /* we now have a different from- and (possibly off-board) to-square */
6405     /* Completed move */
6406     toX = x;
6407     toY = y;
6408     saveAnimate = appData.animate;
6409     if (clickType == Press) {
6410         /* Finish clickclick move */
6411         if (appData.animate || appData.highlightLastMove) {
6412             SetHighlights(fromX, fromY, toX, toY);
6413         } else {
6414             ClearHighlights();
6415         }
6416     } else {
6417         /* Finish drag move */
6418         if (appData.highlightLastMove) {
6419             SetHighlights(fromX, fromY, toX, toY);
6420         } else {
6421             ClearHighlights();
6422         }
6423         DragPieceEnd(xPix, yPix); dragging = 0;
6424         /* Don't animate move and drag both */
6425         appData.animate = FALSE;
6426     }
6427
6428     // moves into holding are invalid for now (except in EditPosition, adapting to-square)
6429     if(x >= 0 && x < BOARD_LEFT || x >= BOARD_RGHT) {
6430         ChessSquare piece = boards[currentMove][fromY][fromX];
6431         if(gameMode == EditPosition && piece != EmptySquare &&
6432            fromX >= BOARD_LEFT && fromX < BOARD_RGHT) {
6433             int n;
6434
6435             if(x == BOARD_LEFT-2 && piece >= BlackPawn) {
6436                 n = PieceToNumber(piece - (int)BlackPawn);
6437                 if(n >= gameInfo.holdingsSize) { n = 0; piece = BlackPawn; }
6438                 boards[currentMove][BOARD_HEIGHT-1 - n][0] = piece;
6439                 boards[currentMove][BOARD_HEIGHT-1 - n][1]++;
6440             } else
6441             if(x == BOARD_RGHT+1 && piece < BlackPawn) {
6442                 n = PieceToNumber(piece);
6443                 if(n >= gameInfo.holdingsSize) { n = 0; piece = WhitePawn; }
6444                 boards[currentMove][n][BOARD_WIDTH-1] = piece;
6445                 boards[currentMove][n][BOARD_WIDTH-2]++;
6446             }
6447             boards[currentMove][fromY][fromX] = EmptySquare;
6448         }
6449         ClearHighlights();
6450         fromX = fromY = -1;
6451         DrawPosition(TRUE, boards[currentMove]);
6452         return;
6453     }
6454
6455     // off-board moves should not be highlighted
6456     if(x < 0 || x < 0) ClearHighlights();
6457
6458     if (HasPromotionChoice(fromX, fromY, toX, toY, &promoChoice)) {
6459         SetHighlights(fromX, fromY, toX, toY);
6460         if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
6461             // [HGM] super: promotion to captured piece selected from holdings
6462             ChessSquare p = boards[currentMove][fromY][fromX], q = boards[currentMove][toY][toX];
6463             promotionChoice = TRUE;
6464             // kludge follows to temporarily execute move on display, without promoting yet
6465             boards[currentMove][fromY][fromX] = EmptySquare; // move Pawn to 8th rank
6466             boards[currentMove][toY][toX] = p;
6467             DrawPosition(FALSE, boards[currentMove]);
6468             boards[currentMove][fromY][fromX] = p; // take back, but display stays
6469             boards[currentMove][toY][toX] = q;
6470             DisplayMessage("Click in holdings to choose piece", "");
6471             return;
6472         }
6473         PromotionPopUp();
6474     } else {
6475         UserMoveEvent(fromX, fromY, toX, toY, promoChoice);
6476         if (!appData.highlightLastMove || gotPremove) ClearHighlights();
6477         if (gotPremove) SetPremoveHighlights(fromX, fromY, toX, toY);
6478         fromX = fromY = -1;
6479     }
6480     appData.animate = saveAnimate;
6481     if (appData.animate || appData.animateDragging) {
6482         /* Undo animation damage if needed */
6483         DrawPosition(FALSE, NULL);
6484     }
6485 }
6486
6487 int RightClick(ClickType action, int x, int y, int *fromX, int *fromY)
6488 {   // front-end-free part taken out of PieceMenuPopup
6489     int whichMenu; int xSqr, ySqr;
6490
6491     if(seekGraphUp) { // [HGM] seekgraph
6492         if(action == Press)   SeekGraphClick(Press, x, y, 2); // 2 indicates right-click: no pop-down on miss
6493         if(action == Release) SeekGraphClick(Release, x, y, 2); // and no challenge on hit
6494         return -2;
6495     }
6496
6497     if((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack)
6498          && !appData.zippyPlay && appData.bgObserve) { // [HGM] bughouse: show background game
6499         if(!partnerBoardValid) return -2; // suppress display of uninitialized boards
6500         if( appData.dualBoard) return -2; // [HGM] dual: is already displayed
6501         if(action == Press)   {
6502             originalFlip = flipView;
6503             flipView = !flipView; // temporarily flip board to see game from partners perspective
6504             DrawPosition(TRUE, partnerBoard);
6505             DisplayMessage(partnerStatus, "");
6506             partnerUp = TRUE;
6507         } else if(action == Release) {
6508             flipView = originalFlip;
6509             DrawPosition(TRUE, boards[currentMove]);
6510             partnerUp = FALSE;
6511         }
6512         return -2;
6513     }
6514
6515     xSqr = EventToSquare(x, BOARD_WIDTH);
6516     ySqr = EventToSquare(y, BOARD_HEIGHT);
6517     if (action == Release) UnLoadPV(); // [HGM] pv
6518     if (action != Press) return -2; // return code to be ignored
6519     switch (gameMode) {
6520       case IcsExamining:
6521         if(xSqr < BOARD_LEFT || xSqr >= BOARD_RGHT) return -1;\r
6522       case EditPosition:
6523         if (xSqr == BOARD_LEFT-1 || xSqr == BOARD_RGHT) return -1;\r
6524         if (xSqr < 0 || ySqr < 0) return -1;\r
6525         whichMenu = 0; // edit-position menu
6526         break;
6527       case IcsObserving:
6528         if(!appData.icsEngineAnalyze) return -1;
6529       case IcsPlayingWhite:
6530       case IcsPlayingBlack:
6531         if(!appData.zippyPlay) goto noZip;
6532       case AnalyzeMode:
6533       case AnalyzeFile:
6534       case MachinePlaysWhite:
6535       case MachinePlaysBlack:
6536       case TwoMachinesPlay: // [HGM] pv: use for showing PV
6537         if (!appData.dropMenu) {
6538           LoadPV(x, y);
6539           return 2; // flag front-end to grab mouse events
6540         }
6541         if(gameMode == TwoMachinesPlay || gameMode == AnalyzeMode ||
6542            gameMode == AnalyzeFile || gameMode == IcsObserving) return -1;
6543       case EditGame:
6544       noZip:
6545         if (xSqr < 0 || ySqr < 0) return -1;
6546         if (!appData.dropMenu || appData.testLegality &&
6547             gameInfo.variant != VariantBughouse &&
6548             gameInfo.variant != VariantCrazyhouse) return -1;
6549         whichMenu = 1; // drop menu
6550         break;
6551       default:
6552         return -1;
6553     }
6554
6555     if (((*fromX = xSqr) < 0) ||
6556         ((*fromY = ySqr) < 0)) {
6557         *fromX = *fromY = -1;
6558         return -1;
6559     }
6560     if (flipView)
6561       *fromX = BOARD_WIDTH - 1 - *fromX;
6562     else
6563       *fromY = BOARD_HEIGHT - 1 - *fromY;
6564
6565     return whichMenu;
6566 }
6567
6568 void SendProgramStatsToFrontend( ChessProgramState * cps, ChessProgramStats * cpstats )
6569 {
6570 //    char * hint = lastHint;
6571     FrontEndProgramStats stats;
6572
6573     stats.which = cps == &first ? 0 : 1;
6574     stats.depth = cpstats->depth;
6575     stats.nodes = cpstats->nodes;
6576     stats.score = cpstats->score;
6577     stats.time = cpstats->time;
6578     stats.pv = cpstats->movelist;
6579     stats.hint = lastHint;
6580     stats.an_move_index = 0;
6581     stats.an_move_count = 0;
6582
6583     if( gameMode == AnalyzeMode || gameMode == AnalyzeFile ) {
6584         stats.hint = cpstats->move_name;
6585         stats.an_move_index = cpstats->nr_moves - cpstats->moves_left;
6586         stats.an_move_count = cpstats->nr_moves;
6587     }
6588
6589     if(stats.pv && stats.pv[0]) strcpy(lastPV[stats.which], stats.pv); // [HGM] pv: remember last PV of each
6590
6591     SetProgramStats( &stats );
6592 }
6593
6594 int
6595 Adjudicate(ChessProgramState *cps)
6596 {       // [HGM] some adjudications useful with buggy engines
6597         // [HGM] adjudicate: made into separate routine, which now can be called after every move
6598         //       In any case it determnes if the game is a claimable draw (filling in EP_STATUS).
6599         //       Actually ending the game is now based on the additional internal condition canAdjudicate.
6600         //       Only when the game is ended, and the opponent is a computer, this opponent gets the move relayed.
6601         int k, count = 0; static int bare = 1;
6602         ChessProgramState *engineOpponent = (gameMode == TwoMachinesPlay ? cps->other : (cps ? NULL : &first));
6603         Boolean canAdjudicate = !appData.icsActive;
6604
6605         // most tests only when we understand the game, i.e. legality-checking on, and (for the time being) no piece drops
6606         if(gameInfo.holdingsSize == 0 || gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
6607             if( appData.testLegality )
6608             {   /* [HGM] Some more adjudications for obstinate engines */
6609                 int NrWN=0, NrBN=0, NrWB=0, NrBB=0, NrWR=0, NrBR=0,
6610                     NrWQ=0, NrBQ=0, NrW=0, NrK=0, bishopsColor = 0,
6611                     NrPieces=0, NrPawns=0, PawnAdvance=0, i, j;
6612                 static int moveCount = 6;
6613                 ChessMove result;
6614                 char *reason = NULL;
6615
6616                 /* Count what is on board. */
6617                 for(i=0; i<BOARD_HEIGHT; i++) for(j=BOARD_LEFT; j<BOARD_RGHT; j++)
6618                 {   ChessSquare p = boards[forwardMostMove][i][j];
6619                     int m=i;
6620
6621                     switch((int) p)
6622                     {   /* count B,N,R and other of each side */
6623                         case WhiteKing:
6624                         case BlackKing:
6625                              NrK++; break; // [HGM] atomic: count Kings
6626                         case WhiteKnight:
6627                              NrWN++; break;
6628                         case WhiteBishop:
6629                         case WhiteFerz:    // [HGM] shatranj: kludge to mke it work in shatranj
6630                              bishopsColor |= 1 << ((i^j)&1);
6631                              NrWB++; break;
6632                         case BlackKnight:
6633                              NrBN++; break;
6634                         case BlackBishop:
6635                         case BlackFerz:    // [HGM] shatranj: kludge to mke it work in shatranj
6636                              bishopsColor |= 1 << ((i^j)&1);
6637                              NrBB++; break;
6638                         case WhiteRook:
6639                              NrWR++; break;
6640                         case BlackRook:
6641                              NrBR++; break;
6642                         case WhiteQueen:
6643                              NrWQ++; break;
6644                         case BlackQueen:
6645                              NrBQ++; break;
6646                         case EmptySquare:
6647                              break;
6648                         case BlackPawn:
6649                              m = 7-i;
6650                         case WhitePawn:
6651                              PawnAdvance += m; NrPawns++;
6652                     }
6653                     NrPieces += (p != EmptySquare);
6654                     NrW += ((int)p < (int)BlackPawn);
6655                     if(gameInfo.variant == VariantXiangqi &&
6656                       (p == WhiteFerz || p == WhiteAlfil || p == BlackFerz || p == BlackAlfil)) {
6657                         NrPieces--; // [HGM] XQ: do not count purely defensive pieces
6658                         NrW -= ((int)p < (int)BlackPawn);
6659                     }
6660                 }
6661
6662                 /* Some material-based adjudications that have to be made before stalemate test */
6663                 if(gameInfo.variant == VariantAtomic && NrK < 2) {
6664                     // [HGM] atomic: stm must have lost his King on previous move, as destroying own K is illegal
6665                      boards[forwardMostMove][EP_STATUS] = EP_CHECKMATE; // make claimable as if stm is checkmated
6666                      if(canAdjudicate && appData.checkMates) {
6667                          if(engineOpponent)
6668                            SendMoveToProgram(forwardMostMove-1, engineOpponent); // make sure opponent gets move
6669                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6670                          GameEnds( WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins,
6671                                                         "Xboard adjudication: King destroyed", GE_XBOARD );
6672                          return 1;
6673                      }
6674                 }
6675
6676                 /* Bare King in Shatranj (loses) or Losers (wins) */
6677                 if( NrW == 1 || NrPieces - NrW == 1) {
6678                   if( gameInfo.variant == VariantLosers) { // [HGM] losers: bare King wins (stm must have it first)
6679                      boards[forwardMostMove][EP_STATUS] = EP_WINS;  // mark as win, so it becomes claimable
6680                      if(canAdjudicate && appData.checkMates) {
6681                          if(engineOpponent)
6682                            SendMoveToProgram(forwardMostMove-1, engineOpponent); // make sure opponent gets to see move
6683                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6684                          GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
6685                                                         "Xboard adjudication: Bare king", GE_XBOARD );
6686                          return 1;
6687                      }
6688                   } else
6689                   if( gameInfo.variant == VariantShatranj && --bare < 0)
6690                   {    /* bare King */
6691                         boards[forwardMostMove][EP_STATUS] = EP_WINS; // make claimable as win for stm
6692                         if(canAdjudicate && appData.checkMates) {
6693                             /* but only adjudicate if adjudication enabled */
6694                             if(engineOpponent)
6695                               SendMoveToProgram(forwardMostMove-1, engineOpponent); // make sure opponent gets move
6696                             ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6697                             GameEnds( NrW > 1 ? WhiteWins : NrPieces - NrW > 1 ? BlackWins : GameIsDrawn,
6698                                                         "Xboard adjudication: Bare king", GE_XBOARD );
6699                             return 1;
6700                         }
6701                   }
6702                 } else bare = 1;
6703
6704
6705             // don't wait for engine to announce game end if we can judge ourselves
6706             switch (MateTest(boards[forwardMostMove], PosFlags(forwardMostMove)) ) {
6707               case MT_CHECK:
6708                 if(gameInfo.variant == Variant3Check) { // [HGM] 3check: when in check, test if 3rd time
6709                     int i, checkCnt = 0;    // (should really be done by making nr of checks part of game state)
6710                     for(i=forwardMostMove-2; i>=backwardMostMove; i-=2) {
6711                         if(MateTest(boards[i], PosFlags(i)) == MT_CHECK)
6712                             checkCnt++;
6713                         if(checkCnt >= 2) {
6714                             reason = "Xboard adjudication: 3rd check";
6715                             boards[forwardMostMove][EP_STATUS] = EP_CHECKMATE;
6716                             break;
6717                         }
6718                     }
6719                 }
6720               case MT_NONE:
6721               default:
6722                 break;
6723               case MT_STALEMATE:
6724               case MT_STAINMATE:
6725                 reason = "Xboard adjudication: Stalemate";
6726                 if((signed char)boards[forwardMostMove][EP_STATUS] != EP_CHECKMATE) { // [HGM] don't touch win through baring or K-capt
6727                     boards[forwardMostMove][EP_STATUS] = EP_STALEMATE;   // default result for stalemate is draw
6728                     if(gameInfo.variant == VariantLosers  || gameInfo.variant == VariantGiveaway) // [HGM] losers:
6729                         boards[forwardMostMove][EP_STATUS] = EP_WINS;    // in these variants stalemated is always a win
6730                     else if(gameInfo.variant == VariantSuicide) // in suicide it depends
6731                         boards[forwardMostMove][EP_STATUS] = NrW == NrPieces-NrW ? EP_STALEMATE :
6732                                                    ((NrW < NrPieces-NrW) != WhiteOnMove(forwardMostMove) ?
6733                                                                         EP_CHECKMATE : EP_WINS);
6734                     else if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantXiangqi)
6735                         boards[forwardMostMove][EP_STATUS] = EP_CHECKMATE; // and in these variants being stalemated loses
6736                 }
6737                 break;
6738               case MT_CHECKMATE:
6739                 reason = "Xboard adjudication: Checkmate";
6740                 boards[forwardMostMove][EP_STATUS] = (gameInfo.variant == VariantLosers ? EP_WINS : EP_CHECKMATE);
6741                 break;
6742             }
6743
6744                 switch(i = (signed char)boards[forwardMostMove][EP_STATUS]) {
6745                     case EP_STALEMATE:
6746                         result = GameIsDrawn; break;
6747                     case EP_CHECKMATE:
6748                         result = WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins; break;
6749                     case EP_WINS:
6750                         result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins; break;
6751                     default:
6752                         result = (ChessMove) 0;
6753                 }
6754                 if(canAdjudicate && appData.checkMates && result) { // [HGM] mates: adjudicate finished games if requested
6755                     if(engineOpponent)
6756                       SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
6757                     ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6758                     GameEnds( result, reason, GE_XBOARD );
6759                     return 1;
6760                 }
6761
6762                 /* Next absolutely insufficient mating material. */
6763                 if( NrPieces == 2 || gameInfo.variant != VariantXiangqi &&
6764                                      gameInfo.variant != VariantShatranj && // [HGM] baring will remain possible
6765                         (NrPieces == 3 && NrWN+NrBN+NrWB+NrBB == 1 ||
6766                          NrPieces == NrBB+NrWB+2 && bishopsColor != 3)) // [HGM] all Bishops (Ferz!) same color
6767                 {    /* KBK, KNK, KK of KBKB with like Bishops */
6768
6769                      /* always flag draws, for judging claims */
6770                      boards[forwardMostMove][EP_STATUS] = EP_INSUF_DRAW;
6771
6772                      if(canAdjudicate && appData.materialDraws) {
6773                          /* but only adjudicate them if adjudication enabled */
6774                          if(engineOpponent) {
6775                            SendToProgram("force\n", engineOpponent); // suppress reply
6776                            SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see last move */
6777                          }
6778                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6779                          GameEnds( GameIsDrawn, "Xboard adjudication: Insufficient mating material", GE_XBOARD );
6780                          return 1;
6781                      }
6782                 }
6783
6784                 /* Then some trivial draws (only adjudicate, cannot be claimed) */
6785                 if(NrPieces == 4 &&
6786                    (   NrWR == 1 && NrBR == 1 /* KRKR */
6787                    || NrWQ==1 && NrBQ==1     /* KQKQ */
6788                    || NrWN==2 || NrBN==2     /* KNNK */
6789                    || NrWN+NrWB == 1 && NrBN+NrBB == 1 /* KBKN, KBKB, KNKN */
6790                   ) ) {
6791                      if(--moveCount < 0 && appData.trivialDraws && canAdjudicate)
6792                      {    /* if the first 3 moves do not show a tactical win, declare draw */
6793                           if(engineOpponent) {
6794                             SendToProgram("force\n", engineOpponent); // suppress reply
6795                             SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
6796                           }
6797                           ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6798                           GameEnds( GameIsDrawn, "Xboard adjudication: Trivial draw", GE_XBOARD );
6799                           return 1;
6800                      }
6801                 } else moveCount = 6;
6802             }
6803         }
6804
6805         if (appData.debugMode) { int i;
6806             fprintf(debugFP, "repeat test fmm=%d bmm=%d ep=%d, reps=%d\n",
6807                     forwardMostMove, backwardMostMove, boards[backwardMostMove][EP_STATUS],
6808                     appData.drawRepeats);
6809             for( i=forwardMostMove; i>=backwardMostMove; i-- )
6810               fprintf(debugFP, "%d ep=%d\n", i, (signed char)boards[i][EP_STATUS]);
6811
6812         }
6813
6814         // Repetition draws and 50-move rule can be applied independently of legality testing
6815
6816                 /* Check for rep-draws */
6817                 count = 0;
6818                 for(k = forwardMostMove-2;
6819                     k>=backwardMostMove && k>=forwardMostMove-100 &&
6820                         (signed char)boards[k][EP_STATUS] < EP_UNKNOWN &&
6821                         (signed char)boards[k+2][EP_STATUS] <= EP_NONE && (signed char)boards[k+1][EP_STATUS] <= EP_NONE;
6822                     k-=2)
6823                 {   int rights=0;
6824                     if(CompareBoards(boards[k], boards[forwardMostMove])) {
6825                         /* compare castling rights */
6826                         if( boards[forwardMostMove][CASTLING][2] != boards[k][CASTLING][2] &&
6827                              (boards[k][CASTLING][0] != NoRights || boards[k][CASTLING][1] != NoRights) )
6828                                 rights++; /* King lost rights, while rook still had them */
6829                         if( boards[forwardMostMove][CASTLING][2] != NoRights ) { /* king has rights */
6830                             if( boards[forwardMostMove][CASTLING][0] != boards[k][CASTLING][0] ||
6831                                 boards[forwardMostMove][CASTLING][1] != boards[k][CASTLING][1] )
6832                                    rights++; /* but at least one rook lost them */
6833                         }
6834                         if( boards[forwardMostMove][CASTLING][5] != boards[k][CASTLING][5] &&
6835                              (boards[k][CASTLING][3] != NoRights || boards[k][CASTLING][4] != NoRights) )
6836                                 rights++;
6837                         if( boards[forwardMostMove][CASTLING][5] != NoRights ) {
6838                             if( boards[forwardMostMove][CASTLING][3] != boards[k][CASTLING][3] ||
6839                                 boards[forwardMostMove][CASTLING][4] != boards[k][CASTLING][4] )
6840                                    rights++;
6841                         }
6842                         if( rights == 0 && ++count > appData.drawRepeats-2 && canAdjudicate
6843                             && appData.drawRepeats > 1) {
6844                              /* adjudicate after user-specified nr of repeats */
6845                              int result = GameIsDrawn;
6846                              char *details = "XBoard adjudication: repetition draw";
6847                              if(gameInfo.variant == VariantXiangqi && appData.testLegality) {
6848                                 // [HGM] xiangqi: check for forbidden perpetuals
6849                                 int m, ourPerpetual = 1, hisPerpetual = 1;
6850                                 for(m=forwardMostMove; m>k; m-=2) {
6851                                     if(MateTest(boards[m], PosFlags(m)) != MT_CHECK)
6852                                         ourPerpetual = 0; // the current mover did not always check
6853                                     if(MateTest(boards[m-1], PosFlags(m-1)) != MT_CHECK)
6854                                         hisPerpetual = 0; // the opponent did not always check
6855                                 }
6856                                 if(appData.debugMode) fprintf(debugFP, "XQ perpetual test, our=%d, his=%d\n",
6857                                                                         ourPerpetual, hisPerpetual);
6858                                 if(ourPerpetual && !hisPerpetual) { // we are actively checking him: forfeit
6859                                     result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
6860                                     details = "Xboard adjudication: perpetual checking";
6861                                 } else
6862                                 if(hisPerpetual && !ourPerpetual) { // he is checking us, but did not repeat yet
6863                                     break; // (or we would have caught him before). Abort repetition-checking loop.
6864                                 } else
6865                                 // Now check for perpetual chases
6866                                 if(!ourPerpetual && !hisPerpetual) { // no perpetual check, test for chase
6867                                     hisPerpetual = PerpetualChase(k, forwardMostMove);
6868                                     ourPerpetual = PerpetualChase(k+1, forwardMostMove);
6869                                     if(ourPerpetual && !hisPerpetual) { // we are actively chasing him: forfeit
6870                                         result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
6871                                         details = "Xboard adjudication: perpetual chasing";
6872                                     } else
6873                                     if(hisPerpetual && !ourPerpetual)   // he is chasing us, but did not repeat yet
6874                                         break; // Abort repetition-checking loop.
6875                                 }
6876                                 // if neither of us is checking or chasing all the time, or both are, it is draw
6877                              }
6878                              if(engineOpponent) {
6879                                SendToProgram("force\n", engineOpponent); // suppress reply
6880                                SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
6881                              }
6882                              ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6883                              GameEnds( result, details, GE_XBOARD );
6884                              return 1;
6885                         }
6886                         if( rights == 0 && count > 1 ) /* occurred 2 or more times before */
6887                              boards[forwardMostMove][EP_STATUS] = EP_REP_DRAW;
6888                     }
6889                 }
6890
6891                 /* Now we test for 50-move draws. Determine ply count */
6892                 count = forwardMostMove;
6893                 /* look for last irreversble move */
6894                 while( (signed char)boards[count][EP_STATUS] <= EP_NONE && count > backwardMostMove )
6895                     count--;
6896                 /* if we hit starting position, add initial plies */
6897                 if( count == backwardMostMove )
6898                     count -= initialRulePlies;
6899                 count = forwardMostMove - count;
6900                 if(gameInfo.variant == VariantXiangqi && ( count >= 100 || count >= 2*appData.ruleMoves ) ) {
6901                         // adjust reversible move counter for checks in Xiangqi
6902                         int i = forwardMostMove - count, inCheck = 0, lastCheck;
6903                         if(i < backwardMostMove) i = backwardMostMove;
6904                         while(i <= forwardMostMove) {
6905                                 lastCheck = inCheck; // check evasion does not count
6906                                 inCheck = (MateTest(boards[i], PosFlags(i)) == MT_CHECK);
6907                                 if(inCheck || lastCheck) count--; // check does not count
6908                                 i++;
6909                         }
6910                 }
6911                 if( count >= 100)
6912                          boards[forwardMostMove][EP_STATUS] = EP_RULE_DRAW;
6913                          /* this is used to judge if draw claims are legal */
6914                 if(canAdjudicate && appData.ruleMoves > 0 && count >= 2*appData.ruleMoves) {
6915                          if(engineOpponent) {
6916                            SendToProgram("force\n", engineOpponent); // suppress reply
6917                            SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
6918                          }
6919                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6920                          GameEnds( GameIsDrawn, "Xboard adjudication: 50-move rule", GE_XBOARD );
6921                          return 1;
6922                 }
6923
6924                 /* if draw offer is pending, treat it as a draw claim
6925                  * when draw condition present, to allow engines a way to
6926                  * claim draws before making their move to avoid a race
6927                  * condition occurring after their move
6928                  */
6929                 if((gameMode == TwoMachinesPlay ? second.offeredDraw : userOfferedDraw) || first.offeredDraw ) {
6930                          char *p = NULL;
6931                          if((signed char)boards[forwardMostMove][EP_STATUS] == EP_RULE_DRAW)
6932                              p = "Draw claim: 50-move rule";
6933                          if((signed char)boards[forwardMostMove][EP_STATUS] == EP_REP_DRAW)
6934                              p = "Draw claim: 3-fold repetition";
6935                          if((signed char)boards[forwardMostMove][EP_STATUS] == EP_INSUF_DRAW)
6936                              p = "Draw claim: insufficient mating material";
6937                          if( p != NULL && canAdjudicate) {
6938                              if(engineOpponent) {
6939                                SendToProgram("force\n", engineOpponent); // suppress reply
6940                                SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
6941                              }
6942                              ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6943                              GameEnds( GameIsDrawn, p, GE_XBOARD );
6944                              return 1;
6945                          }
6946                 }
6947
6948                 if( canAdjudicate && appData.adjudicateDrawMoves > 0 && forwardMostMove > (2*appData.adjudicateDrawMoves) ) {
6949                     if(engineOpponent) {
6950                       SendToProgram("force\n", engineOpponent); // suppress reply
6951                       SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
6952                     }
6953                     ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6954                     GameEnds( GameIsDrawn, "Xboard adjudication: long game", GE_XBOARD );
6955                     return 1;
6956                 }
6957         return 0;
6958 }
6959
6960 char *SendMoveToBookUser(int moveNr, ChessProgramState *cps, int initial)
6961 {   // [HGM] book: this routine intercepts moves to simulate book replies
6962     char *bookHit = NULL;
6963
6964     //first determine if the incoming move brings opponent into his book
6965     if(appData.usePolyglotBook && (cps == &first ? !appData.firstHasOwnBookUCI : !appData.secondHasOwnBookUCI))
6966         bookHit = ProbeBook(moveNr+1, appData.polyglotBook); // returns move
6967     if(appData.debugMode) fprintf(debugFP, "book hit = %s\n", bookHit ? bookHit : "(NULL)");
6968     if(bookHit != NULL && !cps->bookSuspend) {
6969         // make sure opponent is not going to reply after receiving move to book position
6970         SendToProgram("force\n", cps);
6971         cps->bookSuspend = TRUE; // flag indicating it has to be restarted
6972     }
6973     if(!initial) SendMoveToProgram(moveNr, cps); // with hit on initial position there is no move
6974     // now arrange restart after book miss
6975     if(bookHit) {
6976         // after a book hit we never send 'go', and the code after the call to this routine
6977         // has '&& !bookHit' added to suppress potential sending there (based on 'firstMove').
6978         char buf[MSG_SIZ];
6979         sprintf(buf, "%s%s\n", (cps->useUsermove ? "usermove " : ""), bookHit); // force book move into program supposed to play it
6980         SendToProgram(buf, cps);
6981         if(!initial) firstMove = FALSE; // normally we would clear the firstMove condition after return & sending 'go'
6982     } else if(initial) { // 'go' was needed irrespective of firstMove, and it has to be done in this routine
6983         SendToProgram("go\n", cps);
6984         cps->bookSuspend = FALSE; // after a 'go' we are never suspended
6985     } else { // 'go' might be sent based on 'firstMove' after this routine returns
6986         if(cps->bookSuspend && !firstMove) // 'go' needed, and it will not be done after we return
6987             SendToProgram("go\n", cps);
6988         cps->bookSuspend = FALSE; // anyhow, we will not be suspended after a miss
6989     }
6990     return bookHit; // notify caller of hit, so it can take action to send move to opponent
6991 }
6992
6993 char *savedMessage;
6994 ChessProgramState *savedState;
6995 void DeferredBookMove(void)
6996 {
6997         if(savedState->lastPing != savedState->lastPong)
6998                     ScheduleDelayedEvent(DeferredBookMove, 10);
6999         else
7000         HandleMachineMove(savedMessage, savedState);
7001 }
7002
7003 void
7004 HandleMachineMove(message, cps)
7005      char *message;
7006      ChessProgramState *cps;
7007 {
7008     char machineMove[MSG_SIZ], buf1[MSG_SIZ*10], buf2[MSG_SIZ];
7009     char realname[MSG_SIZ];
7010     int fromX, fromY, toX, toY;
7011     ChessMove moveType;
7012     char promoChar;
7013     char *p;
7014     int machineWhite;
7015     char *bookHit;
7016
7017     cps->userError = 0;
7018
7019 FakeBookMove: // [HGM] book: we jump here to simulate machine moves after book hit
7020     /*
7021      * Kludge to ignore BEL characters
7022      */
7023     while (*message == '\007') message++;
7024
7025     /*
7026      * [HGM] engine debug message: ignore lines starting with '#' character
7027      */
7028     if(cps->debug && *message == '#') return;
7029
7030     /*
7031      * Look for book output
7032      */
7033     if (cps == &first && bookRequested) {
7034         if (message[0] == '\t' || message[0] == ' ') {
7035             /* Part of the book output is here; append it */
7036             strcat(bookOutput, message);
7037             strcat(bookOutput, "  \n");
7038             return;
7039         } else if (bookOutput[0] != NULLCHAR) {
7040             /* All of book output has arrived; display it */
7041             char *p = bookOutput;
7042             while (*p != NULLCHAR) {
7043                 if (*p == '\t') *p = ' ';
7044                 p++;
7045             }
7046             DisplayInformation(bookOutput);
7047             bookRequested = FALSE;
7048             /* Fall through to parse the current output */
7049         }
7050     }
7051
7052     /*
7053      * Look for machine move.
7054      */
7055     if ((sscanf(message, "%s %s %s", buf1, buf2, machineMove) == 3 && strcmp(buf2, "...") == 0) ||
7056         (sscanf(message, "%s %s", buf1, machineMove) == 2 && strcmp(buf1, "move") == 0))
7057     {
7058         /* This method is only useful on engines that support ping */
7059         if (cps->lastPing != cps->lastPong) {
7060           if (gameMode == BeginningOfGame) {
7061             /* Extra move from before last new; ignore */
7062             if (appData.debugMode) {
7063                 fprintf(debugFP, "Ignoring extra move from %s\n", cps->which);
7064             }
7065           } else {
7066             if (appData.debugMode) {
7067                 fprintf(debugFP, "Undoing extra move from %s, gameMode %d\n",
7068                         cps->which, gameMode);
7069             }
7070
7071             SendToProgram("undo\n", cps);
7072           }
7073           return;
7074         }
7075
7076         switch (gameMode) {
7077           case BeginningOfGame:
7078             /* Extra move from before last reset; ignore */
7079             if (appData.debugMode) {
7080                 fprintf(debugFP, "Ignoring extra move from %s\n", cps->which);
7081             }
7082             return;
7083
7084           case EndOfGame:
7085           case IcsIdle:
7086           default:
7087             /* Extra move after we tried to stop.  The mode test is
7088                not a reliable way of detecting this problem, but it's
7089                the best we can do on engines that don't support ping.
7090             */
7091             if (appData.debugMode) {
7092                 fprintf(debugFP, "Undoing extra move from %s, gameMode %d\n",
7093                         cps->which, gameMode);
7094             }
7095             SendToProgram("undo\n", cps);
7096             return;
7097
7098           case MachinePlaysWhite:
7099           case IcsPlayingWhite:
7100             machineWhite = TRUE;
7101             break;
7102
7103           case MachinePlaysBlack:
7104           case IcsPlayingBlack:
7105             machineWhite = FALSE;
7106             break;
7107
7108           case TwoMachinesPlay:
7109             machineWhite = (cps->twoMachinesColor[0] == 'w');
7110             break;
7111         }
7112         if (WhiteOnMove(forwardMostMove) != machineWhite) {
7113             if (appData.debugMode) {
7114                 fprintf(debugFP,
7115                         "Ignoring move out of turn by %s, gameMode %d"
7116                         ", forwardMost %d\n",
7117                         cps->which, gameMode, forwardMostMove);
7118             }
7119             return;
7120         }
7121
7122     if (appData.debugMode) { int f = forwardMostMove;
7123         fprintf(debugFP, "machine move %d, castling = %d %d %d %d %d %d\n", f,
7124                 boards[f][CASTLING][0],boards[f][CASTLING][1],boards[f][CASTLING][2],
7125                 boards[f][CASTLING][3],boards[f][CASTLING][4],boards[f][CASTLING][5]);
7126     }
7127         if(cps->alphaRank) AlphaRank(machineMove, 4);
7128         if (!ParseOneMove(machineMove, forwardMostMove, &moveType,
7129                               &fromX, &fromY, &toX, &toY, &promoChar)) {
7130             /* Machine move could not be parsed; ignore it. */
7131             sprintf(buf1, _("Illegal move \"%s\" from %s machine"),
7132                     machineMove, cps->which);
7133             DisplayError(buf1, 0);
7134             sprintf(buf1, "Xboard: Forfeit due to invalid move: %s (%c%c%c%c) res=%d",
7135                     machineMove, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, moveType);
7136             if (gameMode == TwoMachinesPlay) {
7137               GameEnds(machineWhite ? BlackWins : WhiteWins,
7138                        buf1, GE_XBOARD);
7139             }
7140             return;
7141         }
7142
7143         /* [HGM] Apparently legal, but so far only tested with EP_UNKOWN */
7144         /* So we have to redo legality test with true e.p. status here,  */
7145         /* to make sure an illegal e.p. capture does not slip through,   */
7146         /* to cause a forfeit on a justified illegal-move complaint      */
7147         /* of the opponent.                                              */
7148         if( gameMode==TwoMachinesPlay && appData.testLegality
7149             && fromY != DROP_RANK /* [HGM] temporary; should still add legality test for drops */
7150                                                               ) {
7151            ChessMove moveType;
7152            moveType = LegalityTest(boards[forwardMostMove], PosFlags(forwardMostMove),
7153                              fromY, fromX, toY, toX, promoChar);
7154             if (appData.debugMode) {
7155                 int i;
7156                 for(i=0; i< nrCastlingRights; i++) fprintf(debugFP, "(%d,%d) ",
7157                     boards[forwardMostMove][CASTLING][i], castlingRank[i]);
7158                 fprintf(debugFP, "castling rights\n");
7159             }
7160             if(moveType == IllegalMove) {
7161                 sprintf(buf1, "Xboard: Forfeit due to illegal move: %s (%c%c%c%c)%c",
7162                         machineMove, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, 0);
7163                 GameEnds(machineWhite ? BlackWins : WhiteWins,
7164                            buf1, GE_XBOARD);
7165                 return;
7166            } else if(gameInfo.variant != VariantFischeRandom && gameInfo.variant != VariantCapaRandom)
7167            /* [HGM] Kludge to handle engines that send FRC-style castling
7168               when they shouldn't (like TSCP-Gothic) */
7169            switch(moveType) {
7170              case WhiteASideCastleFR:
7171              case BlackASideCastleFR:
7172                toX+=2;
7173                currentMoveString[2]++;
7174                break;
7175              case WhiteHSideCastleFR:
7176              case BlackHSideCastleFR:
7177                toX--;
7178                currentMoveString[2]--;
7179                break;
7180              default: ; // nothing to do, but suppresses warning of pedantic compilers
7181            }
7182         }
7183         hintRequested = FALSE;
7184         lastHint[0] = NULLCHAR;
7185         bookRequested = FALSE;
7186         /* Program may be pondering now */
7187         cps->maybeThinking = TRUE;
7188         if (cps->sendTime == 2) cps->sendTime = 1;
7189         if (cps->offeredDraw) cps->offeredDraw--;
7190
7191         /* currentMoveString is set as a side-effect of ParseOneMove */
7192         strcpy(machineMove, currentMoveString);
7193         strcat(machineMove, "\n");
7194         strcpy(moveList[forwardMostMove], machineMove);
7195
7196         /* [AS] Save move info*/
7197         pvInfoList[ forwardMostMove ].score = programStats.score;
7198         pvInfoList[ forwardMostMove ].depth = programStats.depth;
7199         pvInfoList[ forwardMostMove ].time =  programStats.time; // [HGM] PGNtime: take time from engine stats
7200
7201         MakeMove(fromX, fromY, toX, toY, promoChar);/*updates forwardMostMove*/
7202
7203         /* [AS] Adjudicate game if needed (note: remember that forwardMostMove now points past the last move) */
7204         if( gameMode == TwoMachinesPlay && adjudicateLossThreshold != 0 && forwardMostMove >= adjudicateLossPlies ) {
7205             int count = 0;
7206
7207             while( count < adjudicateLossPlies ) {
7208                 int score = pvInfoList[ forwardMostMove - count - 1 ].score;
7209
7210                 if( count & 1 ) {
7211                     score = -score; /* Flip score for winning side */
7212                 }
7213
7214                 if( score > adjudicateLossThreshold ) {
7215                     break;
7216                 }
7217
7218                 count++;
7219             }
7220
7221             if( count >= adjudicateLossPlies ) {
7222                 ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
7223
7224                 GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
7225                     "Xboard adjudication",
7226                     GE_XBOARD );
7227
7228                 return;
7229             }
7230         }
7231
7232         if(Adjudicate(cps)) return; // [HGM] adjudicate: for all automatic game ends
7233
7234 #if ZIPPY
7235         if ((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack) &&
7236             first.initDone) {
7237           if(cps->offeredDraw && (signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
7238                 SendToICS(ics_prefix); // [HGM] drawclaim: send caim and move on one line for FICS
7239                 SendToICS("draw ");
7240                 SendMoveToICS(moveType, fromX, fromY, toX, toY);
7241           }
7242           SendMoveToICS(moveType, fromX, fromY, toX, toY);
7243           ics_user_moved = 1;
7244           if(appData.autoKibitz && !appData.icsEngineAnalyze ) { /* [HGM] kibitz: send most-recent PV info to ICS */
7245                 char buf[3*MSG_SIZ];
7246
7247                 sprintf(buf, "kibitz !!! %+.2f/%d (%.2f sec, %u nodes, %.0f knps) PV=%s\n",
7248                         programStats.score / 100.,
7249                         programStats.depth,
7250                         programStats.time / 100.,
7251                         (unsigned int)programStats.nodes,
7252                         (unsigned int)programStats.nodes / (10*abs(programStats.time) + 1.),
7253                         programStats.movelist);
7254                 SendToICS(buf);
7255 if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.nodes, programStats.nodes);
7256           }
7257         }
7258 #endif
7259
7260         /* [AS] Clear stats for next move */
7261         ClearProgramStats();
7262         thinkOutput[0] = NULLCHAR;
7263         hiddenThinkOutputState = 0;
7264
7265         bookHit = NULL;
7266         if (gameMode == TwoMachinesPlay) {
7267             /* [HGM] relaying draw offers moved to after reception of move */
7268             /* and interpreting offer as claim if it brings draw condition */
7269             if (cps->offeredDraw == 1 && cps->other->sendDrawOffers) {
7270                 SendToProgram("draw\n", cps->other);
7271             }
7272             if (cps->other->sendTime) {
7273                 SendTimeRemaining(cps->other,
7274                                   cps->other->twoMachinesColor[0] == 'w');
7275             }
7276             bookHit = SendMoveToBookUser(forwardMostMove-1, cps->other, FALSE);
7277             if (firstMove && !bookHit) {
7278                 firstMove = FALSE;
7279                 if (cps->other->useColors) {
7280                   SendToProgram(cps->other->twoMachinesColor, cps->other);
7281                 }
7282                 SendToProgram("go\n", cps->other);
7283             }
7284             cps->other->maybeThinking = TRUE;
7285         }
7286
7287         ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
7288
7289         if (!pausing && appData.ringBellAfterMoves) {
7290             RingBell();
7291         }
7292
7293         /*
7294          * Reenable menu items that were disabled while
7295          * machine was thinking
7296          */
7297         if (gameMode != TwoMachinesPlay)
7298             SetUserThinkingEnables();
7299
7300         // [HGM] book: after book hit opponent has received move and is now in force mode
7301         // force the book reply into it, and then fake that it outputted this move by jumping
7302         // back to the beginning of HandleMachineMove, with cps toggled and message set to this move
7303         if(bookHit) {
7304                 static char bookMove[MSG_SIZ]; // a bit generous?
7305
7306                 strcpy(bookMove, "move ");
7307                 strcat(bookMove, bookHit);
7308                 message = bookMove;
7309                 cps = cps->other;
7310                 programStats.nodes = programStats.depth = programStats.time =
7311                 programStats.score = programStats.got_only_move = 0;
7312                 sprintf(programStats.movelist, "%s (xbook)", bookHit);
7313
7314                 if(cps->lastPing != cps->lastPong) {
7315                     savedMessage = message; // args for deferred call
7316                     savedState = cps;
7317                     ScheduleDelayedEvent(DeferredBookMove, 10);
7318                     return;
7319                 }
7320                 goto FakeBookMove;
7321         }
7322
7323         return;
7324     }
7325
7326     /* Set special modes for chess engines.  Later something general
7327      *  could be added here; for now there is just one kludge feature,
7328      *  needed because Crafty 15.10 and earlier don't ignore SIGINT
7329      *  when "xboard" is given as an interactive command.
7330      */
7331     if (strncmp(message, "kibitz Hello from Crafty", 24) == 0) {
7332         cps->useSigint = FALSE;
7333         cps->useSigterm = FALSE;
7334     }
7335     if (strncmp(message, "feature ", 8) == 0) { // [HGM] moved forward to pre-empt non-compliant commands
7336       ParseFeatures(message+8, cps);
7337       return; // [HGM] This return was missing, causing option features to be recognized as non-compliant commands!
7338     }
7339
7340     /* [HGM] Allow engine to set up a position. Don't ask me why one would
7341      * want this, I was asked to put it in, and obliged.
7342      */
7343     if (!strncmp(message, "setboard ", 9)) {
7344         Board initial_position;
7345
7346         GameEnds(GameUnfinished, "Engine aborts game", GE_XBOARD);
7347
7348         if (!ParseFEN(initial_position, &blackPlaysFirst, message + 9)) {
7349             DisplayError(_("Bad FEN received from engine"), 0);
7350             return ;
7351         } else {
7352            Reset(TRUE, FALSE);
7353            CopyBoard(boards[0], initial_position);
7354            initialRulePlies = FENrulePlies;
7355            if(blackPlaysFirst) gameMode = MachinePlaysWhite;
7356            else gameMode = MachinePlaysBlack;
7357            DrawPosition(FALSE, boards[currentMove]);
7358         }
7359         return;
7360     }
7361
7362     /*
7363      * Look for communication commands
7364      */
7365     if (!strncmp(message, "telluser ", 9)) {
7366         EscapeExpand(message+9, message+9); // [HGM] esc: allow escape sequences in popup box
7367         DisplayNote(message + 9);
7368         return;
7369     }
7370     if (!strncmp(message, "tellusererror ", 14)) {
7371         cps->userError = 1;
7372         EscapeExpand(message+14, message+14); // [HGM] esc: allow escape sequences in popup box
7373         DisplayError(message + 14, 0);
7374         return;
7375     }
7376     if (!strncmp(message, "tellopponent ", 13)) {
7377       if (appData.icsActive) {
7378         if (loggedOn) {
7379           snprintf(buf1, sizeof(buf1), "%ssay %s\n", ics_prefix, message + 13);
7380           SendToICS(buf1);
7381         }
7382       } else {
7383         DisplayNote(message + 13);
7384       }
7385       return;
7386     }
7387     if (!strncmp(message, "tellothers ", 11)) {
7388       if (appData.icsActive) {
7389         if (loggedOn) {
7390           snprintf(buf1, sizeof(buf1), "%swhisper %s\n", ics_prefix, message + 11);
7391           SendToICS(buf1);
7392         }
7393       }
7394       return;
7395     }
7396     if (!strncmp(message, "tellall ", 8)) {
7397       if (appData.icsActive) {
7398         if (loggedOn) {
7399           snprintf(buf1, sizeof(buf1), "%skibitz %s\n", ics_prefix, message + 8);
7400           SendToICS(buf1);
7401         }
7402       } else {
7403         DisplayNote(message + 8);
7404       }
7405       return;
7406     }
7407     if (strncmp(message, "warning", 7) == 0) {
7408         /* Undocumented feature, use tellusererror in new code */
7409         DisplayError(message, 0);
7410         return;
7411     }
7412     if (sscanf(message, "askuser %s %[^\n]", buf1, buf2) == 2) {
7413         strcpy(realname, cps->tidy);
7414         strcat(realname, " query");
7415         AskQuestion(realname, buf2, buf1, cps->pr);
7416         return;
7417     }
7418     /* Commands from the engine directly to ICS.  We don't allow these to be
7419      *  sent until we are logged on. Crafty kibitzes have been known to
7420      *  interfere with the login process.
7421      */
7422     if (loggedOn) {
7423         if (!strncmp(message, "tellics ", 8)) {
7424             SendToICS(message + 8);
7425             SendToICS("\n");
7426             return;
7427         }
7428         if (!strncmp(message, "tellicsnoalias ", 15)) {
7429             SendToICS(ics_prefix);
7430             SendToICS(message + 15);
7431             SendToICS("\n");
7432             return;
7433         }
7434         /* The following are for backward compatibility only */
7435         if (!strncmp(message,"whisper",7) || !strncmp(message,"kibitz",6) ||
7436             !strncmp(message,"draw",4) || !strncmp(message,"tell",3)) {
7437             SendToICS(ics_prefix);
7438             SendToICS(message);
7439             SendToICS("\n");
7440             return;
7441         }
7442     }
7443     if (sscanf(message, "pong %d", &cps->lastPong) == 1) {
7444         return;
7445     }
7446     /*
7447      * If the move is illegal, cancel it and redraw the board.
7448      * Also deal with other error cases.  Matching is rather loose
7449      * here to accommodate engines written before the spec.
7450      */
7451     if (strncmp(message + 1, "llegal move", 11) == 0 ||
7452         strncmp(message, "Error", 5) == 0) {
7453         if (StrStr(message, "name") ||
7454             StrStr(message, "rating") || StrStr(message, "?") ||
7455             StrStr(message, "result") || StrStr(message, "board") ||
7456             StrStr(message, "bk") || StrStr(message, "computer") ||
7457             StrStr(message, "variant") || StrStr(message, "hint") ||
7458             StrStr(message, "random") || StrStr(message, "depth") ||
7459             StrStr(message, "accepted")) {
7460             return;
7461         }
7462         if (StrStr(message, "protover")) {
7463           /* Program is responding to input, so it's apparently done
7464              initializing, and this error message indicates it is
7465              protocol version 1.  So we don't need to wait any longer
7466              for it to initialize and send feature commands. */
7467           FeatureDone(cps, 1);
7468           cps->protocolVersion = 1;
7469           return;
7470         }
7471         cps->maybeThinking = FALSE;
7472
7473         if (StrStr(message, "draw")) {
7474             /* Program doesn't have "draw" command */
7475             cps->sendDrawOffers = 0;
7476             return;
7477         }
7478         if (cps->sendTime != 1 &&
7479             (StrStr(message, "time") || StrStr(message, "otim"))) {
7480           /* Program apparently doesn't have "time" or "otim" command */
7481           cps->sendTime = 0;
7482           return;
7483         }
7484         if (StrStr(message, "analyze")) {
7485             cps->analysisSupport = FALSE;
7486             cps->analyzing = FALSE;
7487             Reset(FALSE, TRUE);
7488             sprintf(buf2, _("%s does not support analysis"), cps->tidy);
7489             DisplayError(buf2, 0);
7490             return;
7491         }
7492         if (StrStr(message, "(no matching move)st")) {
7493           /* Special kludge for GNU Chess 4 only */
7494           cps->stKludge = TRUE;
7495           SendTimeControl(cps, movesPerSession, timeControl,
7496                           timeIncrement, appData.searchDepth,
7497                           searchTime);
7498           return;
7499         }
7500         if (StrStr(message, "(no matching move)sd")) {
7501           /* Special kludge for GNU Chess 4 only */
7502           cps->sdKludge = TRUE;
7503           SendTimeControl(cps, movesPerSession, timeControl,
7504                           timeIncrement, appData.searchDepth,
7505                           searchTime);
7506           return;
7507         }
7508         if (!StrStr(message, "llegal")) {
7509             return;
7510         }
7511         if (gameMode == BeginningOfGame || gameMode == EndOfGame ||
7512             gameMode == IcsIdle) return;
7513         if (forwardMostMove <= backwardMostMove) return;
7514         if (pausing) PauseEvent();
7515       if(appData.forceIllegal) {
7516             // [HGM] illegal: machine refused move; force position after move into it
7517           SendToProgram("force\n", cps);
7518           if(!cps->useSetboard) { // hideous kludge on kludge, because SendBoard sucks.
7519                 // we have a real problem now, as SendBoard will use the a2a3 kludge
7520                 // when black is to move, while there might be nothing on a2 or black
7521                 // might already have the move. So send the board as if white has the move.
7522                 // But first we must change the stm of the engine, as it refused the last move
7523                 SendBoard(cps, 0); // always kludgeless, as white is to move on boards[0]
7524                 if(WhiteOnMove(forwardMostMove)) {
7525                     SendToProgram("a7a6\n", cps); // for the engine black still had the move
7526                     SendBoard(cps, forwardMostMove); // kludgeless board
7527                 } else {
7528                     SendToProgram("a2a3\n", cps); // for the engine white still had the move
7529                     CopyBoard(boards[forwardMostMove+1], boards[forwardMostMove]);
7530                     SendBoard(cps, forwardMostMove+1); // kludgeless board
7531                 }
7532           } else SendBoard(cps, forwardMostMove); // FEN case, also sets stm properly
7533             if(gameMode == MachinePlaysWhite || gameMode == MachinePlaysBlack ||
7534                  gameMode == TwoMachinesPlay)
7535               SendToProgram("go\n", cps);
7536             return;
7537       } else
7538         if (gameMode == PlayFromGameFile) {
7539             /* Stop reading this game file */
7540             gameMode = EditGame;
7541             ModeHighlight();
7542         }
7543         currentMove = forwardMostMove-1;
7544         DisplayMove(currentMove-1); /* before DisplayMoveError */
7545         SwitchClocks(forwardMostMove-1); // [HGM] race
7546         DisplayBothClocks();
7547         sprintf(buf1, _("Illegal move \"%s\" (rejected by %s chess program)"),
7548                 parseList[currentMove], cps->which);
7549         DisplayMoveError(buf1);
7550         DrawPosition(FALSE, boards[currentMove]);
7551
7552         /* [HGM] illegal-move claim should forfeit game when Xboard */
7553         /* only passes fully legal moves                            */
7554         if( appData.testLegality && gameMode == TwoMachinesPlay ) {
7555             GameEnds( cps->twoMachinesColor[0] == 'w' ? BlackWins : WhiteWins,
7556                                 "False illegal-move claim", GE_XBOARD );
7557         }
7558         return;
7559     }
7560     if (strncmp(message, "time", 4) == 0 && StrStr(message, "Illegal")) {
7561         /* Program has a broken "time" command that
7562            outputs a string not ending in newline.
7563            Don't use it. */
7564         cps->sendTime = 0;
7565     }
7566
7567     /*
7568      * If chess program startup fails, exit with an error message.
7569      * Attempts to recover here are futile.
7570      */
7571     if ((StrStr(message, "unknown host") != NULL)
7572         || (StrStr(message, "No remote directory") != NULL)
7573         || (StrStr(message, "not found") != NULL)
7574         || (StrStr(message, "No such file") != NULL)
7575         || (StrStr(message, "can't alloc") != NULL)
7576         || (StrStr(message, "Permission denied") != NULL)) {
7577
7578         cps->maybeThinking = FALSE;
7579         snprintf(buf1, sizeof(buf1), _("Failed to start %s chess program %s on %s: %s\n"),
7580                 cps->which, cps->program, cps->host, message);
7581         RemoveInputSource(cps->isr);
7582         DisplayFatalError(buf1, 0, 1);
7583         return;
7584     }
7585
7586     /*
7587      * Look for hint output
7588      */
7589     if (sscanf(message, "Hint: %s", buf1) == 1) {
7590         if (cps == &first && hintRequested) {
7591             hintRequested = FALSE;
7592             if (ParseOneMove(buf1, forwardMostMove, &moveType,
7593                                  &fromX, &fromY, &toX, &toY, &promoChar)) {
7594                 (void) CoordsToAlgebraic(boards[forwardMostMove],
7595                                     PosFlags(forwardMostMove),
7596                                     fromY, fromX, toY, toX, promoChar, buf1);
7597                 snprintf(buf2, sizeof(buf2), _("Hint: %s"), buf1);
7598                 DisplayInformation(buf2);
7599             } else {
7600                 /* Hint move could not be parsed!? */
7601               snprintf(buf2, sizeof(buf2),
7602                         _("Illegal hint move \"%s\"\nfrom %s chess program"),
7603                         buf1, cps->which);
7604                 DisplayError(buf2, 0);
7605             }
7606         } else {
7607             strcpy(lastHint, buf1);
7608         }
7609         return;
7610     }
7611
7612     /*
7613      * Ignore other messages if game is not in progress
7614      */
7615     if (gameMode == BeginningOfGame || gameMode == EndOfGame ||
7616         gameMode == IcsIdle || cps->lastPing != cps->lastPong) return;
7617
7618     /*
7619      * look for win, lose, draw, or draw offer
7620      */
7621     if (strncmp(message, "1-0", 3) == 0) {
7622         char *p, *q, *r = "";
7623         p = strchr(message, '{');
7624         if (p) {
7625             q = strchr(p, '}');
7626             if (q) {
7627                 *q = NULLCHAR;
7628                 r = p + 1;
7629             }
7630         }
7631         GameEnds(WhiteWins, r, GE_ENGINE1 + (cps != &first)); /* [HGM] pass claimer indication for claim test */
7632         return;
7633     } else if (strncmp(message, "0-1", 3) == 0) {
7634         char *p, *q, *r = "";
7635         p = strchr(message, '{');
7636         if (p) {
7637             q = strchr(p, '}');
7638             if (q) {
7639                 *q = NULLCHAR;
7640                 r = p + 1;
7641             }
7642         }
7643         /* Kludge for Arasan 4.1 bug */
7644         if (strcmp(r, "Black resigns") == 0) {
7645             GameEnds(WhiteWins, r, GE_ENGINE1 + (cps != &first));
7646             return;
7647         }
7648         GameEnds(BlackWins, r, GE_ENGINE1 + (cps != &first));
7649         return;
7650     } else if (strncmp(message, "1/2", 3) == 0) {
7651         char *p, *q, *r = "";
7652         p = strchr(message, '{');
7653         if (p) {
7654             q = strchr(p, '}');
7655             if (q) {
7656                 *q = NULLCHAR;
7657                 r = p + 1;
7658             }
7659         }
7660
7661         GameEnds(GameIsDrawn, r, GE_ENGINE1 + (cps != &first));
7662         return;
7663
7664     } else if (strncmp(message, "White resign", 12) == 0) {
7665         GameEnds(BlackWins, "White resigns", GE_ENGINE1 + (cps != &first));
7666         return;
7667     } else if (strncmp(message, "Black resign", 12) == 0) {
7668         GameEnds(WhiteWins, "Black resigns", GE_ENGINE1 + (cps != &first));
7669         return;
7670     } else if (strncmp(message, "White matches", 13) == 0 ||
7671                strncmp(message, "Black matches", 13) == 0   ) {
7672         /* [HGM] ignore GNUShogi noises */
7673         return;
7674     } else if (strncmp(message, "White", 5) == 0 &&
7675                message[5] != '(' &&
7676                StrStr(message, "Black") == NULL) {
7677         GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
7678         return;
7679     } else if (strncmp(message, "Black", 5) == 0 &&
7680                message[5] != '(') {
7681         GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
7682         return;
7683     } else if (strcmp(message, "resign") == 0 ||
7684                strcmp(message, "computer resigns") == 0) {
7685         switch (gameMode) {
7686           case MachinePlaysBlack:
7687           case IcsPlayingBlack:
7688             GameEnds(WhiteWins, "Black resigns", GE_ENGINE);
7689             break;
7690           case MachinePlaysWhite:
7691           case IcsPlayingWhite:
7692             GameEnds(BlackWins, "White resigns", GE_ENGINE);
7693             break;
7694           case TwoMachinesPlay:
7695             if (cps->twoMachinesColor[0] == 'w')
7696               GameEnds(BlackWins, "White resigns", GE_ENGINE1 + (cps != &first));
7697             else
7698               GameEnds(WhiteWins, "Black resigns", GE_ENGINE1 + (cps != &first));
7699             break;
7700           default:
7701             /* can't happen */
7702             break;
7703         }
7704         return;
7705     } else if (strncmp(message, "opponent mates", 14) == 0) {
7706         switch (gameMode) {
7707           case MachinePlaysBlack:
7708           case IcsPlayingBlack:
7709             GameEnds(WhiteWins, "White mates", GE_ENGINE);
7710             break;
7711           case MachinePlaysWhite:
7712           case IcsPlayingWhite:
7713             GameEnds(BlackWins, "Black mates", GE_ENGINE);
7714             break;
7715           case TwoMachinesPlay:
7716             if (cps->twoMachinesColor[0] == 'w')
7717               GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
7718             else
7719               GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
7720             break;
7721           default:
7722             /* can't happen */
7723             break;
7724         }
7725         return;
7726     } else if (strncmp(message, "computer mates", 14) == 0) {
7727         switch (gameMode) {
7728           case MachinePlaysBlack:
7729           case IcsPlayingBlack:
7730             GameEnds(BlackWins, "Black mates", GE_ENGINE1);
7731             break;
7732           case MachinePlaysWhite:
7733           case IcsPlayingWhite:
7734             GameEnds(WhiteWins, "White mates", GE_ENGINE);
7735             break;
7736           case TwoMachinesPlay:
7737             if (cps->twoMachinesColor[0] == 'w')
7738               GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
7739             else
7740               GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
7741             break;
7742           default:
7743             /* can't happen */
7744             break;
7745         }
7746         return;
7747     } else if (strncmp(message, "checkmate", 9) == 0) {
7748         if (WhiteOnMove(forwardMostMove)) {
7749             GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
7750         } else {
7751             GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
7752         }
7753         return;
7754     } else if (strstr(message, "Draw") != NULL ||
7755                strstr(message, "game is a draw") != NULL) {
7756         GameEnds(GameIsDrawn, "Draw", GE_ENGINE1 + (cps != &first));
7757         return;
7758     } else if (strstr(message, "offer") != NULL &&
7759                strstr(message, "draw") != NULL) {
7760 #if ZIPPY
7761         if (appData.zippyPlay && first.initDone) {
7762             /* Relay offer to ICS */
7763             SendToICS(ics_prefix);
7764             SendToICS("draw\n");
7765         }
7766 #endif
7767         cps->offeredDraw = 2; /* valid until this engine moves twice */
7768         if (gameMode == TwoMachinesPlay) {
7769             if (cps->other->offeredDraw) {
7770                 GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
7771             /* [HGM] in two-machine mode we delay relaying draw offer      */
7772             /* until after we also have move, to see if it is really claim */
7773             }
7774         } else if (gameMode == MachinePlaysWhite ||
7775                    gameMode == MachinePlaysBlack) {
7776           if (userOfferedDraw) {
7777             DisplayInformation(_("Machine accepts your draw offer"));
7778             GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
7779           } else {
7780             DisplayInformation(_("Machine offers a draw\nSelect Action / Draw to agree"));
7781           }
7782         }
7783     }
7784
7785
7786     /*
7787      * Look for thinking output
7788      */
7789     if ( appData.showThinking // [HGM] thinking: test all options that cause this output
7790           || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp()
7791                                 ) {
7792         int plylev, mvleft, mvtot, curscore, time;
7793         char mvname[MOVE_LEN];
7794         u64 nodes; // [DM]
7795         char plyext;
7796         int ignore = FALSE;
7797         int prefixHint = FALSE;
7798         mvname[0] = NULLCHAR;
7799
7800         switch (gameMode) {
7801           case MachinePlaysBlack:
7802           case IcsPlayingBlack:
7803             if (WhiteOnMove(forwardMostMove)) prefixHint = TRUE;
7804             break;
7805           case MachinePlaysWhite:
7806           case IcsPlayingWhite:
7807             if (!WhiteOnMove(forwardMostMove)) prefixHint = TRUE;
7808             break;
7809           case AnalyzeMode:
7810           case AnalyzeFile:
7811             break;
7812           case IcsObserving: /* [DM] icsEngineAnalyze */
7813             if (!appData.icsEngineAnalyze) ignore = TRUE;
7814             break;
7815           case TwoMachinesPlay:
7816             if ((cps->twoMachinesColor[0] == 'w') != WhiteOnMove(forwardMostMove)) {
7817                 ignore = TRUE;
7818             }
7819             break;
7820           default:
7821             ignore = TRUE;
7822             break;
7823         }
7824
7825         if (!ignore) {
7826             ChessProgramStats tempStats = programStats; // [HGM] info: filter out info lines
7827             buf1[0] = NULLCHAR;
7828             if (sscanf(message, "%d%c %d %d " u64Display " %[^\n]\n",
7829                        &plylev, &plyext, &curscore, &time, &nodes, buf1) >= 5) {
7830
7831                 if (plyext != ' ' && plyext != '\t') {
7832                     time *= 100;
7833                 }
7834
7835                 /* [AS] Negate score if machine is playing black and reporting absolute scores */
7836                 if( cps->scoreIsAbsolute &&
7837                     ( gameMode == MachinePlaysBlack ||
7838                       gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b' ||
7839                       gameMode == IcsPlayingBlack ||     // [HGM] also add other situations where engine should report black POV
7840                      (gameMode == AnalyzeMode || gameMode == AnalyzeFile || gameMode == IcsObserving && appData.icsEngineAnalyze) &&
7841                      !WhiteOnMove(currentMove)
7842                     ) )
7843                 {
7844                     curscore = -curscore;
7845                 }
7846
7847
7848                 tempStats.depth = plylev;
7849                 tempStats.nodes = nodes;
7850                 tempStats.time = time;
7851                 tempStats.score = curscore;
7852                 tempStats.got_only_move = 0;
7853
7854                 if(cps->nps >= 0) { /* [HGM] nps: use engine nodes or time to decrement clock */
7855                         int ticklen;
7856
7857                         if(cps->nps == 0) ticklen = 10*time;                    // use engine reported time
7858                         else ticklen = (1000. * u64ToDouble(nodes)) / cps->nps; // convert node count to time
7859                         if(WhiteOnMove(forwardMostMove) && (gameMode == MachinePlaysWhite ||
7860                                                 gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'w'))
7861                              whiteTimeRemaining = timeRemaining[0][forwardMostMove] - ticklen;
7862                         if(!WhiteOnMove(forwardMostMove) && (gameMode == MachinePlaysBlack ||
7863                                                 gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b'))
7864                              blackTimeRemaining = timeRemaining[1][forwardMostMove] - ticklen;
7865                 }
7866
7867                 /* Buffer overflow protection */
7868                 if (buf1[0] != NULLCHAR) {
7869                     if (strlen(buf1) >= sizeof(tempStats.movelist)
7870                         && appData.debugMode) {
7871                         fprintf(debugFP,
7872                                 "PV is too long; using the first %u bytes.\n",
7873                                 (unsigned) sizeof(tempStats.movelist) - 1);
7874                     }
7875
7876                     safeStrCpy( tempStats.movelist, buf1, sizeof(tempStats.movelist) );
7877                 } else {
7878                     sprintf(tempStats.movelist, " no PV\n");
7879                 }
7880
7881                 if (tempStats.seen_stat) {
7882                     tempStats.ok_to_send = 1;
7883                 }
7884
7885                 if (strchr(tempStats.movelist, '(') != NULL) {
7886                     tempStats.line_is_book = 1;
7887                     tempStats.nr_moves = 0;
7888                     tempStats.moves_left = 0;
7889                 } else {
7890                     tempStats.line_is_book = 0;
7891                 }
7892
7893                     if(tempStats.score != 0 || tempStats.nodes != 0 || tempStats.time != 0)
7894                         programStats = tempStats; // [HGM] info: only set stats if genuine PV and not an info line
7895
7896                 SendProgramStatsToFrontend( cps, &tempStats );
7897
7898                 /*
7899                     [AS] Protect the thinkOutput buffer from overflow... this
7900                     is only useful if buf1 hasn't overflowed first!
7901                 */
7902                 sprintf(thinkOutput, "[%d]%c%+.2f %s%s",
7903                         plylev,
7904                         (gameMode == TwoMachinesPlay ?
7905                          ToUpper(cps->twoMachinesColor[0]) : ' '),
7906                         ((double) curscore) / 100.0,
7907                         prefixHint ? lastHint : "",
7908                         prefixHint ? " " : "" );
7909
7910                 if( buf1[0] != NULLCHAR ) {
7911                     unsigned max_len = sizeof(thinkOutput) - strlen(thinkOutput) - 1;
7912
7913                     if( strlen(buf1) > max_len ) {
7914                         if( appData.debugMode) {
7915                             fprintf(debugFP,"PV is too long for thinkOutput, truncating.\n");
7916                         }
7917                         buf1[max_len+1] = '\0';
7918                     }
7919
7920                     strcat( thinkOutput, buf1 );
7921                 }
7922
7923                 if (currentMove == forwardMostMove || gameMode == AnalyzeMode
7924                         || gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
7925                     DisplayMove(currentMove - 1);
7926                 }
7927                 return;
7928
7929             } else if ((p=StrStr(message, "(only move)")) != NULL) {
7930                 /* crafty (9.25+) says "(only move) <move>"
7931                  * if there is only 1 legal move
7932                  */
7933                 sscanf(p, "(only move) %s", buf1);
7934                 sprintf(thinkOutput, "%s (only move)", buf1);
7935                 sprintf(programStats.movelist, "%s (only move)", buf1);
7936                 programStats.depth = 1;
7937                 programStats.nr_moves = 1;
7938                 programStats.moves_left = 1;
7939                 programStats.nodes = 1;
7940                 programStats.time = 1;
7941                 programStats.got_only_move = 1;
7942
7943                 /* Not really, but we also use this member to
7944                    mean "line isn't going to change" (Crafty
7945                    isn't searching, so stats won't change) */
7946                 programStats.line_is_book = 1;
7947
7948                 SendProgramStatsToFrontend( cps, &programStats );
7949
7950                 if (currentMove == forwardMostMove || gameMode==AnalyzeMode ||
7951                            gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
7952                     DisplayMove(currentMove - 1);
7953                 }
7954                 return;
7955             } else if (sscanf(message,"stat01: %d " u64Display " %d %d %d %s",
7956                               &time, &nodes, &plylev, &mvleft,
7957                               &mvtot, mvname) >= 5) {
7958                 /* The stat01: line is from Crafty (9.29+) in response
7959                    to the "." command */
7960                 programStats.seen_stat = 1;
7961                 cps->maybeThinking = TRUE;
7962
7963                 if (programStats.got_only_move || !appData.periodicUpdates)
7964                   return;
7965
7966                 programStats.depth = plylev;
7967                 programStats.time = time;
7968                 programStats.nodes = nodes;
7969                 programStats.moves_left = mvleft;
7970                 programStats.nr_moves = mvtot;
7971                 strcpy(programStats.move_name, mvname);
7972                 programStats.ok_to_send = 1;
7973                 programStats.movelist[0] = '\0';
7974
7975                 SendProgramStatsToFrontend( cps, &programStats );
7976
7977                 return;
7978
7979             } else if (strncmp(message,"++",2) == 0) {
7980                 /* Crafty 9.29+ outputs this */
7981                 programStats.got_fail = 2;
7982                 return;
7983
7984             } else if (strncmp(message,"--",2) == 0) {
7985                 /* Crafty 9.29+ outputs this */
7986                 programStats.got_fail = 1;
7987                 return;
7988
7989             } else if (thinkOutput[0] != NULLCHAR &&
7990                        strncmp(message, "    ", 4) == 0) {
7991                 unsigned message_len;
7992
7993                 p = message;
7994                 while (*p && *p == ' ') p++;
7995
7996                 message_len = strlen( p );
7997
7998                 /* [AS] Avoid buffer overflow */
7999                 if( sizeof(thinkOutput) - strlen(thinkOutput) - 1 > message_len ) {
8000                     strcat(thinkOutput, " ");
8001                     strcat(thinkOutput, p);
8002                 }
8003
8004                 if( sizeof(programStats.movelist) - strlen(programStats.movelist) - 1 > message_len ) {
8005                     strcat(programStats.movelist, " ");
8006                     strcat(programStats.movelist, p);
8007                 }
8008
8009                 if (currentMove == forwardMostMove || gameMode==AnalyzeMode ||
8010                            gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
8011                     DisplayMove(currentMove - 1);
8012                 }
8013                 return;
8014             }
8015         }
8016         else {
8017             buf1[0] = NULLCHAR;
8018
8019             if (sscanf(message, "%d%c %d %d " u64Display " %[^\n]\n",
8020                        &plylev, &plyext, &curscore, &time, &nodes, buf1) >= 5)
8021             {
8022                 ChessProgramStats cpstats;
8023
8024                 if (plyext != ' ' && plyext != '\t') {
8025                     time *= 100;
8026                 }
8027
8028                 /* [AS] Negate score if machine is playing black and reporting absolute scores */
8029                 if( cps->scoreIsAbsolute && ((gameMode == MachinePlaysBlack) || (gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b')) ) {
8030                     curscore = -curscore;
8031                 }
8032
8033                 cpstats.depth = plylev;
8034                 cpstats.nodes = nodes;
8035                 cpstats.time = time;
8036                 cpstats.score = curscore;
8037                 cpstats.got_only_move = 0;
8038                 cpstats.movelist[0] = '\0';
8039
8040                 if (buf1[0] != NULLCHAR) {
8041                     safeStrCpy( cpstats.movelist, buf1, sizeof(cpstats.movelist) );
8042                 }
8043
8044                 cpstats.ok_to_send = 0;
8045                 cpstats.line_is_book = 0;
8046                 cpstats.nr_moves = 0;
8047                 cpstats.moves_left = 0;
8048
8049                 SendProgramStatsToFrontend( cps, &cpstats );
8050             }
8051         }
8052     }
8053 }
8054
8055
8056 /* Parse a game score from the character string "game", and
8057    record it as the history of the current game.  The game
8058    score is NOT assumed to start from the standard position.
8059    The display is not updated in any way.
8060    */
8061 void
8062 ParseGameHistory(game)
8063      char *game;
8064 {
8065     ChessMove moveType;
8066     int fromX, fromY, toX, toY, boardIndex;
8067     char promoChar;
8068     char *p, *q;
8069     char buf[MSG_SIZ];
8070
8071     if (appData.debugMode)
8072       fprintf(debugFP, "Parsing game history: %s\n", game);
8073
8074     if (gameInfo.event == NULL) gameInfo.event = StrSave("ICS game");
8075     gameInfo.site = StrSave(appData.icsHost);
8076     gameInfo.date = PGNDate();
8077     gameInfo.round = StrSave("-");
8078
8079     /* Parse out names of players */
8080     while (*game == ' ') game++;
8081     p = buf;
8082     while (*game != ' ') *p++ = *game++;
8083     *p = NULLCHAR;
8084     gameInfo.white = StrSave(buf);
8085     while (*game == ' ') game++;
8086     p = buf;
8087     while (*game != ' ' && *game != '\n') *p++ = *game++;
8088     *p = NULLCHAR;
8089     gameInfo.black = StrSave(buf);
8090
8091     /* Parse moves */
8092     boardIndex = blackPlaysFirst ? 1 : 0;
8093     yynewstr(game);
8094     for (;;) {
8095         yyboardindex = boardIndex;
8096         moveType = (ChessMove) yylex();
8097         switch (moveType) {
8098           case IllegalMove:             /* maybe suicide chess, etc. */
8099   if (appData.debugMode) {
8100     fprintf(debugFP, "Illegal move from ICS: '%s'\n", yy_text);
8101     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
8102     setbuf(debugFP, NULL);
8103   }
8104           case WhitePromotionChancellor:
8105           case BlackPromotionChancellor:
8106           case WhitePromotionArchbishop:
8107           case BlackPromotionArchbishop:
8108           case WhitePromotionQueen:
8109           case BlackPromotionQueen:
8110           case WhitePromotionRook:
8111           case BlackPromotionRook:
8112           case WhitePromotionBishop:
8113           case BlackPromotionBishop:
8114           case WhitePromotionKnight:
8115           case BlackPromotionKnight:
8116           case WhitePromotionKing:
8117           case BlackPromotionKing:
8118           case NormalMove:
8119           case WhiteCapturesEnPassant:
8120           case BlackCapturesEnPassant:
8121           case WhiteKingSideCastle:
8122           case WhiteQueenSideCastle:
8123           case BlackKingSideCastle:
8124           case BlackQueenSideCastle:
8125           case WhiteKingSideCastleWild:
8126           case WhiteQueenSideCastleWild:
8127           case BlackKingSideCastleWild:
8128           case BlackQueenSideCastleWild:
8129           /* PUSH Fabien */
8130           case WhiteHSideCastleFR:
8131           case WhiteASideCastleFR:
8132           case BlackHSideCastleFR:
8133           case BlackASideCastleFR:
8134           /* POP Fabien */
8135             fromX = currentMoveString[0] - AAA;
8136             fromY = currentMoveString[1] - ONE;
8137             toX = currentMoveString[2] - AAA;
8138             toY = currentMoveString[3] - ONE;
8139             promoChar = currentMoveString[4];
8140             break;
8141           case WhiteDrop:
8142           case BlackDrop:
8143             fromX = moveType == WhiteDrop ?
8144               (int) CharToPiece(ToUpper(currentMoveString[0])) :
8145             (int) CharToPiece(ToLower(currentMoveString[0]));
8146             fromY = DROP_RANK;
8147             toX = currentMoveString[2] - AAA;
8148             toY = currentMoveString[3] - ONE;
8149             promoChar = NULLCHAR;
8150             break;
8151           case AmbiguousMove:
8152             /* bug? */
8153             sprintf(buf, _("Ambiguous move in ICS output: \"%s\""), yy_text);
8154   if (appData.debugMode) {
8155     fprintf(debugFP, "Ambiguous move from ICS: '%s'\n", yy_text);
8156     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
8157     setbuf(debugFP, NULL);
8158   }
8159             DisplayError(buf, 0);
8160             return;
8161           case ImpossibleMove:
8162             /* bug? */
8163             sprintf(buf, _("Illegal move in ICS output: \"%s\""), yy_text);
8164   if (appData.debugMode) {
8165     fprintf(debugFP, "Impossible move from ICS: '%s'\n", yy_text);
8166     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
8167     setbuf(debugFP, NULL);
8168   }
8169             DisplayError(buf, 0);
8170             return;
8171           case (ChessMove) 0:   /* end of file */
8172             if (boardIndex < backwardMostMove) {
8173                 /* Oops, gap.  How did that happen? */
8174                 DisplayError(_("Gap in move list"), 0);
8175                 return;
8176             }
8177             backwardMostMove =  blackPlaysFirst ? 1 : 0;
8178             if (boardIndex > forwardMostMove) {
8179                 forwardMostMove = boardIndex;
8180             }
8181             return;
8182           case ElapsedTime:
8183             if (boardIndex > (blackPlaysFirst ? 1 : 0)) {
8184                 strcat(parseList[boardIndex-1], " ");
8185                 strcat(parseList[boardIndex-1], yy_text);
8186             }
8187             continue;
8188           case Comment:
8189           case PGNTag:
8190           case NAG:
8191           default:
8192             /* ignore */
8193             continue;
8194           case WhiteWins:
8195           case BlackWins:
8196           case GameIsDrawn:
8197           case GameUnfinished:
8198             if (gameMode == IcsExamining) {
8199                 if (boardIndex < backwardMostMove) {
8200                     /* Oops, gap.  How did that happen? */
8201                     return;
8202                 }
8203                 backwardMostMove = blackPlaysFirst ? 1 : 0;
8204                 return;
8205             }
8206             gameInfo.result = moveType;
8207             p = strchr(yy_text, '{');
8208             if (p == NULL) p = strchr(yy_text, '(');
8209             if (p == NULL) {
8210                 p = yy_text;
8211                 if (p[0] == '0' || p[0] == '1' || p[0] == '*') p = "";
8212             } else {
8213                 q = strchr(p, *p == '{' ? '}' : ')');
8214                 if (q != NULL) *q = NULLCHAR;
8215                 p++;
8216             }
8217             gameInfo.resultDetails = StrSave(p);
8218             continue;
8219         }
8220         if (boardIndex >= forwardMostMove &&
8221             !(gameMode == IcsObserving && ics_gamenum == -1)) {
8222             backwardMostMove = blackPlaysFirst ? 1 : 0;
8223             return;
8224         }
8225         (void) CoordsToAlgebraic(boards[boardIndex], PosFlags(boardIndex),
8226                                  fromY, fromX, toY, toX, promoChar,
8227                                  parseList[boardIndex]);
8228         CopyBoard(boards[boardIndex + 1], boards[boardIndex]);
8229         /* currentMoveString is set as a side-effect of yylex */
8230         strcpy(moveList[boardIndex], currentMoveString);
8231         strcat(moveList[boardIndex], "\n");
8232         boardIndex++;
8233         ApplyMove(fromX, fromY, toX, toY, promoChar, boards[boardIndex]);
8234         switch (MateTest(boards[boardIndex], PosFlags(boardIndex)) ) {
8235           case MT_NONE:
8236           case MT_STALEMATE:
8237           default:
8238             break;
8239           case MT_CHECK:
8240             if(gameInfo.variant != VariantShogi)
8241                 strcat(parseList[boardIndex - 1], "+");
8242             break;
8243           case MT_CHECKMATE:
8244           case MT_STAINMATE:
8245             strcat(parseList[boardIndex - 1], "#");
8246             break;
8247         }
8248     }
8249 }
8250
8251
8252 /* Apply a move to the given board  */
8253 void
8254 ApplyMove(fromX, fromY, toX, toY, promoChar, board)
8255      int fromX, fromY, toX, toY;
8256      int promoChar;
8257      Board board;
8258 {
8259   ChessSquare captured = board[toY][toX], piece, king; int p, oldEP = EP_NONE, berolina = 0;
8260   int promoRank = gameInfo.variant == VariantMakruk ? 3 : 1;
8261
8262     /* [HGM] compute & store e.p. status and castling rights for new position */
8263     /* we can always do that 'in place', now pointers to these rights are passed to ApplyMove */
8264     { int i;
8265
8266       if(gameInfo.variant == VariantBerolina) berolina = EP_BEROLIN_A;
8267       oldEP = (signed char)board[EP_STATUS];
8268       board[EP_STATUS] = EP_NONE;
8269
8270       if( board[toY][toX] != EmptySquare )
8271            board[EP_STATUS] = EP_CAPTURE;
8272
8273       if( board[fromY][fromX] == WhitePawn ) {
8274            if(fromY != toY) // [HGM] Xiangqi sideway Pawn moves should not count as 50-move breakers
8275                board[EP_STATUS] = EP_PAWN_MOVE;
8276            if( toY-fromY==2) {
8277                if(toX>BOARD_LEFT   && board[toY][toX-1] == BlackPawn &&
8278                         gameInfo.variant != VariantBerolina || toX < fromX)
8279                       board[EP_STATUS] = toX | berolina;
8280                if(toX<BOARD_RGHT-1 && board[toY][toX+1] == BlackPawn &&
8281                         gameInfo.variant != VariantBerolina || toX > fromX)
8282                       board[EP_STATUS] = toX;
8283            }
8284       } else
8285       if( board[fromY][fromX] == BlackPawn ) {
8286            if(fromY != toY) // [HGM] Xiangqi sideway Pawn moves should not count as 50-move breakers
8287                board[EP_STATUS] = EP_PAWN_MOVE;
8288            if( toY-fromY== -2) {
8289                if(toX>BOARD_LEFT   && board[toY][toX-1] == WhitePawn &&
8290                         gameInfo.variant != VariantBerolina || toX < fromX)
8291                       board[EP_STATUS] = toX | berolina;
8292                if(toX<BOARD_RGHT-1 && board[toY][toX+1] == WhitePawn &&
8293                         gameInfo.variant != VariantBerolina || toX > fromX)
8294                       board[EP_STATUS] = toX;
8295            }
8296        }
8297
8298        for(i=0; i<nrCastlingRights; i++) {
8299            if(board[CASTLING][i] == fromX && castlingRank[i] == fromY ||
8300               board[CASTLING][i] == toX   && castlingRank[i] == toY
8301              ) board[CASTLING][i] = NoRights; // revoke for moved or captured piece
8302        }
8303
8304     }
8305
8306   /* [HGM] In Shatranj and Courier all promotions are to Ferz */
8307   if((gameInfo.variant==VariantShatranj || gameInfo.variant==VariantCourier || gameInfo.variant == VariantMakruk)
8308        && promoChar != 0) promoChar = PieceToChar(WhiteFerz);
8309
8310   if (fromX == toX && fromY == toY) return;
8311
8312   if (fromY == DROP_RANK) {
8313         /* must be first */
8314         piece = board[toY][toX] = (ChessSquare) fromX;
8315   } else {
8316      piece = board[fromY][fromX]; /* [HGM] remember, for Shogi promotion */
8317      king = piece < (int) BlackPawn ? WhiteKing : BlackKing; /* [HGM] Knightmate simplify testing for castling */
8318      if(gameInfo.variant == VariantKnightmate)
8319          king += (int) WhiteUnicorn - (int) WhiteKing;
8320
8321     /* Code added by Tord: */
8322     /* FRC castling assumed when king captures friendly rook. */
8323     if (board[fromY][fromX] == WhiteKing &&
8324              board[toY][toX] == WhiteRook) {
8325       board[fromY][fromX] = EmptySquare;
8326       board[toY][toX] = EmptySquare;
8327       if(toX > fromX) {
8328         board[0][BOARD_RGHT-2] = WhiteKing; board[0][BOARD_RGHT-3] = WhiteRook;
8329       } else {
8330         board[0][BOARD_LEFT+2] = WhiteKing; board[0][BOARD_LEFT+3] = WhiteRook;
8331       }
8332     } else if (board[fromY][fromX] == BlackKing &&
8333                board[toY][toX] == BlackRook) {
8334       board[fromY][fromX] = EmptySquare;
8335       board[toY][toX] = EmptySquare;
8336       if(toX > fromX) {
8337         board[BOARD_HEIGHT-1][BOARD_RGHT-2] = BlackKing; board[BOARD_HEIGHT-1][BOARD_RGHT-3] = BlackRook;
8338       } else {
8339         board[BOARD_HEIGHT-1][BOARD_LEFT+2] = BlackKing; board[BOARD_HEIGHT-1][BOARD_LEFT+3] = BlackRook;
8340       }
8341     /* End of code added by Tord */
8342
8343     } else if (board[fromY][fromX] == king
8344         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
8345         && toY == fromY && toX > fromX+1) {
8346         board[fromY][fromX] = EmptySquare;
8347         board[toY][toX] = king;
8348         board[toY][toX-1] = board[fromY][BOARD_RGHT-1];
8349         board[fromY][BOARD_RGHT-1] = EmptySquare;
8350     } else if (board[fromY][fromX] == king
8351         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
8352                && toY == fromY && toX < fromX-1) {
8353         board[fromY][fromX] = EmptySquare;
8354         board[toY][toX] = king;
8355         board[toY][toX+1] = board[fromY][BOARD_LEFT];
8356         board[fromY][BOARD_LEFT] = EmptySquare;
8357     } else if (board[fromY][fromX] == WhitePawn
8358                && toY >= BOARD_HEIGHT-promoRank
8359                && gameInfo.variant != VariantXiangqi
8360                ) {
8361         /* white pawn promotion */
8362         board[toY][toX] = CharToPiece(ToUpper(promoChar));
8363         if (board[toY][toX] == EmptySquare) {
8364             board[toY][toX] = WhiteQueen;
8365         }
8366         if(gameInfo.variant==VariantBughouse ||
8367            gameInfo.variant==VariantCrazyhouse) /* [HGM] use shadow piece */
8368             board[toY][toX] = (ChessSquare) (PROMOTED board[toY][toX]);
8369         board[fromY][fromX] = EmptySquare;
8370     } else if ((fromY == BOARD_HEIGHT-4)
8371                && (toX != fromX)
8372                && gameInfo.variant != VariantXiangqi
8373                && gameInfo.variant != VariantBerolina
8374                && (board[fromY][fromX] == WhitePawn)
8375                && (board[toY][toX] == EmptySquare)) {
8376         board[fromY][fromX] = EmptySquare;
8377         board[toY][toX] = WhitePawn;
8378         captured = board[toY - 1][toX];
8379         board[toY - 1][toX] = EmptySquare;
8380     } else if ((fromY == BOARD_HEIGHT-4)
8381                && (toX == fromX)
8382                && gameInfo.variant == VariantBerolina
8383                && (board[fromY][fromX] == WhitePawn)
8384                && (board[toY][toX] == EmptySquare)) {
8385         board[fromY][fromX] = EmptySquare;
8386         board[toY][toX] = WhitePawn;
8387         if(oldEP & EP_BEROLIN_A) {
8388                 captured = board[fromY][fromX-1];
8389                 board[fromY][fromX-1] = EmptySquare;
8390         }else{  captured = board[fromY][fromX+1];
8391                 board[fromY][fromX+1] = EmptySquare;
8392         }
8393     } else if (board[fromY][fromX] == king
8394         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
8395                && toY == fromY && toX > fromX+1) {
8396         board[fromY][fromX] = EmptySquare;
8397         board[toY][toX] = king;
8398         board[toY][toX-1] = board[fromY][BOARD_RGHT-1];
8399         board[fromY][BOARD_RGHT-1] = EmptySquare;
8400     } else if (board[fromY][fromX] == king
8401         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
8402                && toY == fromY && toX < fromX-1) {
8403         board[fromY][fromX] = EmptySquare;
8404         board[toY][toX] = king;
8405         board[toY][toX+1] = board[fromY][BOARD_LEFT];
8406         board[fromY][BOARD_LEFT] = EmptySquare;
8407     } else if (fromY == 7 && fromX == 3
8408                && board[fromY][fromX] == BlackKing
8409                && toY == 7 && toX == 5) {
8410         board[fromY][fromX] = EmptySquare;
8411         board[toY][toX] = BlackKing;
8412         board[fromY][7] = EmptySquare;
8413         board[toY][4] = BlackRook;
8414     } else if (fromY == 7 && fromX == 3
8415                && board[fromY][fromX] == BlackKing
8416                && toY == 7 && toX == 1) {
8417         board[fromY][fromX] = EmptySquare;
8418         board[toY][toX] = BlackKing;
8419         board[fromY][0] = EmptySquare;
8420         board[toY][2] = BlackRook;
8421     } else if (board[fromY][fromX] == BlackPawn
8422                && toY < promoRank
8423                && gameInfo.variant != VariantXiangqi
8424                ) {
8425         /* black pawn promotion */
8426         board[toY][toX] = CharToPiece(ToLower(promoChar));
8427         if (board[toY][toX] == EmptySquare) {
8428             board[toY][toX] = BlackQueen;
8429         }
8430         if(gameInfo.variant==VariantBughouse ||
8431            gameInfo.variant==VariantCrazyhouse) /* [HGM] use shadow piece */
8432             board[toY][toX] = (ChessSquare) (PROMOTED board[toY][toX]);
8433         board[fromY][fromX] = EmptySquare;
8434     } else if ((fromY == 3)
8435                && (toX != fromX)
8436                && gameInfo.variant != VariantXiangqi
8437                && gameInfo.variant != VariantBerolina
8438                && (board[fromY][fromX] == BlackPawn)
8439                && (board[toY][toX] == EmptySquare)) {
8440         board[fromY][fromX] = EmptySquare;
8441         board[toY][toX] = BlackPawn;
8442         captured = board[toY + 1][toX];
8443         board[toY + 1][toX] = EmptySquare;
8444     } else if ((fromY == 3)
8445                && (toX == fromX)
8446                && gameInfo.variant == VariantBerolina
8447                && (board[fromY][fromX] == BlackPawn)
8448                && (board[toY][toX] == EmptySquare)) {
8449         board[fromY][fromX] = EmptySquare;
8450         board[toY][toX] = BlackPawn;
8451         if(oldEP & EP_BEROLIN_A) {
8452                 captured = board[fromY][fromX-1];
8453                 board[fromY][fromX-1] = EmptySquare;
8454         }else{  captured = board[fromY][fromX+1];
8455                 board[fromY][fromX+1] = EmptySquare;
8456         }
8457     } else {
8458         board[toY][toX] = board[fromY][fromX];
8459         board[fromY][fromX] = EmptySquare;
8460     }
8461
8462     /* [HGM] now we promote for Shogi, if needed */
8463     if(gameInfo.variant == VariantShogi && promoChar == 'q')
8464         board[toY][toX] = (ChessSquare) (PROMOTED piece);
8465   }
8466
8467     if (gameInfo.holdingsWidth != 0) {
8468
8469       /* !!A lot more code needs to be written to support holdings  */
8470       /* [HGM] OK, so I have written it. Holdings are stored in the */
8471       /* penultimate board files, so they are automaticlly stored   */
8472       /* in the game history.                                       */
8473       if (fromY == DROP_RANK) {
8474         /* Delete from holdings, by decreasing count */
8475         /* and erasing image if necessary            */
8476         p = (int) fromX;
8477         if(p < (int) BlackPawn) { /* white drop */
8478              p -= (int)WhitePawn;
8479                  p = PieceToNumber((ChessSquare)p);
8480              if(p >= gameInfo.holdingsSize) p = 0;
8481              if(--board[p][BOARD_WIDTH-2] <= 0)
8482                   board[p][BOARD_WIDTH-1] = EmptySquare;
8483              if((int)board[p][BOARD_WIDTH-2] < 0)
8484                         board[p][BOARD_WIDTH-2] = 0;
8485         } else {                  /* black drop */
8486              p -= (int)BlackPawn;
8487                  p = PieceToNumber((ChessSquare)p);
8488              if(p >= gameInfo.holdingsSize) p = 0;
8489              if(--board[BOARD_HEIGHT-1-p][1] <= 0)
8490                   board[BOARD_HEIGHT-1-p][0] = EmptySquare;
8491              if((int)board[BOARD_HEIGHT-1-p][1] < 0)
8492                         board[BOARD_HEIGHT-1-p][1] = 0;
8493         }
8494       }
8495       if (captured != EmptySquare && gameInfo.holdingsSize > 0
8496           && gameInfo.variant != VariantBughouse        ) {
8497         /* [HGM] holdings: Add to holdings, if holdings exist */
8498         if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
8499                 // [HGM] superchess: suppress flipping color of captured pieces by reverse pre-flip
8500                 captured = (int) captured >= (int) BlackPawn ? BLACK_TO_WHITE captured : WHITE_TO_BLACK captured;
8501         }
8502         p = (int) captured;
8503         if (p >= (int) BlackPawn) {
8504           p -= (int)BlackPawn;
8505           if(gameInfo.variant == VariantShogi && DEMOTED p >= 0) {
8506                   /* in Shogi restore piece to its original  first */
8507                   captured = (ChessSquare) (DEMOTED captured);
8508                   p = DEMOTED p;
8509           }
8510           p = PieceToNumber((ChessSquare)p);
8511           if(p >= gameInfo.holdingsSize) { p = 0; captured = BlackPawn; }
8512           board[p][BOARD_WIDTH-2]++;
8513           board[p][BOARD_WIDTH-1] = BLACK_TO_WHITE captured;
8514         } else {
8515           p -= (int)WhitePawn;
8516           if(gameInfo.variant == VariantShogi && DEMOTED p >= 0) {
8517                   captured = (ChessSquare) (DEMOTED captured);
8518                   p = DEMOTED p;
8519           }
8520           p = PieceToNumber((ChessSquare)p);
8521           if(p >= gameInfo.holdingsSize) { p = 0; captured = WhitePawn; }
8522           board[BOARD_HEIGHT-1-p][1]++;
8523           board[BOARD_HEIGHT-1-p][0] = WHITE_TO_BLACK captured;
8524         }
8525       }
8526     } else if (gameInfo.variant == VariantAtomic) {
8527       if (captured != EmptySquare) {
8528         int y, x;
8529         for (y = toY-1; y <= toY+1; y++) {
8530           for (x = toX-1; x <= toX+1; x++) {
8531             if (y >= 0 && y < BOARD_HEIGHT && x >= BOARD_LEFT && x < BOARD_RGHT &&
8532                 board[y][x] != WhitePawn && board[y][x] != BlackPawn) {
8533               board[y][x] = EmptySquare;
8534             }
8535           }
8536         }
8537         board[toY][toX] = EmptySquare;
8538       }
8539     }
8540     if(gameInfo.variant == VariantShogi && promoChar != NULLCHAR && promoChar != '=') {
8541         /* [HGM] Shogi promotions */
8542         board[toY][toX] = (ChessSquare) (PROMOTED piece);
8543     }
8544
8545     if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat)
8546                 && promoChar != NULLCHAR && gameInfo.holdingsSize) {
8547         // [HGM] superchess: take promotion piece out of holdings
8548         int k = PieceToNumber(CharToPiece(ToUpper(promoChar)));
8549         if((int)piece < (int)BlackPawn) { // determine stm from piece color
8550             if(!--board[k][BOARD_WIDTH-2])
8551                 board[k][BOARD_WIDTH-1] = EmptySquare;
8552         } else {
8553             if(!--board[BOARD_HEIGHT-1-k][1])
8554                 board[BOARD_HEIGHT-1-k][0] = EmptySquare;
8555         }
8556     }
8557
8558 }
8559
8560 /* Updates forwardMostMove */
8561 void
8562 MakeMove(fromX, fromY, toX, toY, promoChar)
8563      int fromX, fromY, toX, toY;
8564      int promoChar;
8565 {
8566 //    forwardMostMove++; // [HGM] bare: moved downstream
8567
8568     if(serverMoves != NULL) { /* [HGM] write moves on file for broadcasting (should be separate routine, really) */
8569         int timeLeft; static int lastLoadFlag=0; int king, piece;
8570         piece = boards[forwardMostMove][fromY][fromX];
8571         king = piece < (int) BlackPawn ? WhiteKing : BlackKing;
8572         if(gameInfo.variant == VariantKnightmate)
8573             king += (int) WhiteUnicorn - (int) WhiteKing;
8574         if(forwardMostMove == 0) {
8575             if(blackPlaysFirst)
8576                 fprintf(serverMoves, "%s;", second.tidy);
8577             fprintf(serverMoves, "%s;", first.tidy);
8578             if(!blackPlaysFirst)
8579                 fprintf(serverMoves, "%s;", second.tidy);
8580         } else fprintf(serverMoves, loadFlag|lastLoadFlag ? ":" : ";");
8581         lastLoadFlag = loadFlag;
8582         // print base move
8583         fprintf(serverMoves, "%c%c:%c%c", AAA+fromX, ONE+fromY, AAA+toX, ONE+toY);
8584         // print castling suffix
8585         if( toY == fromY && piece == king ) {
8586             if(toX-fromX > 1)
8587                 fprintf(serverMoves, ":%c%c:%c%c", AAA+BOARD_RGHT-1, ONE+fromY, AAA+toX-1,ONE+toY);
8588             if(fromX-toX >1)
8589                 fprintf(serverMoves, ":%c%c:%c%c", AAA+BOARD_LEFT, ONE+fromY, AAA+toX+1,ONE+toY);
8590         }
8591         // e.p. suffix
8592         if( (boards[forwardMostMove][fromY][fromX] == WhitePawn ||
8593              boards[forwardMostMove][fromY][fromX] == BlackPawn   ) &&
8594              boards[forwardMostMove][toY][toX] == EmptySquare
8595              && fromX != toX && fromY != toY)
8596                 fprintf(serverMoves, ":%c%c:%c%c", AAA+fromX, ONE+fromY, AAA+toX, ONE+fromY);
8597         // promotion suffix
8598         if(promoChar != NULLCHAR)
8599                 fprintf(serverMoves, ":%c:%c%c", promoChar, AAA+toX, ONE+toY);
8600         if(!loadFlag) {
8601             fprintf(serverMoves, "/%d/%d",
8602                pvInfoList[forwardMostMove].depth, pvInfoList[forwardMostMove].score);
8603             if(forwardMostMove+1 & 1) timeLeft = whiteTimeRemaining/1000;
8604             else                      timeLeft = blackTimeRemaining/1000;
8605             fprintf(serverMoves, "/%d", timeLeft);
8606         }
8607         fflush(serverMoves);
8608     }
8609
8610     if (forwardMostMove+1 > framePtr) { // [HGM] vari: do not run into saved variations
8611       DisplayFatalError(_("Game too long; increase MAX_MOVES and recompile"),
8612                         0, 1);
8613       return;
8614     }
8615     UnLoadPV(); // [HGM] pv: if we are looking at a PV, abort this
8616     if (commentList[forwardMostMove+1] != NULL) {
8617         free(commentList[forwardMostMove+1]);
8618         commentList[forwardMostMove+1] = NULL;
8619     }
8620     CopyBoard(boards[forwardMostMove+1], boards[forwardMostMove]);
8621     ApplyMove(fromX, fromY, toX, toY, promoChar, boards[forwardMostMove+1]);
8622     // forwardMostMove++; // [HGM] bare: moved to after ApplyMove, to make sure clock interrupt finds complete board
8623     SwitchClocks(forwardMostMove+1); // [HGM] race: incrementing move nr inside
8624     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
8625     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
8626     gameInfo.result = GameUnfinished;
8627     if (gameInfo.resultDetails != NULL) {
8628         free(gameInfo.resultDetails);
8629         gameInfo.resultDetails = NULL;
8630     }
8631     CoordsToComputerAlgebraic(fromY, fromX, toY, toX, promoChar,
8632                               moveList[forwardMostMove - 1]);
8633     (void) CoordsToAlgebraic(boards[forwardMostMove - 1],
8634                              PosFlags(forwardMostMove - 1),
8635                              fromY, fromX, toY, toX, promoChar,
8636                              parseList[forwardMostMove - 1]);
8637     switch (MateTest(boards[forwardMostMove], PosFlags(forwardMostMove)) ) {
8638       case MT_NONE:
8639       case MT_STALEMATE:
8640       default:
8641         break;
8642       case MT_CHECK:
8643         if(gameInfo.variant != VariantShogi)
8644             strcat(parseList[forwardMostMove - 1], "+");
8645         break;
8646       case MT_CHECKMATE:
8647       case MT_STAINMATE:
8648         strcat(parseList[forwardMostMove - 1], "#");
8649         break;
8650     }
8651     if (appData.debugMode) {
8652         fprintf(debugFP, "move: %s, parse: %s (%c)\n", moveList[forwardMostMove-1], parseList[forwardMostMove-1], moveList[forwardMostMove-1][4]);
8653     }
8654
8655 }
8656
8657 /* Updates currentMove if not pausing */
8658 void
8659 ShowMove(fromX, fromY, toX, toY)
8660 {
8661     int instant = (gameMode == PlayFromGameFile) ?
8662         (matchMode || (appData.timeDelay == 0 && !pausing)) : pausing;
8663     if(appData.noGUI) return;
8664     if (!pausing || gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
8665         if (!instant) {
8666             if (forwardMostMove == currentMove + 1) {
8667                 AnimateMove(boards[forwardMostMove - 1],
8668                             fromX, fromY, toX, toY);
8669             }
8670             if (appData.highlightLastMove) {
8671                 SetHighlights(fromX, fromY, toX, toY);
8672             }
8673         }
8674         currentMove = forwardMostMove;
8675     }
8676
8677     if (instant) return;
8678
8679     DisplayMove(currentMove - 1);
8680     DrawPosition(FALSE, boards[currentMove]);
8681     DisplayBothClocks();
8682     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
8683 }
8684
8685 void SendEgtPath(ChessProgramState *cps)
8686 {       /* [HGM] EGT: match formats given in feature with those given by user, and send info for each match */
8687         char buf[MSG_SIZ], name[MSG_SIZ], *p;
8688
8689         if((p = cps->egtFormats) == NULL || appData.egtFormats == NULL) return;
8690
8691         while(*p) {
8692             char c, *q = name+1, *r, *s;
8693
8694             name[0] = ','; // extract next format name from feature and copy with prefixed ','
8695             while(*p && *p != ',') *q++ = *p++;
8696             *q++ = ':'; *q = 0;
8697             if( appData.defaultPathEGTB && appData.defaultPathEGTB[0] &&
8698                 strcmp(name, ",nalimov:") == 0 ) {
8699                 // take nalimov path from the menu-changeable option first, if it is defined
8700                 sprintf(buf, "egtpath nalimov %s\n", appData.defaultPathEGTB);
8701                 SendToProgram(buf,cps);     // send egtbpath command for nalimov
8702             } else
8703             if( (s = StrStr(appData.egtFormats, name+1)) == appData.egtFormats ||
8704                 (s = StrStr(appData.egtFormats, name)) != NULL) {
8705                 // format name occurs amongst user-supplied formats, at beginning or immediately after comma
8706                 s = r = StrStr(s, ":") + 1; // beginning of path info
8707                 while(*r && *r != ',') r++; // path info is everything upto next ';' or end of string
8708                 c = *r; *r = 0;             // temporarily null-terminate path info
8709                     *--q = 0;               // strip of trailig ':' from name
8710                     sprintf(buf, "egtpath %s %s\n", name+1, s);
8711                 *r = c;
8712                 SendToProgram(buf,cps);     // send egtbpath command for this format
8713             }
8714             if(*p == ',') p++; // read away comma to position for next format name
8715         }
8716 }
8717
8718 void
8719 InitChessProgram(cps, setup)
8720      ChessProgramState *cps;
8721      int setup; /* [HGM] needed to setup FRC opening position */
8722 {
8723     char buf[MSG_SIZ], b[MSG_SIZ]; int overruled;
8724     if (appData.noChessProgram) return;
8725     hintRequested = FALSE;
8726     bookRequested = FALSE;
8727
8728     /* [HGM] some new WB protocol commands to configure engine are sent now, if engine supports them */
8729     /*       moved to before sending initstring in 4.3.15, so Polyglot can delay UCI 'isready' to recepton of 'new' */
8730     if(cps->memSize) { /* [HGM] memory */
8731         sprintf(buf, "memory %d\n", appData.defaultHashSize + appData.defaultCacheSizeEGTB);
8732         SendToProgram(buf, cps);
8733     }
8734     SendEgtPath(cps); /* [HGM] EGT */
8735     if(cps->maxCores) { /* [HGM] SMP: (protocol specified must be last settings command before new!) */
8736         sprintf(buf, "cores %d\n", appData.smpCores);
8737         SendToProgram(buf, cps);
8738     }
8739
8740     SendToProgram(cps->initString, cps);
8741     if (gameInfo.variant != VariantNormal &&
8742         gameInfo.variant != VariantLoadable
8743         /* [HGM] also send variant if board size non-standard */
8744         || gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0
8745                                             ) {
8746       char *v = VariantName(gameInfo.variant);
8747       if (cps->protocolVersion != 1 && StrStr(cps->variants, v) == NULL) {
8748         /* [HGM] in protocol 1 we have to assume all variants valid */
8749         sprintf(buf, _("Variant %s not supported by %s"), v, cps->tidy);
8750         DisplayFatalError(buf, 0, 1);
8751         return;
8752       }
8753
8754       /* [HGM] make prefix for non-standard board size. Awkward testing... */
8755       overruled = gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0;
8756       if( gameInfo.variant == VariantXiangqi )
8757            overruled = gameInfo.boardWidth != 9 || gameInfo.boardHeight != 10 || gameInfo.holdingsSize != 0;
8758       if( gameInfo.variant == VariantShogi )
8759            overruled = gameInfo.boardWidth != 9 || gameInfo.boardHeight != 9 || gameInfo.holdingsSize != 7;
8760       if( gameInfo.variant == VariantBughouse || gameInfo.variant == VariantCrazyhouse )
8761            overruled = gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 5;
8762       if( gameInfo.variant == VariantCapablanca || gameInfo.variant == VariantCapaRandom ||
8763                                gameInfo.variant == VariantGothic  || gameInfo.variant == VariantFalcon )
8764            overruled = gameInfo.boardWidth != 10 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0;
8765       if( gameInfo.variant == VariantCourier )
8766            overruled = gameInfo.boardWidth != 12 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0;
8767       if( gameInfo.variant == VariantSuper )
8768            overruled = gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 8;
8769       if( gameInfo.variant == VariantGreat )
8770            overruled = gameInfo.boardWidth != 10 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 8;
8771
8772       if(overruled) {
8773            sprintf(b, "%dx%d+%d_%s", gameInfo.boardWidth, gameInfo.boardHeight,
8774                                gameInfo.holdingsSize, VariantName(gameInfo.variant)); // cook up sized variant name
8775            /* [HGM] varsize: try first if this defiant size variant is specifically known */
8776            if(StrStr(cps->variants, b) == NULL) {
8777                // specific sized variant not known, check if general sizing allowed
8778                if (cps->protocolVersion != 1) { // for protocol 1 we cannot check and hope for the best
8779                    if(StrStr(cps->variants, "boardsize") == NULL) {
8780                        sprintf(buf, "Board size %dx%d+%d not supported by %s",
8781                             gameInfo.boardWidth, gameInfo.boardHeight, gameInfo.holdingsSize, cps->tidy);
8782                        DisplayFatalError(buf, 0, 1);
8783                        return;
8784                    }
8785                    /* [HGM] here we really should compare with the maximum supported board size */
8786                }
8787            }
8788       } else sprintf(b, "%s", VariantName(gameInfo.variant));
8789       sprintf(buf, "variant %s\n", b);
8790       SendToProgram(buf, cps);
8791     }
8792     currentlyInitializedVariant = gameInfo.variant;
8793
8794     /* [HGM] send opening position in FRC to first engine */
8795     if(setup) {
8796           SendToProgram("force\n", cps);
8797           SendBoard(cps, 0);
8798           /* engine is now in force mode! Set flag to wake it up after first move. */
8799           setboardSpoiledMachineBlack = 1;
8800     }
8801
8802     if (cps->sendICS) {
8803       snprintf(buf, sizeof(buf), "ics %s\n", appData.icsActive ? appData.icsHost : "-");
8804       SendToProgram(buf, cps);
8805     }
8806     cps->maybeThinking = FALSE;
8807     cps->offeredDraw = 0;
8808     if (!appData.icsActive) {
8809         SendTimeControl(cps, movesPerSession, timeControl,
8810                         timeIncrement, appData.searchDepth,
8811                         searchTime);
8812     }
8813     if (appData.showThinking
8814         // [HGM] thinking: four options require thinking output to be sent
8815         || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp()
8816                                 ) {
8817         SendToProgram("post\n", cps);
8818     }
8819     SendToProgram("hard\n", cps);
8820     if (!appData.ponderNextMove) {
8821         /* Warning: "easy" is a toggle in GNU Chess, so don't send
8822            it without being sure what state we are in first.  "hard"
8823            is not a toggle, so that one is OK.
8824          */
8825         SendToProgram("easy\n", cps);
8826     }
8827     if (cps->usePing) {
8828       sprintf(buf, "ping %d\n", ++cps->lastPing);
8829       SendToProgram(buf, cps);
8830     }
8831     cps->initDone = TRUE;
8832 }
8833
8834
8835 void
8836 StartChessProgram(cps)
8837      ChessProgramState *cps;
8838 {
8839     char buf[MSG_SIZ];
8840     int err;
8841
8842     if (appData.noChessProgram) return;
8843     cps->initDone = FALSE;
8844
8845     if (strcmp(cps->host, "localhost") == 0) {
8846         err = StartChildProcess(cps->program, cps->dir, &cps->pr);
8847     } else if (*appData.remoteShell == NULLCHAR) {
8848         err = OpenRcmd(cps->host, appData.remoteUser, cps->program, &cps->pr);
8849     } else {
8850         if (*appData.remoteUser == NULLCHAR) {
8851           snprintf(buf, sizeof(buf), "%s %s %s", appData.remoteShell, cps->host,
8852                     cps->program);
8853         } else {
8854           snprintf(buf, sizeof(buf), "%s %s -l %s %s", appData.remoteShell,
8855                     cps->host, appData.remoteUser, cps->program);
8856         }
8857         err = StartChildProcess(buf, "", &cps->pr);
8858     }
8859
8860     if (err != 0) {
8861         sprintf(buf, _("Startup failure on '%s'"), cps->program);
8862         DisplayFatalError(buf, err, 1);
8863         cps->pr = NoProc;
8864         cps->isr = NULL;
8865         return;
8866     }
8867
8868     cps->isr = AddInputSource(cps->pr, TRUE, ReceiveFromProgram, cps);
8869     if (cps->protocolVersion > 1) {
8870       sprintf(buf, "xboard\nprotover %d\n", cps->protocolVersion);
8871       cps->nrOptions = 0; // [HGM] options: clear all engine-specific options
8872       cps->comboCnt = 0;  //                and values of combo boxes
8873       SendToProgram(buf, cps);
8874     } else {
8875       SendToProgram("xboard\n", cps);
8876     }
8877 }
8878
8879
8880 void
8881 TwoMachinesEventIfReady P((void))
8882 {
8883   if (first.lastPing != first.lastPong) {
8884     DisplayMessage("", _("Waiting for first chess program"));
8885     ScheduleDelayedEvent(TwoMachinesEventIfReady, 10); // [HGM] fast: lowered from 1000
8886     return;
8887   }
8888   if (second.lastPing != second.lastPong) {
8889     DisplayMessage("", _("Waiting for second chess program"));
8890     ScheduleDelayedEvent(TwoMachinesEventIfReady, 10); // [HGM] fast: lowered from 1000
8891     return;
8892   }
8893   ThawUI();
8894   TwoMachinesEvent();
8895 }
8896
8897 void
8898 NextMatchGame P((void))
8899 {
8900     int index; /* [HGM] autoinc: step load index during match */
8901     Reset(FALSE, TRUE);
8902     if (*appData.loadGameFile != NULLCHAR) {
8903         index = appData.loadGameIndex;
8904         if(index < 0) { // [HGM] autoinc
8905             lastIndex = index = (index == -2 && first.twoMachinesColor[0] == 'b') ? lastIndex : lastIndex+1;
8906             if(appData.rewindIndex > 0 && index > appData.rewindIndex) lastIndex = index = 1;
8907         }
8908         LoadGameFromFile(appData.loadGameFile,
8909                          index,
8910                          appData.loadGameFile, FALSE);
8911     } else if (*appData.loadPositionFile != NULLCHAR) {
8912         index = appData.loadPositionIndex;
8913         if(index < 0) { // [HGM] autoinc
8914             lastIndex = index = (index == -2 && first.twoMachinesColor[0] == 'b') ? lastIndex : lastIndex+1;
8915             if(appData.rewindIndex > 0 && index > appData.rewindIndex) lastIndex = index = 1;
8916         }
8917         LoadPositionFromFile(appData.loadPositionFile,
8918                              index,
8919                              appData.loadPositionFile);
8920     }
8921     TwoMachinesEventIfReady();
8922 }
8923
8924 void UserAdjudicationEvent( int result )
8925 {
8926     ChessMove gameResult = GameIsDrawn;
8927
8928     if( result > 0 ) {
8929         gameResult = WhiteWins;
8930     }
8931     else if( result < 0 ) {
8932         gameResult = BlackWins;
8933     }
8934
8935     if( gameMode == TwoMachinesPlay ) {
8936         GameEnds( gameResult, "User adjudication", GE_XBOARD );
8937     }
8938 }
8939
8940
8941 // [HGM] save: calculate checksum of game to make games easily identifiable
8942 int StringCheckSum(char *s)
8943 {
8944         int i = 0;
8945         if(s==NULL) return 0;
8946         while(*s) i = i*259 + *s++;
8947         return i;
8948 }
8949
8950 int GameCheckSum()
8951 {
8952         int i, sum=0;
8953         for(i=backwardMostMove; i<forwardMostMove; i++) {
8954                 sum += pvInfoList[i].depth;
8955                 sum += StringCheckSum(parseList[i]);
8956                 sum += StringCheckSum(commentList[i]);
8957                 sum *= 261;
8958         }
8959         if(i>1 && sum==0) sum++; // make sure never zero for non-empty game
8960         return sum + StringCheckSum(commentList[i]);
8961 } // end of save patch
8962
8963 void
8964 GameEnds(result, resultDetails, whosays)
8965      ChessMove result;
8966      char *resultDetails;
8967      int whosays;
8968 {
8969     GameMode nextGameMode;
8970     int isIcsGame;
8971     char buf[MSG_SIZ];
8972
8973     if(endingGame) return; /* [HGM] crash: forbid recursion */
8974     endingGame = 1;
8975     if(twoBoards) { // [HGM] dual: switch back to one board
8976         twoBoards = partnerUp = 0; InitDrawingSizes(-2, 0);
8977         DrawPosition(TRUE, partnerBoard); // observed game becomes foreground
8978     }
8979     if (appData.debugMode) {
8980       fprintf(debugFP, "GameEnds(%d, %s, %d)\n",
8981               result, resultDetails ? resultDetails : "(null)", whosays);
8982     }
8983
8984     fromX = fromY = -1; // [HGM] abort any move the user is entering.
8985
8986     if (appData.icsActive && (whosays == GE_ENGINE || whosays >= GE_ENGINE1)) {
8987         /* If we are playing on ICS, the server decides when the
8988            game is over, but the engine can offer to draw, claim
8989            a draw, or resign.
8990          */
8991 #if ZIPPY
8992         if (appData.zippyPlay && first.initDone) {
8993             if (result == GameIsDrawn) {
8994                 /* In case draw still needs to be claimed */
8995                 SendToICS(ics_prefix);
8996                 SendToICS("draw\n");
8997             } else if (StrCaseStr(resultDetails, "resign")) {
8998                 SendToICS(ics_prefix);
8999                 SendToICS("resign\n");
9000             }
9001         }
9002 #endif
9003         endingGame = 0; /* [HGM] crash */
9004         return;
9005     }
9006
9007     /* If we're loading the game from a file, stop */
9008     if (whosays == GE_FILE) {
9009       (void) StopLoadGameTimer();
9010       gameFileFP = NULL;
9011     }
9012
9013     /* Cancel draw offers */
9014     first.offeredDraw = second.offeredDraw = 0;
9015
9016     /* If this is an ICS game, only ICS can really say it's done;
9017        if not, anyone can. */
9018     isIcsGame = (gameMode == IcsPlayingWhite ||
9019                  gameMode == IcsPlayingBlack ||
9020                  gameMode == IcsObserving    ||
9021                  gameMode == IcsExamining);
9022
9023     if (!isIcsGame || whosays == GE_ICS) {
9024         /* OK -- not an ICS game, or ICS said it was done */
9025         StopClocks();
9026         if (!isIcsGame && !appData.noChessProgram)
9027           SetUserThinkingEnables();
9028
9029         /* [HGM] if a machine claims the game end we verify this claim */
9030         if(gameMode == TwoMachinesPlay && appData.testClaims) {
9031             if(appData.testLegality && whosays >= GE_ENGINE1 ) {
9032                 char claimer;
9033                 ChessMove trueResult = (ChessMove) -1;
9034
9035                 claimer = whosays == GE_ENGINE1 ?      /* color of claimer */
9036                                             first.twoMachinesColor[0] :
9037                                             second.twoMachinesColor[0] ;
9038
9039                 // [HGM] losers: because the logic is becoming a bit hairy, determine true result first
9040                 if((signed char)boards[forwardMostMove][EP_STATUS] == EP_CHECKMATE) {
9041                     /* [HGM] verify: engine mate claims accepted if they were flagged */
9042                     trueResult = WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins;
9043                 } else
9044                 if((signed char)boards[forwardMostMove][EP_STATUS] == EP_WINS) { // added code for games where being mated is a win
9045                     /* [HGM] verify: engine mate claims accepted if they were flagged */
9046                     trueResult = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
9047                 } else
9048                 if((signed char)boards[forwardMostMove][EP_STATUS] == EP_STALEMATE) { // only used to indicate draws now
9049                     trueResult = GameIsDrawn; // default; in variants where stalemate loses, Status is CHECKMATE
9050                 }
9051
9052                 // now verify win claims, but not in drop games, as we don't understand those yet
9053                 if( (gameInfo.holdingsWidth == 0 || gameInfo.variant == VariantSuper
9054                                                  || gameInfo.variant == VariantGreat) &&
9055                     (result == WhiteWins && claimer == 'w' ||
9056                      result == BlackWins && claimer == 'b'   ) ) { // case to verify: engine claims own win
9057                       if (appData.debugMode) {
9058                         fprintf(debugFP, "result=%d sp=%d move=%d\n",
9059                                 result, (signed char)boards[forwardMostMove][EP_STATUS], forwardMostMove);
9060                       }
9061                       if(result != trueResult) {
9062                               sprintf(buf, "False win claim: '%s'", resultDetails);
9063                               result = claimer == 'w' ? BlackWins : WhiteWins;
9064                               resultDetails = buf;
9065                       }
9066                 } else
9067                 if( result == GameIsDrawn && (signed char)boards[forwardMostMove][EP_STATUS] > EP_DRAWS
9068                     && (forwardMostMove <= backwardMostMove ||
9069                         (signed char)boards[forwardMostMove-1][EP_STATUS] > EP_DRAWS ||
9070                         (claimer=='b')==(forwardMostMove&1))
9071                                                                                   ) {
9072                       /* [HGM] verify: draws that were not flagged are false claims */
9073                       sprintf(buf, "False draw claim: '%s'", resultDetails);
9074                       result = claimer == 'w' ? BlackWins : WhiteWins;
9075                       resultDetails = buf;
9076                 }
9077                 /* (Claiming a loss is accepted no questions asked!) */
9078             }
9079             /* [HGM] bare: don't allow bare King to win */
9080             if((gameInfo.holdingsWidth == 0 || gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat)
9081                && gameInfo.variant != VariantLosers && gameInfo.variant != VariantGiveaway
9082                && gameInfo.variant != VariantSuicide // [HGM] losers: except in losers, of course...
9083                && result != GameIsDrawn)
9084             {   int i, j, k=0, color = (result==WhiteWins ? (int)WhitePawn : (int)BlackPawn);
9085                 for(j=BOARD_LEFT; j<BOARD_RGHT; j++) for(i=0; i<BOARD_HEIGHT; i++) {
9086                         int p = (signed char)boards[forwardMostMove][i][j] - color;
9087                         if(p >= 0 && p <= (int)WhiteKing) k++;
9088                 }
9089                 if (appData.debugMode) {
9090                      fprintf(debugFP, "GE(%d, %s, %d) bare king k=%d color=%d\n",
9091                         result, resultDetails ? resultDetails : "(null)", whosays, k, color);
9092                 }
9093                 if(k <= 1) {
9094                         result = GameIsDrawn;
9095                         sprintf(buf, "%s but bare king", resultDetails);
9096                         resultDetails = buf;
9097                 }
9098             }
9099         }
9100
9101
9102         if(serverMoves != NULL && !loadFlag) { char c = '=';
9103             if(result==WhiteWins) c = '+';
9104             if(result==BlackWins) c = '-';
9105             if(resultDetails != NULL)
9106                 fprintf(serverMoves, ";%c;%s\n", c, resultDetails);
9107         }
9108         if (resultDetails != NULL) {
9109             gameInfo.result = result;
9110             gameInfo.resultDetails = StrSave(resultDetails);
9111
9112             /* display last move only if game was not loaded from file */
9113             if ((whosays != GE_FILE) && (currentMove == forwardMostMove))
9114                 DisplayMove(currentMove - 1);
9115
9116             if (forwardMostMove != 0) {
9117                 if (gameMode != PlayFromGameFile && gameMode != EditGame
9118                     && lastSavedGame != GameCheckSum() // [HGM] save: suppress duplicates
9119                                                                 ) {
9120                     if (*appData.saveGameFile != NULLCHAR) {
9121                         SaveGameToFile(appData.saveGameFile, TRUE);
9122                     } else if (appData.autoSaveGames) {
9123                         AutoSaveGame();
9124                     }
9125                     if (*appData.savePositionFile != NULLCHAR) {
9126                         SavePositionToFile(appData.savePositionFile);
9127                     }
9128                 }
9129             }
9130
9131             /* Tell program how game ended in case it is learning */
9132             /* [HGM] Moved this to after saving the PGN, just in case */
9133             /* engine died and we got here through time loss. In that */
9134             /* case we will get a fatal error writing the pipe, which */
9135             /* would otherwise lose us the PGN.                       */
9136             /* [HGM] crash: not needed anymore, but doesn't hurt;     */
9137             /* output during GameEnds should never be fatal anymore   */
9138             if (gameMode == MachinePlaysWhite ||
9139                 gameMode == MachinePlaysBlack ||
9140                 gameMode == TwoMachinesPlay ||
9141                 gameMode == IcsPlayingWhite ||
9142                 gameMode == IcsPlayingBlack ||
9143                 gameMode == BeginningOfGame) {
9144                 char buf[MSG_SIZ];
9145                 sprintf(buf, "result %s {%s}\n", PGNResult(result),
9146                         resultDetails);
9147                 if (first.pr != NoProc) {
9148                     SendToProgram(buf, &first);
9149                 }
9150                 if (second.pr != NoProc &&
9151                     gameMode == TwoMachinesPlay) {
9152                     SendToProgram(buf, &second);
9153                 }
9154             }
9155         }
9156
9157         if (appData.icsActive) {
9158             if (appData.quietPlay &&
9159                 (gameMode == IcsPlayingWhite ||
9160                  gameMode == IcsPlayingBlack)) {
9161                 SendToICS(ics_prefix);
9162                 SendToICS("set shout 1\n");
9163             }
9164             nextGameMode = IcsIdle;
9165             ics_user_moved = FALSE;
9166             /* clean up premove.  It's ugly when the game has ended and the
9167              * premove highlights are still on the board.
9168              */
9169             if (gotPremove) {
9170               gotPremove = FALSE;
9171               ClearPremoveHighlights();
9172               DrawPosition(FALSE, boards[currentMove]);
9173             }
9174             if (whosays == GE_ICS) {
9175                 switch (result) {
9176                 case WhiteWins:
9177                     if (gameMode == IcsPlayingWhite)
9178                         PlayIcsWinSound();
9179                     else if(gameMode == IcsPlayingBlack)
9180                         PlayIcsLossSound();
9181                     break;
9182                 case BlackWins:
9183                     if (gameMode == IcsPlayingBlack)
9184                         PlayIcsWinSound();
9185                     else if(gameMode == IcsPlayingWhite)
9186                         PlayIcsLossSound();
9187                     break;
9188                 case GameIsDrawn:
9189                     PlayIcsDrawSound();
9190                     break;
9191                 default:
9192                     PlayIcsUnfinishedSound();
9193                 }
9194             }
9195         } else if (gameMode == EditGame ||
9196                    gameMode == PlayFromGameFile ||
9197                    gameMode == AnalyzeMode ||
9198                    gameMode == AnalyzeFile) {
9199             nextGameMode = gameMode;
9200         } else {
9201             nextGameMode = EndOfGame;
9202         }
9203         pausing = FALSE;
9204         ModeHighlight();
9205     } else {
9206         nextGameMode = gameMode;
9207     }
9208
9209     if (appData.noChessProgram) {
9210         gameMode = nextGameMode;
9211         ModeHighlight();
9212         endingGame = 0; /* [HGM] crash */
9213         return;
9214     }
9215
9216     if (first.reuse) {
9217         /* Put first chess program into idle state */
9218         if (first.pr != NoProc &&
9219             (gameMode == MachinePlaysWhite ||
9220              gameMode == MachinePlaysBlack ||
9221              gameMode == TwoMachinesPlay ||
9222              gameMode == IcsPlayingWhite ||
9223              gameMode == IcsPlayingBlack ||
9224              gameMode == BeginningOfGame)) {
9225             SendToProgram("force\n", &first);
9226             if (first.usePing) {
9227               char buf[MSG_SIZ];
9228               sprintf(buf, "ping %d\n", ++first.lastPing);
9229               SendToProgram(buf, &first);
9230             }
9231         }
9232     } else if (result != GameUnfinished || nextGameMode == IcsIdle) {
9233         /* Kill off first chess program */
9234         if (first.isr != NULL)
9235           RemoveInputSource(first.isr);
9236         first.isr = NULL;
9237
9238         if (first.pr != NoProc) {
9239             ExitAnalyzeMode();
9240             DoSleep( appData.delayBeforeQuit );
9241             SendToProgram("quit\n", &first);
9242             DoSleep( appData.delayAfterQuit );
9243             DestroyChildProcess(first.pr, first.useSigterm);
9244         }
9245         first.pr = NoProc;
9246     }
9247     if (second.reuse) {
9248         /* Put second chess program into idle state */
9249         if (second.pr != NoProc &&
9250             gameMode == TwoMachinesPlay) {
9251             SendToProgram("force\n", &second);
9252             if (second.usePing) {
9253               char buf[MSG_SIZ];
9254               sprintf(buf, "ping %d\n", ++second.lastPing);
9255               SendToProgram(buf, &second);
9256             }
9257         }
9258     } else if (result != GameUnfinished || nextGameMode == IcsIdle) {
9259         /* Kill off second chess program */
9260         if (second.isr != NULL)
9261           RemoveInputSource(second.isr);
9262         second.isr = NULL;
9263
9264         if (second.pr != NoProc) {
9265             DoSleep( appData.delayBeforeQuit );
9266             SendToProgram("quit\n", &second);
9267             DoSleep( appData.delayAfterQuit );
9268             DestroyChildProcess(second.pr, second.useSigterm);
9269         }
9270         second.pr = NoProc;
9271     }
9272
9273     if (matchMode && gameMode == TwoMachinesPlay) {
9274         switch (result) {
9275         case WhiteWins:
9276           if (first.twoMachinesColor[0] == 'w') {
9277             first.matchWins++;
9278           } else {
9279             second.matchWins++;
9280           }
9281           break;
9282         case BlackWins:
9283           if (first.twoMachinesColor[0] == 'b') {
9284             first.matchWins++;
9285           } else {
9286             second.matchWins++;
9287           }
9288           break;
9289         default:
9290           break;
9291         }
9292         if (matchGame < appData.matchGames) {
9293             char *tmp;
9294             if(appData.sameColorGames <= 1) { /* [HGM] alternate: suppress color swap */
9295                 tmp = first.twoMachinesColor;
9296                 first.twoMachinesColor = second.twoMachinesColor;
9297                 second.twoMachinesColor = tmp;
9298             }
9299             gameMode = nextGameMode;
9300             matchGame++;
9301             if(appData.matchPause>10000 || appData.matchPause<10)
9302                 appData.matchPause = 10000; /* [HGM] make pause adjustable */
9303             ScheduleDelayedEvent(NextMatchGame, appData.matchPause);
9304             endingGame = 0; /* [HGM] crash */
9305             return;
9306         } else {
9307             char buf[MSG_SIZ];
9308             gameMode = nextGameMode;
9309             sprintf(buf, _("Match %s vs. %s: final score %d-%d-%d"),
9310                     first.tidy, second.tidy,
9311                     first.matchWins, second.matchWins,
9312                     appData.matchGames - (first.matchWins + second.matchWins));
9313             DisplayFatalError(buf, 0, 0);
9314         }
9315     }
9316     if ((gameMode == AnalyzeMode || gameMode == AnalyzeFile) &&
9317         !(nextGameMode == AnalyzeMode || nextGameMode == AnalyzeFile))
9318       ExitAnalyzeMode();
9319     gameMode = nextGameMode;
9320     ModeHighlight();
9321     endingGame = 0;  /* [HGM] crash */
9322 }
9323
9324 /* Assumes program was just initialized (initString sent).
9325    Leaves program in force mode. */
9326 void
9327 FeedMovesToProgram(cps, upto)
9328      ChessProgramState *cps;
9329      int upto;
9330 {
9331     int i;
9332
9333     if (appData.debugMode)
9334       fprintf(debugFP, "Feeding %smoves %d through %d to %s chess program\n",
9335               startedFromSetupPosition ? "position and " : "",
9336               backwardMostMove, upto, cps->which);
9337     if(currentlyInitializedVariant != gameInfo.variant) { char buf[MSG_SIZ];
9338         // [HGM] variantswitch: make engine aware of new variant
9339         if(cps->protocolVersion > 1 && StrStr(cps->variants, VariantName(gameInfo.variant)) == NULL)
9340                 return; // [HGM] refrain from feeding moves altogether if variant is unsupported!
9341         sprintf(buf, "variant %s\n", VariantName(gameInfo.variant));
9342         SendToProgram(buf, cps);
9343         currentlyInitializedVariant = gameInfo.variant;
9344     }
9345     SendToProgram("force\n", cps);
9346     if (startedFromSetupPosition) {
9347         SendBoard(cps, backwardMostMove);
9348     if (appData.debugMode) {
9349         fprintf(debugFP, "feedMoves\n");
9350     }
9351     }
9352     for (i = backwardMostMove; i < upto; i++) {
9353         SendMoveToProgram(i, cps);
9354     }
9355 }
9356
9357
9358 void
9359 ResurrectChessProgram()
9360 {
9361      /* The chess program may have exited.
9362         If so, restart it and feed it all the moves made so far. */
9363
9364     if (appData.noChessProgram || first.pr != NoProc) return;
9365
9366     StartChessProgram(&first);
9367     InitChessProgram(&first, FALSE);
9368     FeedMovesToProgram(&first, currentMove);
9369
9370     if (!first.sendTime) {
9371         /* can't tell gnuchess what its clock should read,
9372            so we bow to its notion. */
9373         ResetClocks();
9374         timeRemaining[0][currentMove] = whiteTimeRemaining;
9375         timeRemaining[1][currentMove] = blackTimeRemaining;
9376     }
9377
9378     if ((gameMode == AnalyzeMode || gameMode == AnalyzeFile ||
9379                 appData.icsEngineAnalyze) && first.analysisSupport) {
9380       SendToProgram("analyze\n", &first);
9381       first.analyzing = TRUE;
9382     }
9383 }
9384
9385 /*
9386  * Button procedures
9387  */
9388 void
9389 Reset(redraw, init)
9390      int redraw, init;
9391 {
9392     int i;
9393
9394     if (appData.debugMode) {
9395         fprintf(debugFP, "Reset(%d, %d) from gameMode %d\n",
9396                 redraw, init, gameMode);
9397     }
9398     CleanupTail(); // [HGM] vari: delete any stored variations
9399     pausing = pauseExamInvalid = FALSE;
9400     startedFromSetupPosition = blackPlaysFirst = FALSE;
9401     firstMove = TRUE;
9402     whiteFlag = blackFlag = FALSE;
9403     userOfferedDraw = FALSE;
9404     hintRequested = bookRequested = FALSE;
9405     first.maybeThinking = FALSE;
9406     second.maybeThinking = FALSE;
9407     first.bookSuspend = FALSE; // [HGM] book
9408     second.bookSuspend = FALSE;
9409     thinkOutput[0] = NULLCHAR;
9410     lastHint[0] = NULLCHAR;
9411     ClearGameInfo(&gameInfo);
9412     gameInfo.variant = StringToVariant(appData.variant);
9413     ics_user_moved = ics_clock_paused = FALSE;
9414     ics_getting_history = H_FALSE;
9415     ics_gamenum = -1;
9416     white_holding[0] = black_holding[0] = NULLCHAR;
9417     ClearProgramStats();
9418     opponentKibitzes = FALSE; // [HGM] kibitz: do not reserve space in engine-output window in zippy mode
9419
9420     ResetFrontEnd();
9421     ClearHighlights();
9422     flipView = appData.flipView;
9423     ClearPremoveHighlights();
9424     gotPremove = FALSE;
9425     alarmSounded = FALSE;
9426
9427     GameEnds((ChessMove) 0, NULL, GE_PLAYER);
9428     if(appData.serverMovesName != NULL) {
9429         /* [HGM] prepare to make moves file for broadcasting */
9430         clock_t t = clock();
9431         if(serverMoves != NULL) fclose(serverMoves);
9432         serverMoves = fopen(appData.serverMovesName, "r");
9433         if(serverMoves != NULL) {
9434             fclose(serverMoves);
9435             /* delay 15 sec before overwriting, so all clients can see end */
9436             while(clock()-t < appData.serverPause*CLOCKS_PER_SEC);
9437         }
9438         serverMoves = fopen(appData.serverMovesName, "w");
9439     }
9440
9441     ExitAnalyzeMode();
9442     gameMode = BeginningOfGame;
9443     ModeHighlight();
9444     if(appData.icsActive) gameInfo.variant = VariantNormal;
9445     currentMove = forwardMostMove = backwardMostMove = 0;
9446     InitPosition(redraw);
9447     for (i = 0; i < MAX_MOVES; i++) {
9448         if (commentList[i] != NULL) {
9449             free(commentList[i]);
9450             commentList[i] = NULL;
9451         }
9452     }
9453     ResetClocks();
9454     timeRemaining[0][0] = whiteTimeRemaining;
9455     timeRemaining[1][0] = blackTimeRemaining;
9456     if (first.pr == NULL) {
9457         StartChessProgram(&first);
9458     }
9459     if (init) {
9460             InitChessProgram(&first, startedFromSetupPosition);
9461     }
9462     DisplayTitle("");
9463     DisplayMessage("", "");
9464     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
9465     lastSavedGame = 0; // [HGM] save: make sure next game counts as unsaved
9466 }
9467
9468 void
9469 AutoPlayGameLoop()
9470 {
9471     for (;;) {
9472         if (!AutoPlayOneMove())
9473           return;
9474         if (matchMode || appData.timeDelay == 0)
9475           continue;
9476         if (appData.timeDelay < 0 || gameMode == AnalyzeFile)
9477           return;
9478         StartLoadGameTimer((long)(1000.0 * appData.timeDelay));
9479         break;
9480     }
9481 }
9482
9483
9484 int
9485 AutoPlayOneMove()
9486 {
9487     int fromX, fromY, toX, toY;
9488
9489     if (appData.debugMode) {
9490       fprintf(debugFP, "AutoPlayOneMove(): current %d\n", currentMove);
9491     }
9492
9493     if (gameMode != PlayFromGameFile)
9494       return FALSE;
9495
9496     if (currentMove >= forwardMostMove) {
9497       gameMode = EditGame;
9498       ModeHighlight();
9499
9500       /* [AS] Clear current move marker at the end of a game */
9501       /* HistorySet(parseList, backwardMostMove, forwardMostMove, -1); */
9502
9503       return FALSE;
9504     }
9505
9506     toX = moveList[currentMove][2] - AAA;
9507     toY = moveList[currentMove][3] - ONE;
9508
9509     if (moveList[currentMove][1] == '@') {
9510         if (appData.highlightLastMove) {
9511             SetHighlights(-1, -1, toX, toY);
9512         }
9513     } else {
9514         fromX = moveList[currentMove][0] - AAA;
9515         fromY = moveList[currentMove][1] - ONE;
9516
9517         HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove); /* [AS] */
9518
9519         AnimateMove(boards[currentMove], fromX, fromY, toX, toY);
9520
9521         if (appData.highlightLastMove) {
9522             SetHighlights(fromX, fromY, toX, toY);
9523         }
9524     }
9525     DisplayMove(currentMove);
9526     SendMoveToProgram(currentMove++, &first);
9527     DisplayBothClocks();
9528     DrawPosition(FALSE, boards[currentMove]);
9529     // [HGM] PV info: always display, routine tests if empty
9530     DisplayComment(currentMove - 1, commentList[currentMove]);
9531     return TRUE;
9532 }
9533
9534
9535 int
9536 LoadGameOneMove(readAhead)
9537      ChessMove readAhead;
9538 {
9539     int fromX = 0, fromY = 0, toX = 0, toY = 0, done;
9540     char promoChar = NULLCHAR;
9541     ChessMove moveType;
9542     char move[MSG_SIZ];
9543     char *p, *q;
9544
9545     if (gameMode != PlayFromGameFile && gameMode != AnalyzeFile &&
9546         gameMode != AnalyzeMode && gameMode != Training) {
9547         gameFileFP = NULL;
9548         return FALSE;
9549     }
9550
9551     yyboardindex = forwardMostMove;
9552     if (readAhead != (ChessMove)0) {
9553       moveType = readAhead;
9554     } else {
9555       if (gameFileFP == NULL)
9556           return FALSE;
9557       moveType = (ChessMove) yylex();
9558     }
9559
9560     done = FALSE;
9561     switch (moveType) {
9562       case Comment:
9563         if (appData.debugMode)
9564           fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
9565         p = yy_text;
9566
9567         /* append the comment but don't display it */
9568         AppendComment(currentMove, p, FALSE);
9569         return TRUE;
9570
9571       case WhiteCapturesEnPassant:
9572       case BlackCapturesEnPassant:
9573       case WhitePromotionChancellor:
9574       case BlackPromotionChancellor:
9575       case WhitePromotionArchbishop:
9576       case BlackPromotionArchbishop:
9577       case WhitePromotionCentaur:
9578       case BlackPromotionCentaur:
9579       case WhitePromotionQueen:
9580       case BlackPromotionQueen:
9581       case WhitePromotionRook:
9582       case BlackPromotionRook:
9583       case WhitePromotionBishop:
9584       case BlackPromotionBishop:
9585       case WhitePromotionKnight:
9586       case BlackPromotionKnight:
9587       case WhitePromotionKing:
9588       case BlackPromotionKing:
9589       case NormalMove:
9590       case WhiteKingSideCastle:
9591       case WhiteQueenSideCastle:
9592       case BlackKingSideCastle:
9593       case BlackQueenSideCastle:
9594       case WhiteKingSideCastleWild:
9595       case WhiteQueenSideCastleWild:
9596       case BlackKingSideCastleWild:
9597       case BlackQueenSideCastleWild:
9598       /* PUSH Fabien */
9599       case WhiteHSideCastleFR:
9600       case WhiteASideCastleFR:
9601       case BlackHSideCastleFR:
9602       case BlackASideCastleFR:
9603       /* POP Fabien */
9604         if (appData.debugMode)
9605           fprintf(debugFP, "Parsed %s into %s\n", yy_text, currentMoveString);
9606         fromX = currentMoveString[0] - AAA;
9607         fromY = currentMoveString[1] - ONE;
9608         toX = currentMoveString[2] - AAA;
9609         toY = currentMoveString[3] - ONE;
9610         promoChar = currentMoveString[4];
9611         break;
9612
9613       case WhiteDrop:
9614       case BlackDrop:
9615         if (appData.debugMode)
9616           fprintf(debugFP, "Parsed %s into %s\n", yy_text, currentMoveString);
9617         fromX = moveType == WhiteDrop ?
9618           (int) CharToPiece(ToUpper(currentMoveString[0])) :
9619         (int) CharToPiece(ToLower(currentMoveString[0]));
9620         fromY = DROP_RANK;
9621         toX = currentMoveString[2] - AAA;
9622         toY = currentMoveString[3] - ONE;
9623         break;
9624
9625       case WhiteWins:
9626       case BlackWins:
9627       case GameIsDrawn:
9628       case GameUnfinished:
9629         if (appData.debugMode)
9630           fprintf(debugFP, "Parsed game end: %s\n", yy_text);
9631         p = strchr(yy_text, '{');
9632         if (p == NULL) p = strchr(yy_text, '(');
9633         if (p == NULL) {
9634             p = yy_text;
9635             if (p[0] == '0' || p[0] == '1' || p[0] == '*') p = "";
9636         } else {
9637             q = strchr(p, *p == '{' ? '}' : ')');
9638             if (q != NULL) *q = NULLCHAR;
9639             p++;
9640         }
9641         GameEnds(moveType, p, GE_FILE);
9642         done = TRUE;
9643         if (cmailMsgLoaded) {
9644             ClearHighlights();
9645             flipView = WhiteOnMove(currentMove);
9646             if (moveType == GameUnfinished) flipView = !flipView;
9647             if (appData.debugMode)
9648               fprintf(debugFP, "Setting flipView to %d\n", flipView) ;
9649         }
9650         break;
9651
9652       case (ChessMove) 0:       /* end of file */
9653         if (appData.debugMode)
9654           fprintf(debugFP, "Parser hit end of file\n");
9655         switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
9656           case MT_NONE:
9657           case MT_CHECK:
9658             break;
9659           case MT_CHECKMATE:
9660           case MT_STAINMATE:
9661             if (WhiteOnMove(currentMove)) {
9662                 GameEnds(BlackWins, "Black mates", GE_FILE);
9663             } else {
9664                 GameEnds(WhiteWins, "White mates", GE_FILE);
9665             }
9666             break;
9667           case MT_STALEMATE:
9668             GameEnds(GameIsDrawn, "Stalemate", GE_FILE);
9669             break;
9670         }
9671         done = TRUE;
9672         break;
9673
9674       case MoveNumberOne:
9675         if (lastLoadGameStart == GNUChessGame) {
9676             /* GNUChessGames have numbers, but they aren't move numbers */
9677             if (appData.debugMode)
9678               fprintf(debugFP, "Parser ignoring: '%s' (%d)\n",
9679                       yy_text, (int) moveType);
9680             return LoadGameOneMove((ChessMove)0); /* tail recursion */
9681         }
9682         /* else fall thru */
9683
9684       case XBoardGame:
9685       case GNUChessGame:
9686       case PGNTag:
9687         /* Reached start of next game in file */
9688         if (appData.debugMode)
9689           fprintf(debugFP, "Parsed start of next game: %s\n", yy_text);
9690         switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
9691           case MT_NONE:
9692           case MT_CHECK:
9693             break;
9694           case MT_CHECKMATE:
9695           case MT_STAINMATE:
9696             if (WhiteOnMove(currentMove)) {
9697                 GameEnds(BlackWins, "Black mates", GE_FILE);
9698             } else {
9699                 GameEnds(WhiteWins, "White mates", GE_FILE);
9700             }
9701             break;
9702           case MT_STALEMATE:
9703             GameEnds(GameIsDrawn, "Stalemate", GE_FILE);
9704             break;
9705         }
9706         done = TRUE;
9707         break;
9708
9709       case PositionDiagram:     /* should not happen; ignore */
9710       case ElapsedTime:         /* ignore */
9711       case NAG:                 /* ignore */
9712         if (appData.debugMode)
9713           fprintf(debugFP, "Parser ignoring: '%s' (%d)\n",
9714                   yy_text, (int) moveType);
9715         return LoadGameOneMove((ChessMove)0); /* tail recursion */
9716
9717       case IllegalMove:
9718         if (appData.testLegality) {
9719             if (appData.debugMode)
9720               fprintf(debugFP, "Parsed IllegalMove: %s\n", yy_text);
9721             sprintf(move, _("Illegal move: %d.%s%s"),
9722                     (forwardMostMove / 2) + 1,
9723                     WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
9724             DisplayError(move, 0);
9725             done = TRUE;
9726         } else {
9727             if (appData.debugMode)
9728               fprintf(debugFP, "Parsed %s into IllegalMove %s\n",
9729                       yy_text, currentMoveString);
9730             fromX = currentMoveString[0] - AAA;
9731             fromY = currentMoveString[1] - ONE;
9732             toX = currentMoveString[2] - AAA;
9733             toY = currentMoveString[3] - ONE;
9734             promoChar = currentMoveString[4];
9735         }
9736         break;
9737
9738       case AmbiguousMove:
9739         if (appData.debugMode)
9740           fprintf(debugFP, "Parsed AmbiguousMove: %s\n", yy_text);
9741         sprintf(move, _("Ambiguous move: %d.%s%s"),
9742                 (forwardMostMove / 2) + 1,
9743                 WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
9744         DisplayError(move, 0);
9745         done = TRUE;
9746         break;
9747
9748       default:
9749       case ImpossibleMove:
9750         if (appData.debugMode)
9751           fprintf(debugFP, "Parsed ImpossibleMove (type = %d): %s\n", moveType, yy_text);
9752         sprintf(move, _("Illegal move: %d.%s%s"),
9753                 (forwardMostMove / 2) + 1,
9754                 WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
9755         DisplayError(move, 0);
9756         done = TRUE;
9757         break;
9758     }
9759
9760     if (done) {
9761         if (appData.matchMode || (appData.timeDelay == 0 && !pausing)) {
9762             DrawPosition(FALSE, boards[currentMove]);
9763             DisplayBothClocks();
9764             if (!appData.matchMode) // [HGM] PV info: routine tests if empty
9765               DisplayComment(currentMove - 1, commentList[currentMove]);
9766         }
9767         (void) StopLoadGameTimer();
9768         gameFileFP = NULL;
9769         cmailOldMove = forwardMostMove;
9770         return FALSE;
9771     } else {
9772         /* currentMoveString is set as a side-effect of yylex */
9773         strcat(currentMoveString, "\n");
9774         strcpy(moveList[forwardMostMove], currentMoveString);
9775
9776         thinkOutput[0] = NULLCHAR;
9777         MakeMove(fromX, fromY, toX, toY, promoChar);
9778         currentMove = forwardMostMove;
9779         return TRUE;
9780     }
9781 }
9782
9783 /* Load the nth game from the given file */
9784 int
9785 LoadGameFromFile(filename, n, title, useList)
9786      char *filename;
9787      int n;
9788      char *title;
9789      /*Boolean*/ int useList;
9790 {
9791     FILE *f;
9792     char buf[MSG_SIZ];
9793
9794     if (strcmp(filename, "-") == 0) {
9795         f = stdin;
9796         title = "stdin";
9797     } else {
9798         f = fopen(filename, "rb");
9799         if (f == NULL) {
9800           snprintf(buf, sizeof(buf),  _("Can't open \"%s\""), filename);
9801             DisplayError(buf, errno);
9802             return FALSE;
9803         }
9804     }
9805     if (fseek(f, 0, 0) == -1) {
9806         /* f is not seekable; probably a pipe */
9807         useList = FALSE;
9808     }
9809     if (useList && n == 0) {
9810         int error = GameListBuild(f);
9811         if (error) {
9812             DisplayError(_("Cannot build game list"), error);
9813         } else if (!ListEmpty(&gameList) &&
9814                    ((ListGame *) gameList.tailPred)->number > 1) {
9815             GameListPopUp(f, title);
9816             return TRUE;
9817         }
9818         GameListDestroy();
9819         n = 1;
9820     }
9821     if (n == 0) n = 1;
9822     return LoadGame(f, n, title, FALSE);
9823 }
9824
9825
9826 void
9827 MakeRegisteredMove()
9828 {
9829     int fromX, fromY, toX, toY;
9830     char promoChar;
9831     if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
9832         switch (cmailMoveType[lastLoadGameNumber - 1]) {
9833           case CMAIL_MOVE:
9834           case CMAIL_DRAW:
9835             if (appData.debugMode)
9836               fprintf(debugFP, "Restoring %s for game %d\n",
9837                       cmailMove[lastLoadGameNumber - 1], lastLoadGameNumber);
9838
9839             thinkOutput[0] = NULLCHAR;
9840             strcpy(moveList[currentMove], cmailMove[lastLoadGameNumber - 1]);
9841             fromX = cmailMove[lastLoadGameNumber - 1][0] - AAA;
9842             fromY = cmailMove[lastLoadGameNumber - 1][1] - ONE;
9843             toX = cmailMove[lastLoadGameNumber - 1][2] - AAA;
9844             toY = cmailMove[lastLoadGameNumber - 1][3] - ONE;
9845             promoChar = cmailMove[lastLoadGameNumber - 1][4];
9846             MakeMove(fromX, fromY, toX, toY, promoChar);
9847             ShowMove(fromX, fromY, toX, toY);
9848
9849             switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
9850               case MT_NONE:
9851               case MT_CHECK:
9852                 break;
9853
9854               case MT_CHECKMATE:
9855               case MT_STAINMATE:
9856                 if (WhiteOnMove(currentMove)) {
9857                     GameEnds(BlackWins, "Black mates", GE_PLAYER);
9858                 } else {
9859                     GameEnds(WhiteWins, "White mates", GE_PLAYER);
9860                 }
9861                 break;
9862
9863               case MT_STALEMATE:
9864                 GameEnds(GameIsDrawn, "Stalemate", GE_PLAYER);
9865                 break;
9866             }
9867
9868             break;
9869
9870           case CMAIL_RESIGN:
9871             if (WhiteOnMove(currentMove)) {
9872                 GameEnds(BlackWins, "White resigns", GE_PLAYER);
9873             } else {
9874                 GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
9875             }
9876             break;
9877
9878           case CMAIL_ACCEPT:
9879             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
9880             break;
9881
9882           default:
9883             break;
9884         }
9885     }
9886
9887     return;
9888 }
9889
9890 /* Wrapper around LoadGame for use when a Cmail message is loaded */
9891 int
9892 CmailLoadGame(f, gameNumber, title, useList)
9893      FILE *f;
9894      int gameNumber;
9895      char *title;
9896      int useList;
9897 {
9898     int retVal;
9899
9900     if (gameNumber > nCmailGames) {
9901         DisplayError(_("No more games in this message"), 0);
9902         return FALSE;
9903     }
9904     if (f == lastLoadGameFP) {
9905         int offset = gameNumber - lastLoadGameNumber;
9906         if (offset == 0) {
9907             cmailMsg[0] = NULLCHAR;
9908             if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
9909                 cmailMoveRegistered[lastLoadGameNumber - 1] = FALSE;
9910                 nCmailMovesRegistered--;
9911             }
9912             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
9913             if (cmailResult[lastLoadGameNumber - 1] == CMAIL_NEW_RESULT) {
9914                 cmailResult[lastLoadGameNumber - 1] = CMAIL_NOT_RESULT;
9915             }
9916         } else {
9917             if (! RegisterMove()) return FALSE;
9918         }
9919     }
9920
9921     retVal = LoadGame(f, gameNumber, title, useList);
9922
9923     /* Make move registered during previous look at this game, if any */
9924     MakeRegisteredMove();
9925
9926     if (cmailCommentList[lastLoadGameNumber - 1] != NULL) {
9927         commentList[currentMove]
9928           = StrSave(cmailCommentList[lastLoadGameNumber - 1]);
9929         DisplayComment(currentMove - 1, commentList[currentMove]);
9930     }
9931
9932     return retVal;
9933 }
9934
9935 /* Support for LoadNextGame, LoadPreviousGame, ReloadSameGame */
9936 int
9937 ReloadGame(offset)
9938      int offset;
9939 {
9940     int gameNumber = lastLoadGameNumber + offset;
9941     if (lastLoadGameFP == NULL) {
9942         DisplayError(_("No game has been loaded yet"), 0);
9943         return FALSE;
9944     }
9945     if (gameNumber <= 0) {
9946         DisplayError(_("Can't back up any further"), 0);
9947         return FALSE;
9948     }
9949     if (cmailMsgLoaded) {
9950         return CmailLoadGame(lastLoadGameFP, gameNumber,
9951                              lastLoadGameTitle, lastLoadGameUseList);
9952     } else {
9953         return LoadGame(lastLoadGameFP, gameNumber,
9954                         lastLoadGameTitle, lastLoadGameUseList);
9955     }
9956 }
9957
9958
9959
9960 /* Load the nth game from open file f */
9961 int
9962 LoadGame(f, gameNumber, title, useList)
9963      FILE *f;
9964      int gameNumber;
9965      char *title;
9966      int useList;
9967 {
9968     ChessMove cm;
9969     char buf[MSG_SIZ];
9970     int gn = gameNumber;
9971     ListGame *lg = NULL;
9972     int numPGNTags = 0;
9973     int err;
9974     GameMode oldGameMode;
9975     VariantClass oldVariant = gameInfo.variant; /* [HGM] PGNvariant */
9976
9977     if (appData.debugMode)
9978         fprintf(debugFP, "LoadGame(): on entry, gameMode %d\n", gameMode);
9979
9980     if (gameMode == Training )
9981         SetTrainingModeOff();
9982
9983     oldGameMode = gameMode;
9984     if (gameMode != BeginningOfGame) {
9985       Reset(FALSE, TRUE);
9986     }
9987
9988     gameFileFP = f;
9989     if (lastLoadGameFP != NULL && lastLoadGameFP != f) {
9990         fclose(lastLoadGameFP);
9991     }
9992
9993     if (useList) {
9994         lg = (ListGame *) ListElem(&gameList, gameNumber-1);
9995
9996         if (lg) {
9997             fseek(f, lg->offset, 0);
9998             GameListHighlight(gameNumber);
9999             gn = 1;
10000         }
10001         else {
10002             DisplayError(_("Game number out of range"), 0);
10003             return FALSE;
10004         }
10005     } else {
10006         GameListDestroy();
10007         if (fseek(f, 0, 0) == -1) {
10008             if (f == lastLoadGameFP ?
10009                 gameNumber == lastLoadGameNumber + 1 :
10010                 gameNumber == 1) {
10011                 gn = 1;
10012             } else {
10013                 DisplayError(_("Can't seek on game file"), 0);
10014                 return FALSE;
10015             }
10016         }
10017     }
10018     lastLoadGameFP = f;
10019     lastLoadGameNumber = gameNumber;
10020     strcpy(lastLoadGameTitle, title);
10021     lastLoadGameUseList = useList;
10022
10023     yynewfile(f);
10024
10025     if (lg && lg->gameInfo.white && lg->gameInfo.black) {
10026       snprintf(buf, sizeof(buf), "%s vs. %s", lg->gameInfo.white,
10027                 lg->gameInfo.black);
10028             DisplayTitle(buf);
10029     } else if (*title != NULLCHAR) {
10030         if (gameNumber > 1) {
10031             sprintf(buf, "%s %d", title, gameNumber);
10032             DisplayTitle(buf);
10033         } else {
10034             DisplayTitle(title);
10035         }
10036     }
10037
10038     if (gameMode != AnalyzeFile && gameMode != AnalyzeMode) {
10039         gameMode = PlayFromGameFile;
10040         ModeHighlight();
10041     }
10042
10043     currentMove = forwardMostMove = backwardMostMove = 0;
10044     CopyBoard(boards[0], initialPosition);
10045     StopClocks();
10046
10047     /*
10048      * Skip the first gn-1 games in the file.
10049      * Also skip over anything that precedes an identifiable
10050      * start of game marker, to avoid being confused by
10051      * garbage at the start of the file.  Currently
10052      * recognized start of game markers are the move number "1",
10053      * the pattern "gnuchess .* game", the pattern
10054      * "^[#;%] [^ ]* game file", and a PGN tag block.
10055      * A game that starts with one of the latter two patterns
10056      * will also have a move number 1, possibly
10057      * following a position diagram.
10058      * 5-4-02: Let's try being more lenient and allowing a game to
10059      * start with an unnumbered move.  Does that break anything?
10060      */
10061     cm = lastLoadGameStart = (ChessMove) 0;
10062     while (gn > 0) {
10063         yyboardindex = forwardMostMove;
10064         cm = (ChessMove) yylex();
10065         switch (cm) {
10066           case (ChessMove) 0:
10067             if (cmailMsgLoaded) {
10068                 nCmailGames = CMAIL_MAX_GAMES - gn;
10069             } else {
10070                 Reset(TRUE, TRUE);
10071                 DisplayError(_("Game not found in file"), 0);
10072             }
10073             return FALSE;
10074
10075           case GNUChessGame:
10076           case XBoardGame:
10077             gn--;
10078             lastLoadGameStart = cm;
10079             break;
10080
10081           case MoveNumberOne:
10082             switch (lastLoadGameStart) {
10083               case GNUChessGame:
10084               case XBoardGame:
10085               case PGNTag:
10086                 break;
10087               case MoveNumberOne:
10088               case (ChessMove) 0:
10089                 gn--;           /* count this game */
10090                 lastLoadGameStart = cm;
10091                 break;
10092               default:
10093                 /* impossible */
10094                 break;
10095             }
10096             break;
10097
10098           case PGNTag:
10099             switch (lastLoadGameStart) {
10100               case GNUChessGame:
10101               case PGNTag:
10102               case MoveNumberOne:
10103               case (ChessMove) 0:
10104                 gn--;           /* count this game */
10105                 lastLoadGameStart = cm;
10106                 break;
10107               case XBoardGame:
10108                 lastLoadGameStart = cm; /* game counted already */
10109                 break;
10110               default:
10111                 /* impossible */
10112                 break;
10113             }
10114             if (gn > 0) {
10115                 do {
10116                     yyboardindex = forwardMostMove;
10117                     cm = (ChessMove) yylex();
10118                 } while (cm == PGNTag || cm == Comment);
10119             }
10120             break;
10121
10122           case WhiteWins:
10123           case BlackWins:
10124           case GameIsDrawn:
10125             if (cmailMsgLoaded && (CMAIL_MAX_GAMES == lastLoadGameNumber)) {
10126                 if (   cmailResult[CMAIL_MAX_GAMES - gn - 1]
10127                     != CMAIL_OLD_RESULT) {
10128                     nCmailResults ++ ;
10129                     cmailResult[  CMAIL_MAX_GAMES
10130                                 - gn - 1] = CMAIL_OLD_RESULT;
10131                 }
10132             }
10133             break;
10134
10135           case NormalMove:
10136             /* Only a NormalMove can be at the start of a game
10137              * without a position diagram. */
10138             if (lastLoadGameStart == (ChessMove) 0) {
10139               gn--;
10140               lastLoadGameStart = MoveNumberOne;
10141             }
10142             break;
10143
10144           default:
10145             break;
10146         }
10147     }
10148
10149     if (appData.debugMode)
10150       fprintf(debugFP, "Parsed game start '%s' (%d)\n", yy_text, (int) cm);
10151
10152     if (cm == XBoardGame) {
10153         /* Skip any header junk before position diagram and/or move 1 */
10154         for (;;) {
10155             yyboardindex = forwardMostMove;
10156             cm = (ChessMove) yylex();
10157
10158             if (cm == (ChessMove) 0 ||
10159                 cm == GNUChessGame || cm == XBoardGame) {
10160                 /* Empty game; pretend end-of-file and handle later */
10161                 cm = (ChessMove) 0;
10162                 break;
10163             }
10164
10165             if (cm == MoveNumberOne || cm == PositionDiagram ||
10166                 cm == PGNTag || cm == Comment)
10167               break;
10168         }
10169     } else if (cm == GNUChessGame) {
10170         if (gameInfo.event != NULL) {
10171             free(gameInfo.event);
10172         }
10173         gameInfo.event = StrSave(yy_text);
10174     }
10175
10176     startedFromSetupPosition = FALSE;
10177     while (cm == PGNTag) {
10178         if (appData.debugMode)
10179           fprintf(debugFP, "Parsed PGNTag: %s\n", yy_text);
10180         err = ParsePGNTag(yy_text, &gameInfo);
10181         if (!err) numPGNTags++;
10182
10183         /* [HGM] PGNvariant: automatically switch to variant given in PGN tag */
10184         if(gameInfo.variant != oldVariant) {
10185             startedFromPositionFile = FALSE; /* [HGM] loadPos: variant switch likely makes position invalid */
10186             InitPosition(TRUE);
10187             oldVariant = gameInfo.variant;
10188             if (appData.debugMode)
10189               fprintf(debugFP, "New variant %d\n", (int) oldVariant);
10190         }
10191
10192
10193         if (gameInfo.fen != NULL) {
10194           Board initial_position;
10195           startedFromSetupPosition = TRUE;
10196           if (!ParseFEN(initial_position, &blackPlaysFirst, gameInfo.fen)) {
10197             Reset(TRUE, TRUE);
10198             DisplayError(_("Bad FEN position in file"), 0);
10199             return FALSE;
10200           }
10201           CopyBoard(boards[0], initial_position);
10202           if (blackPlaysFirst) {
10203             currentMove = forwardMostMove = backwardMostMove = 1;
10204             CopyBoard(boards[1], initial_position);
10205             strcpy(moveList[0], "");
10206             strcpy(parseList[0], "");
10207             timeRemaining[0][1] = whiteTimeRemaining;
10208             timeRemaining[1][1] = blackTimeRemaining;
10209             if (commentList[0] != NULL) {
10210               commentList[1] = commentList[0];
10211               commentList[0] = NULL;
10212             }
10213           } else {
10214             currentMove = forwardMostMove = backwardMostMove = 0;
10215           }
10216           /* [HGM] copy FEN attributes as well. Bugfix 4.3.14m and 4.3.15e: moved to after 'blackPlaysFirst' */
10217           {   int i;
10218               initialRulePlies = FENrulePlies;
10219               for( i=0; i< nrCastlingRights; i++ )
10220                   initialRights[i] = initial_position[CASTLING][i];
10221           }
10222           yyboardindex = forwardMostMove;
10223           free(gameInfo.fen);
10224           gameInfo.fen = NULL;
10225         }
10226
10227         yyboardindex = forwardMostMove;
10228         cm = (ChessMove) yylex();
10229
10230         /* Handle comments interspersed among the tags */
10231         while (cm == Comment) {
10232             char *p;
10233             if (appData.debugMode)
10234               fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
10235             p = yy_text;
10236             AppendComment(currentMove, p, FALSE);
10237             yyboardindex = forwardMostMove;
10238             cm = (ChessMove) yylex();
10239         }
10240     }
10241
10242     /* don't rely on existence of Event tag since if game was
10243      * pasted from clipboard the Event tag may not exist
10244      */
10245     if (numPGNTags > 0){
10246         char *tags;
10247         if (gameInfo.variant == VariantNormal) {
10248           VariantClass v = StringToVariant(gameInfo.event);
10249           // [HGM] do not recognize variants from event tag that were introduced after supporting variant tag
10250           if(v < VariantShogi) gameInfo.variant = v;
10251         }
10252         if (!matchMode) {
10253           if( appData.autoDisplayTags ) {
10254             tags = PGNTags(&gameInfo);
10255             TagsPopUp(tags, CmailMsg());
10256             free(tags);
10257           }
10258         }
10259     } else {
10260         /* Make something up, but don't display it now */
10261         SetGameInfo();
10262         TagsPopDown();
10263     }
10264
10265     if (cm == PositionDiagram) {
10266         int i, j;
10267         char *p;
10268         Board initial_position;
10269
10270         if (appData.debugMode)
10271           fprintf(debugFP, "Parsed PositionDiagram: %s\n", yy_text);
10272
10273         if (!startedFromSetupPosition) {
10274             p = yy_text;
10275             for (i = BOARD_HEIGHT - 1; i >= 0; i--)
10276               for (j = BOARD_LEFT; j < BOARD_RGHT; p++)
10277                 switch (*p) {
10278                   case '[':
10279                   case '-':
10280                   case ' ':
10281                   case '\t':
10282                   case '\n':
10283                   case '\r':
10284                     break;
10285                   default:
10286                     initial_position[i][j++] = CharToPiece(*p);
10287                     break;
10288                 }
10289             while (*p == ' ' || *p == '\t' ||
10290                    *p == '\n' || *p == '\r') p++;
10291
10292             if (strncmp(p, "black", strlen("black"))==0)
10293               blackPlaysFirst = TRUE;
10294             else
10295               blackPlaysFirst = FALSE;
10296             startedFromSetupPosition = TRUE;
10297
10298             CopyBoard(boards[0], initial_position);
10299             if (blackPlaysFirst) {
10300                 currentMove = forwardMostMove = backwardMostMove = 1;
10301                 CopyBoard(boards[1], initial_position);
10302                 strcpy(moveList[0], "");
10303                 strcpy(parseList[0], "");
10304                 timeRemaining[0][1] = whiteTimeRemaining;
10305                 timeRemaining[1][1] = blackTimeRemaining;
10306                 if (commentList[0] != NULL) {
10307                     commentList[1] = commentList[0];
10308                     commentList[0] = NULL;
10309                 }
10310             } else {
10311                 currentMove = forwardMostMove = backwardMostMove = 0;
10312             }
10313         }
10314         yyboardindex = forwardMostMove;
10315         cm = (ChessMove) yylex();
10316     }
10317
10318     if (first.pr == NoProc) {
10319         StartChessProgram(&first);
10320     }
10321     InitChessProgram(&first, FALSE);
10322     SendToProgram("force\n", &first);
10323     if (startedFromSetupPosition) {
10324         SendBoard(&first, forwardMostMove);
10325     if (appData.debugMode) {
10326         fprintf(debugFP, "Load Game\n");
10327     }
10328         DisplayBothClocks();
10329     }
10330
10331     /* [HGM] server: flag to write setup moves in broadcast file as one */
10332     loadFlag = appData.suppressLoadMoves;
10333
10334     while (cm == Comment) {
10335         char *p;
10336         if (appData.debugMode)
10337           fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
10338         p = yy_text;
10339         AppendComment(currentMove, p, FALSE);
10340         yyboardindex = forwardMostMove;
10341         cm = (ChessMove) yylex();
10342     }
10343
10344     if ((cm == (ChessMove) 0 && lastLoadGameStart != (ChessMove) 0) ||
10345         cm == WhiteWins || cm == BlackWins ||
10346         cm == GameIsDrawn || cm == GameUnfinished) {
10347         DisplayMessage("", _("No moves in game"));
10348         if (cmailMsgLoaded) {
10349             if (appData.debugMode)
10350               fprintf(debugFP, "Setting flipView to %d.\n", FALSE);
10351             ClearHighlights();
10352             flipView = FALSE;
10353         }
10354         DrawPosition(FALSE, boards[currentMove]);
10355         DisplayBothClocks();
10356         gameMode = EditGame;
10357         ModeHighlight();
10358         gameFileFP = NULL;
10359         cmailOldMove = 0;
10360         return TRUE;
10361     }
10362
10363     // [HGM] PV info: routine tests if comment empty
10364     if (!matchMode && (pausing || appData.timeDelay != 0)) {
10365         DisplayComment(currentMove - 1, commentList[currentMove]);
10366     }
10367     if (!matchMode && appData.timeDelay != 0)
10368       DrawPosition(FALSE, boards[currentMove]);
10369
10370     if (gameMode == AnalyzeFile || gameMode == AnalyzeMode) {
10371       programStats.ok_to_send = 1;
10372     }
10373
10374     /* if the first token after the PGN tags is a move
10375      * and not move number 1, retrieve it from the parser
10376      */
10377     if (cm != MoveNumberOne)
10378         LoadGameOneMove(cm);
10379
10380     /* load the remaining moves from the file */
10381     while (LoadGameOneMove((ChessMove)0)) {
10382       timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
10383       timeRemaining[1][forwardMostMove] = blackTimeRemaining;
10384     }
10385
10386     /* rewind to the start of the game */
10387     currentMove = backwardMostMove;
10388
10389     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
10390
10391     if (oldGameMode == AnalyzeFile ||
10392         oldGameMode == AnalyzeMode) {
10393       AnalyzeFileEvent();
10394     }
10395
10396     if (matchMode || appData.timeDelay == 0) {
10397       ToEndEvent();
10398       gameMode = EditGame;
10399       ModeHighlight();
10400     } else if (appData.timeDelay > 0) {
10401       AutoPlayGameLoop();
10402     }
10403
10404     if (appData.debugMode)
10405         fprintf(debugFP, "LoadGame(): on exit, gameMode %d\n", gameMode);
10406
10407     loadFlag = 0; /* [HGM] true game starts */
10408     return TRUE;
10409 }
10410
10411 /* Support for LoadNextPosition, LoadPreviousPosition, ReloadSamePosition */
10412 int
10413 ReloadPosition(offset)
10414      int offset;
10415 {
10416     int positionNumber = lastLoadPositionNumber + offset;
10417     if (lastLoadPositionFP == NULL) {
10418         DisplayError(_("No position has been loaded yet"), 0);
10419         return FALSE;
10420     }
10421     if (positionNumber <= 0) {
10422         DisplayError(_("Can't back up any further"), 0);
10423         return FALSE;
10424     }
10425     return LoadPosition(lastLoadPositionFP, positionNumber,
10426                         lastLoadPositionTitle);
10427 }
10428
10429 /* Load the nth position from the given file */
10430 int
10431 LoadPositionFromFile(filename, n, title)
10432      char *filename;
10433      int n;
10434      char *title;
10435 {
10436     FILE *f;
10437     char buf[MSG_SIZ];
10438
10439     if (strcmp(filename, "-") == 0) {
10440         return LoadPosition(stdin, n, "stdin");
10441     } else {
10442         f = fopen(filename, "rb");
10443         if (f == NULL) {
10444             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
10445             DisplayError(buf, errno);
10446             return FALSE;
10447         } else {
10448             return LoadPosition(f, n, title);
10449         }
10450     }
10451 }
10452
10453 /* Load the nth position from the given open file, and close it */
10454 int
10455 LoadPosition(f, positionNumber, title)
10456      FILE *f;
10457      int positionNumber;
10458      char *title;
10459 {
10460     char *p, line[MSG_SIZ];
10461     Board initial_position;
10462     int i, j, fenMode, pn;
10463
10464     if (gameMode == Training )
10465         SetTrainingModeOff();
10466
10467     if (gameMode != BeginningOfGame) {
10468         Reset(FALSE, TRUE);
10469     }
10470     if (lastLoadPositionFP != NULL && lastLoadPositionFP != f) {
10471         fclose(lastLoadPositionFP);
10472     }
10473     if (positionNumber == 0) positionNumber = 1;
10474     lastLoadPositionFP = f;
10475     lastLoadPositionNumber = positionNumber;
10476     strcpy(lastLoadPositionTitle, title);
10477     if (first.pr == NoProc) {
10478       StartChessProgram(&first);
10479       InitChessProgram(&first, FALSE);
10480     }
10481     pn = positionNumber;
10482     if (positionNumber < 0) {
10483         /* Negative position number means to seek to that byte offset */
10484         if (fseek(f, -positionNumber, 0) == -1) {
10485             DisplayError(_("Can't seek on position file"), 0);
10486             return FALSE;
10487         };
10488         pn = 1;
10489     } else {
10490         if (fseek(f, 0, 0) == -1) {
10491             if (f == lastLoadPositionFP ?
10492                 positionNumber == lastLoadPositionNumber + 1 :
10493                 positionNumber == 1) {
10494                 pn = 1;
10495             } else {
10496                 DisplayError(_("Can't seek on position file"), 0);
10497                 return FALSE;
10498             }
10499         }
10500     }
10501     /* See if this file is FEN or old-style xboard */
10502     if (fgets(line, MSG_SIZ, f) == NULL) {
10503         DisplayError(_("Position not found in file"), 0);
10504         return FALSE;
10505     }
10506     // [HGM] FEN can begin with digit, any piece letter valid in this variant, or a + for Shogi promoted pieces
10507     fenMode = line[0] >= '0' && line[0] <= '9' || line[0] == '+' || CharToPiece(line[0]) != EmptySquare;
10508
10509     if (pn >= 2) {
10510         if (fenMode || line[0] == '#') pn--;
10511         while (pn > 0) {
10512             /* skip positions before number pn */
10513             if (fgets(line, MSG_SIZ, f) == NULL) {
10514                 Reset(TRUE, TRUE);
10515                 DisplayError(_("Position not found in file"), 0);
10516                 return FALSE;
10517             }
10518             if (fenMode || line[0] == '#') pn--;
10519         }
10520     }
10521
10522     if (fenMode) {
10523         if (!ParseFEN(initial_position, &blackPlaysFirst, line)) {
10524             DisplayError(_("Bad FEN position in file"), 0);
10525             return FALSE;
10526         }
10527     } else {
10528         (void) fgets(line, MSG_SIZ, f);
10529         (void) fgets(line, MSG_SIZ, f);
10530
10531         for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
10532             (void) fgets(line, MSG_SIZ, f);
10533             for (p = line, j = BOARD_LEFT; j < BOARD_RGHT; p++) {
10534                 if (*p == ' ')
10535                   continue;
10536                 initial_position[i][j++] = CharToPiece(*p);
10537             }
10538         }
10539
10540         blackPlaysFirst = FALSE;
10541         if (!feof(f)) {
10542             (void) fgets(line, MSG_SIZ, f);
10543             if (strncmp(line, "black", strlen("black"))==0)
10544               blackPlaysFirst = TRUE;
10545         }
10546     }
10547     startedFromSetupPosition = TRUE;
10548
10549     SendToProgram("force\n", &first);
10550     CopyBoard(boards[0], initial_position);
10551     if (blackPlaysFirst) {
10552         currentMove = forwardMostMove = backwardMostMove = 1;
10553         strcpy(moveList[0], "");
10554         strcpy(parseList[0], "");
10555         CopyBoard(boards[1], initial_position);
10556         DisplayMessage("", _("Black to play"));
10557     } else {
10558         currentMove = forwardMostMove = backwardMostMove = 0;
10559         DisplayMessage("", _("White to play"));
10560     }
10561     initialRulePlies = FENrulePlies; /* [HGM] copy FEN attributes as well */
10562     SendBoard(&first, forwardMostMove);
10563     if (appData.debugMode) {
10564 int i, j;
10565   for(i=0;i<2;i++){for(j=0;j<6;j++)fprintf(debugFP, " %d", boards[i][CASTLING][j]);fprintf(debugFP,"\n");}
10566   for(j=0;j<6;j++)fprintf(debugFP, " %d", initialRights[j]);fprintf(debugFP,"\n");
10567         fprintf(debugFP, "Load Position\n");
10568     }
10569
10570     if (positionNumber > 1) {
10571         sprintf(line, "%s %d", title, positionNumber);
10572         DisplayTitle(line);
10573     } else {
10574         DisplayTitle(title);
10575     }
10576     gameMode = EditGame;
10577     ModeHighlight();
10578     ResetClocks();
10579     timeRemaining[0][1] = whiteTimeRemaining;
10580     timeRemaining[1][1] = blackTimeRemaining;
10581     DrawPosition(FALSE, boards[currentMove]);
10582
10583     return TRUE;
10584 }
10585
10586
10587 void
10588 CopyPlayerNameIntoFileName(dest, src)
10589      char **dest, *src;
10590 {
10591     while (*src != NULLCHAR && *src != ',') {
10592         if (*src == ' ') {
10593             *(*dest)++ = '_';
10594             src++;
10595         } else {
10596             *(*dest)++ = *src++;
10597         }
10598     }
10599 }
10600
10601 char *DefaultFileName(ext)
10602      char *ext;
10603 {
10604     static char def[MSG_SIZ];
10605     char *p;
10606
10607     if (gameInfo.white != NULL && gameInfo.white[0] != '-') {
10608         p = def;
10609         CopyPlayerNameIntoFileName(&p, gameInfo.white);
10610         *p++ = '-';
10611         CopyPlayerNameIntoFileName(&p, gameInfo.black);
10612         *p++ = '.';
10613         strcpy(p, ext);
10614     } else {
10615         def[0] = NULLCHAR;
10616     }
10617     return def;
10618 }
10619
10620 /* Save the current game to the given file */
10621 int
10622 SaveGameToFile(filename, append)
10623      char *filename;
10624      int append;
10625 {
10626     FILE *f;
10627     char buf[MSG_SIZ];
10628
10629     if (strcmp(filename, "-") == 0) {
10630         return SaveGame(stdout, 0, NULL);
10631     } else {
10632         f = fopen(filename, append ? "a" : "w");
10633         if (f == NULL) {
10634             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
10635             DisplayError(buf, errno);
10636             return FALSE;
10637         } else {
10638             return SaveGame(f, 0, NULL);
10639         }
10640     }
10641 }
10642
10643 char *
10644 SavePart(str)
10645      char *str;
10646 {
10647     static char buf[MSG_SIZ];
10648     char *p;
10649
10650     p = strchr(str, ' ');
10651     if (p == NULL) return str;
10652     strncpy(buf, str, p - str);
10653     buf[p - str] = NULLCHAR;
10654     return buf;
10655 }
10656
10657 #define PGN_MAX_LINE 75
10658
10659 #define PGN_SIDE_WHITE  0
10660 #define PGN_SIDE_BLACK  1
10661
10662 /* [AS] */
10663 static int FindFirstMoveOutOfBook( int side )
10664 {
10665     int result = -1;
10666
10667     if( backwardMostMove == 0 && ! startedFromSetupPosition) {
10668         int index = backwardMostMove;
10669         int has_book_hit = 0;
10670
10671         if( (index % 2) != side ) {
10672             index++;
10673         }
10674
10675         while( index < forwardMostMove ) {
10676             /* Check to see if engine is in book */
10677             int depth = pvInfoList[index].depth;
10678             int score = pvInfoList[index].score;
10679             int in_book = 0;
10680
10681             if( depth <= 2 ) {
10682                 in_book = 1;
10683             }
10684             else if( score == 0 && depth == 63 ) {
10685                 in_book = 1; /* Zappa */
10686             }
10687             else if( score == 2 && depth == 99 ) {
10688                 in_book = 1; /* Abrok */
10689             }
10690
10691             has_book_hit += in_book;
10692
10693             if( ! in_book ) {
10694                 result = index;
10695
10696                 break;
10697             }
10698
10699             index += 2;
10700         }
10701     }
10702
10703     return result;
10704 }
10705
10706 /* [AS] */
10707 void GetOutOfBookInfo( char * buf )
10708 {
10709     int oob[2];
10710     int i;
10711     int offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
10712
10713     oob[0] = FindFirstMoveOutOfBook( PGN_SIDE_WHITE );
10714     oob[1] = FindFirstMoveOutOfBook( PGN_SIDE_BLACK );
10715
10716     *buf = '\0';
10717
10718     if( oob[0] >= 0 || oob[1] >= 0 ) {
10719         for( i=0; i<2; i++ ) {
10720             int idx = oob[i];
10721
10722             if( idx >= 0 ) {
10723                 if( i > 0 && oob[0] >= 0 ) {
10724                     strcat( buf, "   " );
10725                 }
10726
10727                 sprintf( buf+strlen(buf), "%d%s. ", (idx - offset)/2 + 1, idx & 1 ? ".." : "" );
10728                 sprintf( buf+strlen(buf), "%s%.2f",
10729                     pvInfoList[idx].score >= 0 ? "+" : "",
10730                     pvInfoList[idx].score / 100.0 );
10731             }
10732         }
10733     }
10734 }
10735
10736 /* Save game in PGN style and close the file */
10737 int
10738 SaveGamePGN(f)
10739      FILE *f;
10740 {
10741     int i, offset, linelen, newblock;
10742     time_t tm;
10743 //    char *movetext;
10744     char numtext[32];
10745     int movelen, numlen, blank;
10746     char move_buffer[100]; /* [AS] Buffer for move+PV info */
10747
10748     offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
10749
10750     tm = time((time_t *) NULL);
10751
10752     PrintPGNTags(f, &gameInfo);
10753
10754     if (backwardMostMove > 0 || startedFromSetupPosition) {
10755         char *fen = PositionToFEN(backwardMostMove, NULL);
10756         fprintf(f, "[FEN \"%s\"]\n[SetUp \"1\"]\n", fen);
10757         fprintf(f, "\n{--------------\n");
10758         PrintPosition(f, backwardMostMove);
10759         fprintf(f, "--------------}\n");
10760         free(fen);
10761     }
10762     else {
10763         /* [AS] Out of book annotation */
10764         if( appData.saveOutOfBookInfo ) {
10765             char buf[64];
10766
10767             GetOutOfBookInfo( buf );
10768
10769             if( buf[0] != '\0' ) {
10770                 fprintf( f, "[%s \"%s\"]\n", PGN_OUT_OF_BOOK, buf );
10771             }
10772         }
10773
10774         fprintf(f, "\n");
10775     }
10776
10777     i = backwardMostMove;
10778     linelen = 0;
10779     newblock = TRUE;
10780
10781     while (i < forwardMostMove) {
10782         /* Print comments preceding this move */
10783         if (commentList[i] != NULL) {
10784             if (linelen > 0) fprintf(f, "\n");
10785             fprintf(f, "%s", commentList[i]);
10786             linelen = 0;
10787             newblock = TRUE;
10788         }
10789
10790         /* Format move number */
10791         if ((i % 2) == 0) {
10792             sprintf(numtext, "%d.", (i - offset)/2 + 1);
10793         } else {
10794             if (newblock) {
10795                 sprintf(numtext, "%d...", (i - offset)/2 + 1);
10796             } else {
10797                 numtext[0] = NULLCHAR;
10798             }
10799         }
10800         numlen = strlen(numtext);
10801         newblock = FALSE;
10802
10803         /* Print move number */
10804         blank = linelen > 0 && numlen > 0;
10805         if (linelen + (blank ? 1 : 0) + numlen > PGN_MAX_LINE) {
10806             fprintf(f, "\n");
10807             linelen = 0;
10808             blank = 0;
10809         }
10810         if (blank) {
10811             fprintf(f, " ");
10812             linelen++;
10813         }
10814         fprintf(f, "%s", numtext);
10815         linelen += numlen;
10816
10817         /* Get move */
10818         strcpy(move_buffer, SavePart(parseList[i])); // [HGM] pgn: print move via buffer, so it can be edited
10819         movelen = strlen(move_buffer); /* [HGM] pgn: line-break point before move */
10820
10821         /* Print move */
10822         blank = linelen > 0 && movelen > 0;
10823         if (linelen + (blank ? 1 : 0) + movelen > PGN_MAX_LINE) {
10824             fprintf(f, "\n");
10825             linelen = 0;
10826             blank = 0;
10827         }
10828         if (blank) {
10829             fprintf(f, " ");
10830             linelen++;
10831         }
10832         fprintf(f, "%s", move_buffer);
10833         linelen += movelen;
10834
10835         /* [AS] Add PV info if present */
10836         if( i >= 0 && appData.saveExtendedInfoInPGN && pvInfoList[i].depth > 0 ) {
10837             /* [HGM] add time */
10838             char buf[MSG_SIZ]; int seconds;
10839
10840             seconds = (pvInfoList[i].time+5)/10; // deci-seconds, rounded to nearest
10841
10842             if( seconds <= 0) buf[0] = 0; else
10843             if( seconds < 30 ) sprintf(buf, " %3.1f%c", seconds/10., 0); else {
10844                 seconds = (seconds + 4)/10; // round to full seconds
10845                 if( seconds < 60 ) sprintf(buf, " %d%c", seconds, 0); else
10846                                    sprintf(buf, " %d:%02d%c", seconds/60, seconds%60, 0);
10847             }
10848
10849             sprintf( move_buffer, "{%s%.2f/%d%s}",
10850                 pvInfoList[i].score >= 0 ? "+" : "",
10851                 pvInfoList[i].score / 100.0,
10852                 pvInfoList[i].depth,
10853                 buf );
10854
10855             movelen = strlen(move_buffer); /* [HGM] pgn: line-break point after move */
10856
10857             /* Print score/depth */
10858             blank = linelen > 0 && movelen > 0;
10859             if (linelen + (blank ? 1 : 0) + movelen > PGN_MAX_LINE) {
10860                 fprintf(f, "\n");
10861                 linelen = 0;
10862                 blank = 0;
10863             }
10864             if (blank) {
10865                 fprintf(f, " ");
10866                 linelen++;
10867             }
10868             fprintf(f, "%s", move_buffer);
10869             linelen += movelen;
10870         }
10871
10872         i++;
10873     }
10874
10875     /* Start a new line */
10876     if (linelen > 0) fprintf(f, "\n");
10877
10878     /* Print comments after last move */
10879     if (commentList[i] != NULL) {
10880         fprintf(f, "%s\n", commentList[i]);
10881     }
10882
10883     /* Print result */
10884     if (gameInfo.resultDetails != NULL &&
10885         gameInfo.resultDetails[0] != NULLCHAR) {
10886         fprintf(f, "{%s} %s\n\n", gameInfo.resultDetails,
10887                 PGNResult(gameInfo.result));
10888     } else {
10889         fprintf(f, "%s\n\n", PGNResult(gameInfo.result));
10890     }
10891
10892     fclose(f);
10893     lastSavedGame = GameCheckSum(); // [HGM] save: remember ID of last saved game to prevent double saving
10894     return TRUE;
10895 }
10896
10897 /* Save game in old style and close the file */
10898 int
10899 SaveGameOldStyle(f)
10900      FILE *f;
10901 {
10902     int i, offset;
10903     time_t tm;
10904
10905     tm = time((time_t *) NULL);
10906
10907     fprintf(f, "# %s game file -- %s", programName, ctime(&tm));
10908     PrintOpponents(f);
10909
10910     if (backwardMostMove > 0 || startedFromSetupPosition) {
10911         fprintf(f, "\n[--------------\n");
10912         PrintPosition(f, backwardMostMove);
10913         fprintf(f, "--------------]\n");
10914     } else {
10915         fprintf(f, "\n");
10916     }
10917
10918     i = backwardMostMove;
10919     offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
10920
10921     while (i < forwardMostMove) {
10922         if (commentList[i] != NULL) {
10923             fprintf(f, "[%s]\n", commentList[i]);
10924         }
10925
10926         if ((i % 2) == 1) {
10927             fprintf(f, "%d. ...  %s\n", (i - offset)/2 + 1, parseList[i]);
10928             i++;
10929         } else {
10930             fprintf(f, "%d. %s  ", (i - offset)/2 + 1, parseList[i]);
10931             i++;
10932             if (commentList[i] != NULL) {
10933                 fprintf(f, "\n");
10934                 continue;
10935             }
10936             if (i >= forwardMostMove) {
10937                 fprintf(f, "\n");
10938                 break;
10939             }
10940             fprintf(f, "%s\n", parseList[i]);
10941             i++;
10942         }
10943     }
10944
10945     if (commentList[i] != NULL) {
10946         fprintf(f, "[%s]\n", commentList[i]);
10947     }
10948
10949     /* This isn't really the old style, but it's close enough */
10950     if (gameInfo.resultDetails != NULL &&
10951         gameInfo.resultDetails[0] != NULLCHAR) {
10952         fprintf(f, "%s (%s)\n\n", PGNResult(gameInfo.result),
10953                 gameInfo.resultDetails);
10954     } else {
10955         fprintf(f, "%s\n\n", PGNResult(gameInfo.result));
10956     }
10957
10958     fclose(f);
10959     return TRUE;
10960 }
10961
10962 /* Save the current game to open file f and close the file */
10963 int
10964 SaveGame(f, dummy, dummy2)
10965      FILE *f;
10966      int dummy;
10967      char *dummy2;
10968 {
10969     if (gameMode == EditPosition) EditPositionDone(TRUE);
10970     lastSavedGame = GameCheckSum(); // [HGM] save: remember ID of last saved game to prevent double saving
10971     if (appData.oldSaveStyle)
10972       return SaveGameOldStyle(f);
10973     else
10974       return SaveGamePGN(f);
10975 }
10976
10977 /* Save the current position to the given file */
10978 int
10979 SavePositionToFile(filename)
10980      char *filename;
10981 {
10982     FILE *f;
10983     char buf[MSG_SIZ];
10984
10985     if (strcmp(filename, "-") == 0) {
10986         return SavePosition(stdout, 0, NULL);
10987     } else {
10988         f = fopen(filename, "a");
10989         if (f == NULL) {
10990             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
10991             DisplayError(buf, errno);
10992             return FALSE;
10993         } else {
10994             SavePosition(f, 0, NULL);
10995             return TRUE;
10996         }
10997     }
10998 }
10999
11000 /* Save the current position to the given open file and close the file */
11001 int
11002 SavePosition(f, dummy, dummy2)
11003      FILE *f;
11004      int dummy;
11005      char *dummy2;
11006 {
11007     time_t tm;
11008     char *fen;
11009
11010     if (gameMode == EditPosition) EditPositionDone(TRUE);
11011     if (appData.oldSaveStyle) {
11012         tm = time((time_t *) NULL);
11013
11014         fprintf(f, "# %s position file -- %s", programName, ctime(&tm));
11015         PrintOpponents(f);
11016         fprintf(f, "[--------------\n");
11017         PrintPosition(f, currentMove);
11018         fprintf(f, "--------------]\n");
11019     } else {
11020         fen = PositionToFEN(currentMove, NULL);
11021         fprintf(f, "%s\n", fen);
11022         free(fen);
11023     }
11024     fclose(f);
11025     return TRUE;
11026 }
11027
11028 void
11029 ReloadCmailMsgEvent(unregister)
11030      int unregister;
11031 {
11032 #if !WIN32
11033     static char *inFilename = NULL;
11034     static char *outFilename;
11035     int i;
11036     struct stat inbuf, outbuf;
11037     int status;
11038
11039     /* Any registered moves are unregistered if unregister is set, */
11040     /* i.e. invoked by the signal handler */
11041     if (unregister) {
11042         for (i = 0; i < CMAIL_MAX_GAMES; i ++) {
11043             cmailMoveRegistered[i] = FALSE;
11044             if (cmailCommentList[i] != NULL) {
11045                 free(cmailCommentList[i]);
11046                 cmailCommentList[i] = NULL;
11047             }
11048         }
11049         nCmailMovesRegistered = 0;
11050     }
11051
11052     for (i = 0; i < CMAIL_MAX_GAMES; i ++) {
11053         cmailResult[i] = CMAIL_NOT_RESULT;
11054     }
11055     nCmailResults = 0;
11056
11057     if (inFilename == NULL) {
11058         /* Because the filenames are static they only get malloced once  */
11059         /* and they never get freed                                      */
11060         inFilename = (char *) malloc(strlen(appData.cmailGameName) + 9);
11061         sprintf(inFilename, "%s.game.in", appData.cmailGameName);
11062
11063         outFilename = (char *) malloc(strlen(appData.cmailGameName) + 5);
11064         sprintf(outFilename, "%s.out", appData.cmailGameName);
11065     }
11066
11067     status = stat(outFilename, &outbuf);
11068     if (status < 0) {
11069         cmailMailedMove = FALSE;
11070     } else {
11071         status = stat(inFilename, &inbuf);
11072         cmailMailedMove = (inbuf.st_mtime < outbuf.st_mtime);
11073     }
11074
11075     /* LoadGameFromFile(CMAIL_MAX_GAMES) with cmailMsgLoaded == TRUE
11076        counts the games, notes how each one terminated, etc.
11077
11078        It would be nice to remove this kludge and instead gather all
11079        the information while building the game list.  (And to keep it
11080        in the game list nodes instead of having a bunch of fixed-size
11081        parallel arrays.)  Note this will require getting each game's
11082        termination from the PGN tags, as the game list builder does
11083        not process the game moves.  --mann
11084        */
11085     cmailMsgLoaded = TRUE;
11086     LoadGameFromFile(inFilename, CMAIL_MAX_GAMES, "", FALSE);
11087
11088     /* Load first game in the file or popup game menu */
11089     LoadGameFromFile(inFilename, 0, appData.cmailGameName, TRUE);
11090
11091 #endif /* !WIN32 */
11092     return;
11093 }
11094
11095 int
11096 RegisterMove()
11097 {
11098     FILE *f;
11099     char string[MSG_SIZ];
11100
11101     if (   cmailMailedMove
11102         || (cmailResult[lastLoadGameNumber - 1] == CMAIL_OLD_RESULT)) {
11103         return TRUE;            /* Allow free viewing  */
11104     }
11105
11106     /* Unregister move to ensure that we don't leave RegisterMove        */
11107     /* with the move registered when the conditions for registering no   */
11108     /* longer hold                                                       */
11109     if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
11110         cmailMoveRegistered[lastLoadGameNumber - 1] = FALSE;
11111         nCmailMovesRegistered --;
11112
11113         if (cmailCommentList[lastLoadGameNumber - 1] != NULL)
11114           {
11115               free(cmailCommentList[lastLoadGameNumber - 1]);
11116               cmailCommentList[lastLoadGameNumber - 1] = NULL;
11117           }
11118     }
11119
11120     if (cmailOldMove == -1) {
11121         DisplayError(_("You have edited the game history.\nUse Reload Same Game and make your move again."), 0);
11122         return FALSE;
11123     }
11124
11125     if (currentMove > cmailOldMove + 1) {
11126         DisplayError(_("You have entered too many moves.\nBack up to the correct position and try again."), 0);
11127         return FALSE;
11128     }
11129
11130     if (currentMove < cmailOldMove) {
11131         DisplayError(_("Displayed position is not current.\nStep forward to the correct position and try again."), 0);
11132         return FALSE;
11133     }
11134
11135     if (forwardMostMove > currentMove) {
11136         /* Silently truncate extra moves */
11137         TruncateGame();
11138     }
11139
11140     if (   (currentMove == cmailOldMove + 1)
11141         || (   (currentMove == cmailOldMove)
11142             && (   (cmailMoveType[lastLoadGameNumber - 1] == CMAIL_ACCEPT)
11143                 || (cmailMoveType[lastLoadGameNumber - 1] == CMAIL_RESIGN)))) {
11144         if (gameInfo.result != GameUnfinished) {
11145             cmailResult[lastLoadGameNumber - 1] = CMAIL_NEW_RESULT;
11146         }
11147
11148         if (commentList[currentMove] != NULL) {
11149             cmailCommentList[lastLoadGameNumber - 1]
11150               = StrSave(commentList[currentMove]);
11151         }
11152         strcpy(cmailMove[lastLoadGameNumber - 1], moveList[currentMove - 1]);
11153
11154         if (appData.debugMode)
11155           fprintf(debugFP, "Saving %s for game %d\n",
11156                   cmailMove[lastLoadGameNumber - 1], lastLoadGameNumber);
11157
11158         sprintf(string,
11159                 "%s.game.out.%d", appData.cmailGameName, lastLoadGameNumber);
11160
11161         f = fopen(string, "w");
11162         if (appData.oldSaveStyle) {
11163             SaveGameOldStyle(f); /* also closes the file */
11164
11165             sprintf(string, "%s.pos.out", appData.cmailGameName);
11166             f = fopen(string, "w");
11167             SavePosition(f, 0, NULL); /* also closes the file */
11168         } else {
11169             fprintf(f, "{--------------\n");
11170             PrintPosition(f, currentMove);
11171             fprintf(f, "--------------}\n\n");
11172
11173             SaveGame(f, 0, NULL); /* also closes the file*/
11174         }
11175
11176         cmailMoveRegistered[lastLoadGameNumber - 1] = TRUE;
11177         nCmailMovesRegistered ++;
11178     } else if (nCmailGames == 1) {
11179         DisplayError(_("You have not made a move yet"), 0);
11180         return FALSE;
11181     }
11182
11183     return TRUE;
11184 }
11185
11186 void
11187 MailMoveEvent()
11188 {
11189 #if !WIN32
11190     static char *partCommandString = "cmail -xv%s -remail -game %s 2>&1";
11191     FILE *commandOutput;
11192     char buffer[MSG_SIZ], msg[MSG_SIZ], string[MSG_SIZ];
11193     int nBytes = 0;             /*  Suppress warnings on uninitialized variables    */
11194     int nBuffers;
11195     int i;
11196     int archived;
11197     char *arcDir;
11198
11199     if (! cmailMsgLoaded) {
11200         DisplayError(_("The cmail message is not loaded.\nUse Reload CMail Message and make your move again."), 0);
11201         return;
11202     }
11203
11204     if (nCmailGames == nCmailResults) {
11205         DisplayError(_("No unfinished games"), 0);
11206         return;
11207     }
11208
11209 #if CMAIL_PROHIBIT_REMAIL
11210     if (cmailMailedMove) {
11211         sprintf(msg, _("You have already mailed a move.\nWait until a move arrives from your opponent.\nTo resend the same move, type\n\"cmail -remail -game %s\"\non the command line."), appData.cmailGameName);
11212         DisplayError(msg, 0);
11213         return;
11214     }
11215 #endif
11216
11217     if (! (cmailMailedMove || RegisterMove())) return;
11218
11219     if (   cmailMailedMove
11220         || (nCmailMovesRegistered + nCmailResults == nCmailGames)) {
11221         sprintf(string, partCommandString,
11222                 appData.debugMode ? " -v" : "", appData.cmailGameName);
11223         commandOutput = popen(string, "r");
11224
11225         if (commandOutput == NULL) {
11226             DisplayError(_("Failed to invoke cmail"), 0);
11227         } else {
11228             for (nBuffers = 0; (! feof(commandOutput)); nBuffers ++) {
11229                 nBytes = fread(buffer, 1, MSG_SIZ - 1, commandOutput);
11230             }
11231             if (nBuffers > 1) {
11232                 (void) memcpy(msg, buffer + nBytes, MSG_SIZ - nBytes - 1);
11233                 (void) memcpy(msg + MSG_SIZ - nBytes - 1, buffer, nBytes);
11234                 nBytes = MSG_SIZ - 1;
11235             } else {
11236                 (void) memcpy(msg, buffer, nBytes);
11237             }
11238             *(msg + nBytes) = '\0'; /* \0 for end-of-string*/
11239
11240             if(StrStr(msg, "Mailed cmail message to ") != NULL) {
11241                 cmailMailedMove = TRUE; /* Prevent >1 moves    */
11242
11243                 archived = TRUE;
11244                 for (i = 0; i < nCmailGames; i ++) {
11245                     if (cmailResult[i] == CMAIL_NOT_RESULT) {
11246                         archived = FALSE;
11247                     }
11248                 }
11249                 if (   archived
11250                     && (   (arcDir = (char *) getenv("CMAIL_ARCDIR"))
11251                         != NULL)) {
11252                     sprintf(buffer, "%s/%s.%s.archive",
11253                             arcDir,
11254                             appData.cmailGameName,
11255                             gameInfo.date);
11256                     LoadGameFromFile(buffer, 1, buffer, FALSE);
11257                     cmailMsgLoaded = FALSE;
11258                 }
11259             }
11260
11261             DisplayInformation(msg);
11262             pclose(commandOutput);
11263         }
11264     } else {
11265         if ((*cmailMsg) != '\0') {
11266             DisplayInformation(cmailMsg);
11267         }
11268     }
11269
11270     return;
11271 #endif /* !WIN32 */
11272 }
11273
11274 char *
11275 CmailMsg()
11276 {
11277 #if WIN32
11278     return NULL;
11279 #else
11280     int  prependComma = 0;
11281     char number[5];
11282     char string[MSG_SIZ];       /* Space for game-list */
11283     int  i;
11284
11285     if (!cmailMsgLoaded) return "";
11286
11287     if (cmailMailedMove) {
11288         sprintf(cmailMsg, _("Waiting for reply from opponent\n"));
11289     } else {
11290         /* Create a list of games left */
11291         sprintf(string, "[");
11292         for (i = 0; i < nCmailGames; i ++) {
11293             if (! (   cmailMoveRegistered[i]
11294                    || (cmailResult[i] == CMAIL_OLD_RESULT))) {
11295                 if (prependComma) {
11296                     sprintf(number, ",%d", i + 1);
11297                 } else {
11298                     sprintf(number, "%d", i + 1);
11299                     prependComma = 1;
11300                 }
11301
11302                 strcat(string, number);
11303             }
11304         }
11305         strcat(string, "]");
11306
11307         if (nCmailMovesRegistered + nCmailResults == 0) {
11308             switch (nCmailGames) {
11309               case 1:
11310                 sprintf(cmailMsg,
11311                         _("Still need to make move for game\n"));
11312                 break;
11313
11314               case 2:
11315                 sprintf(cmailMsg,
11316                         _("Still need to make moves for both games\n"));
11317                 break;
11318
11319               default:
11320                 sprintf(cmailMsg,
11321                         _("Still need to make moves for all %d games\n"),
11322                         nCmailGames);
11323                 break;
11324             }
11325         } else {
11326             switch (nCmailGames - nCmailMovesRegistered - nCmailResults) {
11327               case 1:
11328                 sprintf(cmailMsg,
11329                         _("Still need to make a move for game %s\n"),
11330                         string);
11331                 break;
11332
11333               case 0:
11334                 if (nCmailResults == nCmailGames) {
11335                     sprintf(cmailMsg, _("No unfinished games\n"));
11336                 } else {
11337                     sprintf(cmailMsg, _("Ready to send mail\n"));
11338                 }
11339                 break;
11340
11341               default:
11342                 sprintf(cmailMsg,
11343                         _("Still need to make moves for games %s\n"),
11344                         string);
11345             }
11346         }
11347     }
11348     return cmailMsg;
11349 #endif /* WIN32 */
11350 }
11351
11352 void
11353 ResetGameEvent()
11354 {
11355     if (gameMode == Training)
11356       SetTrainingModeOff();
11357
11358     Reset(TRUE, TRUE);
11359     cmailMsgLoaded = FALSE;
11360     if (appData.icsActive) {
11361       SendToICS(ics_prefix);
11362       SendToICS("refresh\n");
11363     }
11364 }
11365
11366 void
11367 ExitEvent(status)
11368      int status;
11369 {
11370     exiting++;
11371     if (exiting > 2) {
11372       /* Give up on clean exit */
11373       exit(status);
11374     }
11375     if (exiting > 1) {
11376       /* Keep trying for clean exit */
11377       return;
11378     }
11379
11380     if (appData.icsActive && appData.colorize) Colorize(ColorNone, FALSE);
11381
11382     if (telnetISR != NULL) {
11383       RemoveInputSource(telnetISR);
11384     }
11385     if (icsPR != NoProc) {
11386       DestroyChildProcess(icsPR, TRUE);
11387     }
11388
11389     /* [HGM] crash: leave writing PGN and position entirely to GameEnds() */
11390     GameEnds(gameInfo.result, gameInfo.resultDetails==NULL ? "xboard exit" : gameInfo.resultDetails, GE_PLAYER);
11391
11392     /* [HGM] crash: the above GameEnds() is a dud if another one was running */
11393     /* make sure this other one finishes before killing it!                  */
11394     if(endingGame) { int count = 0;
11395         if(appData.debugMode) fprintf(debugFP, "ExitEvent() during GameEnds(), wait\n");
11396         while(endingGame && count++ < 10) DoSleep(1);
11397         if(appData.debugMode && endingGame) fprintf(debugFP, "GameEnds() seems stuck, proceed exiting\n");
11398     }
11399
11400     /* Kill off chess programs */
11401     if (first.pr != NoProc) {
11402         ExitAnalyzeMode();
11403
11404         DoSleep( appData.delayBeforeQuit );
11405         SendToProgram("quit\n", &first);
11406         DoSleep( appData.delayAfterQuit );
11407         DestroyChildProcess(first.pr, 10 /* [AS] first.useSigterm */ );
11408     }
11409     if (second.pr != NoProc) {
11410         DoSleep( appData.delayBeforeQuit );
11411         SendToProgram("quit\n", &second);
11412         DoSleep( appData.delayAfterQuit );
11413         DestroyChildProcess(second.pr, 10 /* [AS] second.useSigterm */ );
11414     }
11415     if (first.isr != NULL) {
11416         RemoveInputSource(first.isr);
11417     }
11418     if (second.isr != NULL) {
11419         RemoveInputSource(second.isr);
11420     }
11421
11422     ShutDownFrontEnd();
11423     exit(status);
11424 }
11425
11426 void
11427 PauseEvent()
11428 {
11429     if (appData.debugMode)
11430         fprintf(debugFP, "PauseEvent(): pausing %d\n", pausing);
11431     if (pausing) {
11432         pausing = FALSE;
11433         ModeHighlight();
11434         if (gameMode == MachinePlaysWhite ||
11435             gameMode == MachinePlaysBlack) {
11436             StartClocks();
11437         } else {
11438             DisplayBothClocks();
11439         }
11440         if (gameMode == PlayFromGameFile) {
11441             if (appData.timeDelay >= 0)
11442                 AutoPlayGameLoop();
11443         } else if (gameMode == IcsExamining && pauseExamInvalid) {
11444             Reset(FALSE, TRUE);
11445             SendToICS(ics_prefix);
11446             SendToICS("refresh\n");
11447         } else if (currentMove < forwardMostMove) {
11448             ForwardInner(forwardMostMove);
11449         }
11450         pauseExamInvalid = FALSE;
11451     } else {
11452         switch (gameMode) {
11453           default:
11454             return;
11455           case IcsExamining:
11456             pauseExamForwardMostMove = forwardMostMove;
11457             pauseExamInvalid = FALSE;
11458             /* fall through */
11459           case IcsObserving:
11460           case IcsPlayingWhite:
11461           case IcsPlayingBlack:
11462             pausing = TRUE;
11463             ModeHighlight();
11464             return;
11465           case PlayFromGameFile:
11466             (void) StopLoadGameTimer();
11467             pausing = TRUE;
11468             ModeHighlight();
11469             break;
11470           case BeginningOfGame:
11471             if (appData.icsActive) return;
11472             /* else fall through */
11473           case MachinePlaysWhite:
11474           case MachinePlaysBlack:
11475           case TwoMachinesPlay:
11476             if (forwardMostMove == 0)
11477               return;           /* don't pause if no one has moved */
11478             if ((gameMode == MachinePlaysWhite &&
11479                  !WhiteOnMove(forwardMostMove)) ||
11480                 (gameMode == MachinePlaysBlack &&
11481                  WhiteOnMove(forwardMostMove))) {
11482                 StopClocks();
11483             }
11484             pausing = TRUE;
11485             ModeHighlight();
11486             break;
11487         }
11488     }
11489 }
11490
11491 void
11492 EditCommentEvent()
11493 {
11494     char title[MSG_SIZ];
11495
11496     if (currentMove < 1 || parseList[currentMove - 1][0] == NULLCHAR) {
11497         strcpy(title, _("Edit comment"));
11498     } else {
11499         sprintf(title, _("Edit comment on %d.%s%s"), (currentMove - 1) / 2 + 1,
11500                 WhiteOnMove(currentMove - 1) ? " " : ".. ",
11501                 parseList[currentMove - 1]);
11502     }
11503
11504     EditCommentPopUp(currentMove, title, commentList[currentMove]);
11505 }
11506
11507
11508 void
11509 EditTagsEvent()
11510 {
11511     char *tags = PGNTags(&gameInfo);
11512     EditTagsPopUp(tags);
11513     free(tags);
11514 }
11515
11516 void
11517 AnalyzeModeEvent()
11518 {
11519     if (appData.noChessProgram || gameMode == AnalyzeMode)
11520       return;
11521
11522     if (gameMode != AnalyzeFile) {
11523         if (!appData.icsEngineAnalyze) {
11524                EditGameEvent();
11525                if (gameMode != EditGame) return;
11526         }
11527         ResurrectChessProgram();
11528         SendToProgram("analyze\n", &first);
11529         first.analyzing = TRUE;
11530         /*first.maybeThinking = TRUE;*/
11531         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
11532         EngineOutputPopUp();
11533     }
11534     if (!appData.icsEngineAnalyze) gameMode = AnalyzeMode;
11535     pausing = FALSE;
11536     ModeHighlight();
11537     SetGameInfo();
11538
11539     StartAnalysisClock();
11540     GetTimeMark(&lastNodeCountTime);
11541     lastNodeCount = 0;
11542 }
11543
11544 void
11545 AnalyzeFileEvent()
11546 {
11547     if (appData.noChessProgram || gameMode == AnalyzeFile)
11548       return;
11549
11550     if (gameMode != AnalyzeMode) {
11551         EditGameEvent();
11552         if (gameMode != EditGame) return;
11553         ResurrectChessProgram();
11554         SendToProgram("analyze\n", &first);
11555         first.analyzing = TRUE;
11556         /*first.maybeThinking = TRUE;*/
11557         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
11558         EngineOutputPopUp();
11559     }
11560     gameMode = AnalyzeFile;
11561     pausing = FALSE;
11562     ModeHighlight();
11563     SetGameInfo();
11564
11565     StartAnalysisClock();
11566     GetTimeMark(&lastNodeCountTime);
11567     lastNodeCount = 0;
11568 }
11569
11570 void
11571 MachineWhiteEvent()
11572 {
11573     char buf[MSG_SIZ];
11574     char *bookHit = NULL;
11575
11576     if (appData.noChessProgram || (gameMode == MachinePlaysWhite))
11577       return;
11578
11579
11580     if (gameMode == PlayFromGameFile ||
11581         gameMode == TwoMachinesPlay  ||
11582         gameMode == Training         ||
11583         gameMode == AnalyzeMode      ||
11584         gameMode == EndOfGame)
11585         EditGameEvent();
11586
11587     if (gameMode == EditPosition)
11588         EditPositionDone(TRUE);
11589
11590     if (!WhiteOnMove(currentMove)) {
11591         DisplayError(_("It is not White's turn"), 0);
11592         return;
11593     }
11594
11595     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile)
11596       ExitAnalyzeMode();
11597
11598     if (gameMode == EditGame || gameMode == AnalyzeMode ||
11599         gameMode == AnalyzeFile)
11600         TruncateGame();
11601
11602     ResurrectChessProgram();    /* in case it isn't running */
11603     if(gameMode == BeginningOfGame) { /* [HGM] time odds: to get right odds in human mode */
11604         gameMode = MachinePlaysWhite;
11605         ResetClocks();
11606     } else
11607     gameMode = MachinePlaysWhite;
11608     pausing = FALSE;
11609     ModeHighlight();
11610     SetGameInfo();
11611     sprintf(buf, "%s vs. %s", gameInfo.white, gameInfo.black);
11612     DisplayTitle(buf);
11613     if (first.sendName) {
11614       sprintf(buf, "name %s\n", gameInfo.black);
11615       SendToProgram(buf, &first);
11616     }
11617     if (first.sendTime) {
11618       if (first.useColors) {
11619         SendToProgram("black\n", &first); /*gnu kludge*/
11620       }
11621       SendTimeRemaining(&first, TRUE);
11622     }
11623     if (first.useColors) {
11624       SendToProgram("white\n", &first); // [HGM] book: send 'go' separately
11625     }
11626     bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: send go or retrieve book move
11627     SetMachineThinkingEnables();
11628     first.maybeThinking = TRUE;
11629     StartClocks();
11630     firstMove = FALSE;
11631
11632     if (appData.autoFlipView && !flipView) {
11633       flipView = !flipView;
11634       DrawPosition(FALSE, NULL);
11635       DisplayBothClocks();       // [HGM] logo: clocks might have to be exchanged;
11636     }
11637
11638     if(bookHit) { // [HGM] book: simulate book reply
11639         static char bookMove[MSG_SIZ]; // a bit generous?
11640
11641         programStats.nodes = programStats.depth = programStats.time =
11642         programStats.score = programStats.got_only_move = 0;
11643         sprintf(programStats.movelist, "%s (xbook)", bookHit);
11644
11645         strcpy(bookMove, "move ");
11646         strcat(bookMove, bookHit);
11647         HandleMachineMove(bookMove, &first);
11648     }
11649 }
11650
11651 void
11652 MachineBlackEvent()
11653 {
11654     char buf[MSG_SIZ];
11655    char *bookHit = NULL;
11656
11657     if (appData.noChessProgram || (gameMode == MachinePlaysBlack))
11658         return;
11659
11660
11661     if (gameMode == PlayFromGameFile ||
11662         gameMode == TwoMachinesPlay  ||
11663         gameMode == Training         ||
11664         gameMode == AnalyzeMode      ||
11665         gameMode == EndOfGame)
11666         EditGameEvent();
11667
11668     if (gameMode == EditPosition)
11669         EditPositionDone(TRUE);
11670
11671     if (WhiteOnMove(currentMove)) {
11672         DisplayError(_("It is not Black's turn"), 0);
11673         return;
11674     }
11675
11676     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile)
11677       ExitAnalyzeMode();
11678
11679     if (gameMode == EditGame || gameMode == AnalyzeMode ||
11680         gameMode == AnalyzeFile)
11681         TruncateGame();
11682
11683     ResurrectChessProgram();    /* in case it isn't running */
11684     gameMode = MachinePlaysBlack;
11685     pausing = FALSE;
11686     ModeHighlight();
11687     SetGameInfo();
11688     sprintf(buf, "%s vs. %s", gameInfo.white, gameInfo.black);
11689     DisplayTitle(buf);
11690     if (first.sendName) {
11691       sprintf(buf, "name %s\n", gameInfo.white);
11692       SendToProgram(buf, &first);
11693     }
11694     if (first.sendTime) {
11695       if (first.useColors) {
11696         SendToProgram("white\n", &first); /*gnu kludge*/
11697       }
11698       SendTimeRemaining(&first, FALSE);
11699     }
11700     if (first.useColors) {
11701       SendToProgram("black\n", &first); // [HGM] book: 'go' sent separately
11702     }
11703     bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: send go or retrieve book move
11704     SetMachineThinkingEnables();
11705     first.maybeThinking = TRUE;
11706     StartClocks();
11707
11708     if (appData.autoFlipView && flipView) {
11709       flipView = !flipView;
11710       DrawPosition(FALSE, NULL);
11711       DisplayBothClocks();       // [HGM] logo: clocks might have to be exchanged;
11712     }
11713     if(bookHit) { // [HGM] book: simulate book reply
11714         static char bookMove[MSG_SIZ]; // a bit generous?
11715
11716         programStats.nodes = programStats.depth = programStats.time =
11717         programStats.score = programStats.got_only_move = 0;
11718         sprintf(programStats.movelist, "%s (xbook)", bookHit);
11719
11720         strcpy(bookMove, "move ");
11721         strcat(bookMove, bookHit);
11722         HandleMachineMove(bookMove, &first);
11723     }
11724 }
11725
11726
11727 void
11728 DisplayTwoMachinesTitle()
11729 {
11730     char buf[MSG_SIZ];
11731     if (appData.matchGames > 0) {
11732         if (first.twoMachinesColor[0] == 'w') {
11733             sprintf(buf, "%s vs. %s (%d-%d-%d)",
11734                     gameInfo.white, gameInfo.black,
11735                     first.matchWins, second.matchWins,
11736                     matchGame - 1 - (first.matchWins + second.matchWins));
11737         } else {
11738             sprintf(buf, "%s vs. %s (%d-%d-%d)",
11739                     gameInfo.white, gameInfo.black,
11740                     second.matchWins, first.matchWins,
11741                     matchGame - 1 - (first.matchWins + second.matchWins));
11742         }
11743     } else {
11744         sprintf(buf, "%s vs. %s", gameInfo.white, gameInfo.black);
11745     }
11746     DisplayTitle(buf);
11747 }
11748
11749 void
11750 TwoMachinesEvent P((void))
11751 {
11752     int i;
11753     char buf[MSG_SIZ];
11754     ChessProgramState *onmove;
11755     char *bookHit = NULL;
11756
11757     if (appData.noChessProgram) return;
11758
11759     switch (gameMode) {
11760       case TwoMachinesPlay:
11761         return;
11762       case MachinePlaysWhite:
11763       case MachinePlaysBlack:
11764         if (WhiteOnMove(forwardMostMove) == (gameMode == MachinePlaysWhite)) {
11765             DisplayError(_("Wait until your turn,\nor select Move Now"), 0);
11766             return;
11767         }
11768         /* fall through */
11769       case BeginningOfGame:
11770       case PlayFromGameFile:
11771       case EndOfGame:
11772         EditGameEvent();
11773         if (gameMode != EditGame) return;
11774         break;
11775       case EditPosition:
11776         EditPositionDone(TRUE);
11777         break;
11778       case AnalyzeMode:
11779       case AnalyzeFile:
11780         ExitAnalyzeMode();
11781         break;
11782       case EditGame:
11783       default:
11784         break;
11785     }
11786
11787 //    forwardMostMove = currentMove;
11788     TruncateGame(); // [HGM] vari: MachineWhite and MachineBlack do this...
11789     ResurrectChessProgram();    /* in case first program isn't running */
11790
11791     if (second.pr == NULL) {
11792         StartChessProgram(&second);
11793         if (second.protocolVersion == 1) {
11794           TwoMachinesEventIfReady();
11795         } else {
11796           /* kludge: allow timeout for initial "feature" command */
11797           FreezeUI();
11798           DisplayMessage("", _("Starting second chess program"));
11799           ScheduleDelayedEvent(TwoMachinesEventIfReady, FEATURE_TIMEOUT);
11800         }
11801         return;
11802     }
11803     DisplayMessage("", "");
11804     InitChessProgram(&second, FALSE);
11805     SendToProgram("force\n", &second);
11806     if (startedFromSetupPosition) {
11807         SendBoard(&second, backwardMostMove);
11808     if (appData.debugMode) {
11809         fprintf(debugFP, "Two Machines\n");
11810     }
11811     }
11812     for (i = backwardMostMove; i < forwardMostMove; i++) {
11813         SendMoveToProgram(i, &second);
11814     }
11815
11816     gameMode = TwoMachinesPlay;
11817     pausing = FALSE;
11818     ModeHighlight();
11819     SetGameInfo();
11820     DisplayTwoMachinesTitle();
11821     firstMove = TRUE;
11822     if ((first.twoMachinesColor[0] == 'w') == WhiteOnMove(forwardMostMove)) {
11823         onmove = &first;
11824     } else {
11825         onmove = &second;
11826     }
11827
11828     SendToProgram(first.computerString, &first);
11829     if (first.sendName) {
11830       sprintf(buf, "name %s\n", second.tidy);
11831       SendToProgram(buf, &first);
11832     }
11833     SendToProgram(second.computerString, &second);
11834     if (second.sendName) {
11835       sprintf(buf, "name %s\n", first.tidy);
11836       SendToProgram(buf, &second);
11837     }
11838
11839     ResetClocks();
11840     if (!first.sendTime || !second.sendTime) {
11841         timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
11842         timeRemaining[1][forwardMostMove] = blackTimeRemaining;
11843     }
11844     if (onmove->sendTime) {
11845       if (onmove->useColors) {
11846         SendToProgram(onmove->other->twoMachinesColor, onmove); /*gnu kludge*/
11847       }
11848       SendTimeRemaining(onmove, WhiteOnMove(forwardMostMove));
11849     }
11850     if (onmove->useColors) {
11851       SendToProgram(onmove->twoMachinesColor, onmove);
11852     }
11853     bookHit = SendMoveToBookUser(forwardMostMove-1, onmove, TRUE); // [HGM] book: send go or retrieve book move
11854 //    SendToProgram("go\n", onmove);
11855     onmove->maybeThinking = TRUE;
11856     SetMachineThinkingEnables();
11857
11858     StartClocks();
11859
11860     if(bookHit) { // [HGM] book: simulate book reply
11861         static char bookMove[MSG_SIZ]; // a bit generous?
11862
11863         programStats.nodes = programStats.depth = programStats.time =
11864         programStats.score = programStats.got_only_move = 0;
11865         sprintf(programStats.movelist, "%s (xbook)", bookHit);
11866
11867         strcpy(bookMove, "move ");
11868         strcat(bookMove, bookHit);
11869         savedMessage = bookMove; // args for deferred call
11870         savedState = onmove;
11871         ScheduleDelayedEvent(DeferredBookMove, 1);
11872     }
11873 }
11874
11875 void
11876 TrainingEvent()
11877 {
11878     if (gameMode == Training) {
11879       SetTrainingModeOff();
11880       gameMode = PlayFromGameFile;
11881       DisplayMessage("", _("Training mode off"));
11882     } else {
11883       gameMode = Training;
11884       animateTraining = appData.animate;
11885
11886       /* make sure we are not already at the end of the game */
11887       if (currentMove < forwardMostMove) {
11888         SetTrainingModeOn();
11889         DisplayMessage("", _("Training mode on"));
11890       } else {
11891         gameMode = PlayFromGameFile;
11892         DisplayError(_("Already at end of game"), 0);
11893       }
11894     }
11895     ModeHighlight();
11896 }
11897
11898 void
11899 IcsClientEvent()
11900 {
11901     if (!appData.icsActive) return;
11902     switch (gameMode) {
11903       case IcsPlayingWhite:
11904       case IcsPlayingBlack:
11905       case IcsObserving:
11906       case IcsIdle:
11907       case BeginningOfGame:
11908       case IcsExamining:
11909         return;
11910
11911       case EditGame:
11912         break;
11913
11914       case EditPosition:
11915         EditPositionDone(TRUE);
11916         break;
11917
11918       case AnalyzeMode:
11919       case AnalyzeFile:
11920         ExitAnalyzeMode();
11921         break;
11922
11923       default:
11924         EditGameEvent();
11925         break;
11926     }
11927
11928     gameMode = IcsIdle;
11929     ModeHighlight();
11930     return;
11931 }
11932
11933
11934 void
11935 EditGameEvent()
11936 {
11937     int i;
11938
11939     switch (gameMode) {
11940       case Training:
11941         SetTrainingModeOff();
11942         break;
11943       case MachinePlaysWhite:
11944       case MachinePlaysBlack:
11945       case BeginningOfGame:
11946         SendToProgram("force\n", &first);
11947         SetUserThinkingEnables();
11948         break;
11949       case PlayFromGameFile:
11950         (void) StopLoadGameTimer();
11951         if (gameFileFP != NULL) {
11952             gameFileFP = NULL;
11953         }
11954         break;
11955       case EditPosition:
11956         EditPositionDone(TRUE);
11957         break;
11958       case AnalyzeMode:
11959       case AnalyzeFile:
11960         ExitAnalyzeMode();
11961         SendToProgram("force\n", &first);
11962         break;
11963       case TwoMachinesPlay:
11964         GameEnds((ChessMove) 0, NULL, GE_PLAYER);
11965         ResurrectChessProgram();
11966         SetUserThinkingEnables();
11967         break;
11968       case EndOfGame:
11969         ResurrectChessProgram();
11970         break;
11971       case IcsPlayingBlack:
11972       case IcsPlayingWhite:
11973         DisplayError(_("Warning: You are still playing a game"), 0);
11974         break;
11975       case IcsObserving:
11976         DisplayError(_("Warning: You are still observing a game"), 0);
11977         break;
11978       case IcsExamining:
11979         DisplayError(_("Warning: You are still examining a game"), 0);
11980         break;
11981       case IcsIdle:
11982         break;
11983       case EditGame:
11984       default:
11985         return;
11986     }
11987
11988     pausing = FALSE;
11989     StopClocks();
11990     first.offeredDraw = second.offeredDraw = 0;
11991
11992     if (gameMode == PlayFromGameFile) {
11993         whiteTimeRemaining = timeRemaining[0][currentMove];
11994         blackTimeRemaining = timeRemaining[1][currentMove];
11995         DisplayTitle("");
11996     }
11997
11998     if (gameMode == MachinePlaysWhite ||
11999         gameMode == MachinePlaysBlack ||
12000         gameMode == TwoMachinesPlay ||
12001         gameMode == EndOfGame) {
12002         i = forwardMostMove;
12003         while (i > currentMove) {
12004             SendToProgram("undo\n", &first);
12005             i--;
12006         }
12007         whiteTimeRemaining = timeRemaining[0][currentMove];
12008         blackTimeRemaining = timeRemaining[1][currentMove];
12009         DisplayBothClocks();
12010         if (whiteFlag || blackFlag) {
12011             whiteFlag = blackFlag = 0;
12012         }
12013         DisplayTitle("");
12014     }
12015
12016     gameMode = EditGame;
12017     ModeHighlight();
12018     SetGameInfo();
12019 }
12020
12021
12022 void
12023 EditPositionEvent()
12024 {
12025     if (gameMode == EditPosition) {
12026         EditGameEvent();
12027         return;
12028     }
12029
12030     EditGameEvent();
12031     if (gameMode != EditGame) return;
12032
12033     gameMode = EditPosition;
12034     ModeHighlight();
12035     SetGameInfo();
12036     if (currentMove > 0)
12037       CopyBoard(boards[0], boards[currentMove]);
12038
12039     blackPlaysFirst = !WhiteOnMove(currentMove);
12040     ResetClocks();
12041     currentMove = forwardMostMove = backwardMostMove = 0;
12042     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
12043     DisplayMove(-1);
12044 }
12045
12046 void
12047 ExitAnalyzeMode()
12048 {
12049     /* [DM] icsEngineAnalyze - possible call from other functions */
12050     if (appData.icsEngineAnalyze) {
12051         appData.icsEngineAnalyze = FALSE;
12052
12053         DisplayMessage("",_("Close ICS engine analyze..."));
12054     }
12055     if (first.analysisSupport && first.analyzing) {
12056       SendToProgram("exit\n", &first);
12057       first.analyzing = FALSE;
12058     }
12059     thinkOutput[0] = NULLCHAR;
12060 }
12061
12062 void
12063 EditPositionDone(Boolean fakeRights)
12064 {
12065     int king = gameInfo.variant == VariantKnightmate ? WhiteUnicorn : WhiteKing;
12066
12067     startedFromSetupPosition = TRUE;
12068     InitChessProgram(&first, FALSE);
12069     if(fakeRights) { // [HGM] suppress this if we just pasted a FEN.
12070       boards[0][EP_STATUS] = EP_NONE;
12071       boards[0][CASTLING][2] = boards[0][CASTLING][5] = BOARD_WIDTH>>1;
12072     if(boards[0][0][BOARD_WIDTH>>1] == king) {
12073         boards[0][CASTLING][1] = boards[0][0][BOARD_LEFT] == WhiteRook ? 0 : NoRights;
12074         boards[0][CASTLING][0] = boards[0][0][BOARD_RGHT-1] == WhiteRook ? BOARD_RGHT-1 : NoRights;
12075       } else boards[0][CASTLING][2] = NoRights;
12076     if(boards[0][BOARD_HEIGHT-1][BOARD_WIDTH>>1] == WHITE_TO_BLACK king) {
12077         boards[0][CASTLING][4] = boards[0][BOARD_HEIGHT-1][BOARD_LEFT] == BlackRook ? 0 : NoRights;
12078         boards[0][CASTLING][3] = boards[0][BOARD_HEIGHT-1][BOARD_RGHT-1] == BlackRook ? BOARD_RGHT-1 : NoRights;
12079       } else boards[0][CASTLING][5] = NoRights;
12080     }
12081     SendToProgram("force\n", &first);
12082     if (blackPlaysFirst) {
12083         strcpy(moveList[0], "");
12084         strcpy(parseList[0], "");
12085         currentMove = forwardMostMove = backwardMostMove = 1;
12086         CopyBoard(boards[1], boards[0]);
12087     } else {
12088         currentMove = forwardMostMove = backwardMostMove = 0;
12089     }
12090     SendBoard(&first, forwardMostMove);
12091     if (appData.debugMode) {
12092         fprintf(debugFP, "EditPosDone\n");
12093     }
12094     DisplayTitle("");
12095     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
12096     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
12097     gameMode = EditGame;
12098     ModeHighlight();
12099     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
12100     ClearHighlights(); /* [AS] */
12101 }
12102
12103 /* Pause for `ms' milliseconds */
12104 /* !! Ugh, this is a kludge. Fix it sometime. --tpm */
12105 void
12106 TimeDelay(ms)
12107      long ms;
12108 {
12109     TimeMark m1, m2;
12110
12111     GetTimeMark(&m1);
12112     do {
12113         GetTimeMark(&m2);
12114     } while (SubtractTimeMarks(&m2, &m1) < ms);
12115 }
12116
12117 /* !! Ugh, this is a kludge. Fix it sometime. --tpm */
12118 void
12119 SendMultiLineToICS(buf)
12120      char *buf;
12121 {
12122     char temp[MSG_SIZ+1], *p;
12123     int len;
12124
12125     len = strlen(buf);
12126     if (len > MSG_SIZ)
12127       len = MSG_SIZ;
12128
12129     strncpy(temp, buf, len);
12130     temp[len] = 0;
12131
12132     p = temp;
12133     while (*p) {
12134         if (*p == '\n' || *p == '\r')
12135           *p = ' ';
12136         ++p;
12137     }
12138
12139     strcat(temp, "\n");
12140     SendToICS(temp);
12141     SendToPlayer(temp, strlen(temp));
12142 }
12143
12144 void
12145 SetWhiteToPlayEvent()
12146 {
12147     if (gameMode == EditPosition) {
12148         blackPlaysFirst = FALSE;
12149         DisplayBothClocks();    /* works because currentMove is 0 */
12150     } else if (gameMode == IcsExamining) {
12151         SendToICS(ics_prefix);
12152         SendToICS("tomove white\n");
12153     }
12154 }
12155
12156 void
12157 SetBlackToPlayEvent()
12158 {
12159     if (gameMode == EditPosition) {
12160         blackPlaysFirst = TRUE;
12161         currentMove = 1;        /* kludge */
12162         DisplayBothClocks();
12163         currentMove = 0;
12164     } else if (gameMode == IcsExamining) {
12165         SendToICS(ics_prefix);
12166         SendToICS("tomove black\n");
12167     }
12168 }
12169
12170 void
12171 EditPositionMenuEvent(selection, x, y)
12172      ChessSquare selection;
12173      int x, y;
12174 {
12175     char buf[MSG_SIZ];
12176     ChessSquare piece = boards[0][y][x];
12177
12178     if (gameMode != EditPosition && gameMode != IcsExamining) return;
12179
12180     switch (selection) {
12181       case ClearBoard:
12182         if (gameMode == IcsExamining && ics_type == ICS_FICS) {
12183             SendToICS(ics_prefix);
12184             SendToICS("bsetup clear\n");
12185         } else if (gameMode == IcsExamining && ics_type == ICS_ICC) {
12186             SendToICS(ics_prefix);
12187             SendToICS("clearboard\n");
12188         } else {
12189             for (x = 0; x < BOARD_WIDTH; x++) { ChessSquare p = EmptySquare;
12190                 if(x == BOARD_LEFT-1 || x == BOARD_RGHT) p = (ChessSquare) 0; /* [HGM] holdings */
12191                 for (y = 0; y < BOARD_HEIGHT; y++) {
12192                     if (gameMode == IcsExamining) {
12193                         if (boards[currentMove][y][x] != EmptySquare) {
12194                             sprintf(buf, "%sx@%c%c\n", ics_prefix,
12195                                     AAA + x, ONE + y);
12196                             SendToICS(buf);
12197                         }
12198                     } else {
12199                         boards[0][y][x] = p;
12200                     }
12201                 }
12202             }
12203         }
12204         if (gameMode == EditPosition) {
12205             DrawPosition(FALSE, boards[0]);
12206         }
12207         break;
12208
12209       case WhitePlay:
12210         SetWhiteToPlayEvent();
12211         break;
12212
12213       case BlackPlay:
12214         SetBlackToPlayEvent();
12215         break;
12216
12217       case EmptySquare:
12218         if (gameMode == IcsExamining) {
12219             if (x < BOARD_LEFT || x >= BOARD_RGHT) break; // [HGM] holdings
12220             sprintf(buf, "%sx@%c%c\n", ics_prefix, AAA + x, ONE + y);
12221             SendToICS(buf);
12222         } else {
12223             if(x < BOARD_LEFT || x >= BOARD_RGHT) {
12224                 if(x == BOARD_LEFT-2) {
12225                     if(y < BOARD_HEIGHT-1-gameInfo.holdingsSize) break;
12226                     boards[0][y][1] = 0;
12227                 } else
12228                 if(x == BOARD_RGHT+1) {
12229                     if(y >= gameInfo.holdingsSize) break;
12230                     boards[0][y][BOARD_WIDTH-2] = 0;
12231                 } else break;
12232             }
12233             boards[0][y][x] = EmptySquare;
12234             DrawPosition(FALSE, boards[0]);
12235         }
12236         break;
12237
12238       case PromotePiece:
12239         if(piece >= (int)WhitePawn && piece < (int)WhiteMan ||
12240            piece >= (int)BlackPawn && piece < (int)BlackMan   ) {
12241             selection = (ChessSquare) (PROMOTED piece);
12242         } else if(piece == EmptySquare) selection = WhiteSilver;
12243         else selection = (ChessSquare)((int)piece - 1);
12244         goto defaultlabel;
12245
12246       case DemotePiece:
12247         if(piece > (int)WhiteMan && piece <= (int)WhiteKing ||
12248            piece > (int)BlackMan && piece <= (int)BlackKing   ) {
12249             selection = (ChessSquare) (DEMOTED piece);
12250         } else if(piece == EmptySquare) selection = BlackSilver;
12251         else selection = (ChessSquare)((int)piece + 1);
12252         goto defaultlabel;
12253
12254       case WhiteQueen:
12255       case BlackQueen:
12256         if(gameInfo.variant == VariantShatranj ||
12257            gameInfo.variant == VariantXiangqi  ||
12258            gameInfo.variant == VariantCourier  ||
12259            gameInfo.variant == VariantMakruk     )
12260             selection = (ChessSquare)((int)selection - (int)WhiteQueen + (int)WhiteFerz);
12261         goto defaultlabel;
12262
12263       case WhiteKing:
12264       case BlackKing:
12265         if(gameInfo.variant == VariantXiangqi)
12266             selection = (ChessSquare)((int)selection - (int)WhiteKing + (int)WhiteWazir);
12267         if(gameInfo.variant == VariantKnightmate)
12268             selection = (ChessSquare)((int)selection - (int)WhiteKing + (int)WhiteUnicorn);
12269       default:
12270         defaultlabel:
12271         if (gameMode == IcsExamining) {
12272             if (x < BOARD_LEFT || x >= BOARD_RGHT) break; // [HGM] holdings
12273             sprintf(buf, "%s%c@%c%c\n", ics_prefix,
12274                     PieceToChar(selection), AAA + x, ONE + y);
12275             SendToICS(buf);
12276         } else {
12277             if(x < BOARD_LEFT || x >= BOARD_RGHT) {
12278                 int n;
12279                 if(x == BOARD_LEFT-2 && selection >= BlackPawn) {
12280                     n = PieceToNumber(selection - BlackPawn);
12281                     if(n >= gameInfo.holdingsSize) { n = 0; selection = BlackPawn; }
12282                     boards[0][BOARD_HEIGHT-1-n][0] = selection;
12283                     boards[0][BOARD_HEIGHT-1-n][1]++;
12284                 } else
12285                 if(x == BOARD_RGHT+1 && selection < BlackPawn) {
12286                     n = PieceToNumber(selection);
12287                     if(n >= gameInfo.holdingsSize) { n = 0; selection = WhitePawn; }
12288                     boards[0][n][BOARD_WIDTH-1] = selection;
12289                     boards[0][n][BOARD_WIDTH-2]++;
12290                 }
12291             } else
12292             boards[0][y][x] = selection;
12293             DrawPosition(TRUE, boards[0]);
12294         }
12295         break;
12296     }
12297 }
12298
12299
12300 void
12301 DropMenuEvent(selection, x, y)
12302      ChessSquare selection;
12303      int x, y;
12304 {
12305     ChessMove moveType;
12306
12307     switch (gameMode) {
12308       case IcsPlayingWhite:
12309       case MachinePlaysBlack:
12310         if (!WhiteOnMove(currentMove)) {
12311             DisplayMoveError(_("It is Black's turn"));
12312             return;
12313         }
12314         moveType = WhiteDrop;
12315         break;
12316       case IcsPlayingBlack:
12317       case MachinePlaysWhite:
12318         if (WhiteOnMove(currentMove)) {
12319             DisplayMoveError(_("It is White's turn"));
12320             return;
12321         }
12322         moveType = BlackDrop;
12323         break;
12324       case EditGame:
12325         moveType = WhiteOnMove(currentMove) ? WhiteDrop : BlackDrop;
12326         break;
12327       default:
12328         return;
12329     }
12330
12331     if (moveType == BlackDrop && selection < BlackPawn) {
12332       selection = (ChessSquare) ((int) selection
12333                                  + (int) BlackPawn - (int) WhitePawn);
12334     }
12335     if (boards[currentMove][y][x] != EmptySquare) {
12336         DisplayMoveError(_("That square is occupied"));
12337         return;
12338     }
12339
12340     FinishMove(moveType, (int) selection, DROP_RANK, x, y, NULLCHAR);
12341 }
12342
12343 void
12344 AcceptEvent()
12345 {
12346     /* Accept a pending offer of any kind from opponent */
12347
12348     if (appData.icsActive) {
12349         SendToICS(ics_prefix);
12350         SendToICS("accept\n");
12351     } else if (cmailMsgLoaded) {
12352         if (currentMove == cmailOldMove &&
12353             commentList[cmailOldMove] != NULL &&
12354             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
12355                    "Black offers a draw" : "White offers a draw")) {
12356             TruncateGame();
12357             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
12358             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_ACCEPT;
12359         } else {
12360             DisplayError(_("There is no pending offer on this move"), 0);
12361             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
12362         }
12363     } else {
12364         /* Not used for offers from chess program */
12365     }
12366 }
12367
12368 void
12369 DeclineEvent()
12370 {
12371     /* Decline a pending offer of any kind from opponent */
12372
12373     if (appData.icsActive) {
12374         SendToICS(ics_prefix);
12375         SendToICS("decline\n");
12376     } else if (cmailMsgLoaded) {
12377         if (currentMove == cmailOldMove &&
12378             commentList[cmailOldMove] != NULL &&
12379             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
12380                    "Black offers a draw" : "White offers a draw")) {
12381 #ifdef NOTDEF
12382             AppendComment(cmailOldMove, "Draw declined", TRUE);
12383             DisplayComment(cmailOldMove - 1, "Draw declined");
12384 #endif /*NOTDEF*/
12385         } else {
12386             DisplayError(_("There is no pending offer on this move"), 0);
12387         }
12388     } else {
12389         /* Not used for offers from chess program */
12390     }
12391 }
12392
12393 void
12394 RematchEvent()
12395 {
12396     /* Issue ICS rematch command */
12397     if (appData.icsActive) {
12398         SendToICS(ics_prefix);
12399         SendToICS("rematch\n");
12400     }
12401 }
12402
12403 void
12404 CallFlagEvent()
12405 {
12406     /* Call your opponent's flag (claim a win on time) */
12407     if (appData.icsActive) {
12408         SendToICS(ics_prefix);
12409         SendToICS("flag\n");
12410     } else {
12411         switch (gameMode) {
12412           default:
12413             return;
12414           case MachinePlaysWhite:
12415             if (whiteFlag) {
12416                 if (blackFlag)
12417                   GameEnds(GameIsDrawn, "Both players ran out of time",
12418                            GE_PLAYER);
12419                 else
12420                   GameEnds(BlackWins, "Black wins on time", GE_PLAYER);
12421             } else {
12422                 DisplayError(_("Your opponent is not out of time"), 0);
12423             }
12424             break;
12425           case MachinePlaysBlack:
12426             if (blackFlag) {
12427                 if (whiteFlag)
12428                   GameEnds(GameIsDrawn, "Both players ran out of time",
12429                            GE_PLAYER);
12430                 else
12431                   GameEnds(WhiteWins, "White wins on time", GE_PLAYER);
12432             } else {
12433                 DisplayError(_("Your opponent is not out of time"), 0);
12434             }
12435             break;
12436         }
12437     }
12438 }
12439
12440 void
12441 DrawEvent()
12442 {
12443     /* Offer draw or accept pending draw offer from opponent */
12444
12445     if (appData.icsActive) {
12446         /* Note: tournament rules require draw offers to be
12447            made after you make your move but before you punch
12448            your clock.  Currently ICS doesn't let you do that;
12449            instead, you immediately punch your clock after making
12450            a move, but you can offer a draw at any time. */
12451
12452         SendToICS(ics_prefix);
12453         SendToICS("draw\n");
12454         userOfferedDraw = TRUE; // [HGM] drawclaim: also set flag in ICS play
12455     } else if (cmailMsgLoaded) {
12456         if (currentMove == cmailOldMove &&
12457             commentList[cmailOldMove] != NULL &&
12458             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
12459                    "Black offers a draw" : "White offers a draw")) {
12460             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
12461             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_ACCEPT;
12462         } else if (currentMove == cmailOldMove + 1) {
12463             char *offer = WhiteOnMove(cmailOldMove) ?
12464               "White offers a draw" : "Black offers a draw";
12465             AppendComment(currentMove, offer, TRUE);
12466             DisplayComment(currentMove - 1, offer);
12467             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_DRAW;
12468         } else {
12469             DisplayError(_("You must make your move before offering a draw"), 0);
12470             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
12471         }
12472     } else if (first.offeredDraw) {
12473         GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
12474     } else {
12475         if (first.sendDrawOffers) {
12476             SendToProgram("draw\n", &first);
12477             userOfferedDraw = TRUE;
12478         }
12479     }
12480 }
12481
12482 void
12483 AdjournEvent()
12484 {
12485     /* Offer Adjourn or accept pending Adjourn offer from opponent */
12486
12487     if (appData.icsActive) {
12488         SendToICS(ics_prefix);
12489         SendToICS("adjourn\n");
12490     } else {
12491         /* Currently GNU Chess doesn't offer or accept Adjourns */
12492     }
12493 }
12494
12495
12496 void
12497 AbortEvent()
12498 {
12499     /* Offer Abort or accept pending Abort offer from opponent */
12500
12501     if (appData.icsActive) {
12502         SendToICS(ics_prefix);
12503         SendToICS("abort\n");
12504     } else {
12505         GameEnds(GameUnfinished, "Game aborted", GE_PLAYER);
12506     }
12507 }
12508
12509 void
12510 ResignEvent()
12511 {
12512     /* Resign.  You can do this even if it's not your turn. */
12513
12514     if (appData.icsActive) {
12515         SendToICS(ics_prefix);
12516         SendToICS("resign\n");
12517     } else {
12518         switch (gameMode) {
12519           case MachinePlaysWhite:
12520             GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
12521             break;
12522           case MachinePlaysBlack:
12523             GameEnds(BlackWins, "White resigns", GE_PLAYER);
12524             break;
12525           case EditGame:
12526             if (cmailMsgLoaded) {
12527                 TruncateGame();
12528                 if (WhiteOnMove(cmailOldMove)) {
12529                     GameEnds(BlackWins, "White resigns", GE_PLAYER);
12530                 } else {
12531                     GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
12532                 }
12533                 cmailMoveType[lastLoadGameNumber - 1] = CMAIL_RESIGN;
12534             }
12535             break;
12536           default:
12537             break;
12538         }
12539     }
12540 }
12541
12542
12543 void
12544 StopObservingEvent()
12545 {
12546     /* Stop observing current games */
12547     SendToICS(ics_prefix);
12548     SendToICS("unobserve\n");
12549 }
12550
12551 void
12552 StopExaminingEvent()
12553 {
12554     /* Stop observing current game */
12555     SendToICS(ics_prefix);
12556     SendToICS("unexamine\n");
12557 }
12558
12559 void
12560 ForwardInner(target)
12561      int target;
12562 {
12563     int limit;
12564
12565     if (appData.debugMode)
12566         fprintf(debugFP, "ForwardInner(%d), current %d, forward %d\n",
12567                 target, currentMove, forwardMostMove);
12568
12569     if (gameMode == EditPosition)
12570       return;
12571
12572     if (gameMode == PlayFromGameFile && !pausing)
12573       PauseEvent();
12574
12575     if (gameMode == IcsExamining && pausing)
12576       limit = pauseExamForwardMostMove;
12577     else
12578       limit = forwardMostMove;
12579
12580     if (target > limit) target = limit;
12581
12582     if (target > 0 && moveList[target - 1][0]) {
12583         int fromX, fromY, toX, toY;
12584         toX = moveList[target - 1][2] - AAA;
12585         toY = moveList[target - 1][3] - ONE;
12586         if (moveList[target - 1][1] == '@') {
12587             if (appData.highlightLastMove) {
12588                 SetHighlights(-1, -1, toX, toY);
12589             }
12590         } else {
12591             fromX = moveList[target - 1][0] - AAA;
12592             fromY = moveList[target - 1][1] - ONE;
12593             if (target == currentMove + 1) {
12594                 AnimateMove(boards[currentMove], fromX, fromY, toX, toY);
12595             }
12596             if (appData.highlightLastMove) {
12597                 SetHighlights(fromX, fromY, toX, toY);
12598             }
12599         }
12600     }
12601     if (gameMode == EditGame || gameMode == AnalyzeMode ||
12602         gameMode == Training || gameMode == PlayFromGameFile ||
12603         gameMode == AnalyzeFile) {
12604         while (currentMove < target) {
12605             SendMoveToProgram(currentMove++, &first);
12606         }
12607     } else {
12608         currentMove = target;
12609     }
12610
12611     if (gameMode == EditGame || gameMode == EndOfGame) {
12612         whiteTimeRemaining = timeRemaining[0][currentMove];
12613         blackTimeRemaining = timeRemaining[1][currentMove];
12614     }
12615     DisplayBothClocks();
12616     DisplayMove(currentMove - 1);
12617     DrawPosition(FALSE, boards[currentMove]);
12618     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
12619     if ( !matchMode && gameMode != Training) { // [HGM] PV info: routine tests if empty
12620         DisplayComment(currentMove - 1, commentList[currentMove]);
12621     }
12622 }
12623
12624
12625 void
12626 ForwardEvent()
12627 {
12628     if (gameMode == IcsExamining && !pausing) {
12629         SendToICS(ics_prefix);
12630         SendToICS("forward\n");
12631     } else {
12632         ForwardInner(currentMove + 1);
12633     }
12634 }
12635
12636 void
12637 ToEndEvent()
12638 {
12639     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
12640         /* to optimze, we temporarily turn off analysis mode while we feed
12641          * the remaining moves to the engine. Otherwise we get analysis output
12642          * after each move.
12643          */
12644         if (first.analysisSupport) {
12645           SendToProgram("exit\nforce\n", &first);
12646           first.analyzing = FALSE;
12647         }
12648     }
12649
12650     if (gameMode == IcsExamining && !pausing) {
12651         SendToICS(ics_prefix);
12652         SendToICS("forward 999999\n");
12653     } else {
12654         ForwardInner(forwardMostMove);
12655     }
12656
12657     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
12658         /* we have fed all the moves, so reactivate analysis mode */
12659         SendToProgram("analyze\n", &first);
12660         first.analyzing = TRUE;
12661         /*first.maybeThinking = TRUE;*/
12662         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
12663     }
12664 }
12665
12666 void
12667 BackwardInner(target)
12668      int target;
12669 {
12670     int full_redraw = TRUE; /* [AS] Was FALSE, had to change it! */
12671
12672     if (appData.debugMode)
12673         fprintf(debugFP, "BackwardInner(%d), current %d, forward %d\n",
12674                 target, currentMove, forwardMostMove);
12675
12676     if (gameMode == EditPosition) return;
12677     if (currentMove <= backwardMostMove) {
12678         ClearHighlights();
12679         DrawPosition(full_redraw, boards[currentMove]);
12680         return;
12681     }
12682     if (gameMode == PlayFromGameFile && !pausing)
12683       PauseEvent();
12684
12685     if (moveList[target][0]) {
12686         int fromX, fromY, toX, toY;
12687         toX = moveList[target][2] - AAA;
12688         toY = moveList[target][3] - ONE;
12689         if (moveList[target][1] == '@') {
12690             if (appData.highlightLastMove) {
12691                 SetHighlights(-1, -1, toX, toY);
12692             }
12693         } else {
12694             fromX = moveList[target][0] - AAA;
12695             fromY = moveList[target][1] - ONE;
12696             if (target == currentMove - 1) {
12697                 AnimateMove(boards[currentMove], toX, toY, fromX, fromY);
12698             }
12699             if (appData.highlightLastMove) {
12700                 SetHighlights(fromX, fromY, toX, toY);
12701             }
12702         }
12703     }
12704     if (gameMode == EditGame || gameMode==AnalyzeMode ||
12705         gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
12706         while (currentMove > target) {
12707             SendToProgram("undo\n", &first);
12708             currentMove--;
12709         }
12710     } else {
12711         currentMove = target;
12712     }
12713
12714     if (gameMode == EditGame || gameMode == EndOfGame) {
12715         whiteTimeRemaining = timeRemaining[0][currentMove];
12716         blackTimeRemaining = timeRemaining[1][currentMove];
12717     }
12718     DisplayBothClocks();
12719     DisplayMove(currentMove - 1);
12720     DrawPosition(full_redraw, boards[currentMove]);
12721     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
12722     // [HGM] PV info: routine tests if comment empty
12723     DisplayComment(currentMove - 1, commentList[currentMove]);
12724 }
12725
12726 void
12727 BackwardEvent()
12728 {
12729     if (gameMode == IcsExamining && !pausing) {
12730         SendToICS(ics_prefix);
12731         SendToICS("backward\n");
12732     } else {
12733         BackwardInner(currentMove - 1);
12734     }
12735 }
12736
12737 void
12738 ToStartEvent()
12739 {
12740     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
12741         /* to optimize, we temporarily turn off analysis mode while we undo
12742          * all the moves. Otherwise we get analysis output after each undo.
12743          */
12744         if (first.analysisSupport) {
12745           SendToProgram("exit\nforce\n", &first);
12746           first.analyzing = FALSE;
12747         }
12748     }
12749
12750     if (gameMode == IcsExamining && !pausing) {
12751         SendToICS(ics_prefix);
12752         SendToICS("backward 999999\n");
12753     } else {
12754         BackwardInner(backwardMostMove);
12755     }
12756
12757     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
12758         /* we have fed all the moves, so reactivate analysis mode */
12759         SendToProgram("analyze\n", &first);
12760         first.analyzing = TRUE;
12761         /*first.maybeThinking = TRUE;*/
12762         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
12763     }
12764 }
12765
12766 void
12767 ToNrEvent(int to)
12768 {
12769   if (gameMode == PlayFromGameFile && !pausing) PauseEvent();
12770   if (to >= forwardMostMove) to = forwardMostMove;
12771   if (to <= backwardMostMove) to = backwardMostMove;
12772   if (to < currentMove) {
12773     BackwardInner(to);
12774   } else {
12775     ForwardInner(to);
12776   }
12777 }
12778
12779 void
12780 RevertEvent(Boolean annotate)
12781 {
12782     if(PopTail(annotate)) { // [HGM] vari: restore old game tail
12783         return;
12784     }
12785     if (gameMode != IcsExamining) {
12786         DisplayError(_("You are not examining a game"), 0);
12787         return;
12788     }
12789     if (pausing) {
12790         DisplayError(_("You can't revert while pausing"), 0);
12791         return;
12792     }
12793     SendToICS(ics_prefix);
12794     SendToICS("revert\n");
12795 }
12796
12797 void
12798 RetractMoveEvent()
12799 {
12800     switch (gameMode) {
12801       case MachinePlaysWhite:
12802       case MachinePlaysBlack:
12803         if (WhiteOnMove(forwardMostMove) == (gameMode == MachinePlaysWhite)) {
12804             DisplayError(_("Wait until your turn,\nor select Move Now"), 0);
12805             return;
12806         }
12807         if (forwardMostMove < 2) return;
12808         currentMove = forwardMostMove = forwardMostMove - 2;
12809         whiteTimeRemaining = timeRemaining[0][currentMove];
12810         blackTimeRemaining = timeRemaining[1][currentMove];
12811         DisplayBothClocks();
12812         DisplayMove(currentMove - 1);
12813         ClearHighlights();/*!! could figure this out*/
12814         DrawPosition(TRUE, boards[currentMove]); /* [AS] Changed to full redraw! */
12815         SendToProgram("remove\n", &first);
12816         /*first.maybeThinking = TRUE;*/ /* GNU Chess does not ponder here */
12817         break;
12818
12819       case BeginningOfGame:
12820       default:
12821         break;
12822
12823       case IcsPlayingWhite:
12824       case IcsPlayingBlack:
12825         if (WhiteOnMove(forwardMostMove) == (gameMode == IcsPlayingWhite)) {
12826             SendToICS(ics_prefix);
12827             SendToICS("takeback 2\n");
12828         } else {
12829             SendToICS(ics_prefix);
12830             SendToICS("takeback 1\n");
12831         }
12832         break;
12833     }
12834 }
12835
12836 void
12837 MoveNowEvent()
12838 {
12839     ChessProgramState *cps;
12840
12841     switch (gameMode) {
12842       case MachinePlaysWhite:
12843         if (!WhiteOnMove(forwardMostMove)) {
12844             DisplayError(_("It is your turn"), 0);
12845             return;
12846         }
12847         cps = &first;
12848         break;
12849       case MachinePlaysBlack:
12850         if (WhiteOnMove(forwardMostMove)) {
12851             DisplayError(_("It is your turn"), 0);
12852             return;
12853         }
12854         cps = &first;
12855         break;
12856       case TwoMachinesPlay:
12857         if (WhiteOnMove(forwardMostMove) ==
12858             (first.twoMachinesColor[0] == 'w')) {
12859             cps = &first;
12860         } else {
12861             cps = &second;
12862         }
12863         break;
12864       case BeginningOfGame:
12865       default:
12866         return;
12867     }
12868     SendToProgram("?\n", cps);
12869 }
12870
12871 void
12872 TruncateGameEvent()
12873 {
12874     EditGameEvent();
12875     if (gameMode != EditGame) return;
12876     TruncateGame();
12877 }
12878
12879 void
12880 TruncateGame()
12881 {
12882     CleanupTail(); // [HGM] vari: only keep current variation if we explicitly truncate
12883     if (forwardMostMove > currentMove) {
12884         if (gameInfo.resultDetails != NULL) {
12885             free(gameInfo.resultDetails);
12886             gameInfo.resultDetails = NULL;
12887             gameInfo.result = GameUnfinished;
12888         }
12889         forwardMostMove = currentMove;
12890         HistorySet(parseList, backwardMostMove, forwardMostMove,
12891                    currentMove-1);
12892     }
12893 }
12894
12895 void
12896 HintEvent()
12897 {
12898     if (appData.noChessProgram) return;
12899     switch (gameMode) {
12900       case MachinePlaysWhite:
12901         if (WhiteOnMove(forwardMostMove)) {
12902             DisplayError(_("Wait until your turn"), 0);
12903             return;
12904         }
12905         break;
12906       case BeginningOfGame:
12907       case MachinePlaysBlack:
12908         if (!WhiteOnMove(forwardMostMove)) {
12909             DisplayError(_("Wait until your turn"), 0);
12910             return;
12911         }
12912         break;
12913       default:
12914         DisplayError(_("No hint available"), 0);
12915         return;
12916     }
12917     SendToProgram("hint\n", &first);
12918     hintRequested = TRUE;
12919 }
12920
12921 void
12922 BookEvent()
12923 {
12924     if (appData.noChessProgram) return;
12925     switch (gameMode) {
12926       case MachinePlaysWhite:
12927         if (WhiteOnMove(forwardMostMove)) {
12928             DisplayError(_("Wait until your turn"), 0);
12929             return;
12930         }
12931         break;
12932       case BeginningOfGame:
12933       case MachinePlaysBlack:
12934         if (!WhiteOnMove(forwardMostMove)) {
12935             DisplayError(_("Wait until your turn"), 0);
12936             return;
12937         }
12938         break;
12939       case EditPosition:
12940         EditPositionDone(TRUE);
12941         break;
12942       case TwoMachinesPlay:
12943         return;
12944       default:
12945         break;
12946     }
12947     SendToProgram("bk\n", &first);
12948     bookOutput[0] = NULLCHAR;
12949     bookRequested = TRUE;
12950 }
12951
12952 void
12953 AboutGameEvent()
12954 {
12955     char *tags = PGNTags(&gameInfo);
12956     TagsPopUp(tags, CmailMsg());
12957     free(tags);
12958 }
12959
12960 /* end button procedures */
12961
12962 void
12963 PrintPosition(fp, move)
12964      FILE *fp;
12965      int move;
12966 {
12967     int i, j;
12968
12969     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
12970         for (j = BOARD_LEFT; j < BOARD_RGHT; j++) {
12971             char c = PieceToChar(boards[move][i][j]);
12972             fputc(c == 'x' ? '.' : c, fp);
12973             fputc(j == BOARD_RGHT - 1 ? '\n' : ' ', fp);
12974         }
12975     }
12976     if ((gameMode == EditPosition) ? !blackPlaysFirst : (move % 2 == 0))
12977       fprintf(fp, "white to play\n");
12978     else
12979       fprintf(fp, "black to play\n");
12980 }
12981
12982 void
12983 PrintOpponents(fp)
12984      FILE *fp;
12985 {
12986     if (gameInfo.white != NULL) {
12987         fprintf(fp, "\t%s vs. %s\n", gameInfo.white, gameInfo.black);
12988     } else {
12989         fprintf(fp, "\n");
12990     }
12991 }
12992
12993 /* Find last component of program's own name, using some heuristics */
12994 void
12995 TidyProgramName(prog, host, buf)
12996      char *prog, *host, buf[MSG_SIZ];
12997 {
12998     char *p, *q;
12999     int local = (strcmp(host, "localhost") == 0);
13000     while (!local && (p = strchr(prog, ';')) != NULL) {
13001         p++;
13002         while (*p == ' ') p++;
13003         prog = p;
13004     }
13005     if (*prog == '"' || *prog == '\'') {
13006         q = strchr(prog + 1, *prog);
13007     } else {
13008         q = strchr(prog, ' ');
13009     }
13010     if (q == NULL) q = prog + strlen(prog);
13011     p = q;
13012     while (p >= prog && *p != '/' && *p != '\\') p--;
13013     p++;
13014     if(p == prog && *p == '"') p++;
13015     if (q - p >= 4 && StrCaseCmp(q - 4, ".exe") == 0) q -= 4;
13016     memcpy(buf, p, q - p);
13017     buf[q - p] = NULLCHAR;
13018     if (!local) {
13019         strcat(buf, "@");
13020         strcat(buf, host);
13021     }
13022 }
13023
13024 char *
13025 TimeControlTagValue()
13026 {
13027     char buf[MSG_SIZ];
13028     if (!appData.clockMode) {
13029         strcpy(buf, "-");
13030     } else if (movesPerSession > 0) {
13031         sprintf(buf, "%d/%ld", movesPerSession, timeControl/1000);
13032     } else if (timeIncrement == 0) {
13033         sprintf(buf, "%ld", timeControl/1000);
13034     } else {
13035         sprintf(buf, "%ld+%ld", timeControl/1000, timeIncrement/1000);
13036     }
13037     return StrSave(buf);
13038 }
13039
13040 void
13041 SetGameInfo()
13042 {
13043     /* This routine is used only for certain modes */
13044     VariantClass v = gameInfo.variant;
13045     ChessMove r = GameUnfinished;
13046     char *p = NULL;
13047
13048     if(gameMode == EditGame) { // [HGM] vari: do not erase result on EditGame
13049         r = gameInfo.result;
13050         p = gameInfo.resultDetails;
13051         gameInfo.resultDetails = NULL;
13052     }
13053     ClearGameInfo(&gameInfo);
13054     gameInfo.variant = v;
13055
13056     switch (gameMode) {
13057       case MachinePlaysWhite:
13058         gameInfo.event = StrSave( appData.pgnEventHeader );
13059         gameInfo.site = StrSave(HostName());
13060         gameInfo.date = PGNDate();
13061         gameInfo.round = StrSave("-");
13062         gameInfo.white = StrSave(first.tidy);
13063         gameInfo.black = StrSave(UserName());
13064         gameInfo.timeControl = TimeControlTagValue();
13065         break;
13066
13067       case MachinePlaysBlack:
13068         gameInfo.event = StrSave( appData.pgnEventHeader );
13069         gameInfo.site = StrSave(HostName());
13070         gameInfo.date = PGNDate();
13071         gameInfo.round = StrSave("-");
13072         gameInfo.white = StrSave(UserName());
13073         gameInfo.black = StrSave(first.tidy);
13074         gameInfo.timeControl = TimeControlTagValue();
13075         break;
13076
13077       case TwoMachinesPlay:
13078         gameInfo.event = StrSave( appData.pgnEventHeader );
13079         gameInfo.site = StrSave(HostName());
13080         gameInfo.date = PGNDate();
13081         if (matchGame > 0) {
13082             char buf[MSG_SIZ];
13083             sprintf(buf, "%d", matchGame);
13084             gameInfo.round = StrSave(buf);
13085         } else {
13086             gameInfo.round = StrSave("-");
13087         }
13088         if (first.twoMachinesColor[0] == 'w') {
13089             gameInfo.white = StrSave(first.tidy);
13090             gameInfo.black = StrSave(second.tidy);
13091         } else {
13092             gameInfo.white = StrSave(second.tidy);
13093             gameInfo.black = StrSave(first.tidy);
13094         }
13095         gameInfo.timeControl = TimeControlTagValue();
13096         break;
13097
13098       case EditGame:
13099         gameInfo.event = StrSave("Edited game");
13100         gameInfo.site = StrSave(HostName());
13101         gameInfo.date = PGNDate();
13102         gameInfo.round = StrSave("-");
13103         gameInfo.white = StrSave("-");
13104         gameInfo.black = StrSave("-");
13105         gameInfo.result = r;
13106         gameInfo.resultDetails = p;
13107         break;
13108
13109       case EditPosition:
13110         gameInfo.event = StrSave("Edited position");
13111         gameInfo.site = StrSave(HostName());
13112         gameInfo.date = PGNDate();
13113         gameInfo.round = StrSave("-");
13114         gameInfo.white = StrSave("-");
13115         gameInfo.black = StrSave("-");
13116         break;
13117
13118       case IcsPlayingWhite:
13119       case IcsPlayingBlack:
13120       case IcsObserving:
13121       case IcsExamining:
13122         break;
13123
13124       case PlayFromGameFile:
13125         gameInfo.event = StrSave("Game from non-PGN file");
13126         gameInfo.site = StrSave(HostName());
13127         gameInfo.date = PGNDate();
13128         gameInfo.round = StrSave("-");
13129         gameInfo.white = StrSave("?");
13130         gameInfo.black = StrSave("?");
13131         break;
13132
13133       default:
13134         break;
13135     }
13136 }
13137
13138 void
13139 ReplaceComment(index, text)
13140      int index;
13141      char *text;
13142 {
13143     int len;
13144
13145     while (*text == '\n') text++;
13146     len = strlen(text);
13147     while (len > 0 && text[len - 1] == '\n') len--;
13148
13149     if (commentList[index] != NULL)
13150       free(commentList[index]);
13151
13152     if (len == 0) {
13153         commentList[index] = NULL;
13154         return;
13155     }
13156   if( *text == '{' && strchr(text, '}') || // [HGM] braces: if certainy malformed, put braces
13157       *text == '[' && strchr(text, ']') || // otherwise hope the user knows what he is doing
13158       *text == '(' && strchr(text, ')')) { // (perhaps check if this parses as comment-only?)
13159     commentList[index] = (char *) malloc(len + 2);
13160     strncpy(commentList[index], text, len);
13161     commentList[index][len] = '\n';
13162     commentList[index][len + 1] = NULLCHAR;
13163   } else {
13164     // [HGM] braces: if text does not start with known OK delimiter, put braces around it.
13165     char *p;
13166     commentList[index] = (char *) malloc(len + 6);
13167     strcpy(commentList[index], "{\n");
13168     strncpy(commentList[index]+2, text, len);
13169     commentList[index][len+2] = NULLCHAR;
13170     while(p = strchr(commentList[index], '}')) *p = ')'; // kill all } to make it one comment
13171     strcat(commentList[index], "\n}\n");
13172   }
13173 }
13174
13175 void
13176 CrushCRs(text)
13177      char *text;
13178 {
13179   char *p = text;
13180   char *q = text;
13181   char ch;
13182
13183   do {
13184     ch = *p++;
13185     if (ch == '\r') continue;
13186     *q++ = ch;
13187   } while (ch != '\0');
13188 }
13189
13190 void
13191 AppendComment(index, text, addBraces)
13192      int index;
13193      char *text;
13194      Boolean addBraces; // [HGM] braces: tells if we should add {}
13195 {
13196     int oldlen, len;
13197     char *old;
13198
13199 if(appData.debugMode) fprintf(debugFP, "Append: in='%s' %d\n", text, addBraces); fflush(debugFP);
13200     text = GetInfoFromComment( index, text ); /* [HGM] PV time: strip PV info from comment */
13201
13202     CrushCRs(text);
13203     while (*text == '\n') text++;
13204     len = strlen(text);
13205     while (len > 0 && text[len - 1] == '\n') len--;
13206
13207     if (len == 0) return;
13208
13209     if (commentList[index] != NULL) {
13210         old = commentList[index];
13211         oldlen = strlen(old);
13212         while(commentList[index][oldlen-1] ==  '\n')
13213           commentList[index][--oldlen] = NULLCHAR;
13214         commentList[index] = (char *) malloc(oldlen + len + 6); // might waste 4
13215         strcpy(commentList[index], old);
13216         free(old);
13217         // [HGM] braces: join "{A\n}\n" + "{\nB}" as "{A\nB\n}"
13218         if(commentList[index][oldlen-1] == '}' && (text[0] == '{' || addBraces)) {
13219           if(addBraces) addBraces = FALSE; else { text++; len--; }
13220           while (*text == '\n') { text++; len--; }
13221           commentList[index][--oldlen] = NULLCHAR;
13222       }
13223         if(addBraces) strcat(commentList[index], "\n{\n");
13224         else          strcat(commentList[index], "\n");
13225         strcat(commentList[index], text);
13226         if(addBraces) strcat(commentList[index], "\n}\n");
13227         else          strcat(commentList[index], "\n");
13228     } else {
13229         commentList[index] = (char *) malloc(len + 6); // perhaps wastes 4...
13230         if(addBraces)
13231              strcpy(commentList[index], "{\n");
13232         else commentList[index][0] = NULLCHAR;
13233         strcat(commentList[index], text);
13234         strcat(commentList[index], "\n");
13235         if(addBraces) strcat(commentList[index], "}\n");
13236     }
13237 }
13238
13239 static char * FindStr( char * text, char * sub_text )
13240 {
13241     char * result = strstr( text, sub_text );
13242
13243     if( result != NULL ) {
13244         result += strlen( sub_text );
13245     }
13246
13247     return result;
13248 }
13249
13250 /* [AS] Try to extract PV info from PGN comment */
13251 /* [HGM] PV time: and then remove it, to prevent it appearing twice */
13252 char *GetInfoFromComment( int index, char * text )
13253 {
13254     char * sep = text;
13255
13256     if( text != NULL && index > 0 ) {
13257         int score = 0;
13258         int depth = 0;
13259         int time = -1, sec = 0, deci;
13260         char * s_eval = FindStr( text, "[%eval " );
13261         char * s_emt = FindStr( text, "[%emt " );
13262
13263         if( s_eval != NULL || s_emt != NULL ) {
13264             /* New style */
13265             char delim;
13266
13267             if( s_eval != NULL ) {
13268                 if( sscanf( s_eval, "%d,%d%c", &score, &depth, &delim ) != 3 ) {
13269                     return text;
13270                 }
13271
13272                 if( delim != ']' ) {
13273                     return text;
13274                 }
13275             }
13276
13277             if( s_emt != NULL ) {
13278             }
13279                 return text;
13280         }
13281         else {
13282             /* We expect something like: [+|-]nnn.nn/dd */
13283             int score_lo = 0;
13284
13285             if(*text != '{') return text; // [HGM] braces: must be normal comment
13286
13287             sep = strchr( text, '/' );
13288             if( sep == NULL || sep < (text+4) ) {
13289                 return text;
13290             }
13291
13292             time = -1; sec = -1; deci = -1;
13293             if( sscanf( text+1, "%d.%d/%d %d:%d", &score, &score_lo, &depth, &time, &sec ) != 5 &&
13294                 sscanf( text+1, "%d.%d/%d %d.%d", &score, &score_lo, &depth, &time, &deci ) != 5 &&
13295                 sscanf( text+1, "%d.%d/%d %d", &score, &score_lo, &depth, &time ) != 4 &&
13296                 sscanf( text+1, "%d.%d/%d", &score, &score_lo, &depth ) != 3   ) {
13297                 return text;
13298             }
13299
13300             if( score_lo < 0 || score_lo >= 100 ) {
13301                 return text;
13302             }
13303
13304             if(sec >= 0) time = 600*time + 10*sec; else
13305             if(deci >= 0) time = 10*time + deci; else time *= 10; // deci-sec
13306
13307             score = score >= 0 ? score*100 + score_lo : score*100 - score_lo;
13308
13309             /* [HGM] PV time: now locate end of PV info */
13310             while( *++sep >= '0' && *sep <= '9'); // strip depth
13311             if(time >= 0)
13312             while( *++sep >= '0' && *sep <= '9'); // strip time
13313             if(sec >= 0)
13314             while( *++sep >= '0' && *sep <= '9'); // strip seconds
13315             if(deci >= 0)
13316             while( *++sep >= '0' && *sep <= '9'); // strip fractional seconds
13317             while(*sep == ' ') sep++;
13318         }
13319
13320         if( depth <= 0 ) {
13321             return text;
13322         }
13323
13324         if( time < 0 ) {
13325             time = -1;
13326         }
13327
13328         pvInfoList[index-1].depth = depth;
13329         pvInfoList[index-1].score = score;
13330         pvInfoList[index-1].time  = 10*time; // centi-sec
13331         if(*sep == '}') *sep = 0; else *--sep = '{';
13332     }
13333     return sep;
13334 }
13335
13336 void
13337 SendToProgram(message, cps)
13338      char *message;
13339      ChessProgramState *cps;
13340 {
13341     int count, outCount, error;
13342     char buf[MSG_SIZ];
13343
13344     if (cps->pr == NULL) return;
13345     Attention(cps);
13346
13347     if (appData.debugMode) {
13348         TimeMark now;
13349         GetTimeMark(&now);
13350         fprintf(debugFP, "%ld >%-6s: %s",
13351                 SubtractTimeMarks(&now, &programStartTime),
13352                 cps->which, message);
13353     }
13354
13355     count = strlen(message);
13356     outCount = OutputToProcess(cps->pr, message, count, &error);
13357     if (outCount < count && !exiting
13358                          && !endingGame) { /* [HGM] crash: to not hang GameEnds() writing to deceased engines */
13359         sprintf(buf, _("Error writing to %s chess program"), cps->which);
13360         if(gameInfo.resultDetails==NULL) { /* [HGM] crash: if game in progress, give reason for abort */
13361             if((signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
13362                 gameInfo.result = GameIsDrawn; /* [HGM] accept exit as draw claim */
13363                 sprintf(buf, "%s program exits in draw position (%s)", cps->which, cps->program);
13364             } else {
13365                 gameInfo.result = cps->twoMachinesColor[0]=='w' ? BlackWins : WhiteWins;
13366             }
13367             gameInfo.resultDetails = StrSave(buf);
13368         }
13369         if(!cps->userError || !appData.popupExitMessage) DisplayFatalError(buf, error, 1); else errorExitStatus = 1;
13370     }
13371 }
13372
13373 void
13374 ReceiveFromProgram(isr, closure, message, count, error)
13375      InputSourceRef isr;
13376      VOIDSTAR closure;
13377      char *message;
13378      int count;
13379      int error;
13380 {
13381     char *end_str;
13382     char buf[MSG_SIZ];
13383     ChessProgramState *cps = (ChessProgramState *)closure;
13384
13385     if (isr != cps->isr) return; /* Killed intentionally */
13386     if (count <= 0) {
13387         if (count == 0) {
13388             sprintf(buf,
13389                     _("Error: %s chess program (%s) exited unexpectedly"),
13390                     cps->which, cps->program);
13391         if(gameInfo.resultDetails==NULL) { /* [HGM] crash: if game in progress, give reason for abort */
13392                 if((signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
13393                     gameInfo.result = GameIsDrawn; /* [HGM] accept exit as draw claim */
13394                     sprintf(buf, _("%s program exits in draw position (%s)"), cps->which, cps->program);
13395                 } else {
13396                     gameInfo.result = cps->twoMachinesColor[0]=='w' ? BlackWins : WhiteWins;
13397                 }
13398                 gameInfo.resultDetails = StrSave(buf);
13399             }
13400             RemoveInputSource(cps->isr);
13401             if(!cps->userError || !appData.popupExitMessage) DisplayFatalError(buf, 0, 1); else errorExitStatus = 1;
13402         } else {
13403             sprintf(buf,
13404                     _("Error reading from %s chess program (%s)"),
13405                     cps->which, cps->program);
13406             RemoveInputSource(cps->isr);
13407
13408             /* [AS] Program is misbehaving badly... kill it */
13409             if( count == -2 ) {
13410                 DestroyChildProcess( cps->pr, 9 );
13411                 cps->pr = NoProc;
13412             }
13413
13414             if(!cps->userError || !appData.popupExitMessage) DisplayFatalError(buf, error, 1); else errorExitStatus = 1;
13415         }
13416         return;
13417     }
13418
13419     if ((end_str = strchr(message, '\r')) != NULL)
13420       *end_str = NULLCHAR;
13421     if ((end_str = strchr(message, '\n')) != NULL)
13422       *end_str = NULLCHAR;
13423
13424     if (appData.debugMode) {
13425         TimeMark now; int print = 1;
13426         char *quote = ""; char c; int i;
13427
13428         if(appData.engineComments != 1) { /* [HGM] debug: decide if protocol-violating output is written */
13429                 char start = message[0];
13430                 if(start >='A' && start <= 'Z') start += 'a' - 'A'; // be tolerant to capitalizing
13431                 if(sscanf(message, "%d%c%d%d%d", &i, &c, &i, &i, &i) != 5 &&
13432                    sscanf(message, "move %c", &c)!=1  && sscanf(message, "offer%c", &c)!=1 &&
13433                    sscanf(message, "resign%c", &c)!=1 && sscanf(message, "feature %c", &c)!=1 &&
13434                    sscanf(message, "error %c", &c)!=1 && sscanf(message, "illegal %c", &c)!=1 &&
13435                    sscanf(message, "tell%c", &c)!=1   && sscanf(message, "0-1 %c", &c)!=1 &&
13436                    sscanf(message, "1-0 %c", &c)!=1   && sscanf(message, "1/2-1/2 %c", &c)!=1 &&
13437                    sscanf(message, "pong %c", &c)!=1   && start != '#') {
13438                     quote = appData.engineComments == 2 ? "# " : "### NON-COMPLIANT! ### ";
13439                     print = (appData.engineComments >= 2);
13440                 }
13441                 message[0] = start; // restore original message
13442         }
13443         if(print) {
13444                 GetTimeMark(&now);
13445                 fprintf(debugFP, "%ld <%-6s: %s%s\n",
13446                         SubtractTimeMarks(&now, &programStartTime), cps->which,
13447                         quote,
13448                         message);
13449         }
13450     }
13451
13452     /* [DM] if icsEngineAnalyze is active we block all whisper and kibitz output, because nobody want to see this */
13453     if (appData.icsEngineAnalyze) {
13454         if (strstr(message, "whisper") != NULL ||
13455              strstr(message, "kibitz") != NULL ||
13456             strstr(message, "tellics") != NULL) return;
13457     }
13458
13459     HandleMachineMove(message, cps);
13460 }
13461
13462
13463 void
13464 SendTimeControl(cps, mps, tc, inc, sd, st)
13465      ChessProgramState *cps;
13466      int mps, inc, sd, st;
13467      long tc;
13468 {
13469     char buf[MSG_SIZ];
13470     int seconds;
13471
13472     if( timeControl_2 > 0 ) {
13473         if( (gameMode == MachinePlaysBlack) || (gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b') ) {
13474             tc = timeControl_2;
13475         }
13476     }
13477     tc  /= cps->timeOdds; /* [HGM] time odds: apply before telling engine */
13478     inc /= cps->timeOdds;
13479     st  /= cps->timeOdds;
13480
13481     seconds = (tc / 1000) % 60; /* [HGM] displaced to after applying odds */
13482
13483     if (st > 0) {
13484       /* Set exact time per move, normally using st command */
13485       if (cps->stKludge) {
13486         /* GNU Chess 4 has no st command; uses level in a nonstandard way */
13487         seconds = st % 60;
13488         if (seconds == 0) {
13489           sprintf(buf, "level 1 %d\n", st/60);
13490         } else {
13491           sprintf(buf, "level 1 %d:%02d\n", st/60, seconds);
13492         }
13493       } else {
13494         sprintf(buf, "st %d\n", st);
13495       }
13496     } else {
13497       /* Set conventional or incremental time control, using level command */
13498       if (seconds == 0) {
13499         /* Note old gnuchess bug -- minutes:seconds used to not work.
13500            Fixed in later versions, but still avoid :seconds
13501            when seconds is 0. */
13502         sprintf(buf, "level %d %ld %d\n", mps, tc/60000, inc/1000);
13503       } else {
13504         sprintf(buf, "level %d %ld:%02d %d\n", mps, tc/60000,
13505                 seconds, inc/1000);
13506       }
13507     }
13508     SendToProgram(buf, cps);
13509
13510     /* Orthoganally (except for GNU Chess 4), limit time to st seconds */
13511     /* Orthogonally, limit search to given depth */
13512     if (sd > 0) {
13513       if (cps->sdKludge) {
13514         sprintf(buf, "depth\n%d\n", sd);
13515       } else {
13516         sprintf(buf, "sd %d\n", sd);
13517       }
13518       SendToProgram(buf, cps);
13519     }
13520
13521     if(cps->nps > 0) { /* [HGM] nps */
13522         if(cps->supportsNPS == FALSE) cps->nps = -1; // don't use if engine explicitly says not supported!
13523         else {
13524                 sprintf(buf, "nps %d\n", cps->nps);
13525               SendToProgram(buf, cps);
13526         }
13527     }
13528 }
13529
13530 ChessProgramState *WhitePlayer()
13531 /* [HGM] return pointer to 'first' or 'second', depending on who plays white */
13532 {
13533     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b' ||
13534        gameMode == BeginningOfGame || gameMode == MachinePlaysBlack)
13535         return &second;
13536     return &first;
13537 }
13538
13539 void
13540 SendTimeRemaining(cps, machineWhite)
13541      ChessProgramState *cps;
13542      int /*boolean*/ machineWhite;
13543 {
13544     char message[MSG_SIZ];
13545     long time, otime;
13546
13547     /* Note: this routine must be called when the clocks are stopped
13548        or when they have *just* been set or switched; otherwise
13549        it will be off by the time since the current tick started.
13550     */
13551     if (machineWhite) {
13552         time = whiteTimeRemaining / 10;
13553         otime = blackTimeRemaining / 10;
13554     } else {
13555         time = blackTimeRemaining / 10;
13556         otime = whiteTimeRemaining / 10;
13557     }
13558     /* [HGM] translate opponent's time by time-odds factor */
13559     otime = (otime * cps->other->timeOdds) / cps->timeOdds;
13560     if (appData.debugMode) {
13561         fprintf(debugFP, "time odds: %f %f \n", cps->timeOdds, cps->other->timeOdds);
13562     }
13563
13564     if (time <= 0) time = 1;
13565     if (otime <= 0) otime = 1;
13566
13567     sprintf(message, "time %ld\n", time);
13568     SendToProgram(message, cps);
13569
13570     sprintf(message, "otim %ld\n", otime);
13571     SendToProgram(message, cps);
13572 }
13573
13574 int
13575 BoolFeature(p, name, loc, cps)
13576      char **p;
13577      char *name;
13578      int *loc;
13579      ChessProgramState *cps;
13580 {
13581   char buf[MSG_SIZ];
13582   int len = strlen(name);
13583   int val;
13584   if (strncmp((*p), name, len) == 0 && (*p)[len] == '=') {
13585     (*p) += len + 1;
13586     sscanf(*p, "%d", &val);
13587     *loc = (val != 0);
13588     while (**p && **p != ' ') (*p)++;
13589     sprintf(buf, "accepted %s\n", name);
13590     SendToProgram(buf, cps);
13591     return TRUE;
13592   }
13593   return FALSE;
13594 }
13595
13596 int
13597 IntFeature(p, name, loc, cps)
13598      char **p;
13599      char *name;
13600      int *loc;
13601      ChessProgramState *cps;
13602 {
13603   char buf[MSG_SIZ];
13604   int len = strlen(name);
13605   if (strncmp((*p), name, len) == 0 && (*p)[len] == '=') {
13606     (*p) += len + 1;
13607     sscanf(*p, "%d", loc);
13608     while (**p && **p != ' ') (*p)++;
13609     sprintf(buf, "accepted %s\n", name);
13610     SendToProgram(buf, cps);
13611     return TRUE;
13612   }
13613   return FALSE;
13614 }
13615
13616 int
13617 StringFeature(p, name, loc, cps)
13618      char **p;
13619      char *name;
13620      char loc[];
13621      ChessProgramState *cps;
13622 {
13623   char buf[MSG_SIZ];
13624   int len = strlen(name);
13625   if (strncmp((*p), name, len) == 0
13626       && (*p)[len] == '=' && (*p)[len+1] == '\"') {
13627     (*p) += len + 2;
13628     sscanf(*p, "%[^\"]", loc);
13629     while (**p && **p != '\"') (*p)++;
13630     if (**p == '\"') (*p)++;
13631     sprintf(buf, "accepted %s\n", name);
13632     SendToProgram(buf, cps);
13633     return TRUE;
13634   }
13635   return FALSE;
13636 }
13637
13638 int
13639 ParseOption(Option *opt, ChessProgramState *cps)
13640 // [HGM] options: process the string that defines an engine option, and determine
13641 // name, type, default value, and allowed value range
13642 {
13643         char *p, *q, buf[MSG_SIZ];
13644         int n, min = (-1)<<31, max = 1<<31, def;
13645
13646         if(p = strstr(opt->name, " -spin ")) {
13647             if((n = sscanf(p, " -spin %d %d %d", &def, &min, &max)) < 3 ) return FALSE;
13648             if(max < min) max = min; // enforce consistency
13649             if(def < min) def = min;
13650             if(def > max) def = max;
13651             opt->value = def;
13652             opt->min = min;
13653             opt->max = max;
13654             opt->type = Spin;
13655         } else if((p = strstr(opt->name, " -slider "))) {
13656             // for now -slider is a synonym for -spin, to already provide compatibility with future polyglots
13657             if((n = sscanf(p, " -slider %d %d %d", &def, &min, &max)) < 3 ) return FALSE;
13658             if(max < min) max = min; // enforce consistency
13659             if(def < min) def = min;
13660             if(def > max) def = max;
13661             opt->value = def;
13662             opt->min = min;
13663             opt->max = max;
13664             opt->type = Spin; // Slider;
13665         } else if((p = strstr(opt->name, " -string "))) {
13666             opt->textValue = p+9;
13667             opt->type = TextBox;
13668         } else if((p = strstr(opt->name, " -file "))) {
13669             // for now -file is a synonym for -string, to already provide compatibility with future polyglots
13670             opt->textValue = p+7;
13671             opt->type = TextBox; // FileName;
13672         } else if((p = strstr(opt->name, " -path "))) {
13673             // for now -file is a synonym for -string, to already provide compatibility with future polyglots
13674             opt->textValue = p+7;
13675             opt->type = TextBox; // PathName;
13676         } else if(p = strstr(opt->name, " -check ")) {
13677             if(sscanf(p, " -check %d", &def) < 1) return FALSE;
13678             opt->value = (def != 0);
13679             opt->type = CheckBox;
13680         } else if(p = strstr(opt->name, " -combo ")) {
13681             opt->textValue = (char*) (&cps->comboList[cps->comboCnt]); // cheat with pointer type
13682             cps->comboList[cps->comboCnt++] = q = p+8; // holds possible choices
13683             if(*q == '*') cps->comboList[cps->comboCnt-1]++;
13684             opt->value = n = 0;
13685             while(q = StrStr(q, " /// ")) {
13686                 n++; *q = 0;    // count choices, and null-terminate each of them
13687                 q += 5;
13688                 if(*q == '*') { // remember default, which is marked with * prefix
13689                     q++;
13690                     opt->value = n;
13691                 }
13692                 cps->comboList[cps->comboCnt++] = q;
13693             }
13694             cps->comboList[cps->comboCnt++] = NULL;
13695             opt->max = n + 1;
13696             opt->type = ComboBox;
13697         } else if(p = strstr(opt->name, " -button")) {
13698             opt->type = Button;
13699         } else if(p = strstr(opt->name, " -save")) {
13700             opt->type = SaveButton;
13701         } else return FALSE;
13702         *p = 0; // terminate option name
13703         // now look if the command-line options define a setting for this engine option.
13704         if(cps->optionSettings && cps->optionSettings[0])
13705             p = strstr(cps->optionSettings, opt->name); else p = NULL;
13706         if(p && (p == cps->optionSettings || p[-1] == ',')) {
13707                 sprintf(buf, "option %s", p);
13708                 if(p = strstr(buf, ",")) *p = 0;
13709                 strcat(buf, "\n");
13710                 SendToProgram(buf, cps);
13711         }
13712         return TRUE;
13713 }
13714
13715 void
13716 FeatureDone(cps, val)
13717      ChessProgramState* cps;
13718      int val;
13719 {
13720   DelayedEventCallback cb = GetDelayedEvent();
13721   if ((cb == InitBackEnd3 && cps == &first) ||
13722       (cb == TwoMachinesEventIfReady && cps == &second)) {
13723     CancelDelayedEvent();
13724     ScheduleDelayedEvent(cb, val ? 1 : 3600000);
13725   }
13726   cps->initDone = val;
13727 }
13728
13729 /* Parse feature command from engine */
13730 void
13731 ParseFeatures(args, cps)
13732      char* args;
13733      ChessProgramState *cps;
13734 {
13735   char *p = args;
13736   char *q;
13737   int val;
13738   char buf[MSG_SIZ];
13739
13740   for (;;) {
13741     while (*p == ' ') p++;
13742     if (*p == NULLCHAR) return;
13743
13744     if (BoolFeature(&p, "setboard", &cps->useSetboard, cps)) continue;
13745     if (BoolFeature(&p, "time", &cps->sendTime, cps)) continue;
13746     if (BoolFeature(&p, "draw", &cps->sendDrawOffers, cps)) continue;
13747     if (BoolFeature(&p, "sigint", &cps->useSigint, cps)) continue;
13748     if (BoolFeature(&p, "sigterm", &cps->useSigterm, cps)) continue;
13749     if (BoolFeature(&p, "reuse", &val, cps)) {
13750       /* Engine can disable reuse, but can't enable it if user said no */
13751       if (!val) cps->reuse = FALSE;
13752       continue;
13753     }
13754     if (BoolFeature(&p, "analyze", &cps->analysisSupport, cps)) continue;
13755     if (StringFeature(&p, "myname", &cps->tidy, cps)) {
13756       if (gameMode == TwoMachinesPlay) {
13757         DisplayTwoMachinesTitle();
13758       } else {
13759         DisplayTitle("");
13760       }
13761       continue;
13762     }
13763     if (StringFeature(&p, "variants", &cps->variants, cps)) continue;
13764     if (BoolFeature(&p, "san", &cps->useSAN, cps)) continue;
13765     if (BoolFeature(&p, "ping", &cps->usePing, cps)) continue;
13766     if (BoolFeature(&p, "playother", &cps->usePlayother, cps)) continue;
13767     if (BoolFeature(&p, "colors", &cps->useColors, cps)) continue;
13768     if (BoolFeature(&p, "usermove", &cps->useUsermove, cps)) continue;
13769     if (BoolFeature(&p, "ics", &cps->sendICS, cps)) continue;
13770     if (BoolFeature(&p, "name", &cps->sendName, cps)) continue;
13771     if (BoolFeature(&p, "pause", &val, cps)) continue; /* unused at present */
13772     if (IntFeature(&p, "done", &val, cps)) {
13773       FeatureDone(cps, val);
13774       continue;
13775     }
13776     /* Added by Tord: */
13777     if (BoolFeature(&p, "fen960", &cps->useFEN960, cps)) continue;
13778     if (BoolFeature(&p, "oocastle", &cps->useOOCastle, cps)) continue;
13779     /* End of additions by Tord */
13780
13781     /* [HGM] added features: */
13782     if (BoolFeature(&p, "debug", &cps->debug, cps)) continue;
13783     if (BoolFeature(&p, "nps", &cps->supportsNPS, cps)) continue;
13784     if (IntFeature(&p, "level", &cps->maxNrOfSessions, cps)) continue;
13785     if (BoolFeature(&p, "memory", &cps->memSize, cps)) continue;
13786     if (BoolFeature(&p, "smp", &cps->maxCores, cps)) continue;
13787     if (StringFeature(&p, "egt", &cps->egtFormats, cps)) continue;
13788     if (StringFeature(&p, "option", &(cps->option[cps->nrOptions].name), cps)) {
13789         if(!ParseOption(&(cps->option[cps->nrOptions++]), cps)) { // [HGM] options: add option feature
13790             sprintf(buf, "rejected option %s\n", cps->option[--cps->nrOptions].name);
13791             SendToProgram(buf, cps);
13792             continue;
13793         }
13794         if(cps->nrOptions >= MAX_OPTIONS) {
13795             cps->nrOptions--;
13796             sprintf(buf, "%s engine has too many options\n", cps->which);
13797             DisplayError(buf, 0);
13798         }
13799         continue;
13800     }
13801     if (BoolFeature(&p, "smp", &cps->maxCores, cps)) continue;
13802     /* End of additions by HGM */
13803
13804     /* unknown feature: complain and skip */
13805     q = p;
13806     while (*q && *q != '=') q++;
13807     sprintf(buf, "rejected %.*s\n", (int)(q-p), p);
13808     SendToProgram(buf, cps);
13809     p = q;
13810     if (*p == '=') {
13811       p++;
13812       if (*p == '\"') {
13813         p++;
13814         while (*p && *p != '\"') p++;
13815         if (*p == '\"') p++;
13816       } else {
13817         while (*p && *p != ' ') p++;
13818       }
13819     }
13820   }
13821
13822 }
13823
13824 void
13825 PeriodicUpdatesEvent(newState)
13826      int newState;
13827 {
13828     if (newState == appData.periodicUpdates)
13829       return;
13830
13831     appData.periodicUpdates=newState;
13832
13833     /* Display type changes, so update it now */
13834 //    DisplayAnalysis();
13835
13836     /* Get the ball rolling again... */
13837     if (newState) {
13838         AnalysisPeriodicEvent(1);
13839         StartAnalysisClock();
13840     }
13841 }
13842
13843 void
13844 PonderNextMoveEvent(newState)
13845      int newState;
13846 {
13847     if (newState == appData.ponderNextMove) return;
13848     if (gameMode == EditPosition) EditPositionDone(TRUE);
13849     if (newState) {
13850         SendToProgram("hard\n", &first);
13851         if (gameMode == TwoMachinesPlay) {
13852             SendToProgram("hard\n", &second);
13853         }
13854     } else {
13855         SendToProgram("easy\n", &first);
13856         thinkOutput[0] = NULLCHAR;
13857         if (gameMode == TwoMachinesPlay) {
13858             SendToProgram("easy\n", &second);
13859         }
13860     }
13861     appData.ponderNextMove = newState;
13862 }
13863
13864 void
13865 NewSettingEvent(option, command, value)
13866      char *command;
13867      int option, value;
13868 {
13869     char buf[MSG_SIZ];
13870
13871     if (gameMode == EditPosition) EditPositionDone(TRUE);
13872     sprintf(buf, "%s%s %d\n", (option ? "option ": ""), command, value);
13873     SendToProgram(buf, &first);
13874     if (gameMode == TwoMachinesPlay) {
13875         SendToProgram(buf, &second);
13876     }
13877 }
13878
13879 void
13880 ShowThinkingEvent()
13881 // [HGM] thinking: this routine is now also called from "Options -> Engine..." popup
13882 {
13883     static int oldState = 2; // kludge alert! Neither true nor fals, so first time oldState is always updated
13884     int newState = appData.showThinking
13885         // [HGM] thinking: other features now need thinking output as well
13886         || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp();
13887
13888     if (oldState == newState) return;
13889     oldState = newState;
13890     if (gameMode == EditPosition) EditPositionDone(TRUE);
13891     if (oldState) {
13892         SendToProgram("post\n", &first);
13893         if (gameMode == TwoMachinesPlay) {
13894             SendToProgram("post\n", &second);
13895         }
13896     } else {
13897         SendToProgram("nopost\n", &first);
13898         thinkOutput[0] = NULLCHAR;
13899         if (gameMode == TwoMachinesPlay) {
13900             SendToProgram("nopost\n", &second);
13901         }
13902     }
13903 //    appData.showThinking = newState; // [HGM] thinking: responsible option should already have be changed when calling this routine!
13904 }
13905
13906 void
13907 AskQuestionEvent(title, question, replyPrefix, which)
13908      char *title; char *question; char *replyPrefix; char *which;
13909 {
13910   ProcRef pr = (which[0] == '1') ? first.pr : second.pr;
13911   if (pr == NoProc) return;
13912   AskQuestion(title, question, replyPrefix, pr);
13913 }
13914
13915 void
13916 DisplayMove(moveNumber)
13917      int moveNumber;
13918 {
13919     char message[MSG_SIZ];
13920     char res[MSG_SIZ];
13921     char cpThinkOutput[MSG_SIZ];
13922
13923     if(appData.noGUI) return; // [HGM] fast: suppress display of moves
13924
13925     if (moveNumber == forwardMostMove - 1 ||
13926         gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
13927
13928         safeStrCpy(cpThinkOutput, thinkOutput, sizeof(cpThinkOutput));
13929
13930         if (strchr(cpThinkOutput, '\n')) {
13931             *strchr(cpThinkOutput, '\n') = NULLCHAR;
13932         }
13933     } else {
13934         *cpThinkOutput = NULLCHAR;
13935     }
13936
13937     /* [AS] Hide thinking from human user */
13938     if( appData.hideThinkingFromHuman && gameMode != TwoMachinesPlay ) {
13939         *cpThinkOutput = NULLCHAR;
13940         if( thinkOutput[0] != NULLCHAR ) {
13941             int i;
13942
13943             for( i=0; i<=hiddenThinkOutputState; i++ ) {
13944                 cpThinkOutput[i] = '.';
13945             }
13946             cpThinkOutput[i] = NULLCHAR;
13947             hiddenThinkOutputState = (hiddenThinkOutputState + 1) % 3;
13948         }
13949     }
13950
13951     if (moveNumber == forwardMostMove - 1 &&
13952         gameInfo.resultDetails != NULL) {
13953         if (gameInfo.resultDetails[0] == NULLCHAR) {
13954             sprintf(res, " %s", PGNResult(gameInfo.result));
13955         } else {
13956             sprintf(res, " {%s} %s",
13957                     gameInfo.resultDetails, PGNResult(gameInfo.result));
13958         }
13959     } else {
13960         res[0] = NULLCHAR;
13961     }
13962
13963     if (moveNumber < 0 || parseList[moveNumber][0] == NULLCHAR) {
13964         DisplayMessage(res, cpThinkOutput);
13965     } else {
13966         sprintf(message, "%d.%s%s%s", moveNumber / 2 + 1,
13967                 WhiteOnMove(moveNumber) ? " " : ".. ",
13968                 parseList[moveNumber], res);
13969         DisplayMessage(message, cpThinkOutput);
13970     }
13971 }
13972
13973 void
13974 DisplayComment(moveNumber, text)
13975      int moveNumber;
13976      char *text;
13977 {
13978     char title[MSG_SIZ];
13979     char buf[8000]; // comment can be long!
13980     int score, depth;
13981
13982     if (moveNumber < 0 || parseList[moveNumber][0] == NULLCHAR) {
13983       strcpy(title, "Comment");
13984     } else {
13985       sprintf(title, "Comment on %d.%s%s", moveNumber / 2 + 1,
13986               WhiteOnMove(moveNumber) ? " " : ".. ",
13987               parseList[moveNumber]);
13988     }
13989     // [HGM] PV info: display PV info together with (or as) comment
13990     if(moveNumber >= 0 && (depth = pvInfoList[moveNumber].depth) > 0) {
13991       if(text == NULL) text = "";
13992       score = pvInfoList[moveNumber].score;
13993       sprintf(buf, "%s%.2f/%d %d\n%s", score>0 ? "+" : "", score/100.,
13994               depth, (pvInfoList[moveNumber].time+50)/100, text);
13995       text = buf;
13996     }
13997     if (text != NULL && (appData.autoDisplayComment || commentUp))
13998         CommentPopUp(title, text);
13999 }
14000
14001 /* This routine sends a ^C interrupt to gnuchess, to awaken it if it
14002  * might be busy thinking or pondering.  It can be omitted if your
14003  * gnuchess is configured to stop thinking immediately on any user
14004  * input.  However, that gnuchess feature depends on the FIONREAD
14005  * ioctl, which does not work properly on some flavors of Unix.
14006  */
14007 void
14008 Attention(cps)
14009      ChessProgramState *cps;
14010 {
14011 #if ATTENTION
14012     if (!cps->useSigint) return;
14013     if (appData.noChessProgram || (cps->pr == NoProc)) return;
14014     switch (gameMode) {
14015       case MachinePlaysWhite:
14016       case MachinePlaysBlack:
14017       case TwoMachinesPlay:
14018       case IcsPlayingWhite:
14019       case IcsPlayingBlack:
14020       case AnalyzeMode:
14021       case AnalyzeFile:
14022         /* Skip if we know it isn't thinking */
14023         if (!cps->maybeThinking) return;
14024         if (appData.debugMode)
14025           fprintf(debugFP, "Interrupting %s\n", cps->which);
14026         InterruptChildProcess(cps->pr);
14027         cps->maybeThinking = FALSE;
14028         break;
14029       default:
14030         break;
14031     }
14032 #endif /*ATTENTION*/
14033 }
14034
14035 int
14036 CheckFlags()
14037 {
14038     if (whiteTimeRemaining <= 0) {
14039         if (!whiteFlag) {
14040             whiteFlag = TRUE;
14041             if (appData.icsActive) {
14042                 if (appData.autoCallFlag &&
14043                     gameMode == IcsPlayingBlack && !blackFlag) {
14044                   SendToICS(ics_prefix);
14045                   SendToICS("flag\n");
14046                 }
14047             } else {
14048                 if (blackFlag) {
14049                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Both flags fell"));
14050                 } else {
14051                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("White's flag fell"));
14052                     if (appData.autoCallFlag) {
14053                         GameEnds(BlackWins, "Black wins on time", GE_XBOARD);
14054                         return TRUE;
14055                     }
14056                 }
14057             }
14058         }
14059     }
14060     if (blackTimeRemaining <= 0) {
14061         if (!blackFlag) {
14062             blackFlag = TRUE;
14063             if (appData.icsActive) {
14064                 if (appData.autoCallFlag &&
14065                     gameMode == IcsPlayingWhite && !whiteFlag) {
14066                   SendToICS(ics_prefix);
14067                   SendToICS("flag\n");
14068                 }
14069             } else {
14070                 if (whiteFlag) {
14071                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Both flags fell"));
14072                 } else {
14073                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Black's flag fell"));
14074                     if (appData.autoCallFlag) {
14075                         GameEnds(WhiteWins, "White wins on time", GE_XBOARD);
14076                         return TRUE;
14077                     }
14078                 }
14079             }
14080         }
14081     }
14082     return FALSE;
14083 }
14084
14085 void
14086 CheckTimeControl()
14087 {
14088     if (!appData.clockMode || appData.icsActive || searchTime || // [HGM] st: no inc in st mode
14089         gameMode == PlayFromGameFile || forwardMostMove == 0) return;
14090
14091     /*
14092      * add time to clocks when time control is achieved ([HGM] now also used for increment)
14093      */
14094     if ( !WhiteOnMove(forwardMostMove) )
14095         /* White made time control */
14096         whiteTimeRemaining += GetTimeQuota((forwardMostMove-1)/2)
14097         /* [HGM] time odds: correct new time quota for time odds! */
14098                                             / WhitePlayer()->timeOdds;
14099       else
14100         /* Black made time control */
14101         blackTimeRemaining += GetTimeQuota((forwardMostMove-1)/2)
14102                                             / WhitePlayer()->other->timeOdds;
14103 }
14104
14105 void
14106 DisplayBothClocks()
14107 {
14108     int wom = gameMode == EditPosition ?
14109       !blackPlaysFirst : WhiteOnMove(currentMove);
14110     DisplayWhiteClock(whiteTimeRemaining, wom);
14111     DisplayBlackClock(blackTimeRemaining, !wom);
14112 }
14113
14114
14115 /* Timekeeping seems to be a portability nightmare.  I think everyone
14116    has ftime(), but I'm really not sure, so I'm including some ifdefs
14117    to use other calls if you don't.  Clocks will be less accurate if
14118    you have neither ftime nor gettimeofday.
14119 */
14120
14121 /* VS 2008 requires the #include outside of the function */
14122 #if !HAVE_GETTIMEOFDAY && HAVE_FTIME
14123 #include <sys/timeb.h>
14124 #endif
14125
14126 /* Get the current time as a TimeMark */
14127 void
14128 GetTimeMark(tm)
14129      TimeMark *tm;
14130 {
14131 #if HAVE_GETTIMEOFDAY
14132
14133     struct timeval timeVal;
14134     struct timezone timeZone;
14135
14136     gettimeofday(&timeVal, &timeZone);
14137     tm->sec = (long) timeVal.tv_sec;
14138     tm->ms = (int) (timeVal.tv_usec / 1000L);
14139
14140 #else /*!HAVE_GETTIMEOFDAY*/
14141 #if HAVE_FTIME
14142
14143 // include <sys/timeb.h> / moved to just above start of function
14144     struct timeb timeB;
14145
14146     ftime(&timeB);
14147     tm->sec = (long) timeB.time;
14148     tm->ms = (int) timeB.millitm;
14149
14150 #else /*!HAVE_FTIME && !HAVE_GETTIMEOFDAY*/
14151     tm->sec = (long) time(NULL);
14152     tm->ms = 0;
14153 #endif
14154 #endif
14155 }
14156
14157 /* Return the difference in milliseconds between two
14158    time marks.  We assume the difference will fit in a long!
14159 */
14160 long
14161 SubtractTimeMarks(tm2, tm1)
14162      TimeMark *tm2, *tm1;
14163 {
14164     return 1000L*(tm2->sec - tm1->sec) +
14165            (long) (tm2->ms - tm1->ms);
14166 }
14167
14168
14169 /*
14170  * Code to manage the game clocks.
14171  *
14172  * In tournament play, black starts the clock and then white makes a move.
14173  * We give the human user a slight advantage if he is playing white---the
14174  * clocks don't run until he makes his first move, so it takes zero time.
14175  * Also, we don't account for network lag, so we could get out of sync
14176  * with GNU Chess's clock -- but then, referees are always right.
14177  */
14178
14179 static TimeMark tickStartTM;
14180 static long intendedTickLength;
14181
14182 long
14183 NextTickLength(timeRemaining)
14184      long timeRemaining;
14185 {
14186     long nominalTickLength, nextTickLength;
14187
14188     if (timeRemaining > 0L && timeRemaining <= 10000L)
14189       nominalTickLength = 100L;
14190     else
14191       nominalTickLength = 1000L;
14192     nextTickLength = timeRemaining % nominalTickLength;
14193     if (nextTickLength <= 0) nextTickLength += nominalTickLength;
14194
14195     return nextTickLength;
14196 }
14197
14198 /* Adjust clock one minute up or down */
14199 void
14200 AdjustClock(Boolean which, int dir)
14201 {
14202     if(which) blackTimeRemaining += 60000*dir;
14203     else      whiteTimeRemaining += 60000*dir;
14204     DisplayBothClocks();
14205 }
14206
14207 /* Stop clocks and reset to a fresh time control */
14208 void
14209 ResetClocks()
14210 {
14211     (void) StopClockTimer();
14212     if (appData.icsActive) {
14213         whiteTimeRemaining = blackTimeRemaining = 0;
14214     } else if (searchTime) {
14215         whiteTimeRemaining = 1000*searchTime / WhitePlayer()->timeOdds;
14216         blackTimeRemaining = 1000*searchTime / WhitePlayer()->other->timeOdds;
14217     } else { /* [HGM] correct new time quote for time odds */
14218         whiteTimeRemaining = GetTimeQuota(-1) / WhitePlayer()->timeOdds;
14219         blackTimeRemaining = GetTimeQuota(-1) / WhitePlayer()->other->timeOdds;
14220     }
14221     if (whiteFlag || blackFlag) {
14222         DisplayTitle("");
14223         whiteFlag = blackFlag = FALSE;
14224     }
14225     DisplayBothClocks();
14226 }
14227
14228 #define FUDGE 25 /* 25ms = 1/40 sec; should be plenty even for 50 Hz clocks */
14229
14230 /* Decrement running clock by amount of time that has passed */
14231 void
14232 DecrementClocks()
14233 {
14234     long timeRemaining;
14235     long lastTickLength, fudge;
14236     TimeMark now;
14237
14238     if (!appData.clockMode) return;
14239     if (gameMode==AnalyzeMode || gameMode == AnalyzeFile) return;
14240
14241     GetTimeMark(&now);
14242
14243     lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
14244
14245     /* Fudge if we woke up a little too soon */
14246     fudge = intendedTickLength - lastTickLength;
14247     if (fudge < 0 || fudge > FUDGE) fudge = 0;
14248
14249     if (WhiteOnMove(forwardMostMove)) {
14250         if(whiteNPS >= 0) lastTickLength = 0;
14251         timeRemaining = whiteTimeRemaining -= lastTickLength;
14252         DisplayWhiteClock(whiteTimeRemaining - fudge,
14253                           WhiteOnMove(currentMove < forwardMostMove ? currentMove : forwardMostMove));
14254     } else {
14255         if(blackNPS >= 0) lastTickLength = 0;
14256         timeRemaining = blackTimeRemaining -= lastTickLength;
14257         DisplayBlackClock(blackTimeRemaining - fudge,
14258                           !WhiteOnMove(currentMove < forwardMostMove ? currentMove : forwardMostMove));
14259     }
14260
14261     if (CheckFlags()) return;
14262
14263     tickStartTM = now;
14264     intendedTickLength = NextTickLength(timeRemaining - fudge) + fudge;
14265     StartClockTimer(intendedTickLength);
14266
14267     /* if the time remaining has fallen below the alarm threshold, sound the
14268      * alarm. if the alarm has sounded and (due to a takeback or time control
14269      * with increment) the time remaining has increased to a level above the
14270      * threshold, reset the alarm so it can sound again.
14271      */
14272
14273     if (appData.icsActive && appData.icsAlarm) {
14274
14275         /* make sure we are dealing with the user's clock */
14276         if (!( ((gameMode == IcsPlayingWhite) && WhiteOnMove(currentMove)) ||
14277                ((gameMode == IcsPlayingBlack) && !WhiteOnMove(currentMove))
14278            )) return;
14279
14280         if (alarmSounded && (timeRemaining > appData.icsAlarmTime)) {
14281             alarmSounded = FALSE;
14282         } else if (!alarmSounded && (timeRemaining <= appData.icsAlarmTime)) {
14283             PlayAlarmSound();
14284             alarmSounded = TRUE;
14285         }
14286     }
14287 }
14288
14289
14290 /* A player has just moved, so stop the previously running
14291    clock and (if in clock mode) start the other one.
14292    We redisplay both clocks in case we're in ICS mode, because
14293    ICS gives us an update to both clocks after every move.
14294    Note that this routine is called *after* forwardMostMove
14295    is updated, so the last fractional tick must be subtracted
14296    from the color that is *not* on move now.
14297 */
14298 void
14299 SwitchClocks(int newMoveNr)
14300 {
14301     long lastTickLength;
14302     TimeMark now;
14303     int flagged = FALSE;
14304
14305     GetTimeMark(&now);
14306
14307     if (StopClockTimer() && appData.clockMode) {
14308         lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
14309         if (!WhiteOnMove(forwardMostMove)) {
14310             if(blackNPS >= 0) lastTickLength = 0;
14311             blackTimeRemaining -= lastTickLength;
14312            /* [HGM] PGNtime: save time for PGN file if engine did not give it */
14313 //         if(pvInfoList[forwardMostMove-1].time == -1)
14314                  pvInfoList[forwardMostMove-1].time =               // use GUI time
14315                       (timeRemaining[1][forwardMostMove-1] - blackTimeRemaining)/10;
14316         } else {
14317            if(whiteNPS >= 0) lastTickLength = 0;
14318            whiteTimeRemaining -= lastTickLength;
14319            /* [HGM] PGNtime: save time for PGN file if engine did not give it */
14320 //         if(pvInfoList[forwardMostMove-1].time == -1)
14321                  pvInfoList[forwardMostMove-1].time =
14322                       (timeRemaining[0][forwardMostMove-1] - whiteTimeRemaining)/10;
14323         }
14324         flagged = CheckFlags();
14325     }
14326     forwardMostMove = newMoveNr; // [HGM] race: change stm when no timer interrupt scheduled
14327     CheckTimeControl();
14328
14329     if (flagged || !appData.clockMode) return;
14330
14331     switch (gameMode) {
14332       case MachinePlaysBlack:
14333       case MachinePlaysWhite:
14334       case BeginningOfGame:
14335         if (pausing) return;
14336         break;
14337
14338       case EditGame:
14339       case PlayFromGameFile:
14340       case IcsExamining:
14341         return;
14342
14343       default:
14344         break;
14345     }
14346
14347     if (searchTime) { // [HGM] st: set clock of player that has to move to max time
14348         if(WhiteOnMove(forwardMostMove))
14349              whiteTimeRemaining = 1000*searchTime / WhitePlayer()->timeOdds;
14350         else blackTimeRemaining = 1000*searchTime / WhitePlayer()->other->timeOdds;
14351     }
14352
14353     tickStartTM = now;
14354     intendedTickLength = NextTickLength(WhiteOnMove(forwardMostMove) ?
14355       whiteTimeRemaining : blackTimeRemaining);
14356     StartClockTimer(intendedTickLength);
14357 }
14358
14359
14360 /* Stop both clocks */
14361 void
14362 StopClocks()
14363 {
14364     long lastTickLength;
14365     TimeMark now;
14366
14367     if (!StopClockTimer()) return;
14368     if (!appData.clockMode) return;
14369
14370     GetTimeMark(&now);
14371
14372     lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
14373     if (WhiteOnMove(forwardMostMove)) {
14374         if(whiteNPS >= 0) lastTickLength = 0;
14375         whiteTimeRemaining -= lastTickLength;
14376         DisplayWhiteClock(whiteTimeRemaining, WhiteOnMove(currentMove));
14377     } else {
14378         if(blackNPS >= 0) lastTickLength = 0;
14379         blackTimeRemaining -= lastTickLength;
14380         DisplayBlackClock(blackTimeRemaining, !WhiteOnMove(currentMove));
14381     }
14382     CheckFlags();
14383 }
14384
14385 /* Start clock of player on move.  Time may have been reset, so
14386    if clock is already running, stop and restart it. */
14387 void
14388 StartClocks()
14389 {
14390     (void) StopClockTimer(); /* in case it was running already */
14391     DisplayBothClocks();
14392     if (CheckFlags()) return;
14393
14394     if (!appData.clockMode) return;
14395     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) return;
14396
14397     GetTimeMark(&tickStartTM);
14398     intendedTickLength = NextTickLength(WhiteOnMove(forwardMostMove) ?
14399       whiteTimeRemaining : blackTimeRemaining);
14400
14401    /* [HGM] nps: figure out nps factors, by determining which engine plays white and/or black once and for all */
14402     whiteNPS = blackNPS = -1;
14403     if(gameMode == MachinePlaysWhite || gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'w'
14404        || appData.zippyPlay && gameMode == IcsPlayingBlack) // first (perhaps only) engine has white
14405         whiteNPS = first.nps;
14406     if(gameMode == MachinePlaysBlack || gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b'
14407        || appData.zippyPlay && gameMode == IcsPlayingWhite) // first (perhaps only) engine has black
14408         blackNPS = first.nps;
14409     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b') // second only used in Two-Machines mode
14410         whiteNPS = second.nps;
14411     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'w')
14412         blackNPS = second.nps;
14413     if(appData.debugMode) fprintf(debugFP, "nps: w=%d, b=%d\n", whiteNPS, blackNPS);
14414
14415     StartClockTimer(intendedTickLength);
14416 }
14417
14418 char *
14419 TimeString(ms)
14420      long ms;
14421 {
14422     long second, minute, hour, day;
14423     char *sign = "";
14424     static char buf[32];
14425
14426     if (ms > 0 && ms <= 9900) {
14427       /* convert milliseconds to tenths, rounding up */
14428       double tenths = floor( ((double)(ms + 99L)) / 100.00 );
14429
14430       sprintf(buf, " %03.1f ", tenths/10.0);
14431       return buf;
14432     }
14433
14434     /* convert milliseconds to seconds, rounding up */
14435     /* use floating point to avoid strangeness of integer division
14436        with negative dividends on many machines */
14437     second = (long) floor(((double) (ms + 999L)) / 1000.0);
14438
14439     if (second < 0) {
14440         sign = "-";
14441         second = -second;
14442     }
14443
14444     day = second / (60 * 60 * 24);
14445     second = second % (60 * 60 * 24);
14446     hour = second / (60 * 60);
14447     second = second % (60 * 60);
14448     minute = second / 60;
14449     second = second % 60;
14450
14451     if (day > 0)
14452       sprintf(buf, " %s%ld:%02ld:%02ld:%02ld ",
14453               sign, day, hour, minute, second);
14454     else if (hour > 0)
14455       sprintf(buf, " %s%ld:%02ld:%02ld ", sign, hour, minute, second);
14456     else
14457       sprintf(buf, " %s%2ld:%02ld ", sign, minute, second);
14458
14459     return buf;
14460 }
14461
14462
14463 /*
14464  * This is necessary because some C libraries aren't ANSI C compliant yet.
14465  */
14466 char *
14467 StrStr(string, match)
14468      char *string, *match;
14469 {
14470     int i, length;
14471
14472     length = strlen(match);
14473
14474     for (i = strlen(string) - length; i >= 0; i--, string++)
14475       if (!strncmp(match, string, length))
14476         return string;
14477
14478     return NULL;
14479 }
14480
14481 char *
14482 StrCaseStr(string, match)
14483      char *string, *match;
14484 {
14485     int i, j, length;
14486
14487     length = strlen(match);
14488
14489     for (i = strlen(string) - length; i >= 0; i--, string++) {
14490         for (j = 0; j < length; j++) {
14491             if (ToLower(match[j]) != ToLower(string[j]))
14492               break;
14493         }
14494         if (j == length) return string;
14495     }
14496
14497     return NULL;
14498 }
14499
14500 #ifndef _amigados
14501 int
14502 StrCaseCmp(s1, s2)
14503      char *s1, *s2;
14504 {
14505     char c1, c2;
14506
14507     for (;;) {
14508         c1 = ToLower(*s1++);
14509         c2 = ToLower(*s2++);
14510         if (c1 > c2) return 1;
14511         if (c1 < c2) return -1;
14512         if (c1 == NULLCHAR) return 0;
14513     }
14514 }
14515
14516
14517 int
14518 ToLower(c)
14519      int c;
14520 {
14521     return isupper(c) ? tolower(c) : c;
14522 }
14523
14524
14525 int
14526 ToUpper(c)
14527      int c;
14528 {
14529     return islower(c) ? toupper(c) : c;
14530 }
14531 #endif /* !_amigados    */
14532
14533 char *
14534 StrSave(s)
14535      char *s;
14536 {
14537     char *ret;
14538
14539     if ((ret = (char *) malloc(strlen(s) + 1))) {
14540         strcpy(ret, s);
14541     }
14542     return ret;
14543 }
14544
14545 char *
14546 StrSavePtr(s, savePtr)
14547      char *s, **savePtr;
14548 {
14549     if (*savePtr) {
14550         free(*savePtr);
14551     }
14552     if ((*savePtr = (char *) malloc(strlen(s) + 1))) {
14553         strcpy(*savePtr, s);
14554     }
14555     return(*savePtr);
14556 }
14557
14558 char *
14559 PGNDate()
14560 {
14561     time_t clock;
14562     struct tm *tm;
14563     char buf[MSG_SIZ];
14564
14565     clock = time((time_t *)NULL);
14566     tm = localtime(&clock);
14567     sprintf(buf, "%04d.%02d.%02d",
14568             tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday);
14569     return StrSave(buf);
14570 }
14571
14572
14573 char *
14574 PositionToFEN(move, overrideCastling)
14575      int move;
14576      char *overrideCastling;
14577 {
14578     int i, j, fromX, fromY, toX, toY;
14579     int whiteToPlay;
14580     char buf[128];
14581     char *p, *q;
14582     int emptycount;
14583     ChessSquare piece;
14584
14585     whiteToPlay = (gameMode == EditPosition) ?
14586       !blackPlaysFirst : (move % 2 == 0);
14587     p = buf;
14588
14589     /* Piece placement data */
14590     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
14591         emptycount = 0;
14592         for (j = BOARD_LEFT; j < BOARD_RGHT; j++) {
14593             if (boards[move][i][j] == EmptySquare) {
14594                 emptycount++;
14595             } else { ChessSquare piece = boards[move][i][j];
14596                 if (emptycount > 0) {
14597                     if(emptycount<10) /* [HGM] can be >= 10 */
14598                         *p++ = '0' + emptycount;
14599                     else { *p++ = '0' + emptycount/10; *p++ = '0' + emptycount%10; }
14600                     emptycount = 0;
14601                 }
14602                 if(PieceToChar(piece) == '+') {
14603                     /* [HGM] write promoted pieces as '+<unpromoted>' (Shogi) */
14604                     *p++ = '+';
14605                     piece = (ChessSquare)(DEMOTED piece);
14606                 }
14607                 *p++ = PieceToChar(piece);
14608                 if(p[-1] == '~') {
14609                     /* [HGM] flag promoted pieces as '<promoted>~' (Crazyhouse) */
14610                     p[-1] = PieceToChar((ChessSquare)(DEMOTED piece));
14611                     *p++ = '~';
14612                 }
14613             }
14614         }
14615         if (emptycount > 0) {
14616             if(emptycount<10) /* [HGM] can be >= 10 */
14617                 *p++ = '0' + emptycount;
14618             else { *p++ = '0' + emptycount/10; *p++ = '0' + emptycount%10; }
14619             emptycount = 0;
14620         }
14621         *p++ = '/';
14622     }
14623     *(p - 1) = ' ';
14624
14625     /* [HGM] print Crazyhouse or Shogi holdings */
14626     if( gameInfo.holdingsWidth ) {
14627         *(p-1) = '['; /* if we wanted to support BFEN, this could be '/' */
14628         q = p;
14629         for(i=0; i<gameInfo.holdingsSize; i++) { /* white holdings */
14630             piece = boards[move][i][BOARD_WIDTH-1];
14631             if( piece != EmptySquare )
14632               for(j=0; j<(int) boards[move][i][BOARD_WIDTH-2]; j++)
14633                   *p++ = PieceToChar(piece);
14634         }
14635         for(i=0; i<gameInfo.holdingsSize; i++) { /* black holdings */
14636             piece = boards[move][BOARD_HEIGHT-i-1][0];
14637             if( piece != EmptySquare )
14638               for(j=0; j<(int) boards[move][BOARD_HEIGHT-i-1][1]; j++)
14639                   *p++ = PieceToChar(piece);
14640         }
14641
14642         if( q == p ) *p++ = '-';
14643         *p++ = ']';
14644         *p++ = ' ';
14645     }
14646
14647     /* Active color */
14648     *p++ = whiteToPlay ? 'w' : 'b';
14649     *p++ = ' ';
14650
14651   if(q = overrideCastling) { // [HGM] FRC: override castling & e.p fields for non-compliant engines
14652     while(*p++ = *q++); if(q != overrideCastling+1) p[-1] = ' '; else --p;
14653   } else {
14654   if(nrCastlingRights) {
14655      q = p;
14656      if(gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom) {
14657        /* [HGM] write directly from rights */
14658            if(boards[move][CASTLING][2] != NoRights &&
14659               boards[move][CASTLING][0] != NoRights   )
14660                 *p++ = boards[move][CASTLING][0] + AAA + 'A' - 'a';
14661            if(boards[move][CASTLING][2] != NoRights &&
14662               boards[move][CASTLING][1] != NoRights   )
14663                 *p++ = boards[move][CASTLING][1] + AAA + 'A' - 'a';
14664            if(boards[move][CASTLING][5] != NoRights &&
14665               boards[move][CASTLING][3] != NoRights   )
14666                 *p++ = boards[move][CASTLING][3] + AAA;
14667            if(boards[move][CASTLING][5] != NoRights &&
14668               boards[move][CASTLING][4] != NoRights   )
14669                 *p++ = boards[move][CASTLING][4] + AAA;
14670      } else {
14671
14672         /* [HGM] write true castling rights */
14673         if( nrCastlingRights == 6 ) {
14674             if(boards[move][CASTLING][0] == BOARD_RGHT-1 &&
14675                boards[move][CASTLING][2] != NoRights  ) *p++ = 'K';
14676             if(boards[move][CASTLING][1] == BOARD_LEFT &&
14677                boards[move][CASTLING][2] != NoRights  ) *p++ = 'Q';
14678             if(boards[move][CASTLING][3] == BOARD_RGHT-1 &&
14679                boards[move][CASTLING][5] != NoRights  ) *p++ = 'k';
14680             if(boards[move][CASTLING][4] == BOARD_LEFT &&
14681                boards[move][CASTLING][5] != NoRights  ) *p++ = 'q';
14682         }
14683      }
14684      if (q == p) *p++ = '-'; /* No castling rights */
14685      *p++ = ' ';
14686   }
14687
14688   if(gameInfo.variant != VariantShogi    && gameInfo.variant != VariantXiangqi &&
14689      gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier && gameInfo.variant != VariantMakruk ) {
14690     /* En passant target square */
14691     if (move > backwardMostMove) {
14692         fromX = moveList[move - 1][0] - AAA;
14693         fromY = moveList[move - 1][1] - ONE;
14694         toX = moveList[move - 1][2] - AAA;
14695         toY = moveList[move - 1][3] - ONE;
14696         if (fromY == (whiteToPlay ? BOARD_HEIGHT-2 : 1) &&
14697             toY == (whiteToPlay ? BOARD_HEIGHT-4 : 3) &&
14698             boards[move][toY][toX] == (whiteToPlay ? BlackPawn : WhitePawn) &&
14699             fromX == toX) {
14700             /* 2-square pawn move just happened */
14701             *p++ = toX + AAA;
14702             *p++ = whiteToPlay ? '6'+BOARD_HEIGHT-8 : '3';
14703         } else {
14704             *p++ = '-';
14705         }
14706     } else if(move == backwardMostMove) {
14707         // [HGM] perhaps we should always do it like this, and forget the above?
14708         if((signed char)boards[move][EP_STATUS] >= 0) {
14709             *p++ = boards[move][EP_STATUS] + AAA;
14710             *p++ = whiteToPlay ? '6'+BOARD_HEIGHT-8 : '3';
14711         } else {
14712             *p++ = '-';
14713         }
14714     } else {
14715         *p++ = '-';
14716     }
14717     *p++ = ' ';
14718   }
14719   }
14720
14721     /* [HGM] find reversible plies */
14722     {   int i = 0, j=move;
14723
14724         if (appData.debugMode) { int k;
14725             fprintf(debugFP, "write FEN 50-move: %d %d %d\n", initialRulePlies, forwardMostMove, backwardMostMove);
14726             for(k=backwardMostMove; k<=forwardMostMove; k++)
14727                 fprintf(debugFP, "e%d. p=%d\n", k, (signed char)boards[k][EP_STATUS]);
14728
14729         }
14730
14731         while(j > backwardMostMove && (signed char)boards[j][EP_STATUS] <= EP_NONE) j--,i++;
14732         if( j == backwardMostMove ) i += initialRulePlies;
14733         sprintf(p, "%d ", i);
14734         p += i>=100 ? 4 : i >= 10 ? 3 : 2;
14735     }
14736     /* Fullmove number */
14737     sprintf(p, "%d", (move / 2) + 1);
14738
14739     return StrSave(buf);
14740 }
14741
14742 Boolean
14743 ParseFEN(board, blackPlaysFirst, fen)
14744     Board board;
14745      int *blackPlaysFirst;
14746      char *fen;
14747 {
14748     int i, j;
14749     char *p;
14750     int emptycount;
14751     ChessSquare piece;
14752
14753     p = fen;
14754
14755     /* [HGM] by default clear Crazyhouse holdings, if present */
14756     if(gameInfo.holdingsWidth) {
14757        for(i=0; i<BOARD_HEIGHT; i++) {
14758            board[i][0]             = EmptySquare; /* black holdings */
14759            board[i][BOARD_WIDTH-1] = EmptySquare; /* white holdings */
14760            board[i][1]             = (ChessSquare) 0; /* black counts */
14761            board[i][BOARD_WIDTH-2] = (ChessSquare) 0; /* white counts */
14762        }
14763     }
14764
14765     /* Piece placement data */
14766     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
14767         j = 0;
14768         for (;;) {
14769             if (*p == '/' || *p == ' ' || (*p == '[' && i == 0) ) {
14770                 if (*p == '/') p++;
14771                 emptycount = gameInfo.boardWidth - j;
14772                 while (emptycount--)
14773                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
14774                 break;
14775 #if(BOARD_FILES >= 10)
14776             } else if(*p=='x' || *p=='X') { /* [HGM] X means 10 */
14777                 p++; emptycount=10;
14778                 if (j + emptycount > gameInfo.boardWidth) return FALSE;
14779                 while (emptycount--)
14780                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
14781 #endif
14782             } else if (isdigit(*p)) {
14783                 emptycount = *p++ - '0';
14784                 while(isdigit(*p)) emptycount = 10*emptycount + *p++ - '0'; /* [HGM] allow > 9 */
14785                 if (j + emptycount > gameInfo.boardWidth) return FALSE;
14786                 while (emptycount--)
14787                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
14788             } else if (*p == '+' || isalpha(*p)) {
14789                 if (j >= gameInfo.boardWidth) return FALSE;
14790                 if(*p=='+') {
14791                     piece = CharToPiece(*++p);
14792                     if(piece == EmptySquare) return FALSE; /* unknown piece */
14793                     piece = (ChessSquare) (PROMOTED piece ); p++;
14794                     if(PieceToChar(piece) != '+') return FALSE; /* unpromotable piece */
14795                 } else piece = CharToPiece(*p++);
14796
14797                 if(piece==EmptySquare) return FALSE; /* unknown piece */
14798                 if(*p == '~') { /* [HGM] make it a promoted piece for Crazyhouse */
14799                     piece = (ChessSquare) (PROMOTED piece);
14800                     if(PieceToChar(piece) != '~') return FALSE; /* cannot be a promoted piece */
14801                     p++;
14802                 }
14803                 board[i][(j++)+gameInfo.holdingsWidth] = piece;
14804             } else {
14805                 return FALSE;
14806             }
14807         }
14808     }
14809     while (*p == '/' || *p == ' ') p++;
14810
14811     /* [HGM] look for Crazyhouse holdings here */
14812     while(*p==' ') p++;
14813     if( gameInfo.holdingsWidth && p[-1] == '/' || *p == '[') {
14814         if(*p == '[') p++;
14815         if(*p == '-' ) *p++; /* empty holdings */ else {
14816             if( !gameInfo.holdingsWidth ) return FALSE; /* no room to put holdings! */
14817             /* if we would allow FEN reading to set board size, we would   */
14818             /* have to add holdings and shift the board read so far here   */
14819             while( (piece = CharToPiece(*p) ) != EmptySquare ) {
14820                 *p++;
14821                 if((int) piece >= (int) BlackPawn ) {
14822                     i = (int)piece - (int)BlackPawn;
14823                     i = PieceToNumber((ChessSquare)i);
14824                     if( i >= gameInfo.holdingsSize ) return FALSE;
14825                     board[BOARD_HEIGHT-1-i][0] = piece; /* black holdings */
14826                     board[BOARD_HEIGHT-1-i][1]++;       /* black counts   */
14827                 } else {
14828                     i = (int)piece - (int)WhitePawn;
14829                     i = PieceToNumber((ChessSquare)i);
14830                     if( i >= gameInfo.holdingsSize ) return FALSE;
14831                     board[i][BOARD_WIDTH-1] = piece;    /* white holdings */
14832                     board[i][BOARD_WIDTH-2]++;          /* black holdings */
14833                 }
14834             }
14835         }
14836         if(*p == ']') *p++;
14837     }
14838
14839     while(*p == ' ') p++;
14840
14841     /* Active color */
14842     switch (*p++) {
14843       case 'w':
14844         *blackPlaysFirst = FALSE;
14845         break;
14846       case 'b':
14847         *blackPlaysFirst = TRUE;
14848         break;
14849       default:
14850         return FALSE;
14851     }
14852
14853     /* [HGM] We NO LONGER ignore the rest of the FEN notation */
14854     /* return the extra info in global variiables             */
14855
14856     /* set defaults in case FEN is incomplete */
14857     board[EP_STATUS] = EP_UNKNOWN;
14858     for(i=0; i<nrCastlingRights; i++ ) {
14859         board[CASTLING][i] =
14860             gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom ? NoRights : initialRights[i];
14861     }   /* assume possible unless obviously impossible */
14862     if(initialRights[0]!=NoRights && board[castlingRank[0]][initialRights[0]] != WhiteRook) board[CASTLING][0] = NoRights;
14863     if(initialRights[1]!=NoRights && board[castlingRank[1]][initialRights[1]] != WhiteRook) board[CASTLING][1] = NoRights;
14864     if(initialRights[2]!=NoRights && board[castlingRank[2]][initialRights[2]] != WhiteUnicorn
14865                                   && board[castlingRank[2]][initialRights[2]] != WhiteKing) board[CASTLING][2] = NoRights;
14866     if(initialRights[3]!=NoRights && board[castlingRank[3]][initialRights[3]] != BlackRook) board[CASTLING][3] = NoRights;
14867     if(initialRights[4]!=NoRights && board[castlingRank[4]][initialRights[4]] != BlackRook) board[CASTLING][4] = NoRights;
14868     if(initialRights[5]!=NoRights && board[castlingRank[5]][initialRights[5]] != BlackUnicorn
14869                                   && board[castlingRank[5]][initialRights[5]] != BlackKing) board[CASTLING][5] = NoRights;
14870     FENrulePlies = 0;
14871
14872     while(*p==' ') p++;
14873     if(nrCastlingRights) {
14874       if(*p=='K' || *p=='Q' || *p=='k' || *p=='q' || *p=='-') {
14875           /* castling indicator present, so default becomes no castlings */
14876           for(i=0; i<nrCastlingRights; i++ ) {
14877                  board[CASTLING][i] = NoRights;
14878           }
14879       }
14880       while(*p=='K' || *p=='Q' || *p=='k' || *p=='q' || *p=='-' ||
14881              (gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom) &&
14882              ( *p >= 'a' && *p < 'a' + gameInfo.boardWidth) ||
14883              ( *p >= 'A' && *p < 'A' + gameInfo.boardWidth)   ) {
14884         char c = *p++; int whiteKingFile=NoRights, blackKingFile=NoRights;
14885
14886         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) {
14887             if(board[BOARD_HEIGHT-1][i] == BlackKing) blackKingFile = i;
14888             if(board[0             ][i] == WhiteKing) whiteKingFile = i;
14889         }
14890         if(gameInfo.variant == VariantTwoKings || gameInfo.variant == VariantKnightmate)
14891             whiteKingFile = blackKingFile = BOARD_WIDTH >> 1; // for these variant scanning fails
14892         if(whiteKingFile == NoRights || board[0][whiteKingFile] != WhiteUnicorn
14893                                      && board[0][whiteKingFile] != WhiteKing) whiteKingFile = NoRights;
14894         if(blackKingFile == NoRights || board[BOARD_HEIGHT-1][blackKingFile] != BlackUnicorn
14895                                      && board[BOARD_HEIGHT-1][blackKingFile] != BlackKing) blackKingFile = NoRights;
14896         switch(c) {
14897           case'K':
14898               for(i=BOARD_RGHT-1; board[0][i]!=WhiteRook && i>whiteKingFile; i--);
14899               board[CASTLING][0] = i != whiteKingFile ? i : NoRights;
14900               board[CASTLING][2] = whiteKingFile;
14901               break;
14902           case'Q':
14903               for(i=BOARD_LEFT;  i<BOARD_RGHT && board[0][i]!=WhiteRook && i<whiteKingFile; i++);
14904               board[CASTLING][1] = i != whiteKingFile ? i : NoRights;
14905               board[CASTLING][2] = whiteKingFile;
14906               break;
14907           case'k':
14908               for(i=BOARD_RGHT-1; board[BOARD_HEIGHT-1][i]!=BlackRook && i>blackKingFile; i--);
14909               board[CASTLING][3] = i != blackKingFile ? i : NoRights;
14910               board[CASTLING][5] = blackKingFile;
14911               break;
14912           case'q':
14913               for(i=BOARD_LEFT; i<BOARD_RGHT && board[BOARD_HEIGHT-1][i]!=BlackRook && i<blackKingFile; i++);
14914               board[CASTLING][4] = i != blackKingFile ? i : NoRights;
14915               board[CASTLING][5] = blackKingFile;
14916           case '-':
14917               break;
14918           default: /* FRC castlings */
14919               if(c >= 'a') { /* black rights */
14920                   for(i=BOARD_LEFT; i<BOARD_RGHT; i++)
14921                     if(board[BOARD_HEIGHT-1][i] == BlackKing) break;
14922                   if(i == BOARD_RGHT) break;
14923                   board[CASTLING][5] = i;
14924                   c -= AAA;
14925                   if(board[BOARD_HEIGHT-1][c] <  BlackPawn ||
14926                      board[BOARD_HEIGHT-1][c] >= BlackKing   ) break;
14927                   if(c > i)
14928                       board[CASTLING][3] = c;
14929                   else
14930                       board[CASTLING][4] = c;
14931               } else { /* white rights */
14932                   for(i=BOARD_LEFT; i<BOARD_RGHT; i++)
14933                     if(board[0][i] == WhiteKing) break;
14934                   if(i == BOARD_RGHT) break;
14935                   board[CASTLING][2] = i;
14936                   c -= AAA - 'a' + 'A';
14937                   if(board[0][c] >= WhiteKing) break;
14938                   if(c > i)
14939                       board[CASTLING][0] = c;
14940                   else
14941                       board[CASTLING][1] = c;
14942               }
14943         }
14944       }
14945       for(i=0; i<nrCastlingRights; i++)
14946         if(board[CASTLING][i] != NoRights) initialRights[i] = board[CASTLING][i];
14947     if (appData.debugMode) {
14948         fprintf(debugFP, "FEN castling rights:");
14949         for(i=0; i<nrCastlingRights; i++)
14950         fprintf(debugFP, " %d", board[CASTLING][i]);
14951         fprintf(debugFP, "\n");
14952     }
14953
14954       while(*p==' ') p++;
14955     }
14956
14957     /* read e.p. field in games that know e.p. capture */
14958     if(gameInfo.variant != VariantShogi    && gameInfo.variant != VariantXiangqi &&
14959        gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier && gameInfo.variant != VariantMakruk ) {
14960       if(*p=='-') {
14961         p++; board[EP_STATUS] = EP_NONE;
14962       } else {
14963          char c = *p++ - AAA;
14964
14965          if(c < BOARD_LEFT || c >= BOARD_RGHT) return TRUE;
14966          if(*p >= '0' && *p <='9') *p++;
14967          board[EP_STATUS] = c;
14968       }
14969     }
14970
14971
14972     if(sscanf(p, "%d", &i) == 1) {
14973         FENrulePlies = i; /* 50-move ply counter */
14974         /* (The move number is still ignored)    */
14975     }
14976
14977     return TRUE;
14978 }
14979
14980 void
14981 EditPositionPasteFEN(char *fen)
14982 {
14983   if (fen != NULL) {
14984     Board initial_position;
14985
14986     if (!ParseFEN(initial_position, &blackPlaysFirst, fen)) {
14987       DisplayError(_("Bad FEN position in clipboard"), 0);
14988       return ;
14989     } else {
14990       int savedBlackPlaysFirst = blackPlaysFirst;
14991       EditPositionEvent();
14992       blackPlaysFirst = savedBlackPlaysFirst;
14993       CopyBoard(boards[0], initial_position);
14994       initialRulePlies = FENrulePlies; /* [HGM] copy FEN attributes as well */
14995       EditPositionDone(FALSE); // [HGM] fake: do not fake rights if we had FEN
14996       DisplayBothClocks();
14997       DrawPosition(FALSE, boards[currentMove]);
14998     }
14999   }
15000 }
15001
15002 static char cseq[12] = "\\   ";
15003
15004 Boolean set_cont_sequence(char *new_seq)
15005 {
15006     int len;
15007     Boolean ret;
15008
15009     // handle bad attempts to set the sequence
15010         if (!new_seq)
15011                 return 0; // acceptable error - no debug
15012
15013     len = strlen(new_seq);
15014     ret = (len > 0) && (len < sizeof(cseq));
15015     if (ret)
15016         strcpy(cseq, new_seq);
15017     else if (appData.debugMode)
15018         fprintf(debugFP, "Invalid continuation sequence \"%s\"  (maximum length is: %u)\n", new_seq, (unsigned) sizeof(cseq)-1);
15019     return ret;
15020 }
15021
15022 /*
15023     reformat a source message so words don't cross the width boundary.  internal
15024     newlines are not removed.  returns the wrapped size (no null character unless
15025     included in source message).  If dest is NULL, only calculate the size required
15026     for the dest buffer.  lp argument indicats line position upon entry, and it's
15027     passed back upon exit.
15028 */
15029 int wrap(char *dest, char *src, int count, int width, int *lp)
15030 {
15031     int len, i, ansi, cseq_len, line, old_line, old_i, old_len, clen;
15032
15033     cseq_len = strlen(cseq);
15034     old_line = line = *lp;
15035     ansi = len = clen = 0;
15036
15037     for (i=0; i < count; i++)
15038     {
15039         if (src[i] == '\033')
15040             ansi = 1;
15041
15042         // if we hit the width, back up
15043         if (!ansi && (line >= width) && src[i] != '\n' && src[i] != ' ')
15044         {
15045             // store i & len in case the word is too long
15046             old_i = i, old_len = len;
15047
15048             // find the end of the last word
15049             while (i && src[i] != ' ' && src[i] != '\n')
15050             {
15051                 i--;
15052                 len--;
15053             }
15054
15055             // word too long?  restore i & len before splitting it
15056             if ((old_i-i+clen) >= width)
15057             {
15058                 i = old_i;
15059                 len = old_len;
15060             }
15061
15062             // extra space?
15063             if (i && src[i-1] == ' ')
15064                 len--;
15065
15066             if (src[i] != ' ' && src[i] != '\n')
15067             {
15068                 i--;
15069                 if (len)
15070                     len--;
15071             }
15072
15073             // now append the newline and continuation sequence
15074             if (dest)
15075                 dest[len] = '\n';
15076             len++;
15077             if (dest)
15078                 strncpy(dest+len, cseq, cseq_len);
15079             len += cseq_len;
15080             line = cseq_len;
15081             clen = cseq_len;
15082             continue;
15083         }
15084
15085         if (dest)
15086             dest[len] = src[i];
15087         len++;
15088         if (!ansi)
15089             line++;
15090         if (src[i] == '\n')
15091             line = 0;
15092         if (src[i] == 'm')
15093             ansi = 0;
15094     }
15095     if (dest && appData.debugMode)
15096     {
15097         fprintf(debugFP, "wrap(count:%d,width:%d,line:%d,len:%d,*lp:%d,src: ",
15098             count, width, line, len, *lp);
15099         show_bytes(debugFP, src, count);
15100         fprintf(debugFP, "\ndest: ");
15101         show_bytes(debugFP, dest, len);
15102         fprintf(debugFP, "\n");
15103     }
15104     *lp = dest ? line : old_line;
15105
15106     return len;
15107 }
15108
15109 // [HGM] vari: routines for shelving variations
15110
15111 void
15112 PushTail(int firstMove, int lastMove)
15113 {
15114         int i, j, nrMoves = lastMove - firstMove;
15115
15116         if(appData.icsActive) { // only in local mode
15117                 forwardMostMove = currentMove; // mimic old ICS behavior
15118                 return;
15119         }
15120         if(storedGames >= MAX_VARIATIONS-1) return;
15121
15122         // push current tail of game on stack
15123         savedResult[storedGames] = gameInfo.result;
15124         savedDetails[storedGames] = gameInfo.resultDetails;
15125         gameInfo.resultDetails = NULL;
15126         savedFirst[storedGames] = firstMove;
15127         savedLast [storedGames] = lastMove;
15128         savedFramePtr[storedGames] = framePtr;
15129         framePtr -= nrMoves; // reserve space for the boards
15130         for(i=nrMoves; i>=1; i--) { // copy boards to stack, working downwards, in case of overlap
15131             CopyBoard(boards[framePtr+i], boards[firstMove+i]);
15132             for(j=0; j<MOVE_LEN; j++)
15133                 moveList[framePtr+i][j] = moveList[firstMove+i-1][j];
15134             for(j=0; j<2*MOVE_LEN; j++)
15135                 parseList[framePtr+i][j] = parseList[firstMove+i-1][j];
15136             timeRemaining[0][framePtr+i] = timeRemaining[0][firstMove+i];
15137             timeRemaining[1][framePtr+i] = timeRemaining[1][firstMove+i];
15138             pvInfoList[framePtr+i] = pvInfoList[firstMove+i-1];
15139             pvInfoList[firstMove+i-1].depth = 0;
15140             commentList[framePtr+i] = commentList[firstMove+i];
15141             commentList[firstMove+i] = NULL;
15142         }
15143
15144         storedGames++;
15145         forwardMostMove = firstMove; // truncate game so we can start variation
15146         if(storedGames == 1) GreyRevert(FALSE);
15147 }
15148
15149 Boolean
15150 PopTail(Boolean annotate)
15151 {
15152         int i, j, nrMoves;
15153         char buf[8000], moveBuf[20];
15154
15155         if(appData.icsActive) return FALSE; // only in local mode
15156         if(!storedGames) return FALSE; // sanity
15157         CommentPopDown(); // make sure no stale variation comments to the destroyed line can remain open
15158
15159         storedGames--;
15160         ToNrEvent(savedFirst[storedGames]); // sets currentMove
15161         nrMoves = savedLast[storedGames] - currentMove;
15162         if(annotate) {
15163                 int cnt = 10;
15164                 if(!WhiteOnMove(currentMove)) sprintf(buf, "(%d...", currentMove+2>>1);
15165                 else strcpy(buf, "(");
15166                 for(i=currentMove; i<forwardMostMove; i++) {
15167                         if(WhiteOnMove(i))
15168                              sprintf(moveBuf, " %d. %s", i+2>>1, SavePart(parseList[i]));
15169                         else sprintf(moveBuf, " %s", SavePart(parseList[i]));
15170                         strcat(buf, moveBuf);
15171                         if(commentList[i]) { strcat(buf, " "); strcat(buf, commentList[i]); }
15172                         if(!--cnt) { strcat(buf, "\n"); cnt = 10; }
15173                 }
15174                 strcat(buf, ")");
15175         }
15176         for(i=1; i<=nrMoves; i++) { // copy last variation back
15177             CopyBoard(boards[currentMove+i], boards[framePtr+i]);
15178             for(j=0; j<MOVE_LEN; j++)
15179                 moveList[currentMove+i-1][j] = moveList[framePtr+i][j];
15180             for(j=0; j<2*MOVE_LEN; j++)
15181                 parseList[currentMove+i-1][j] = parseList[framePtr+i][j];
15182             timeRemaining[0][currentMove+i] = timeRemaining[0][framePtr+i];
15183             timeRemaining[1][currentMove+i] = timeRemaining[1][framePtr+i];
15184             pvInfoList[currentMove+i-1] = pvInfoList[framePtr+i];
15185             if(commentList[currentMove+i]) free(commentList[currentMove+i]);
15186             commentList[currentMove+i] = commentList[framePtr+i];
15187             commentList[framePtr+i] = NULL;
15188         }
15189         if(annotate) AppendComment(currentMove+1, buf, FALSE);
15190         framePtr = savedFramePtr[storedGames];
15191         gameInfo.result = savedResult[storedGames];
15192         if(gameInfo.resultDetails != NULL) {
15193             free(gameInfo.resultDetails);
15194       }
15195         gameInfo.resultDetails = savedDetails[storedGames];
15196         forwardMostMove = currentMove + nrMoves;
15197         if(storedGames == 0) GreyRevert(TRUE);
15198         return TRUE;
15199 }
15200
15201 void
15202 CleanupTail()
15203 {       // remove all shelved variations
15204         int i;
15205         for(i=0; i<storedGames; i++) {
15206             if(savedDetails[i])
15207                 free(savedDetails[i]);
15208             savedDetails[i] = NULL;
15209         }
15210         for(i=framePtr; i<MAX_MOVES; i++) {
15211                 if(commentList[i]) free(commentList[i]);
15212                 commentList[i] = NULL;
15213         }
15214         framePtr = MAX_MOVES-1;
15215         storedGames = 0;
15216 }
15217
15218 void
15219 LoadVariation(int index, char *text)
15220 {       // [HGM] vari: shelve previous line and load new variation, parsed from text around text[index]
15221         char *p = text, *start = NULL, *end = NULL, wait = NULLCHAR;
15222         int level = 0, move;
15223
15224         if(gameMode != EditGame && gameMode != AnalyzeMode) return;
15225         // first find outermost bracketing variation
15226         while(*p) { // hope I got this right... Non-nesting {} and [] can screen each other and nesting ()
15227             if(!wait) { // while inside [] pr {}, ignore everyting except matching closing ]}
15228                 if(*p == '{') wait = '}'; else
15229                 if(*p == '[') wait = ']'; else
15230                 if(*p == '(' && level++ == 0 && p-text < index) start = p+1;
15231                 if(*p == ')' && level > 0 && --level == 0 && p-text > index && end == NULL) end = p-1;
15232             }
15233             if(*p == wait) wait = NULLCHAR; // closing ]} found
15234             p++;
15235         }
15236         if(!start || !end) return; // no variation found, or syntax error in PGN: ignore click
15237         if(appData.debugMode) fprintf(debugFP, "at move %d load variation '%s'\n", currentMove, start);
15238         end[1] = NULLCHAR; // clip off comment beyond variation
15239         ToNrEvent(currentMove-1);
15240         PushTail(currentMove, forwardMostMove); // shelve main variation. This truncates game
15241         // kludge: use ParsePV() to append variation to game
15242         move = currentMove;
15243         ParsePV(start, TRUE);
15244         forwardMostMove = endPV; endPV = -1; currentMove = move; // cleanup what ParsePV did
15245         ClearPremoveHighlights();
15246         CommentPopDown();
15247         ToNrEvent(currentMove+1);
15248 }
15249