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;
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);
6330                 if (appData.highlightDragging) {
6331                     SetHighlights(x, y, -1, -1);
6332                 }
6333             }
6334         }
6335         return;
6336       }
6337     }
6338
6339     /* fromX != -1 */
6340     if (clickType == Press && gameMode != EditPosition) {
6341         ChessSquare fromP;
6342         ChessSquare toP;
6343         int frc;
6344
6345         // ignore off-board to clicks
6346         if(y < 0 || x < 0) return;
6347
6348         /* Check if clicking again on the same color piece */
6349         fromP = boards[currentMove][fromY][fromX];
6350         toP = boards[currentMove][y][x];
6351         frc = gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom;
6352         if ((WhitePawn <= fromP && fromP <= WhiteKing &&
6353              WhitePawn <= toP && toP <= WhiteKing &&
6354              !(fromP == WhiteKing && toP == WhiteRook && frc) &&
6355              !(fromP == WhiteRook && toP == WhiteKing && frc)) ||
6356             (BlackPawn <= fromP && fromP <= BlackKing &&
6357              BlackPawn <= toP && toP <= BlackKing &&
6358              !(fromP == BlackRook && toP == BlackKing && frc) && // allow also RxK as FRC castling
6359              !(fromP == BlackKing && toP == BlackRook && frc))) {
6360             /* Clicked again on same color piece -- changed his mind */
6361             second = (x == fromX && y == fromY);
6362            if(!second || !OnlyMove(&x, &y, TRUE)) {
6363             if (appData.highlightDragging) {
6364                 SetHighlights(x, y, -1, -1);
6365             } else {
6366                 ClearHighlights();
6367             }
6368             if (OKToStartUserMove(x, y)) {
6369                 fromX = x;
6370                 fromY = y;
6371                 MarkTargetSquares(0);
6372                 DragPieceBegin(xPix, yPix);
6373             }
6374             return;
6375            }
6376         }
6377         // ignore clicks on holdings
6378         if(x < BOARD_LEFT || x >= BOARD_RGHT) return;
6379     }
6380
6381     if (clickType == Release && x == fromX && y == fromY) {
6382         DragPieceEnd(xPix, yPix);
6383         if (appData.animateDragging) {
6384             /* Undo animation damage if any */
6385             DrawPosition(FALSE, NULL);
6386         }
6387         if (second) {
6388             /* Second up/down in same square; just abort move */
6389             second = 0;
6390             fromX = fromY = -1;
6391             ClearHighlights();
6392             gotPremove = 0;
6393             ClearPremoveHighlights();
6394         } else {
6395             /* First upclick in same square; start click-click mode */
6396             SetHighlights(x, y, -1, -1);
6397         }
6398         return;
6399     }
6400
6401     /* we now have a different from- and (possibly off-board) to-square */
6402     /* Completed move */
6403     toX = x;
6404     toY = y;
6405     saveAnimate = appData.animate;
6406     if (clickType == Press) {
6407         /* Finish clickclick move */
6408         if (appData.animate || appData.highlightLastMove) {
6409             SetHighlights(fromX, fromY, toX, toY);
6410         } else {
6411             ClearHighlights();
6412         }
6413     } else {
6414         /* Finish drag move */
6415         if (appData.highlightLastMove) {
6416             SetHighlights(fromX, fromY, toX, toY);
6417         } else {
6418             ClearHighlights();
6419         }
6420         DragPieceEnd(xPix, yPix);
6421         /* Don't animate move and drag both */
6422         appData.animate = FALSE;
6423     }
6424
6425     // moves into holding are invalid for now (except in EditPosition, adapting to-square)
6426     if(x >= 0 && x < BOARD_LEFT || x >= BOARD_RGHT) {
6427         ChessSquare piece = boards[currentMove][fromY][fromX];
6428         if(gameMode == EditPosition && piece != EmptySquare &&
6429            fromX >= BOARD_LEFT && fromX < BOARD_RGHT) {
6430             int n;
6431
6432             if(x == BOARD_LEFT-2 && piece >= BlackPawn) {
6433                 n = PieceToNumber(piece - (int)BlackPawn);
6434                 if(n >= gameInfo.holdingsSize) { n = 0; piece = BlackPawn; }
6435                 boards[currentMove][BOARD_HEIGHT-1 - n][0] = piece;
6436                 boards[currentMove][BOARD_HEIGHT-1 - n][1]++;
6437             } else
6438             if(x == BOARD_RGHT+1 && piece < BlackPawn) {
6439                 n = PieceToNumber(piece);
6440                 if(n >= gameInfo.holdingsSize) { n = 0; piece = WhitePawn; }
6441                 boards[currentMove][n][BOARD_WIDTH-1] = piece;
6442                 boards[currentMove][n][BOARD_WIDTH-2]++;
6443             }
6444             boards[currentMove][fromY][fromX] = EmptySquare;
6445         }
6446         ClearHighlights();
6447         fromX = fromY = -1;
6448         DrawPosition(TRUE, boards[currentMove]);
6449         return;
6450     }
6451
6452     // off-board moves should not be highlighted
6453     if(x < 0 || x < 0) ClearHighlights();
6454
6455     if (HasPromotionChoice(fromX, fromY, toX, toY, &promoChoice)) {
6456         SetHighlights(fromX, fromY, toX, toY);
6457         if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
6458             // [HGM] super: promotion to captured piece selected from holdings
6459             ChessSquare p = boards[currentMove][fromY][fromX], q = boards[currentMove][toY][toX];
6460             promotionChoice = TRUE;
6461             // kludge follows to temporarily execute move on display, without promoting yet
6462             boards[currentMove][fromY][fromX] = EmptySquare; // move Pawn to 8th rank
6463             boards[currentMove][toY][toX] = p;
6464             DrawPosition(FALSE, boards[currentMove]);
6465             boards[currentMove][fromY][fromX] = p; // take back, but display stays
6466             boards[currentMove][toY][toX] = q;
6467             DisplayMessage("Click in holdings to choose piece", "");
6468             return;
6469         }
6470         PromotionPopUp();
6471     } else {
6472         UserMoveEvent(fromX, fromY, toX, toY, promoChoice);
6473         if (!appData.highlightLastMove || gotPremove) ClearHighlights();
6474         if (gotPremove) SetPremoveHighlights(fromX, fromY, toX, toY);
6475         fromX = fromY = -1;
6476     }
6477     appData.animate = saveAnimate;
6478     if (appData.animate || appData.animateDragging) {
6479         /* Undo animation damage if needed */
6480         DrawPosition(FALSE, NULL);
6481     }
6482 }
6483
6484 int RightClick(ClickType action, int x, int y, int *fromX, int *fromY)
6485 {   // front-end-free part taken out of PieceMenuPopup
6486     int whichMenu; int xSqr, ySqr;
6487
6488     if(seekGraphUp) { // [HGM] seekgraph
6489         if(action == Press)   SeekGraphClick(Press, x, y, 2); // 2 indicates right-click: no pop-down on miss
6490         if(action == Release) SeekGraphClick(Release, x, y, 2); // and no challenge on hit
6491         return -2;
6492     }
6493
6494     if((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack)
6495          && !appData.zippyPlay && appData.bgObserve) { // [HGM] bughouse: show background game
6496         if(!partnerBoardValid) return -2; // suppress display of uninitialized boards
6497         if( appData.dualBoard) return -2; // [HGM] dual: is already displayed
6498         if(action == Press)   {
6499             originalFlip = flipView;
6500             flipView = !flipView; // temporarily flip board to see game from partners perspective
6501             DrawPosition(TRUE, partnerBoard);
6502             DisplayMessage(partnerStatus, "");
6503             partnerUp = TRUE;
6504         } else if(action == Release) {
6505             flipView = originalFlip;
6506             DrawPosition(TRUE, boards[currentMove]);
6507             partnerUp = FALSE;
6508         }
6509         return -2;
6510     }
6511
6512     xSqr = EventToSquare(x, BOARD_WIDTH);
6513     ySqr = EventToSquare(y, BOARD_HEIGHT);
6514     if (action == Release) UnLoadPV(); // [HGM] pv
6515     if (action != Press) return -2; // return code to be ignored
6516     switch (gameMode) {
6517       case IcsExamining:
6518         if(xSqr < BOARD_LEFT || xSqr >= BOARD_RGHT) return -1;\r
6519       case EditPosition:
6520         if (xSqr == BOARD_LEFT-1 || xSqr == BOARD_RGHT) return -1;\r
6521         if (xSqr < 0 || ySqr < 0) return -1;\r
6522         whichMenu = 0; // edit-position menu
6523         break;
6524       case IcsObserving:
6525         if(!appData.icsEngineAnalyze) return -1;
6526       case IcsPlayingWhite:
6527       case IcsPlayingBlack:
6528         if(!appData.zippyPlay) goto noZip;
6529       case AnalyzeMode:
6530       case AnalyzeFile:
6531       case MachinePlaysWhite:
6532       case MachinePlaysBlack:
6533       case TwoMachinesPlay: // [HGM] pv: use for showing PV
6534         if (!appData.dropMenu) {
6535           LoadPV(x, y);
6536           return 2; // flag front-end to grab mouse events
6537         }
6538         if(gameMode == TwoMachinesPlay || gameMode == AnalyzeMode ||
6539            gameMode == AnalyzeFile || gameMode == IcsObserving) return -1;
6540       case EditGame:
6541       noZip:
6542         if (xSqr < 0 || ySqr < 0) return -1;
6543         if (!appData.dropMenu || appData.testLegality &&
6544             gameInfo.variant != VariantBughouse &&
6545             gameInfo.variant != VariantCrazyhouse) return -1;
6546         whichMenu = 1; // drop menu
6547         break;
6548       default:
6549         return -1;
6550     }
6551
6552     if (((*fromX = xSqr) < 0) ||
6553         ((*fromY = ySqr) < 0)) {
6554         *fromX = *fromY = -1;
6555         return -1;
6556     }
6557     if (flipView)
6558       *fromX = BOARD_WIDTH - 1 - *fromX;
6559     else
6560       *fromY = BOARD_HEIGHT - 1 - *fromY;
6561
6562     return whichMenu;
6563 }
6564
6565 void SendProgramStatsToFrontend( ChessProgramState * cps, ChessProgramStats * cpstats )
6566 {
6567 //    char * hint = lastHint;
6568     FrontEndProgramStats stats;
6569
6570     stats.which = cps == &first ? 0 : 1;
6571     stats.depth = cpstats->depth;
6572     stats.nodes = cpstats->nodes;
6573     stats.score = cpstats->score;
6574     stats.time = cpstats->time;
6575     stats.pv = cpstats->movelist;
6576     stats.hint = lastHint;
6577     stats.an_move_index = 0;
6578     stats.an_move_count = 0;
6579
6580     if( gameMode == AnalyzeMode || gameMode == AnalyzeFile ) {
6581         stats.hint = cpstats->move_name;
6582         stats.an_move_index = cpstats->nr_moves - cpstats->moves_left;
6583         stats.an_move_count = cpstats->nr_moves;
6584     }
6585
6586     if(stats.pv && stats.pv[0]) strcpy(lastPV[stats.which], stats.pv); // [HGM] pv: remember last PV of each
6587
6588     SetProgramStats( &stats );
6589 }
6590
6591 int
6592 Adjudicate(ChessProgramState *cps)
6593 {       // [HGM] some adjudications useful with buggy engines
6594         // [HGM] adjudicate: made into separate routine, which now can be called after every move
6595         //       In any case it determnes if the game is a claimable draw (filling in EP_STATUS).
6596         //       Actually ending the game is now based on the additional internal condition canAdjudicate.
6597         //       Only when the game is ended, and the opponent is a computer, this opponent gets the move relayed.
6598         int k, count = 0; static int bare = 1;
6599         ChessProgramState *engineOpponent = (gameMode == TwoMachinesPlay ? cps->other : (cps ? NULL : &first));
6600         Boolean canAdjudicate = !appData.icsActive;
6601
6602         // most tests only when we understand the game, i.e. legality-checking on, and (for the time being) no piece drops
6603         if(gameInfo.holdingsSize == 0 || gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
6604             if( appData.testLegality )
6605             {   /* [HGM] Some more adjudications for obstinate engines */
6606                 int NrWN=0, NrBN=0, NrWB=0, NrBB=0, NrWR=0, NrBR=0,
6607                     NrWQ=0, NrBQ=0, NrW=0, NrK=0, bishopsColor = 0,
6608                     NrPieces=0, NrPawns=0, PawnAdvance=0, i, j;
6609                 static int moveCount = 6;
6610                 ChessMove result;
6611                 char *reason = NULL;
6612
6613                 /* Count what is on board. */
6614                 for(i=0; i<BOARD_HEIGHT; i++) for(j=BOARD_LEFT; j<BOARD_RGHT; j++)
6615                 {   ChessSquare p = boards[forwardMostMove][i][j];
6616                     int m=i;
6617
6618                     switch((int) p)
6619                     {   /* count B,N,R and other of each side */
6620                         case WhiteKing:
6621                         case BlackKing:
6622                              NrK++; break; // [HGM] atomic: count Kings
6623                         case WhiteKnight:
6624                              NrWN++; break;
6625                         case WhiteBishop:
6626                         case WhiteFerz:    // [HGM] shatranj: kludge to mke it work in shatranj
6627                              bishopsColor |= 1 << ((i^j)&1);
6628                              NrWB++; break;
6629                         case BlackKnight:
6630                              NrBN++; break;
6631                         case BlackBishop:
6632                         case BlackFerz:    // [HGM] shatranj: kludge to mke it work in shatranj
6633                              bishopsColor |= 1 << ((i^j)&1);
6634                              NrBB++; break;
6635                         case WhiteRook:
6636                              NrWR++; break;
6637                         case BlackRook:
6638                              NrBR++; break;
6639                         case WhiteQueen:
6640                              NrWQ++; break;
6641                         case BlackQueen:
6642                              NrBQ++; break;
6643                         case EmptySquare:
6644                              break;
6645                         case BlackPawn:
6646                              m = 7-i;
6647                         case WhitePawn:
6648                              PawnAdvance += m; NrPawns++;
6649                     }
6650                     NrPieces += (p != EmptySquare);
6651                     NrW += ((int)p < (int)BlackPawn);
6652                     if(gameInfo.variant == VariantXiangqi &&
6653                       (p == WhiteFerz || p == WhiteAlfil || p == BlackFerz || p == BlackAlfil)) {
6654                         NrPieces--; // [HGM] XQ: do not count purely defensive pieces
6655                         NrW -= ((int)p < (int)BlackPawn);
6656                     }
6657                 }
6658
6659                 /* Some material-based adjudications that have to be made before stalemate test */
6660                 if(gameInfo.variant == VariantAtomic && NrK < 2) {
6661                     // [HGM] atomic: stm must have lost his King on previous move, as destroying own K is illegal
6662                      boards[forwardMostMove][EP_STATUS] = EP_CHECKMATE; // make claimable as if stm is checkmated
6663                      if(canAdjudicate && appData.checkMates) {
6664                          if(engineOpponent)
6665                            SendMoveToProgram(forwardMostMove-1, engineOpponent); // make sure opponent gets move
6666                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6667                          GameEnds( WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins,
6668                                                         "Xboard adjudication: King destroyed", GE_XBOARD );
6669                          return 1;
6670                      }
6671                 }
6672
6673                 /* Bare King in Shatranj (loses) or Losers (wins) */
6674                 if( NrW == 1 || NrPieces - NrW == 1) {
6675                   if( gameInfo.variant == VariantLosers) { // [HGM] losers: bare King wins (stm must have it first)
6676                      boards[forwardMostMove][EP_STATUS] = EP_WINS;  // mark as win, so it becomes claimable
6677                      if(canAdjudicate && appData.checkMates) {
6678                          if(engineOpponent)
6679                            SendMoveToProgram(forwardMostMove-1, engineOpponent); // make sure opponent gets to see move
6680                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6681                          GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
6682                                                         "Xboard adjudication: Bare king", GE_XBOARD );
6683                          return 1;
6684                      }
6685                   } else
6686                   if( gameInfo.variant == VariantShatranj && --bare < 0)
6687                   {    /* bare King */
6688                         boards[forwardMostMove][EP_STATUS] = EP_WINS; // make claimable as win for stm
6689                         if(canAdjudicate && appData.checkMates) {
6690                             /* but only adjudicate if adjudication enabled */
6691                             if(engineOpponent)
6692                               SendMoveToProgram(forwardMostMove-1, engineOpponent); // make sure opponent gets move
6693                             ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6694                             GameEnds( NrW > 1 ? WhiteWins : NrPieces - NrW > 1 ? BlackWins : GameIsDrawn,
6695                                                         "Xboard adjudication: Bare king", GE_XBOARD );
6696                             return 1;
6697                         }
6698                   }
6699                 } else bare = 1;
6700
6701
6702             // don't wait for engine to announce game end if we can judge ourselves
6703             switch (MateTest(boards[forwardMostMove], PosFlags(forwardMostMove)) ) {
6704               case MT_CHECK:
6705                 if(gameInfo.variant == Variant3Check) { // [HGM] 3check: when in check, test if 3rd time
6706                     int i, checkCnt = 0;    // (should really be done by making nr of checks part of game state)
6707                     for(i=forwardMostMove-2; i>=backwardMostMove; i-=2) {
6708                         if(MateTest(boards[i], PosFlags(i)) == MT_CHECK)
6709                             checkCnt++;
6710                         if(checkCnt >= 2) {
6711                             reason = "Xboard adjudication: 3rd check";
6712                             boards[forwardMostMove][EP_STATUS] = EP_CHECKMATE;
6713                             break;
6714                         }
6715                     }
6716                 }
6717               case MT_NONE:
6718               default:
6719                 break;
6720               case MT_STALEMATE:
6721               case MT_STAINMATE:
6722                 reason = "Xboard adjudication: Stalemate";
6723                 if((signed char)boards[forwardMostMove][EP_STATUS] != EP_CHECKMATE) { // [HGM] don't touch win through baring or K-capt
6724                     boards[forwardMostMove][EP_STATUS] = EP_STALEMATE;   // default result for stalemate is draw
6725                     if(gameInfo.variant == VariantLosers  || gameInfo.variant == VariantGiveaway) // [HGM] losers:
6726                         boards[forwardMostMove][EP_STATUS] = EP_WINS;    // in these variants stalemated is always a win
6727                     else if(gameInfo.variant == VariantSuicide) // in suicide it depends
6728                         boards[forwardMostMove][EP_STATUS] = NrW == NrPieces-NrW ? EP_STALEMATE :
6729                                                    ((NrW < NrPieces-NrW) != WhiteOnMove(forwardMostMove) ?
6730                                                                         EP_CHECKMATE : EP_WINS);
6731                     else if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantXiangqi)
6732                         boards[forwardMostMove][EP_STATUS] = EP_CHECKMATE; // and in these variants being stalemated loses
6733                 }
6734                 break;
6735               case MT_CHECKMATE:
6736                 reason = "Xboard adjudication: Checkmate";
6737                 boards[forwardMostMove][EP_STATUS] = (gameInfo.variant == VariantLosers ? EP_WINS : EP_CHECKMATE);
6738                 break;
6739             }
6740
6741                 switch(i = (signed char)boards[forwardMostMove][EP_STATUS]) {
6742                     case EP_STALEMATE:
6743                         result = GameIsDrawn; break;
6744                     case EP_CHECKMATE:
6745                         result = WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins; break;
6746                     case EP_WINS:
6747                         result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins; break;
6748                     default:
6749                         result = (ChessMove) 0;
6750                 }
6751                 if(canAdjudicate && appData.checkMates && result) { // [HGM] mates: adjudicate finished games if requested
6752                     if(engineOpponent)
6753                       SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
6754                     ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6755                     GameEnds( result, reason, GE_XBOARD );
6756                     return 1;
6757                 }
6758
6759                 /* Next absolutely insufficient mating material. */
6760                 if( NrPieces == 2 || gameInfo.variant != VariantXiangqi &&
6761                                      gameInfo.variant != VariantShatranj && // [HGM] baring will remain possible
6762                         (NrPieces == 3 && NrWN+NrBN+NrWB+NrBB == 1 ||
6763                          NrPieces == NrBB+NrWB+2 && bishopsColor != 3)) // [HGM] all Bishops (Ferz!) same color
6764                 {    /* KBK, KNK, KK of KBKB with like Bishops */
6765
6766                      /* always flag draws, for judging claims */
6767                      boards[forwardMostMove][EP_STATUS] = EP_INSUF_DRAW;
6768
6769                      if(canAdjudicate && appData.materialDraws) {
6770                          /* but only adjudicate them if adjudication enabled */
6771                          if(engineOpponent) {
6772                            SendToProgram("force\n", engineOpponent); // suppress reply
6773                            SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see last move */
6774                          }
6775                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6776                          GameEnds( GameIsDrawn, "Xboard adjudication: Insufficient mating material", GE_XBOARD );
6777                          return 1;
6778                      }
6779                 }
6780
6781                 /* Then some trivial draws (only adjudicate, cannot be claimed) */
6782                 if(NrPieces == 4 &&
6783                    (   NrWR == 1 && NrBR == 1 /* KRKR */
6784                    || NrWQ==1 && NrBQ==1     /* KQKQ */
6785                    || NrWN==2 || NrBN==2     /* KNNK */
6786                    || NrWN+NrWB == 1 && NrBN+NrBB == 1 /* KBKN, KBKB, KNKN */
6787                   ) ) {
6788                      if(--moveCount < 0 && appData.trivialDraws && canAdjudicate)
6789                      {    /* if the first 3 moves do not show a tactical win, declare draw */
6790                           if(engineOpponent) {
6791                             SendToProgram("force\n", engineOpponent); // suppress reply
6792                             SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
6793                           }
6794                           ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6795                           GameEnds( GameIsDrawn, "Xboard adjudication: Trivial draw", GE_XBOARD );
6796                           return 1;
6797                      }
6798                 } else moveCount = 6;
6799             }
6800         }
6801
6802         if (appData.debugMode) { int i;
6803             fprintf(debugFP, "repeat test fmm=%d bmm=%d ep=%d, reps=%d\n",
6804                     forwardMostMove, backwardMostMove, boards[backwardMostMove][EP_STATUS],
6805                     appData.drawRepeats);
6806             for( i=forwardMostMove; i>=backwardMostMove; i-- )
6807               fprintf(debugFP, "%d ep=%d\n", i, (signed char)boards[i][EP_STATUS]);
6808
6809         }
6810
6811         // Repetition draws and 50-move rule can be applied independently of legality testing
6812
6813                 /* Check for rep-draws */
6814                 count = 0;
6815                 for(k = forwardMostMove-2;
6816                     k>=backwardMostMove && k>=forwardMostMove-100 &&
6817                         (signed char)boards[k][EP_STATUS] < EP_UNKNOWN &&
6818                         (signed char)boards[k+2][EP_STATUS] <= EP_NONE && (signed char)boards[k+1][EP_STATUS] <= EP_NONE;
6819                     k-=2)
6820                 {   int rights=0;
6821                     if(CompareBoards(boards[k], boards[forwardMostMove])) {
6822                         /* compare castling rights */
6823                         if( boards[forwardMostMove][CASTLING][2] != boards[k][CASTLING][2] &&
6824                              (boards[k][CASTLING][0] != NoRights || boards[k][CASTLING][1] != NoRights) )
6825                                 rights++; /* King lost rights, while rook still had them */
6826                         if( boards[forwardMostMove][CASTLING][2] != NoRights ) { /* king has rights */
6827                             if( boards[forwardMostMove][CASTLING][0] != boards[k][CASTLING][0] ||
6828                                 boards[forwardMostMove][CASTLING][1] != boards[k][CASTLING][1] )
6829                                    rights++; /* but at least one rook lost them */
6830                         }
6831                         if( boards[forwardMostMove][CASTLING][5] != boards[k][CASTLING][5] &&
6832                              (boards[k][CASTLING][3] != NoRights || boards[k][CASTLING][4] != NoRights) )
6833                                 rights++;
6834                         if( boards[forwardMostMove][CASTLING][5] != NoRights ) {
6835                             if( boards[forwardMostMove][CASTLING][3] != boards[k][CASTLING][3] ||
6836                                 boards[forwardMostMove][CASTLING][4] != boards[k][CASTLING][4] )
6837                                    rights++;
6838                         }
6839                         if( rights == 0 && ++count > appData.drawRepeats-2 && canAdjudicate
6840                             && appData.drawRepeats > 1) {
6841                              /* adjudicate after user-specified nr of repeats */
6842                              int result = GameIsDrawn;
6843                              char *details = "XBoard adjudication: repetition draw";
6844                              if(gameInfo.variant == VariantXiangqi && appData.testLegality) {
6845                                 // [HGM] xiangqi: check for forbidden perpetuals
6846                                 int m, ourPerpetual = 1, hisPerpetual = 1;
6847                                 for(m=forwardMostMove; m>k; m-=2) {
6848                                     if(MateTest(boards[m], PosFlags(m)) != MT_CHECK)
6849                                         ourPerpetual = 0; // the current mover did not always check
6850                                     if(MateTest(boards[m-1], PosFlags(m-1)) != MT_CHECK)
6851                                         hisPerpetual = 0; // the opponent did not always check
6852                                 }
6853                                 if(appData.debugMode) fprintf(debugFP, "XQ perpetual test, our=%d, his=%d\n",
6854                                                                         ourPerpetual, hisPerpetual);
6855                                 if(ourPerpetual && !hisPerpetual) { // we are actively checking him: forfeit
6856                                     result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
6857                                     details = "Xboard adjudication: perpetual checking";
6858                                 } else
6859                                 if(hisPerpetual && !ourPerpetual) { // he is checking us, but did not repeat yet
6860                                     break; // (or we would have caught him before). Abort repetition-checking loop.
6861                                 } else
6862                                 // Now check for perpetual chases
6863                                 if(!ourPerpetual && !hisPerpetual) { // no perpetual check, test for chase
6864                                     hisPerpetual = PerpetualChase(k, forwardMostMove);
6865                                     ourPerpetual = PerpetualChase(k+1, forwardMostMove);
6866                                     if(ourPerpetual && !hisPerpetual) { // we are actively chasing him: forfeit
6867                                         result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
6868                                         details = "Xboard adjudication: perpetual chasing";
6869                                     } else
6870                                     if(hisPerpetual && !ourPerpetual)   // he is chasing us, but did not repeat yet
6871                                         break; // Abort repetition-checking loop.
6872                                 }
6873                                 // if neither of us is checking or chasing all the time, or both are, it is draw
6874                              }
6875                              if(engineOpponent) {
6876                                SendToProgram("force\n", engineOpponent); // suppress reply
6877                                SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
6878                              }
6879                              ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6880                              GameEnds( result, details, GE_XBOARD );
6881                              return 1;
6882                         }
6883                         if( rights == 0 && count > 1 ) /* occurred 2 or more times before */
6884                              boards[forwardMostMove][EP_STATUS] = EP_REP_DRAW;
6885                     }
6886                 }
6887
6888                 /* Now we test for 50-move draws. Determine ply count */
6889                 count = forwardMostMove;
6890                 /* look for last irreversble move */
6891                 while( (signed char)boards[count][EP_STATUS] <= EP_NONE && count > backwardMostMove )
6892                     count--;
6893                 /* if we hit starting position, add initial plies */
6894                 if( count == backwardMostMove )
6895                     count -= initialRulePlies;
6896                 count = forwardMostMove - count;
6897                 if( count >= 100)
6898                          boards[forwardMostMove][EP_STATUS] = EP_RULE_DRAW;
6899                          /* this is used to judge if draw claims are legal */
6900                 if(canAdjudicate && appData.ruleMoves > 0 && count >= 2*appData.ruleMoves) {
6901                          if(engineOpponent) {
6902                            SendToProgram("force\n", engineOpponent); // suppress reply
6903                            SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
6904                          }
6905                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6906                          GameEnds( GameIsDrawn, "Xboard adjudication: 50-move rule", GE_XBOARD );
6907                          return 1;
6908                 }
6909
6910                 /* if draw offer is pending, treat it as a draw claim
6911                  * when draw condition present, to allow engines a way to
6912                  * claim draws before making their move to avoid a race
6913                  * condition occurring after their move
6914                  */
6915                 if((gameMode == TwoMachinesPlay ? second.offeredDraw : userOfferedDraw) || first.offeredDraw ) {
6916                          char *p = NULL;
6917                          if((signed char)boards[forwardMostMove][EP_STATUS] == EP_RULE_DRAW)
6918                              p = "Draw claim: 50-move rule";
6919                          if((signed char)boards[forwardMostMove][EP_STATUS] == EP_REP_DRAW)
6920                              p = "Draw claim: 3-fold repetition";
6921                          if((signed char)boards[forwardMostMove][EP_STATUS] == EP_INSUF_DRAW)
6922                              p = "Draw claim: insufficient mating material";
6923                          if( p != NULL && canAdjudicate) {
6924                              if(engineOpponent) {
6925                                SendToProgram("force\n", engineOpponent); // suppress reply
6926                                SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
6927                              }
6928                              ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6929                              GameEnds( GameIsDrawn, p, GE_XBOARD );
6930                              return 1;
6931                          }
6932                 }
6933
6934                 if( canAdjudicate && appData.adjudicateDrawMoves > 0 && forwardMostMove > (2*appData.adjudicateDrawMoves) ) {
6935                     if(engineOpponent) {
6936                       SendToProgram("force\n", engineOpponent); // suppress reply
6937                       SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
6938                     }
6939                     ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6940                     GameEnds( GameIsDrawn, "Xboard adjudication: long game", GE_XBOARD );
6941                     return 1;
6942                 }
6943         return 0;
6944 }
6945
6946 char *SendMoveToBookUser(int moveNr, ChessProgramState *cps, int initial)
6947 {   // [HGM] book: this routine intercepts moves to simulate book replies
6948     char *bookHit = NULL;
6949
6950     //first determine if the incoming move brings opponent into his book
6951     if(appData.usePolyglotBook && (cps == &first ? !appData.firstHasOwnBookUCI : !appData.secondHasOwnBookUCI))
6952         bookHit = ProbeBook(moveNr+1, appData.polyglotBook); // returns move
6953     if(appData.debugMode) fprintf(debugFP, "book hit = %s\n", bookHit ? bookHit : "(NULL)");
6954     if(bookHit != NULL && !cps->bookSuspend) {
6955         // make sure opponent is not going to reply after receiving move to book position
6956         SendToProgram("force\n", cps);
6957         cps->bookSuspend = TRUE; // flag indicating it has to be restarted
6958     }
6959     if(!initial) SendMoveToProgram(moveNr, cps); // with hit on initial position there is no move
6960     // now arrange restart after book miss
6961     if(bookHit) {
6962         // after a book hit we never send 'go', and the code after the call to this routine
6963         // has '&& !bookHit' added to suppress potential sending there (based on 'firstMove').
6964         char buf[MSG_SIZ];
6965         if (cps->useUsermove) sprintf(buf, "usermove "); // sorry, no SAN yet :(
6966         sprintf(buf, "%s\n", bookHit); // force book move into program supposed to play it
6967         SendToProgram(buf, cps);
6968         if(!initial) firstMove = FALSE; // normally we would clear the firstMove condition after return & sending 'go'
6969     } else if(initial) { // 'go' was needed irrespective of firstMove, and it has to be done in this routine
6970         SendToProgram("go\n", cps);
6971         cps->bookSuspend = FALSE; // after a 'go' we are never suspended
6972     } else { // 'go' might be sent based on 'firstMove' after this routine returns
6973         if(cps->bookSuspend && !firstMove) // 'go' needed, and it will not be done after we return
6974             SendToProgram("go\n", cps);
6975         cps->bookSuspend = FALSE; // anyhow, we will not be suspended after a miss
6976     }
6977     return bookHit; // notify caller of hit, so it can take action to send move to opponent
6978 }
6979
6980 char *savedMessage;
6981 ChessProgramState *savedState;
6982 void DeferredBookMove(void)
6983 {
6984         if(savedState->lastPing != savedState->lastPong)
6985                     ScheduleDelayedEvent(DeferredBookMove, 10);
6986         else
6987         HandleMachineMove(savedMessage, savedState);
6988 }
6989
6990 void
6991 HandleMachineMove(message, cps)
6992      char *message;
6993      ChessProgramState *cps;
6994 {
6995     char machineMove[MSG_SIZ], buf1[MSG_SIZ*10], buf2[MSG_SIZ];
6996     char realname[MSG_SIZ];
6997     int fromX, fromY, toX, toY;
6998     ChessMove moveType;
6999     char promoChar;
7000     char *p;
7001     int machineWhite;
7002     char *bookHit;
7003
7004     cps->userError = 0;
7005
7006 FakeBookMove: // [HGM] book: we jump here to simulate machine moves after book hit
7007     /*
7008      * Kludge to ignore BEL characters
7009      */
7010     while (*message == '\007') message++;
7011
7012     /*
7013      * [HGM] engine debug message: ignore lines starting with '#' character
7014      */
7015     if(cps->debug && *message == '#') return;
7016
7017     /*
7018      * Look for book output
7019      */
7020     if (cps == &first && bookRequested) {
7021         if (message[0] == '\t' || message[0] == ' ') {
7022             /* Part of the book output is here; append it */
7023             strcat(bookOutput, message);
7024             strcat(bookOutput, "  \n");
7025             return;
7026         } else if (bookOutput[0] != NULLCHAR) {
7027             /* All of book output has arrived; display it */
7028             char *p = bookOutput;
7029             while (*p != NULLCHAR) {
7030                 if (*p == '\t') *p = ' ';
7031                 p++;
7032             }
7033             DisplayInformation(bookOutput);
7034             bookRequested = FALSE;
7035             /* Fall through to parse the current output */
7036         }
7037     }
7038
7039     /*
7040      * Look for machine move.
7041      */
7042     if ((sscanf(message, "%s %s %s", buf1, buf2, machineMove) == 3 && strcmp(buf2, "...") == 0) ||
7043         (sscanf(message, "%s %s", buf1, machineMove) == 2 && strcmp(buf1, "move") == 0))
7044     {
7045         /* This method is only useful on engines that support ping */
7046         if (cps->lastPing != cps->lastPong) {
7047           if (gameMode == BeginningOfGame) {
7048             /* Extra move from before last new; ignore */
7049             if (appData.debugMode) {
7050                 fprintf(debugFP, "Ignoring extra move from %s\n", cps->which);
7051             }
7052           } else {
7053             if (appData.debugMode) {
7054                 fprintf(debugFP, "Undoing extra move from %s, gameMode %d\n",
7055                         cps->which, gameMode);
7056             }
7057
7058             SendToProgram("undo\n", cps);
7059           }
7060           return;
7061         }
7062
7063         switch (gameMode) {
7064           case BeginningOfGame:
7065             /* Extra move from before last reset; ignore */
7066             if (appData.debugMode) {
7067                 fprintf(debugFP, "Ignoring extra move from %s\n", cps->which);
7068             }
7069             return;
7070
7071           case EndOfGame:
7072           case IcsIdle:
7073           default:
7074             /* Extra move after we tried to stop.  The mode test is
7075                not a reliable way of detecting this problem, but it's
7076                the best we can do on engines that don't support ping.
7077             */
7078             if (appData.debugMode) {
7079                 fprintf(debugFP, "Undoing extra move from %s, gameMode %d\n",
7080                         cps->which, gameMode);
7081             }
7082             SendToProgram("undo\n", cps);
7083             return;
7084
7085           case MachinePlaysWhite:
7086           case IcsPlayingWhite:
7087             machineWhite = TRUE;
7088             break;
7089
7090           case MachinePlaysBlack:
7091           case IcsPlayingBlack:
7092             machineWhite = FALSE;
7093             break;
7094
7095           case TwoMachinesPlay:
7096             machineWhite = (cps->twoMachinesColor[0] == 'w');
7097             break;
7098         }
7099         if (WhiteOnMove(forwardMostMove) != machineWhite) {
7100             if (appData.debugMode) {
7101                 fprintf(debugFP,
7102                         "Ignoring move out of turn by %s, gameMode %d"
7103                         ", forwardMost %d\n",
7104                         cps->which, gameMode, forwardMostMove);
7105             }
7106             return;
7107         }
7108
7109     if (appData.debugMode) { int f = forwardMostMove;
7110         fprintf(debugFP, "machine move %d, castling = %d %d %d %d %d %d\n", f,
7111                 boards[f][CASTLING][0],boards[f][CASTLING][1],boards[f][CASTLING][2],
7112                 boards[f][CASTLING][3],boards[f][CASTLING][4],boards[f][CASTLING][5]);
7113     }
7114         if(cps->alphaRank) AlphaRank(machineMove, 4);
7115         if (!ParseOneMove(machineMove, forwardMostMove, &moveType,
7116                               &fromX, &fromY, &toX, &toY, &promoChar)) {
7117             /* Machine move could not be parsed; ignore it. */
7118             sprintf(buf1, _("Illegal move \"%s\" from %s machine"),
7119                     machineMove, cps->which);
7120             DisplayError(buf1, 0);
7121             sprintf(buf1, "Xboard: Forfeit due to invalid move: %s (%c%c%c%c) res=%d",
7122                     machineMove, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, moveType);
7123             if (gameMode == TwoMachinesPlay) {
7124               GameEnds(machineWhite ? BlackWins : WhiteWins,
7125                        buf1, GE_XBOARD);
7126             }
7127             return;
7128         }
7129
7130         /* [HGM] Apparently legal, but so far only tested with EP_UNKOWN */
7131         /* So we have to redo legality test with true e.p. status here,  */
7132         /* to make sure an illegal e.p. capture does not slip through,   */
7133         /* to cause a forfeit on a justified illegal-move complaint      */
7134         /* of the opponent.                                              */
7135         if( gameMode==TwoMachinesPlay && appData.testLegality
7136             && fromY != DROP_RANK /* [HGM] temporary; should still add legality test for drops */
7137                                                               ) {
7138            ChessMove moveType;
7139            moveType = LegalityTest(boards[forwardMostMove], PosFlags(forwardMostMove),
7140                              fromY, fromX, toY, toX, promoChar);
7141             if (appData.debugMode) {
7142                 int i;
7143                 for(i=0; i< nrCastlingRights; i++) fprintf(debugFP, "(%d,%d) ",
7144                     boards[forwardMostMove][CASTLING][i], castlingRank[i]);
7145                 fprintf(debugFP, "castling rights\n");
7146             }
7147             if(moveType == IllegalMove) {
7148                 sprintf(buf1, "Xboard: Forfeit due to illegal move: %s (%c%c%c%c)%c",
7149                         machineMove, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, 0);
7150                 GameEnds(machineWhite ? BlackWins : WhiteWins,
7151                            buf1, GE_XBOARD);
7152                 return;
7153            } else if(gameInfo.variant != VariantFischeRandom && gameInfo.variant != VariantCapaRandom)
7154            /* [HGM] Kludge to handle engines that send FRC-style castling
7155               when they shouldn't (like TSCP-Gothic) */
7156            switch(moveType) {
7157              case WhiteASideCastleFR:
7158              case BlackASideCastleFR:
7159                toX+=2;
7160                currentMoveString[2]++;
7161                break;
7162              case WhiteHSideCastleFR:
7163              case BlackHSideCastleFR:
7164                toX--;
7165                currentMoveString[2]--;
7166                break;
7167              default: ; // nothing to do, but suppresses warning of pedantic compilers
7168            }
7169         }
7170         hintRequested = FALSE;
7171         lastHint[0] = NULLCHAR;
7172         bookRequested = FALSE;
7173         /* Program may be pondering now */
7174         cps->maybeThinking = TRUE;
7175         if (cps->sendTime == 2) cps->sendTime = 1;
7176         if (cps->offeredDraw) cps->offeredDraw--;
7177
7178         /* currentMoveString is set as a side-effect of ParseOneMove */
7179         strcpy(machineMove, currentMoveString);
7180         strcat(machineMove, "\n");
7181         strcpy(moveList[forwardMostMove], machineMove);
7182
7183         MakeMove(fromX, fromY, toX, toY, promoChar);/*updates forwardMostMove*/
7184
7185         /* [AS] Adjudicate game if needed (note: remember that forwardMostMove now points past the last move) */
7186         if( gameMode == TwoMachinesPlay && adjudicateLossThreshold != 0 && forwardMostMove >= adjudicateLossPlies ) {
7187             int count = 0;
7188
7189             while( count < adjudicateLossPlies ) {
7190                 int score = pvInfoList[ forwardMostMove - count - 1 ].score;
7191
7192                 if( count & 1 ) {
7193                     score = -score; /* Flip score for winning side */
7194                 }
7195
7196                 if( score > adjudicateLossThreshold ) {
7197                     break;
7198                 }
7199
7200                 count++;
7201             }
7202
7203             if( count >= adjudicateLossPlies ) {
7204                 ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
7205
7206                 GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
7207                     "Xboard adjudication",
7208                     GE_XBOARD );
7209
7210                 return;
7211             }
7212         }
7213
7214         if(Adjudicate(cps)) return; // [HGM] adjudicate: for all automatic game ends
7215
7216 #if ZIPPY
7217         if ((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack) &&
7218             first.initDone) {
7219           if(cps->offeredDraw && (signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
7220                 SendToICS(ics_prefix); // [HGM] drawclaim: send caim and move on one line for FICS
7221                 SendToICS("draw ");
7222                 SendMoveToICS(moveType, fromX, fromY, toX, toY);
7223           }
7224           SendMoveToICS(moveType, fromX, fromY, toX, toY);
7225           ics_user_moved = 1;
7226           if(appData.autoKibitz && !appData.icsEngineAnalyze ) { /* [HGM] kibitz: send most-recent PV info to ICS */
7227                 char buf[3*MSG_SIZ];
7228
7229                 sprintf(buf, "kibitz !!! %+.2f/%d (%.2f sec, %u nodes, %.0f knps) PV=%s\n",
7230                         programStats.score / 100.,
7231                         programStats.depth,
7232                         programStats.time / 100.,
7233                         (unsigned int)programStats.nodes,
7234                         (unsigned int)programStats.nodes / (10*abs(programStats.time) + 1.),
7235                         programStats.movelist);
7236                 SendToICS(buf);
7237 if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.nodes, programStats.nodes);
7238           }
7239         }
7240 #endif
7241
7242         /* [AS] Save move info and clear stats for next move */
7243         pvInfoList[ forwardMostMove-1 ].score = programStats.score;
7244         pvInfoList[ forwardMostMove-1 ].depth = programStats.depth;
7245         pvInfoList[ forwardMostMove-1 ].time =  programStats.time; // [HGM] PGNtime: take time from engine stats
7246         ClearProgramStats();
7247         thinkOutput[0] = NULLCHAR;
7248         hiddenThinkOutputState = 0;
7249
7250         bookHit = NULL;
7251         if (gameMode == TwoMachinesPlay) {
7252             /* [HGM] relaying draw offers moved to after reception of move */
7253             /* and interpreting offer as claim if it brings draw condition */
7254             if (cps->offeredDraw == 1 && cps->other->sendDrawOffers) {
7255                 SendToProgram("draw\n", cps->other);
7256             }
7257             if (cps->other->sendTime) {
7258                 SendTimeRemaining(cps->other,
7259                                   cps->other->twoMachinesColor[0] == 'w');
7260             }
7261             bookHit = SendMoveToBookUser(forwardMostMove-1, cps->other, FALSE);
7262             if (firstMove && !bookHit) {
7263                 firstMove = FALSE;
7264                 if (cps->other->useColors) {
7265                   SendToProgram(cps->other->twoMachinesColor, cps->other);
7266                 }
7267                 SendToProgram("go\n", cps->other);
7268             }
7269             cps->other->maybeThinking = TRUE;
7270         }
7271
7272         ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
7273
7274         if (!pausing && appData.ringBellAfterMoves) {
7275             RingBell();
7276         }
7277
7278         /*
7279          * Reenable menu items that were disabled while
7280          * machine was thinking
7281          */
7282         if (gameMode != TwoMachinesPlay)
7283             SetUserThinkingEnables();
7284
7285         // [HGM] book: after book hit opponent has received move and is now in force mode
7286         // force the book reply into it, and then fake that it outputted this move by jumping
7287         // back to the beginning of HandleMachineMove, with cps toggled and message set to this move
7288         if(bookHit) {
7289                 static char bookMove[MSG_SIZ]; // a bit generous?
7290
7291                 strcpy(bookMove, "move ");
7292                 strcat(bookMove, bookHit);
7293                 message = bookMove;
7294                 cps = cps->other;
7295                 programStats.nodes = programStats.depth = programStats.time =
7296                 programStats.score = programStats.got_only_move = 0;
7297                 sprintf(programStats.movelist, "%s (xbook)", bookHit);
7298
7299                 if(cps->lastPing != cps->lastPong) {
7300                     savedMessage = message; // args for deferred call
7301                     savedState = cps;
7302                     ScheduleDelayedEvent(DeferredBookMove, 10);
7303                     return;
7304                 }
7305                 goto FakeBookMove;
7306         }
7307
7308         return;
7309     }
7310
7311     /* Set special modes for chess engines.  Later something general
7312      *  could be added here; for now there is just one kludge feature,
7313      *  needed because Crafty 15.10 and earlier don't ignore SIGINT
7314      *  when "xboard" is given as an interactive command.
7315      */
7316     if (strncmp(message, "kibitz Hello from Crafty", 24) == 0) {
7317         cps->useSigint = FALSE;
7318         cps->useSigterm = FALSE;
7319     }
7320     if (strncmp(message, "feature ", 8) == 0) { // [HGM] moved forward to pre-empt non-compliant commands
7321       ParseFeatures(message+8, cps);
7322       return; // [HGM] This return was missing, causing option features to be recognized as non-compliant commands!
7323     }
7324
7325     /* [HGM] Allow engine to set up a position. Don't ask me why one would
7326      * want this, I was asked to put it in, and obliged.
7327      */
7328     if (!strncmp(message, "setboard ", 9)) {
7329         Board initial_position;
7330
7331         GameEnds(GameUnfinished, "Engine aborts game", GE_XBOARD);
7332
7333         if (!ParseFEN(initial_position, &blackPlaysFirst, message + 9)) {
7334             DisplayError(_("Bad FEN received from engine"), 0);
7335             return ;
7336         } else {
7337            Reset(TRUE, FALSE);
7338            CopyBoard(boards[0], initial_position);
7339            initialRulePlies = FENrulePlies;
7340            if(blackPlaysFirst) gameMode = MachinePlaysWhite;
7341            else gameMode = MachinePlaysBlack;
7342            DrawPosition(FALSE, boards[currentMove]);
7343         }
7344         return;
7345     }
7346
7347     /*
7348      * Look for communication commands
7349      */
7350     if (!strncmp(message, "telluser ", 9)) {
7351         EscapeExpand(message+9, message+9); // [HGM] esc: allow escape sequences in popup box
7352         DisplayNote(message + 9);
7353         return;
7354     }
7355     if (!strncmp(message, "tellusererror ", 14)) {
7356         cps->userError = 1;
7357         EscapeExpand(message+14, message+14); // [HGM] esc: allow escape sequences in popup box
7358         DisplayError(message + 14, 0);
7359         return;
7360     }
7361     if (!strncmp(message, "tellopponent ", 13)) {
7362       if (appData.icsActive) {
7363         if (loggedOn) {
7364           snprintf(buf1, sizeof(buf1), "%ssay %s\n", ics_prefix, message + 13);
7365           SendToICS(buf1);
7366         }
7367       } else {
7368         DisplayNote(message + 13);
7369       }
7370       return;
7371     }
7372     if (!strncmp(message, "tellothers ", 11)) {
7373       if (appData.icsActive) {
7374         if (loggedOn) {
7375           snprintf(buf1, sizeof(buf1), "%swhisper %s\n", ics_prefix, message + 11);
7376           SendToICS(buf1);
7377         }
7378       }
7379       return;
7380     }
7381     if (!strncmp(message, "tellall ", 8)) {
7382       if (appData.icsActive) {
7383         if (loggedOn) {
7384           snprintf(buf1, sizeof(buf1), "%skibitz %s\n", ics_prefix, message + 8);
7385           SendToICS(buf1);
7386         }
7387       } else {
7388         DisplayNote(message + 8);
7389       }
7390       return;
7391     }
7392     if (strncmp(message, "warning", 7) == 0) {
7393         /* Undocumented feature, use tellusererror in new code */
7394         DisplayError(message, 0);
7395         return;
7396     }
7397     if (sscanf(message, "askuser %s %[^\n]", buf1, buf2) == 2) {
7398         strcpy(realname, cps->tidy);
7399         strcat(realname, " query");
7400         AskQuestion(realname, buf2, buf1, cps->pr);
7401         return;
7402     }
7403     /* Commands from the engine directly to ICS.  We don't allow these to be
7404      *  sent until we are logged on. Crafty kibitzes have been known to
7405      *  interfere with the login process.
7406      */
7407     if (loggedOn) {
7408         if (!strncmp(message, "tellics ", 8)) {
7409             SendToICS(message + 8);
7410             SendToICS("\n");
7411             return;
7412         }
7413         if (!strncmp(message, "tellicsnoalias ", 15)) {
7414             SendToICS(ics_prefix);
7415             SendToICS(message + 15);
7416             SendToICS("\n");
7417             return;
7418         }
7419         /* The following are for backward compatibility only */
7420         if (!strncmp(message,"whisper",7) || !strncmp(message,"kibitz",6) ||
7421             !strncmp(message,"draw",4) || !strncmp(message,"tell",3)) {
7422             SendToICS(ics_prefix);
7423             SendToICS(message);
7424             SendToICS("\n");
7425             return;
7426         }
7427     }
7428     if (sscanf(message, "pong %d", &cps->lastPong) == 1) {
7429         return;
7430     }
7431     /*
7432      * If the move is illegal, cancel it and redraw the board.
7433      * Also deal with other error cases.  Matching is rather loose
7434      * here to accommodate engines written before the spec.
7435      */
7436     if (strncmp(message + 1, "llegal move", 11) == 0 ||
7437         strncmp(message, "Error", 5) == 0) {
7438         if (StrStr(message, "name") ||
7439             StrStr(message, "rating") || StrStr(message, "?") ||
7440             StrStr(message, "result") || StrStr(message, "board") ||
7441             StrStr(message, "bk") || StrStr(message, "computer") ||
7442             StrStr(message, "variant") || StrStr(message, "hint") ||
7443             StrStr(message, "random") || StrStr(message, "depth") ||
7444             StrStr(message, "accepted")) {
7445             return;
7446         }
7447         if (StrStr(message, "protover")) {
7448           /* Program is responding to input, so it's apparently done
7449              initializing, and this error message indicates it is
7450              protocol version 1.  So we don't need to wait any longer
7451              for it to initialize and send feature commands. */
7452           FeatureDone(cps, 1);
7453           cps->protocolVersion = 1;
7454           return;
7455         }
7456         cps->maybeThinking = FALSE;
7457
7458         if (StrStr(message, "draw")) {
7459             /* Program doesn't have "draw" command */
7460             cps->sendDrawOffers = 0;
7461             return;
7462         }
7463         if (cps->sendTime != 1 &&
7464             (StrStr(message, "time") || StrStr(message, "otim"))) {
7465           /* Program apparently doesn't have "time" or "otim" command */
7466           cps->sendTime = 0;
7467           return;
7468         }
7469         if (StrStr(message, "analyze")) {
7470             cps->analysisSupport = FALSE;
7471             cps->analyzing = FALSE;
7472             Reset(FALSE, TRUE);
7473             sprintf(buf2, _("%s does not support analysis"), cps->tidy);
7474             DisplayError(buf2, 0);
7475             return;
7476         }
7477         if (StrStr(message, "(no matching move)st")) {
7478           /* Special kludge for GNU Chess 4 only */
7479           cps->stKludge = TRUE;
7480           SendTimeControl(cps, movesPerSession, timeControl,
7481                           timeIncrement, appData.searchDepth,
7482                           searchTime);
7483           return;
7484         }
7485         if (StrStr(message, "(no matching move)sd")) {
7486           /* Special kludge for GNU Chess 4 only */
7487           cps->sdKludge = TRUE;
7488           SendTimeControl(cps, movesPerSession, timeControl,
7489                           timeIncrement, appData.searchDepth,
7490                           searchTime);
7491           return;
7492         }
7493         if (!StrStr(message, "llegal")) {
7494             return;
7495         }
7496         if (gameMode == BeginningOfGame || gameMode == EndOfGame ||
7497             gameMode == IcsIdle) return;
7498         if (forwardMostMove <= backwardMostMove) return;
7499         if (pausing) PauseEvent();
7500       if(appData.forceIllegal) {
7501             // [HGM] illegal: machine refused move; force position after move into it
7502           SendToProgram("force\n", cps);
7503           if(!cps->useSetboard) { // hideous kludge on kludge, because SendBoard sucks.
7504                 // we have a real problem now, as SendBoard will use the a2a3 kludge
7505                 // when black is to move, while there might be nothing on a2 or black
7506                 // might already have the move. So send the board as if white has the move.
7507                 // But first we must change the stm of the engine, as it refused the last move
7508                 SendBoard(cps, 0); // always kludgeless, as white is to move on boards[0]
7509                 if(WhiteOnMove(forwardMostMove)) {
7510                     SendToProgram("a7a6\n", cps); // for the engine black still had the move
7511                     SendBoard(cps, forwardMostMove); // kludgeless board
7512                 } else {
7513                     SendToProgram("a2a3\n", cps); // for the engine white still had the move
7514                     CopyBoard(boards[forwardMostMove+1], boards[forwardMostMove]);
7515                     SendBoard(cps, forwardMostMove+1); // kludgeless board
7516                 }
7517           } else SendBoard(cps, forwardMostMove); // FEN case, also sets stm properly
7518             if(gameMode == MachinePlaysWhite || gameMode == MachinePlaysBlack ||
7519                  gameMode == TwoMachinesPlay)
7520               SendToProgram("go\n", cps);
7521             return;
7522       } else
7523         if (gameMode == PlayFromGameFile) {
7524             /* Stop reading this game file */
7525             gameMode = EditGame;
7526             ModeHighlight();
7527         }
7528         currentMove = forwardMostMove-1;
7529         DisplayMove(currentMove-1); /* before DisplayMoveError */
7530         SwitchClocks(forwardMostMove-1); // [HGM] race
7531         DisplayBothClocks();
7532         sprintf(buf1, _("Illegal move \"%s\" (rejected by %s chess program)"),
7533                 parseList[currentMove], cps->which);
7534         DisplayMoveError(buf1);
7535         DrawPosition(FALSE, boards[currentMove]);
7536
7537         /* [HGM] illegal-move claim should forfeit game when Xboard */
7538         /* only passes fully legal moves                            */
7539         if( appData.testLegality && gameMode == TwoMachinesPlay ) {
7540             GameEnds( cps->twoMachinesColor[0] == 'w' ? BlackWins : WhiteWins,
7541                                 "False illegal-move claim", GE_XBOARD );
7542         }
7543         return;
7544     }
7545     if (strncmp(message, "time", 4) == 0 && StrStr(message, "Illegal")) {
7546         /* Program has a broken "time" command that
7547            outputs a string not ending in newline.
7548            Don't use it. */
7549         cps->sendTime = 0;
7550     }
7551
7552     /*
7553      * If chess program startup fails, exit with an error message.
7554      * Attempts to recover here are futile.
7555      */
7556     if ((StrStr(message, "unknown host") != NULL)
7557         || (StrStr(message, "No remote directory") != NULL)
7558         || (StrStr(message, "not found") != NULL)
7559         || (StrStr(message, "No such file") != NULL)
7560         || (StrStr(message, "can't alloc") != NULL)
7561         || (StrStr(message, "Permission denied") != NULL)) {
7562
7563         cps->maybeThinking = FALSE;
7564         snprintf(buf1, sizeof(buf1), _("Failed to start %s chess program %s on %s: %s\n"),
7565                 cps->which, cps->program, cps->host, message);
7566         RemoveInputSource(cps->isr);
7567         DisplayFatalError(buf1, 0, 1);
7568         return;
7569     }
7570
7571     /*
7572      * Look for hint output
7573      */
7574     if (sscanf(message, "Hint: %s", buf1) == 1) {
7575         if (cps == &first && hintRequested) {
7576             hintRequested = FALSE;
7577             if (ParseOneMove(buf1, forwardMostMove, &moveType,
7578                                  &fromX, &fromY, &toX, &toY, &promoChar)) {
7579                 (void) CoordsToAlgebraic(boards[forwardMostMove],
7580                                     PosFlags(forwardMostMove),
7581                                     fromY, fromX, toY, toX, promoChar, buf1);
7582                 snprintf(buf2, sizeof(buf2), _("Hint: %s"), buf1);
7583                 DisplayInformation(buf2);
7584             } else {
7585                 /* Hint move could not be parsed!? */
7586               snprintf(buf2, sizeof(buf2),
7587                         _("Illegal hint move \"%s\"\nfrom %s chess program"),
7588                         buf1, cps->which);
7589                 DisplayError(buf2, 0);
7590             }
7591         } else {
7592             strcpy(lastHint, buf1);
7593         }
7594         return;
7595     }
7596
7597     /*
7598      * Ignore other messages if game is not in progress
7599      */
7600     if (gameMode == BeginningOfGame || gameMode == EndOfGame ||
7601         gameMode == IcsIdle || cps->lastPing != cps->lastPong) return;
7602
7603     /*
7604      * look for win, lose, draw, or draw offer
7605      */
7606     if (strncmp(message, "1-0", 3) == 0) {
7607         char *p, *q, *r = "";
7608         p = strchr(message, '{');
7609         if (p) {
7610             q = strchr(p, '}');
7611             if (q) {
7612                 *q = NULLCHAR;
7613                 r = p + 1;
7614             }
7615         }
7616         GameEnds(WhiteWins, r, GE_ENGINE1 + (cps != &first)); /* [HGM] pass claimer indication for claim test */
7617         return;
7618     } else if (strncmp(message, "0-1", 3) == 0) {
7619         char *p, *q, *r = "";
7620         p = strchr(message, '{');
7621         if (p) {
7622             q = strchr(p, '}');
7623             if (q) {
7624                 *q = NULLCHAR;
7625                 r = p + 1;
7626             }
7627         }
7628         /* Kludge for Arasan 4.1 bug */
7629         if (strcmp(r, "Black resigns") == 0) {
7630             GameEnds(WhiteWins, r, GE_ENGINE1 + (cps != &first));
7631             return;
7632         }
7633         GameEnds(BlackWins, r, GE_ENGINE1 + (cps != &first));
7634         return;
7635     } else if (strncmp(message, "1/2", 3) == 0) {
7636         char *p, *q, *r = "";
7637         p = strchr(message, '{');
7638         if (p) {
7639             q = strchr(p, '}');
7640             if (q) {
7641                 *q = NULLCHAR;
7642                 r = p + 1;
7643             }
7644         }
7645
7646         GameEnds(GameIsDrawn, r, GE_ENGINE1 + (cps != &first));
7647         return;
7648
7649     } else if (strncmp(message, "White resign", 12) == 0) {
7650         GameEnds(BlackWins, "White resigns", GE_ENGINE1 + (cps != &first));
7651         return;
7652     } else if (strncmp(message, "Black resign", 12) == 0) {
7653         GameEnds(WhiteWins, "Black resigns", GE_ENGINE1 + (cps != &first));
7654         return;
7655     } else if (strncmp(message, "White matches", 13) == 0 ||
7656                strncmp(message, "Black matches", 13) == 0   ) {
7657         /* [HGM] ignore GNUShogi noises */
7658         return;
7659     } else if (strncmp(message, "White", 5) == 0 &&
7660                message[5] != '(' &&
7661                StrStr(message, "Black") == NULL) {
7662         GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
7663         return;
7664     } else if (strncmp(message, "Black", 5) == 0 &&
7665                message[5] != '(') {
7666         GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
7667         return;
7668     } else if (strcmp(message, "resign") == 0 ||
7669                strcmp(message, "computer resigns") == 0) {
7670         switch (gameMode) {
7671           case MachinePlaysBlack:
7672           case IcsPlayingBlack:
7673             GameEnds(WhiteWins, "Black resigns", GE_ENGINE);
7674             break;
7675           case MachinePlaysWhite:
7676           case IcsPlayingWhite:
7677             GameEnds(BlackWins, "White resigns", GE_ENGINE);
7678             break;
7679           case TwoMachinesPlay:
7680             if (cps->twoMachinesColor[0] == 'w')
7681               GameEnds(BlackWins, "White resigns", GE_ENGINE1 + (cps != &first));
7682             else
7683               GameEnds(WhiteWins, "Black resigns", GE_ENGINE1 + (cps != &first));
7684             break;
7685           default:
7686             /* can't happen */
7687             break;
7688         }
7689         return;
7690     } else if (strncmp(message, "opponent mates", 14) == 0) {
7691         switch (gameMode) {
7692           case MachinePlaysBlack:
7693           case IcsPlayingBlack:
7694             GameEnds(WhiteWins, "White mates", GE_ENGINE);
7695             break;
7696           case MachinePlaysWhite:
7697           case IcsPlayingWhite:
7698             GameEnds(BlackWins, "Black mates", GE_ENGINE);
7699             break;
7700           case TwoMachinesPlay:
7701             if (cps->twoMachinesColor[0] == 'w')
7702               GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
7703             else
7704               GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
7705             break;
7706           default:
7707             /* can't happen */
7708             break;
7709         }
7710         return;
7711     } else if (strncmp(message, "computer mates", 14) == 0) {
7712         switch (gameMode) {
7713           case MachinePlaysBlack:
7714           case IcsPlayingBlack:
7715             GameEnds(BlackWins, "Black mates", GE_ENGINE1);
7716             break;
7717           case MachinePlaysWhite:
7718           case IcsPlayingWhite:
7719             GameEnds(WhiteWins, "White mates", GE_ENGINE);
7720             break;
7721           case TwoMachinesPlay:
7722             if (cps->twoMachinesColor[0] == 'w')
7723               GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
7724             else
7725               GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
7726             break;
7727           default:
7728             /* can't happen */
7729             break;
7730         }
7731         return;
7732     } else if (strncmp(message, "checkmate", 9) == 0) {
7733         if (WhiteOnMove(forwardMostMove)) {
7734             GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
7735         } else {
7736             GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
7737         }
7738         return;
7739     } else if (strstr(message, "Draw") != NULL ||
7740                strstr(message, "game is a draw") != NULL) {
7741         GameEnds(GameIsDrawn, "Draw", GE_ENGINE1 + (cps != &first));
7742         return;
7743     } else if (strstr(message, "offer") != NULL &&
7744                strstr(message, "draw") != NULL) {
7745 #if ZIPPY
7746         if (appData.zippyPlay && first.initDone) {
7747             /* Relay offer to ICS */
7748             SendToICS(ics_prefix);
7749             SendToICS("draw\n");
7750         }
7751 #endif
7752         cps->offeredDraw = 2; /* valid until this engine moves twice */
7753         if (gameMode == TwoMachinesPlay) {
7754             if (cps->other->offeredDraw) {
7755                 GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
7756             /* [HGM] in two-machine mode we delay relaying draw offer      */
7757             /* until after we also have move, to see if it is really claim */
7758             }
7759         } else if (gameMode == MachinePlaysWhite ||
7760                    gameMode == MachinePlaysBlack) {
7761           if (userOfferedDraw) {
7762             DisplayInformation(_("Machine accepts your draw offer"));
7763             GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
7764           } else {
7765             DisplayInformation(_("Machine offers a draw\nSelect Action / Draw to agree"));
7766           }
7767         }
7768     }
7769
7770
7771     /*
7772      * Look for thinking output
7773      */
7774     if ( appData.showThinking // [HGM] thinking: test all options that cause this output
7775           || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp()
7776                                 ) {
7777         int plylev, mvleft, mvtot, curscore, time;
7778         char mvname[MOVE_LEN];
7779         u64 nodes; // [DM]
7780         char plyext;
7781         int ignore = FALSE;
7782         int prefixHint = FALSE;
7783         mvname[0] = NULLCHAR;
7784
7785         switch (gameMode) {
7786           case MachinePlaysBlack:
7787           case IcsPlayingBlack:
7788             if (WhiteOnMove(forwardMostMove)) prefixHint = TRUE;
7789             break;
7790           case MachinePlaysWhite:
7791           case IcsPlayingWhite:
7792             if (!WhiteOnMove(forwardMostMove)) prefixHint = TRUE;
7793             break;
7794           case AnalyzeMode:
7795           case AnalyzeFile:
7796             break;
7797           case IcsObserving: /* [DM] icsEngineAnalyze */
7798             if (!appData.icsEngineAnalyze) ignore = TRUE;
7799             break;
7800           case TwoMachinesPlay:
7801             if ((cps->twoMachinesColor[0] == 'w') != WhiteOnMove(forwardMostMove)) {
7802                 ignore = TRUE;
7803             }
7804             break;
7805           default:
7806             ignore = TRUE;
7807             break;
7808         }
7809
7810         if (!ignore) {
7811             ChessProgramStats tempStats = programStats; // [HGM] info: filter out info lines
7812             buf1[0] = NULLCHAR;
7813             if (sscanf(message, "%d%c %d %d " u64Display " %[^\n]\n",
7814                        &plylev, &plyext, &curscore, &time, &nodes, buf1) >= 5) {
7815
7816                 if (plyext != ' ' && plyext != '\t') {
7817                     time *= 100;
7818                 }
7819
7820                 /* [AS] Negate score if machine is playing black and reporting absolute scores */
7821                 if( cps->scoreIsAbsolute &&
7822                     ( gameMode == MachinePlaysBlack ||
7823                       gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b' ||
7824                       gameMode == IcsPlayingBlack ||     // [HGM] also add other situations where engine should report black POV
7825                      (gameMode == AnalyzeMode || gameMode == AnalyzeFile || gameMode == IcsObserving && appData.icsEngineAnalyze) &&
7826                      !WhiteOnMove(currentMove)
7827                     ) )
7828                 {
7829                     curscore = -curscore;
7830                 }
7831
7832
7833                 tempStats.depth = plylev;
7834                 tempStats.nodes = nodes;
7835                 tempStats.time = time;
7836                 tempStats.score = curscore;
7837                 tempStats.got_only_move = 0;
7838
7839                 if(cps->nps >= 0) { /* [HGM] nps: use engine nodes or time to decrement clock */
7840                         int ticklen;
7841
7842                         if(cps->nps == 0) ticklen = 10*time;                    // use engine reported time
7843                         else ticklen = (1000. * u64ToDouble(nodes)) / cps->nps; // convert node count to time
7844                         if(WhiteOnMove(forwardMostMove) && (gameMode == MachinePlaysWhite ||
7845                                                 gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'w'))
7846                              whiteTimeRemaining = timeRemaining[0][forwardMostMove] - ticklen;
7847                         if(!WhiteOnMove(forwardMostMove) && (gameMode == MachinePlaysBlack ||
7848                                                 gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b'))
7849                              blackTimeRemaining = timeRemaining[1][forwardMostMove] - ticklen;
7850                 }
7851
7852                 /* Buffer overflow protection */
7853                 if (buf1[0] != NULLCHAR) {
7854                     if (strlen(buf1) >= sizeof(tempStats.movelist)
7855                         && appData.debugMode) {
7856                         fprintf(debugFP,
7857                                 "PV is too long; using the first %u bytes.\n",
7858                                 (unsigned) sizeof(tempStats.movelist) - 1);
7859                     }
7860
7861                     safeStrCpy( tempStats.movelist, buf1, sizeof(tempStats.movelist) );
7862                 } else {
7863                     sprintf(tempStats.movelist, " no PV\n");
7864                 }
7865
7866                 if (tempStats.seen_stat) {
7867                     tempStats.ok_to_send = 1;
7868                 }
7869
7870                 if (strchr(tempStats.movelist, '(') != NULL) {
7871                     tempStats.line_is_book = 1;
7872                     tempStats.nr_moves = 0;
7873                     tempStats.moves_left = 0;
7874                 } else {
7875                     tempStats.line_is_book = 0;
7876                 }
7877
7878                     if(tempStats.score != 0 || tempStats.nodes != 0 || tempStats.time != 0)
7879                         programStats = tempStats; // [HGM] info: only set stats if genuine PV and not an info line
7880
7881                 SendProgramStatsToFrontend( cps, &tempStats );
7882
7883                 /*
7884                     [AS] Protect the thinkOutput buffer from overflow... this
7885                     is only useful if buf1 hasn't overflowed first!
7886                 */
7887                 sprintf(thinkOutput, "[%d]%c%+.2f %s%s",
7888                         plylev,
7889                         (gameMode == TwoMachinesPlay ?
7890                          ToUpper(cps->twoMachinesColor[0]) : ' '),
7891                         ((double) curscore) / 100.0,
7892                         prefixHint ? lastHint : "",
7893                         prefixHint ? " " : "" );
7894
7895                 if( buf1[0] != NULLCHAR ) {
7896                     unsigned max_len = sizeof(thinkOutput) - strlen(thinkOutput) - 1;
7897
7898                     if( strlen(buf1) > max_len ) {
7899                         if( appData.debugMode) {
7900                             fprintf(debugFP,"PV is too long for thinkOutput, truncating.\n");
7901                         }
7902                         buf1[max_len+1] = '\0';
7903                     }
7904
7905                     strcat( thinkOutput, buf1 );
7906                 }
7907
7908                 if (currentMove == forwardMostMove || gameMode == AnalyzeMode
7909                         || gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
7910                     DisplayMove(currentMove - 1);
7911                 }
7912                 return;
7913
7914             } else if ((p=StrStr(message, "(only move)")) != NULL) {
7915                 /* crafty (9.25+) says "(only move) <move>"
7916                  * if there is only 1 legal move
7917                  */
7918                 sscanf(p, "(only move) %s", buf1);
7919                 sprintf(thinkOutput, "%s (only move)", buf1);
7920                 sprintf(programStats.movelist, "%s (only move)", buf1);
7921                 programStats.depth = 1;
7922                 programStats.nr_moves = 1;
7923                 programStats.moves_left = 1;
7924                 programStats.nodes = 1;
7925                 programStats.time = 1;
7926                 programStats.got_only_move = 1;
7927
7928                 /* Not really, but we also use this member to
7929                    mean "line isn't going to change" (Crafty
7930                    isn't searching, so stats won't change) */
7931                 programStats.line_is_book = 1;
7932
7933                 SendProgramStatsToFrontend( cps, &programStats );
7934
7935                 if (currentMove == forwardMostMove || gameMode==AnalyzeMode ||
7936                            gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
7937                     DisplayMove(currentMove - 1);
7938                 }
7939                 return;
7940             } else if (sscanf(message,"stat01: %d " u64Display " %d %d %d %s",
7941                               &time, &nodes, &plylev, &mvleft,
7942                               &mvtot, mvname) >= 5) {
7943                 /* The stat01: line is from Crafty (9.29+) in response
7944                    to the "." command */
7945                 programStats.seen_stat = 1;
7946                 cps->maybeThinking = TRUE;
7947
7948                 if (programStats.got_only_move || !appData.periodicUpdates)
7949                   return;
7950
7951                 programStats.depth = plylev;
7952                 programStats.time = time;
7953                 programStats.nodes = nodes;
7954                 programStats.moves_left = mvleft;
7955                 programStats.nr_moves = mvtot;
7956                 strcpy(programStats.move_name, mvname);
7957                 programStats.ok_to_send = 1;
7958                 programStats.movelist[0] = '\0';
7959
7960                 SendProgramStatsToFrontend( cps, &programStats );
7961
7962                 return;
7963
7964             } else if (strncmp(message,"++",2) == 0) {
7965                 /* Crafty 9.29+ outputs this */
7966                 programStats.got_fail = 2;
7967                 return;
7968
7969             } else if (strncmp(message,"--",2) == 0) {
7970                 /* Crafty 9.29+ outputs this */
7971                 programStats.got_fail = 1;
7972                 return;
7973
7974             } else if (thinkOutput[0] != NULLCHAR &&
7975                        strncmp(message, "    ", 4) == 0) {
7976                 unsigned message_len;
7977
7978                 p = message;
7979                 while (*p && *p == ' ') p++;
7980
7981                 message_len = strlen( p );
7982
7983                 /* [AS] Avoid buffer overflow */
7984                 if( sizeof(thinkOutput) - strlen(thinkOutput) - 1 > message_len ) {
7985                     strcat(thinkOutput, " ");
7986                     strcat(thinkOutput, p);
7987                 }
7988
7989                 if( sizeof(programStats.movelist) - strlen(programStats.movelist) - 1 > message_len ) {
7990                     strcat(programStats.movelist, " ");
7991                     strcat(programStats.movelist, p);
7992                 }
7993
7994                 if (currentMove == forwardMostMove || gameMode==AnalyzeMode ||
7995                            gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
7996                     DisplayMove(currentMove - 1);
7997                 }
7998                 return;
7999             }
8000         }
8001         else {
8002             buf1[0] = NULLCHAR;
8003
8004             if (sscanf(message, "%d%c %d %d " u64Display " %[^\n]\n",
8005                        &plylev, &plyext, &curscore, &time, &nodes, buf1) >= 5)
8006             {
8007                 ChessProgramStats cpstats;
8008
8009                 if (plyext != ' ' && plyext != '\t') {
8010                     time *= 100;
8011                 }
8012
8013                 /* [AS] Negate score if machine is playing black and reporting absolute scores */
8014                 if( cps->scoreIsAbsolute && ((gameMode == MachinePlaysBlack) || (gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b')) ) {
8015                     curscore = -curscore;
8016                 }
8017
8018                 cpstats.depth = plylev;
8019                 cpstats.nodes = nodes;
8020                 cpstats.time = time;
8021                 cpstats.score = curscore;
8022                 cpstats.got_only_move = 0;
8023                 cpstats.movelist[0] = '\0';
8024
8025                 if (buf1[0] != NULLCHAR) {
8026                     safeStrCpy( cpstats.movelist, buf1, sizeof(cpstats.movelist) );
8027                 }
8028
8029                 cpstats.ok_to_send = 0;
8030                 cpstats.line_is_book = 0;
8031                 cpstats.nr_moves = 0;
8032                 cpstats.moves_left = 0;
8033
8034                 SendProgramStatsToFrontend( cps, &cpstats );
8035             }
8036         }
8037     }
8038 }
8039
8040
8041 /* Parse a game score from the character string "game", and
8042    record it as the history of the current game.  The game
8043    score is NOT assumed to start from the standard position.
8044    The display is not updated in any way.
8045    */
8046 void
8047 ParseGameHistory(game)
8048      char *game;
8049 {
8050     ChessMove moveType;
8051     int fromX, fromY, toX, toY, boardIndex;
8052     char promoChar;
8053     char *p, *q;
8054     char buf[MSG_SIZ];
8055
8056     if (appData.debugMode)
8057       fprintf(debugFP, "Parsing game history: %s\n", game);
8058
8059     if (gameInfo.event == NULL) gameInfo.event = StrSave("ICS game");
8060     gameInfo.site = StrSave(appData.icsHost);
8061     gameInfo.date = PGNDate();
8062     gameInfo.round = StrSave("-");
8063
8064     /* Parse out names of players */
8065     while (*game == ' ') game++;
8066     p = buf;
8067     while (*game != ' ') *p++ = *game++;
8068     *p = NULLCHAR;
8069     gameInfo.white = StrSave(buf);
8070     while (*game == ' ') game++;
8071     p = buf;
8072     while (*game != ' ' && *game != '\n') *p++ = *game++;
8073     *p = NULLCHAR;
8074     gameInfo.black = StrSave(buf);
8075
8076     /* Parse moves */
8077     boardIndex = blackPlaysFirst ? 1 : 0;
8078     yynewstr(game);
8079     for (;;) {
8080         yyboardindex = boardIndex;
8081         moveType = (ChessMove) yylex();
8082         switch (moveType) {
8083           case IllegalMove:             /* maybe suicide chess, etc. */
8084   if (appData.debugMode) {
8085     fprintf(debugFP, "Illegal move from ICS: '%s'\n", yy_text);
8086     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
8087     setbuf(debugFP, NULL);
8088   }
8089           case WhitePromotionChancellor:
8090           case BlackPromotionChancellor:
8091           case WhitePromotionArchbishop:
8092           case BlackPromotionArchbishop:
8093           case WhitePromotionQueen:
8094           case BlackPromotionQueen:
8095           case WhitePromotionRook:
8096           case BlackPromotionRook:
8097           case WhitePromotionBishop:
8098           case BlackPromotionBishop:
8099           case WhitePromotionKnight:
8100           case BlackPromotionKnight:
8101           case WhitePromotionKing:
8102           case BlackPromotionKing:
8103           case NormalMove:
8104           case WhiteCapturesEnPassant:
8105           case BlackCapturesEnPassant:
8106           case WhiteKingSideCastle:
8107           case WhiteQueenSideCastle:
8108           case BlackKingSideCastle:
8109           case BlackQueenSideCastle:
8110           case WhiteKingSideCastleWild:
8111           case WhiteQueenSideCastleWild:
8112           case BlackKingSideCastleWild:
8113           case BlackQueenSideCastleWild:
8114           /* PUSH Fabien */
8115           case WhiteHSideCastleFR:
8116           case WhiteASideCastleFR:
8117           case BlackHSideCastleFR:
8118           case BlackASideCastleFR:
8119           /* POP Fabien */
8120             fromX = currentMoveString[0] - AAA;
8121             fromY = currentMoveString[1] - ONE;
8122             toX = currentMoveString[2] - AAA;
8123             toY = currentMoveString[3] - ONE;
8124             promoChar = currentMoveString[4];
8125             break;
8126           case WhiteDrop:
8127           case BlackDrop:
8128             fromX = moveType == WhiteDrop ?
8129               (int) CharToPiece(ToUpper(currentMoveString[0])) :
8130             (int) CharToPiece(ToLower(currentMoveString[0]));
8131             fromY = DROP_RANK;
8132             toX = currentMoveString[2] - AAA;
8133             toY = currentMoveString[3] - ONE;
8134             promoChar = NULLCHAR;
8135             break;
8136           case AmbiguousMove:
8137             /* bug? */
8138             sprintf(buf, _("Ambiguous move in ICS output: \"%s\""), yy_text);
8139   if (appData.debugMode) {
8140     fprintf(debugFP, "Ambiguous move from ICS: '%s'\n", yy_text);
8141     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
8142     setbuf(debugFP, NULL);
8143   }
8144             DisplayError(buf, 0);
8145             return;
8146           case ImpossibleMove:
8147             /* bug? */
8148             sprintf(buf, _("Illegal move in ICS output: \"%s\""), yy_text);
8149   if (appData.debugMode) {
8150     fprintf(debugFP, "Impossible move from ICS: '%s'\n", yy_text);
8151     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
8152     setbuf(debugFP, NULL);
8153   }
8154             DisplayError(buf, 0);
8155             return;
8156           case (ChessMove) 0:   /* end of file */
8157             if (boardIndex < backwardMostMove) {
8158                 /* Oops, gap.  How did that happen? */
8159                 DisplayError(_("Gap in move list"), 0);
8160                 return;
8161             }
8162             backwardMostMove =  blackPlaysFirst ? 1 : 0;
8163             if (boardIndex > forwardMostMove) {
8164                 forwardMostMove = boardIndex;
8165             }
8166             return;
8167           case ElapsedTime:
8168             if (boardIndex > (blackPlaysFirst ? 1 : 0)) {
8169                 strcat(parseList[boardIndex-1], " ");
8170                 strcat(parseList[boardIndex-1], yy_text);
8171             }
8172             continue;
8173           case Comment:
8174           case PGNTag:
8175           case NAG:
8176           default:
8177             /* ignore */
8178             continue;
8179           case WhiteWins:
8180           case BlackWins:
8181           case GameIsDrawn:
8182           case GameUnfinished:
8183             if (gameMode == IcsExamining) {
8184                 if (boardIndex < backwardMostMove) {
8185                     /* Oops, gap.  How did that happen? */
8186                     return;
8187                 }
8188                 backwardMostMove = blackPlaysFirst ? 1 : 0;
8189                 return;
8190             }
8191             gameInfo.result = moveType;
8192             p = strchr(yy_text, '{');
8193             if (p == NULL) p = strchr(yy_text, '(');
8194             if (p == NULL) {
8195                 p = yy_text;
8196                 if (p[0] == '0' || p[0] == '1' || p[0] == '*') p = "";
8197             } else {
8198                 q = strchr(p, *p == '{' ? '}' : ')');
8199                 if (q != NULL) *q = NULLCHAR;
8200                 p++;
8201             }
8202             gameInfo.resultDetails = StrSave(p);
8203             continue;
8204         }
8205         if (boardIndex >= forwardMostMove &&
8206             !(gameMode == IcsObserving && ics_gamenum == -1)) {
8207             backwardMostMove = blackPlaysFirst ? 1 : 0;
8208             return;
8209         }
8210         (void) CoordsToAlgebraic(boards[boardIndex], PosFlags(boardIndex),
8211                                  fromY, fromX, toY, toX, promoChar,
8212                                  parseList[boardIndex]);
8213         CopyBoard(boards[boardIndex + 1], boards[boardIndex]);
8214         /* currentMoveString is set as a side-effect of yylex */
8215         strcpy(moveList[boardIndex], currentMoveString);
8216         strcat(moveList[boardIndex], "\n");
8217         boardIndex++;
8218         ApplyMove(fromX, fromY, toX, toY, promoChar, boards[boardIndex]);
8219         switch (MateTest(boards[boardIndex], PosFlags(boardIndex)) ) {
8220           case MT_NONE:
8221           case MT_STALEMATE:
8222           default:
8223             break;
8224           case MT_CHECK:
8225             if(gameInfo.variant != VariantShogi)
8226                 strcat(parseList[boardIndex - 1], "+");
8227             break;
8228           case MT_CHECKMATE:
8229           case MT_STAINMATE:
8230             strcat(parseList[boardIndex - 1], "#");
8231             break;
8232         }
8233     }
8234 }
8235
8236
8237 /* Apply a move to the given board  */
8238 void
8239 ApplyMove(fromX, fromY, toX, toY, promoChar, board)
8240      int fromX, fromY, toX, toY;
8241      int promoChar;
8242      Board board;
8243 {
8244   ChessSquare captured = board[toY][toX], piece, king; int p, oldEP = EP_NONE, berolina = 0;
8245   int promoRank = gameInfo.variant == VariantMakruk ? 3 : 1;
8246
8247     /* [HGM] compute & store e.p. status and castling rights for new position */
8248     /* we can always do that 'in place', now pointers to these rights are passed to ApplyMove */
8249     { int i;
8250
8251       if(gameInfo.variant == VariantBerolina) berolina = EP_BEROLIN_A;
8252       oldEP = (signed char)board[EP_STATUS];
8253       board[EP_STATUS] = EP_NONE;
8254
8255       if( board[toY][toX] != EmptySquare )
8256            board[EP_STATUS] = EP_CAPTURE;
8257
8258       if( board[fromY][fromX] == WhitePawn ) {
8259            if(fromY != toY) // [HGM] Xiangqi sideway Pawn moves should not count as 50-move breakers
8260                board[EP_STATUS] = EP_PAWN_MOVE;
8261            if( toY-fromY==2) {
8262                if(toX>BOARD_LEFT   && board[toY][toX-1] == BlackPawn &&
8263                         gameInfo.variant != VariantBerolina || toX < fromX)
8264                       board[EP_STATUS] = toX | berolina;
8265                if(toX<BOARD_RGHT-1 && board[toY][toX+1] == BlackPawn &&
8266                         gameInfo.variant != VariantBerolina || toX > fromX)
8267                       board[EP_STATUS] = toX;
8268            }
8269       } else
8270       if( board[fromY][fromX] == BlackPawn ) {
8271            if(fromY != toY) // [HGM] Xiangqi sideway Pawn moves should not count as 50-move breakers
8272                board[EP_STATUS] = EP_PAWN_MOVE;
8273            if( toY-fromY== -2) {
8274                if(toX>BOARD_LEFT   && board[toY][toX-1] == WhitePawn &&
8275                         gameInfo.variant != VariantBerolina || toX < fromX)
8276                       board[EP_STATUS] = toX | berolina;
8277                if(toX<BOARD_RGHT-1 && board[toY][toX+1] == WhitePawn &&
8278                         gameInfo.variant != VariantBerolina || toX > fromX)
8279                       board[EP_STATUS] = toX;
8280            }
8281        }
8282
8283        for(i=0; i<nrCastlingRights; i++) {
8284            if(board[CASTLING][i] == fromX && castlingRank[i] == fromY ||
8285               board[CASTLING][i] == toX   && castlingRank[i] == toY
8286              ) board[CASTLING][i] = NoRights; // revoke for moved or captured piece
8287        }
8288
8289     }
8290
8291   /* [HGM] In Shatranj and Courier all promotions are to Ferz */
8292   if((gameInfo.variant==VariantShatranj || gameInfo.variant==VariantCourier || gameInfo.variant == VariantMakruk)
8293        && promoChar != 0) promoChar = PieceToChar(WhiteFerz);
8294
8295   if (fromX == toX && fromY == toY) return;
8296
8297   if (fromY == DROP_RANK) {
8298         /* must be first */
8299         piece = board[toY][toX] = (ChessSquare) fromX;
8300   } else {
8301      piece = board[fromY][fromX]; /* [HGM] remember, for Shogi promotion */
8302      king = piece < (int) BlackPawn ? WhiteKing : BlackKing; /* [HGM] Knightmate simplify testing for castling */
8303      if(gameInfo.variant == VariantKnightmate)
8304          king += (int) WhiteUnicorn - (int) WhiteKing;
8305
8306     /* Code added by Tord: */
8307     /* FRC castling assumed when king captures friendly rook. */
8308     if (board[fromY][fromX] == WhiteKing &&
8309              board[toY][toX] == WhiteRook) {
8310       board[fromY][fromX] = EmptySquare;
8311       board[toY][toX] = EmptySquare;
8312       if(toX > fromX) {
8313         board[0][BOARD_RGHT-2] = WhiteKing; board[0][BOARD_RGHT-3] = WhiteRook;
8314       } else {
8315         board[0][BOARD_LEFT+2] = WhiteKing; board[0][BOARD_LEFT+3] = WhiteRook;
8316       }
8317     } else if (board[fromY][fromX] == BlackKing &&
8318                board[toY][toX] == BlackRook) {
8319       board[fromY][fromX] = EmptySquare;
8320       board[toY][toX] = EmptySquare;
8321       if(toX > fromX) {
8322         board[BOARD_HEIGHT-1][BOARD_RGHT-2] = BlackKing; board[BOARD_HEIGHT-1][BOARD_RGHT-3] = BlackRook;
8323       } else {
8324         board[BOARD_HEIGHT-1][BOARD_LEFT+2] = BlackKing; board[BOARD_HEIGHT-1][BOARD_LEFT+3] = BlackRook;
8325       }
8326     /* End of code added by Tord */
8327
8328     } else if (board[fromY][fromX] == king
8329         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
8330         && toY == fromY && toX > fromX+1) {
8331         board[fromY][fromX] = EmptySquare;
8332         board[toY][toX] = king;
8333         board[toY][toX-1] = board[fromY][BOARD_RGHT-1];
8334         board[fromY][BOARD_RGHT-1] = EmptySquare;
8335     } else if (board[fromY][fromX] == king
8336         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
8337                && toY == fromY && toX < fromX-1) {
8338         board[fromY][fromX] = EmptySquare;
8339         board[toY][toX] = king;
8340         board[toY][toX+1] = board[fromY][BOARD_LEFT];
8341         board[fromY][BOARD_LEFT] = EmptySquare;
8342     } else if (board[fromY][fromX] == WhitePawn
8343                && toY >= BOARD_HEIGHT-promoRank
8344                && gameInfo.variant != VariantXiangqi
8345                ) {
8346         /* white pawn promotion */
8347         board[toY][toX] = CharToPiece(ToUpper(promoChar));
8348         if (board[toY][toX] == EmptySquare) {
8349             board[toY][toX] = WhiteQueen;
8350         }
8351         if(gameInfo.variant==VariantBughouse ||
8352            gameInfo.variant==VariantCrazyhouse) /* [HGM] use shadow piece */
8353             board[toY][toX] = (ChessSquare) (PROMOTED board[toY][toX]);
8354         board[fromY][fromX] = EmptySquare;
8355     } else if ((fromY == BOARD_HEIGHT-4)
8356                && (toX != fromX)
8357                && gameInfo.variant != VariantXiangqi
8358                && gameInfo.variant != VariantBerolina
8359                && (board[fromY][fromX] == WhitePawn)
8360                && (board[toY][toX] == EmptySquare)) {
8361         board[fromY][fromX] = EmptySquare;
8362         board[toY][toX] = WhitePawn;
8363         captured = board[toY - 1][toX];
8364         board[toY - 1][toX] = EmptySquare;
8365     } else if ((fromY == BOARD_HEIGHT-4)
8366                && (toX == fromX)
8367                && gameInfo.variant == VariantBerolina
8368                && (board[fromY][fromX] == WhitePawn)
8369                && (board[toY][toX] == EmptySquare)) {
8370         board[fromY][fromX] = EmptySquare;
8371         board[toY][toX] = WhitePawn;
8372         if(oldEP & EP_BEROLIN_A) {
8373                 captured = board[fromY][fromX-1];
8374                 board[fromY][fromX-1] = EmptySquare;
8375         }else{  captured = board[fromY][fromX+1];
8376                 board[fromY][fromX+1] = EmptySquare;
8377         }
8378     } else if (board[fromY][fromX] == king
8379         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
8380                && toY == fromY && toX > fromX+1) {
8381         board[fromY][fromX] = EmptySquare;
8382         board[toY][toX] = king;
8383         board[toY][toX-1] = board[fromY][BOARD_RGHT-1];
8384         board[fromY][BOARD_RGHT-1] = EmptySquare;
8385     } else if (board[fromY][fromX] == king
8386         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
8387                && toY == fromY && toX < fromX-1) {
8388         board[fromY][fromX] = EmptySquare;
8389         board[toY][toX] = king;
8390         board[toY][toX+1] = board[fromY][BOARD_LEFT];
8391         board[fromY][BOARD_LEFT] = EmptySquare;
8392     } else if (fromY == 7 && fromX == 3
8393                && board[fromY][fromX] == BlackKing
8394                && toY == 7 && toX == 5) {
8395         board[fromY][fromX] = EmptySquare;
8396         board[toY][toX] = BlackKing;
8397         board[fromY][7] = EmptySquare;
8398         board[toY][4] = BlackRook;
8399     } else if (fromY == 7 && fromX == 3
8400                && board[fromY][fromX] == BlackKing
8401                && toY == 7 && toX == 1) {
8402         board[fromY][fromX] = EmptySquare;
8403         board[toY][toX] = BlackKing;
8404         board[fromY][0] = EmptySquare;
8405         board[toY][2] = BlackRook;
8406     } else if (board[fromY][fromX] == BlackPawn
8407                && toY < promoRank
8408                && gameInfo.variant != VariantXiangqi
8409                ) {
8410         /* black pawn promotion */
8411         board[toY][toX] = CharToPiece(ToLower(promoChar));
8412         if (board[toY][toX] == EmptySquare) {
8413             board[toY][toX] = BlackQueen;
8414         }
8415         if(gameInfo.variant==VariantBughouse ||
8416            gameInfo.variant==VariantCrazyhouse) /* [HGM] use shadow piece */
8417             board[toY][toX] = (ChessSquare) (PROMOTED board[toY][toX]);
8418         board[fromY][fromX] = EmptySquare;
8419     } else if ((fromY == 3)
8420                && (toX != fromX)
8421                && gameInfo.variant != VariantXiangqi
8422                && gameInfo.variant != VariantBerolina
8423                && (board[fromY][fromX] == BlackPawn)
8424                && (board[toY][toX] == EmptySquare)) {
8425         board[fromY][fromX] = EmptySquare;
8426         board[toY][toX] = BlackPawn;
8427         captured = board[toY + 1][toX];
8428         board[toY + 1][toX] = EmptySquare;
8429     } else if ((fromY == 3)
8430                && (toX == fromX)
8431                && gameInfo.variant == VariantBerolina
8432                && (board[fromY][fromX] == BlackPawn)
8433                && (board[toY][toX] == EmptySquare)) {
8434         board[fromY][fromX] = EmptySquare;
8435         board[toY][toX] = BlackPawn;
8436         if(oldEP & EP_BEROLIN_A) {
8437                 captured = board[fromY][fromX-1];
8438                 board[fromY][fromX-1] = EmptySquare;
8439         }else{  captured = board[fromY][fromX+1];
8440                 board[fromY][fromX+1] = EmptySquare;
8441         }
8442     } else {
8443         board[toY][toX] = board[fromY][fromX];
8444         board[fromY][fromX] = EmptySquare;
8445     }
8446
8447     /* [HGM] now we promote for Shogi, if needed */
8448     if(gameInfo.variant == VariantShogi && promoChar == 'q')
8449         board[toY][toX] = (ChessSquare) (PROMOTED piece);
8450   }
8451
8452     if (gameInfo.holdingsWidth != 0) {
8453
8454       /* !!A lot more code needs to be written to support holdings  */
8455       /* [HGM] OK, so I have written it. Holdings are stored in the */
8456       /* penultimate board files, so they are automaticlly stored   */
8457       /* in the game history.                                       */
8458       if (fromY == DROP_RANK) {
8459         /* Delete from holdings, by decreasing count */
8460         /* and erasing image if necessary            */
8461         p = (int) fromX;
8462         if(p < (int) BlackPawn) { /* white drop */
8463              p -= (int)WhitePawn;
8464                  p = PieceToNumber((ChessSquare)p);
8465              if(p >= gameInfo.holdingsSize) p = 0;
8466              if(--board[p][BOARD_WIDTH-2] <= 0)
8467                   board[p][BOARD_WIDTH-1] = EmptySquare;
8468              if((int)board[p][BOARD_WIDTH-2] < 0)
8469                         board[p][BOARD_WIDTH-2] = 0;
8470         } else {                  /* black drop */
8471              p -= (int)BlackPawn;
8472                  p = PieceToNumber((ChessSquare)p);
8473              if(p >= gameInfo.holdingsSize) p = 0;
8474              if(--board[BOARD_HEIGHT-1-p][1] <= 0)
8475                   board[BOARD_HEIGHT-1-p][0] = EmptySquare;
8476              if((int)board[BOARD_HEIGHT-1-p][1] < 0)
8477                         board[BOARD_HEIGHT-1-p][1] = 0;
8478         }
8479       }
8480       if (captured != EmptySquare && gameInfo.holdingsSize > 0
8481           && gameInfo.variant != VariantBughouse        ) {
8482         /* [HGM] holdings: Add to holdings, if holdings exist */
8483         if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
8484                 // [HGM] superchess: suppress flipping color of captured pieces by reverse pre-flip
8485                 captured = (int) captured >= (int) BlackPawn ? BLACK_TO_WHITE captured : WHITE_TO_BLACK captured;
8486         }
8487         p = (int) captured;
8488         if (p >= (int) BlackPawn) {
8489           p -= (int)BlackPawn;
8490           if(gameInfo.variant == VariantShogi && DEMOTED p >= 0) {
8491                   /* in Shogi restore piece to its original  first */
8492                   captured = (ChessSquare) (DEMOTED captured);
8493                   p = DEMOTED p;
8494           }
8495           p = PieceToNumber((ChessSquare)p);
8496           if(p >= gameInfo.holdingsSize) { p = 0; captured = BlackPawn; }
8497           board[p][BOARD_WIDTH-2]++;
8498           board[p][BOARD_WIDTH-1] = BLACK_TO_WHITE captured;
8499         } else {
8500           p -= (int)WhitePawn;
8501           if(gameInfo.variant == VariantShogi && DEMOTED p >= 0) {
8502                   captured = (ChessSquare) (DEMOTED captured);
8503                   p = DEMOTED p;
8504           }
8505           p = PieceToNumber((ChessSquare)p);
8506           if(p >= gameInfo.holdingsSize) { p = 0; captured = WhitePawn; }
8507           board[BOARD_HEIGHT-1-p][1]++;
8508           board[BOARD_HEIGHT-1-p][0] = WHITE_TO_BLACK captured;
8509         }
8510       }
8511     } else if (gameInfo.variant == VariantAtomic) {
8512       if (captured != EmptySquare) {
8513         int y, x;
8514         for (y = toY-1; y <= toY+1; y++) {
8515           for (x = toX-1; x <= toX+1; x++) {
8516             if (y >= 0 && y < BOARD_HEIGHT && x >= BOARD_LEFT && x < BOARD_RGHT &&
8517                 board[y][x] != WhitePawn && board[y][x] != BlackPawn) {
8518               board[y][x] = EmptySquare;
8519             }
8520           }
8521         }
8522         board[toY][toX] = EmptySquare;
8523       }
8524     }
8525     if(gameInfo.variant == VariantShogi && promoChar != NULLCHAR && promoChar != '=') {
8526         /* [HGM] Shogi promotions */
8527         board[toY][toX] = (ChessSquare) (PROMOTED piece);
8528     }
8529
8530     if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat)
8531                 && promoChar != NULLCHAR && gameInfo.holdingsSize) {
8532         // [HGM] superchess: take promotion piece out of holdings
8533         int k = PieceToNumber(CharToPiece(ToUpper(promoChar)));
8534         if((int)piece < (int)BlackPawn) { // determine stm from piece color
8535             if(!--board[k][BOARD_WIDTH-2])
8536                 board[k][BOARD_WIDTH-1] = EmptySquare;
8537         } else {
8538             if(!--board[BOARD_HEIGHT-1-k][1])
8539                 board[BOARD_HEIGHT-1-k][0] = EmptySquare;
8540         }
8541     }
8542
8543 }
8544
8545 /* Updates forwardMostMove */
8546 void
8547 MakeMove(fromX, fromY, toX, toY, promoChar)
8548      int fromX, fromY, toX, toY;
8549      int promoChar;
8550 {
8551 //    forwardMostMove++; // [HGM] bare: moved downstream
8552
8553     if(serverMoves != NULL) { /* [HGM] write moves on file for broadcasting (should be separate routine, really) */
8554         int timeLeft; static int lastLoadFlag=0; int king, piece;
8555         piece = boards[forwardMostMove][fromY][fromX];
8556         king = piece < (int) BlackPawn ? WhiteKing : BlackKing;
8557         if(gameInfo.variant == VariantKnightmate)
8558             king += (int) WhiteUnicorn - (int) WhiteKing;
8559         if(forwardMostMove == 0) {
8560             if(blackPlaysFirst)
8561                 fprintf(serverMoves, "%s;", second.tidy);
8562             fprintf(serverMoves, "%s;", first.tidy);
8563             if(!blackPlaysFirst)
8564                 fprintf(serverMoves, "%s;", second.tidy);
8565         } else fprintf(serverMoves, loadFlag|lastLoadFlag ? ":" : ";");
8566         lastLoadFlag = loadFlag;
8567         // print base move
8568         fprintf(serverMoves, "%c%c:%c%c", AAA+fromX, ONE+fromY, AAA+toX, ONE+toY);
8569         // print castling suffix
8570         if( toY == fromY && piece == king ) {
8571             if(toX-fromX > 1)
8572                 fprintf(serverMoves, ":%c%c:%c%c", AAA+BOARD_RGHT-1, ONE+fromY, AAA+toX-1,ONE+toY);
8573             if(fromX-toX >1)
8574                 fprintf(serverMoves, ":%c%c:%c%c", AAA+BOARD_LEFT, ONE+fromY, AAA+toX+1,ONE+toY);
8575         }
8576         // e.p. suffix
8577         if( (boards[forwardMostMove][fromY][fromX] == WhitePawn ||
8578              boards[forwardMostMove][fromY][fromX] == BlackPawn   ) &&
8579              boards[forwardMostMove][toY][toX] == EmptySquare
8580              && fromX != toX )
8581                 fprintf(serverMoves, ":%c%c:%c%c", AAA+fromX, ONE+fromY, AAA+toX, ONE+fromY);
8582         // promotion suffix
8583         if(promoChar != NULLCHAR)
8584                 fprintf(serverMoves, ":%c:%c%c", promoChar, AAA+toX, ONE+toY);
8585         if(!loadFlag) {
8586             fprintf(serverMoves, "/%d/%d",
8587                pvInfoList[forwardMostMove].depth, pvInfoList[forwardMostMove].score);
8588             if(forwardMostMove+1 & 1) timeLeft = whiteTimeRemaining/1000;
8589             else                      timeLeft = blackTimeRemaining/1000;
8590             fprintf(serverMoves, "/%d", timeLeft);
8591         }
8592         fflush(serverMoves);
8593     }
8594
8595     if (forwardMostMove+1 > framePtr) { // [HGM] vari: do not run into saved variations
8596       DisplayFatalError(_("Game too long; increase MAX_MOVES and recompile"),
8597                         0, 1);
8598       return;
8599     }
8600     UnLoadPV(); // [HGM] pv: if we are looking at a PV, abort this
8601     if (commentList[forwardMostMove+1] != NULL) {
8602         free(commentList[forwardMostMove+1]);
8603         commentList[forwardMostMove+1] = NULL;
8604     }
8605     CopyBoard(boards[forwardMostMove+1], boards[forwardMostMove]);
8606     ApplyMove(fromX, fromY, toX, toY, promoChar, boards[forwardMostMove+1]);
8607     // forwardMostMove++; // [HGM] bare: moved to after ApplyMove, to make sure clock interrupt finds complete board
8608     SwitchClocks(forwardMostMove+1); // [HGM] race: incrementing move nr inside
8609     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
8610     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
8611     gameInfo.result = GameUnfinished;
8612     if (gameInfo.resultDetails != NULL) {
8613         free(gameInfo.resultDetails);
8614         gameInfo.resultDetails = NULL;
8615     }
8616     CoordsToComputerAlgebraic(fromY, fromX, toY, toX, promoChar,
8617                               moveList[forwardMostMove - 1]);
8618     (void) CoordsToAlgebraic(boards[forwardMostMove - 1],
8619                              PosFlags(forwardMostMove - 1),
8620                              fromY, fromX, toY, toX, promoChar,
8621                              parseList[forwardMostMove - 1]);
8622     switch (MateTest(boards[forwardMostMove], PosFlags(forwardMostMove)) ) {
8623       case MT_NONE:
8624       case MT_STALEMATE:
8625       default:
8626         break;
8627       case MT_CHECK:
8628         if(gameInfo.variant != VariantShogi)
8629             strcat(parseList[forwardMostMove - 1], "+");
8630         break;
8631       case MT_CHECKMATE:
8632       case MT_STAINMATE:
8633         strcat(parseList[forwardMostMove - 1], "#");
8634         break;
8635     }
8636     if (appData.debugMode) {
8637         fprintf(debugFP, "move: %s, parse: %s (%c)\n", moveList[forwardMostMove-1], parseList[forwardMostMove-1], moveList[forwardMostMove-1][4]);
8638     }
8639
8640 }
8641
8642 /* Updates currentMove if not pausing */
8643 void
8644 ShowMove(fromX, fromY, toX, toY)
8645 {
8646     int instant = (gameMode == PlayFromGameFile) ?
8647         (matchMode || (appData.timeDelay == 0 && !pausing)) : pausing;
8648     if(appData.noGUI) return;
8649     if (!pausing || gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
8650         if (!instant) {
8651             if (forwardMostMove == currentMove + 1) {
8652                 AnimateMove(boards[forwardMostMove - 1],
8653                             fromX, fromY, toX, toY);
8654             }
8655             if (appData.highlightLastMove) {
8656                 SetHighlights(fromX, fromY, toX, toY);
8657             }
8658         }
8659         currentMove = forwardMostMove;
8660     }
8661
8662     if (instant) return;
8663
8664     DisplayMove(currentMove - 1);
8665     DrawPosition(FALSE, boards[currentMove]);
8666     DisplayBothClocks();
8667     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
8668 }
8669
8670 void SendEgtPath(ChessProgramState *cps)
8671 {       /* [HGM] EGT: match formats given in feature with those given by user, and send info for each match */
8672         char buf[MSG_SIZ], name[MSG_SIZ], *p;
8673
8674         if((p = cps->egtFormats) == NULL || appData.egtFormats == NULL) return;
8675
8676         while(*p) {
8677             char c, *q = name+1, *r, *s;
8678
8679             name[0] = ','; // extract next format name from feature and copy with prefixed ','
8680             while(*p && *p != ',') *q++ = *p++;
8681             *q++ = ':'; *q = 0;
8682             if( appData.defaultPathEGTB && appData.defaultPathEGTB[0] &&
8683                 strcmp(name, ",nalimov:") == 0 ) {
8684                 // take nalimov path from the menu-changeable option first, if it is defined
8685                 sprintf(buf, "egtpath nalimov %s\n", appData.defaultPathEGTB);
8686                 SendToProgram(buf,cps);     // send egtbpath command for nalimov
8687             } else
8688             if( (s = StrStr(appData.egtFormats, name+1)) == appData.egtFormats ||
8689                 (s = StrStr(appData.egtFormats, name)) != NULL) {
8690                 // format name occurs amongst user-supplied formats, at beginning or immediately after comma
8691                 s = r = StrStr(s, ":") + 1; // beginning of path info
8692                 while(*r && *r != ',') r++; // path info is everything upto next ';' or end of string
8693                 c = *r; *r = 0;             // temporarily null-terminate path info
8694                     *--q = 0;               // strip of trailig ':' from name
8695                     sprintf(buf, "egtpath %s %s\n", name+1, s);
8696                 *r = c;
8697                 SendToProgram(buf,cps);     // send egtbpath command for this format
8698             }
8699             if(*p == ',') p++; // read away comma to position for next format name
8700         }
8701 }
8702
8703 void
8704 InitChessProgram(cps, setup)
8705      ChessProgramState *cps;
8706      int setup; /* [HGM] needed to setup FRC opening position */
8707 {
8708     char buf[MSG_SIZ], b[MSG_SIZ]; int overruled;
8709     if (appData.noChessProgram) return;
8710     hintRequested = FALSE;
8711     bookRequested = FALSE;
8712
8713     /* [HGM] some new WB protocol commands to configure engine are sent now, if engine supports them */
8714     /*       moved to before sending initstring in 4.3.15, so Polyglot can delay UCI 'isready' to recepton of 'new' */
8715     if(cps->memSize) { /* [HGM] memory */
8716         sprintf(buf, "memory %d\n", appData.defaultHashSize + appData.defaultCacheSizeEGTB);
8717         SendToProgram(buf, cps);
8718     }
8719     SendEgtPath(cps); /* [HGM] EGT */
8720     if(cps->maxCores) { /* [HGM] SMP: (protocol specified must be last settings command before new!) */
8721         sprintf(buf, "cores %d\n", appData.smpCores);
8722         SendToProgram(buf, cps);
8723     }
8724
8725     SendToProgram(cps->initString, cps);
8726     if (gameInfo.variant != VariantNormal &&
8727         gameInfo.variant != VariantLoadable
8728         /* [HGM] also send variant if board size non-standard */
8729         || gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0
8730                                             ) {
8731       char *v = VariantName(gameInfo.variant);
8732       if (cps->protocolVersion != 1 && StrStr(cps->variants, v) == NULL) {
8733         /* [HGM] in protocol 1 we have to assume all variants valid */
8734         sprintf(buf, _("Variant %s not supported by %s"), v, cps->tidy);
8735         DisplayFatalError(buf, 0, 1);
8736         return;
8737       }
8738
8739       /* [HGM] make prefix for non-standard board size. Awkward testing... */
8740       overruled = gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0;
8741       if( gameInfo.variant == VariantXiangqi )
8742            overruled = gameInfo.boardWidth != 9 || gameInfo.boardHeight != 10 || gameInfo.holdingsSize != 0;
8743       if( gameInfo.variant == VariantShogi )
8744            overruled = gameInfo.boardWidth != 9 || gameInfo.boardHeight != 9 || gameInfo.holdingsSize != 7;
8745       if( gameInfo.variant == VariantBughouse || gameInfo.variant == VariantCrazyhouse )
8746            overruled = gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 5;
8747       if( gameInfo.variant == VariantCapablanca || gameInfo.variant == VariantCapaRandom ||
8748                                gameInfo.variant == VariantGothic  || gameInfo.variant == VariantFalcon )
8749            overruled = gameInfo.boardWidth != 10 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0;
8750       if( gameInfo.variant == VariantCourier )
8751            overruled = gameInfo.boardWidth != 12 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0;
8752       if( gameInfo.variant == VariantSuper )
8753            overruled = gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 8;
8754       if( gameInfo.variant == VariantGreat )
8755            overruled = gameInfo.boardWidth != 10 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 8;
8756
8757       if(overruled) {
8758            sprintf(b, "%dx%d+%d_%s", gameInfo.boardWidth, gameInfo.boardHeight,
8759                                gameInfo.holdingsSize, VariantName(gameInfo.variant)); // cook up sized variant name
8760            /* [HGM] varsize: try first if this defiant size variant is specifically known */
8761            if(StrStr(cps->variants, b) == NULL) {
8762                // specific sized variant not known, check if general sizing allowed
8763                if (cps->protocolVersion != 1) { // for protocol 1 we cannot check and hope for the best
8764                    if(StrStr(cps->variants, "boardsize") == NULL) {
8765                        sprintf(buf, "Board size %dx%d+%d not supported by %s",
8766                             gameInfo.boardWidth, gameInfo.boardHeight, gameInfo.holdingsSize, cps->tidy);
8767                        DisplayFatalError(buf, 0, 1);
8768                        return;
8769                    }
8770                    /* [HGM] here we really should compare with the maximum supported board size */
8771                }
8772            }
8773       } else sprintf(b, "%s", VariantName(gameInfo.variant));
8774       sprintf(buf, "variant %s\n", b);
8775       SendToProgram(buf, cps);
8776     }
8777     currentlyInitializedVariant = gameInfo.variant;
8778
8779     /* [HGM] send opening position in FRC to first engine */
8780     if(setup) {
8781           SendToProgram("force\n", cps);
8782           SendBoard(cps, 0);
8783           /* engine is now in force mode! Set flag to wake it up after first move. */
8784           setboardSpoiledMachineBlack = 1;
8785     }
8786
8787     if (cps->sendICS) {
8788       snprintf(buf, sizeof(buf), "ics %s\n", appData.icsActive ? appData.icsHost : "-");
8789       SendToProgram(buf, cps);
8790     }
8791     cps->maybeThinking = FALSE;
8792     cps->offeredDraw = 0;
8793     if (!appData.icsActive) {
8794         SendTimeControl(cps, movesPerSession, timeControl,
8795                         timeIncrement, appData.searchDepth,
8796                         searchTime);
8797     }
8798     if (appData.showThinking
8799         // [HGM] thinking: four options require thinking output to be sent
8800         || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp()
8801                                 ) {
8802         SendToProgram("post\n", cps);
8803     }
8804     SendToProgram("hard\n", cps);
8805     if (!appData.ponderNextMove) {
8806         /* Warning: "easy" is a toggle in GNU Chess, so don't send
8807            it without being sure what state we are in first.  "hard"
8808            is not a toggle, so that one is OK.
8809          */
8810         SendToProgram("easy\n", cps);
8811     }
8812     if (cps->usePing) {
8813       sprintf(buf, "ping %d\n", ++cps->lastPing);
8814       SendToProgram(buf, cps);
8815     }
8816     cps->initDone = TRUE;
8817 }
8818
8819
8820 void
8821 StartChessProgram(cps)
8822      ChessProgramState *cps;
8823 {
8824     char buf[MSG_SIZ];
8825     int err;
8826
8827     if (appData.noChessProgram) return;
8828     cps->initDone = FALSE;
8829
8830     if (strcmp(cps->host, "localhost") == 0) {
8831         err = StartChildProcess(cps->program, cps->dir, &cps->pr);
8832     } else if (*appData.remoteShell == NULLCHAR) {
8833         err = OpenRcmd(cps->host, appData.remoteUser, cps->program, &cps->pr);
8834     } else {
8835         if (*appData.remoteUser == NULLCHAR) {
8836           snprintf(buf, sizeof(buf), "%s %s %s", appData.remoteShell, cps->host,
8837                     cps->program);
8838         } else {
8839           snprintf(buf, sizeof(buf), "%s %s -l %s %s", appData.remoteShell,
8840                     cps->host, appData.remoteUser, cps->program);
8841         }
8842         err = StartChildProcess(buf, "", &cps->pr);
8843     }
8844
8845     if (err != 0) {
8846         sprintf(buf, _("Startup failure on '%s'"), cps->program);
8847         DisplayFatalError(buf, err, 1);
8848         cps->pr = NoProc;
8849         cps->isr = NULL;
8850         return;
8851     }
8852
8853     cps->isr = AddInputSource(cps->pr, TRUE, ReceiveFromProgram, cps);
8854     if (cps->protocolVersion > 1) {
8855       sprintf(buf, "xboard\nprotover %d\n", cps->protocolVersion);
8856       cps->nrOptions = 0; // [HGM] options: clear all engine-specific options
8857       cps->comboCnt = 0;  //                and values of combo boxes
8858       SendToProgram(buf, cps);
8859     } else {
8860       SendToProgram("xboard\n", cps);
8861     }
8862 }
8863
8864
8865 void
8866 TwoMachinesEventIfReady P((void))
8867 {
8868   if (first.lastPing != first.lastPong) {
8869     DisplayMessage("", _("Waiting for first chess program"));
8870     ScheduleDelayedEvent(TwoMachinesEventIfReady, 10); // [HGM] fast: lowered from 1000
8871     return;
8872   }
8873   if (second.lastPing != second.lastPong) {
8874     DisplayMessage("", _("Waiting for second chess program"));
8875     ScheduleDelayedEvent(TwoMachinesEventIfReady, 10); // [HGM] fast: lowered from 1000
8876     return;
8877   }
8878   ThawUI();
8879   TwoMachinesEvent();
8880 }
8881
8882 void
8883 NextMatchGame P((void))
8884 {
8885     int index; /* [HGM] autoinc: step load index during match */
8886     Reset(FALSE, TRUE);
8887     if (*appData.loadGameFile != NULLCHAR) {
8888         index = appData.loadGameIndex;
8889         if(index < 0) { // [HGM] autoinc
8890             lastIndex = index = (index == -2 && first.twoMachinesColor[0] == 'b') ? lastIndex : lastIndex+1;
8891             if(appData.rewindIndex > 0 && index > appData.rewindIndex) lastIndex = index = 1;
8892         }
8893         LoadGameFromFile(appData.loadGameFile,
8894                          index,
8895                          appData.loadGameFile, FALSE);
8896     } else if (*appData.loadPositionFile != NULLCHAR) {
8897         index = appData.loadPositionIndex;
8898         if(index < 0) { // [HGM] autoinc
8899             lastIndex = index = (index == -2 && first.twoMachinesColor[0] == 'b') ? lastIndex : lastIndex+1;
8900             if(appData.rewindIndex > 0 && index > appData.rewindIndex) lastIndex = index = 1;
8901         }
8902         LoadPositionFromFile(appData.loadPositionFile,
8903                              index,
8904                              appData.loadPositionFile);
8905     }
8906     TwoMachinesEventIfReady();
8907 }
8908
8909 void UserAdjudicationEvent( int result )
8910 {
8911     ChessMove gameResult = GameIsDrawn;
8912
8913     if( result > 0 ) {
8914         gameResult = WhiteWins;
8915     }
8916     else if( result < 0 ) {
8917         gameResult = BlackWins;
8918     }
8919
8920     if( gameMode == TwoMachinesPlay ) {
8921         GameEnds( gameResult, "User adjudication", GE_XBOARD );
8922     }
8923 }
8924
8925
8926 // [HGM] save: calculate checksum of game to make games easily identifiable
8927 int StringCheckSum(char *s)
8928 {
8929         int i = 0;
8930         if(s==NULL) return 0;
8931         while(*s) i = i*259 + *s++;
8932         return i;
8933 }
8934
8935 int GameCheckSum()
8936 {
8937         int i, sum=0;
8938         for(i=backwardMostMove; i<forwardMostMove; i++) {
8939                 sum += pvInfoList[i].depth;
8940                 sum += StringCheckSum(parseList[i]);
8941                 sum += StringCheckSum(commentList[i]);
8942                 sum *= 261;
8943         }
8944         if(i>1 && sum==0) sum++; // make sure never zero for non-empty game
8945         return sum + StringCheckSum(commentList[i]);
8946 } // end of save patch
8947
8948 void
8949 GameEnds(result, resultDetails, whosays)
8950      ChessMove result;
8951      char *resultDetails;
8952      int whosays;
8953 {
8954     GameMode nextGameMode;
8955     int isIcsGame;
8956     char buf[MSG_SIZ];
8957
8958     if(endingGame) return; /* [HGM] crash: forbid recursion */
8959     endingGame = 1;
8960     if(twoBoards) { // [HGM] dual: switch back to one board
8961         twoBoards = partnerUp = 0; InitDrawingSizes(-2, 0);
8962         DrawPosition(TRUE, partnerBoard); // observed game becomes foreground
8963     }
8964     if (appData.debugMode) {
8965       fprintf(debugFP, "GameEnds(%d, %s, %d)\n",
8966               result, resultDetails ? resultDetails : "(null)", whosays);
8967     }
8968
8969     fromX = fromY = -1; // [HGM] abort any move the user is entering.
8970
8971     if (appData.icsActive && (whosays == GE_ENGINE || whosays >= GE_ENGINE1)) {
8972         /* If we are playing on ICS, the server decides when the
8973            game is over, but the engine can offer to draw, claim
8974            a draw, or resign.
8975          */
8976 #if ZIPPY
8977         if (appData.zippyPlay && first.initDone) {
8978             if (result == GameIsDrawn) {
8979                 /* In case draw still needs to be claimed */
8980                 SendToICS(ics_prefix);
8981                 SendToICS("draw\n");
8982             } else if (StrCaseStr(resultDetails, "resign")) {
8983                 SendToICS(ics_prefix);
8984                 SendToICS("resign\n");
8985             }
8986         }
8987 #endif
8988         endingGame = 0; /* [HGM] crash */
8989         return;
8990     }
8991
8992     /* If we're loading the game from a file, stop */
8993     if (whosays == GE_FILE) {
8994       (void) StopLoadGameTimer();
8995       gameFileFP = NULL;
8996     }
8997
8998     /* Cancel draw offers */
8999     first.offeredDraw = second.offeredDraw = 0;
9000
9001     /* If this is an ICS game, only ICS can really say it's done;
9002        if not, anyone can. */
9003     isIcsGame = (gameMode == IcsPlayingWhite ||
9004                  gameMode == IcsPlayingBlack ||
9005                  gameMode == IcsObserving    ||
9006                  gameMode == IcsExamining);
9007
9008     if (!isIcsGame || whosays == GE_ICS) {
9009         /* OK -- not an ICS game, or ICS said it was done */
9010         StopClocks();
9011         if (!isIcsGame && !appData.noChessProgram)
9012           SetUserThinkingEnables();
9013
9014         /* [HGM] if a machine claims the game end we verify this claim */
9015         if(gameMode == TwoMachinesPlay && appData.testClaims) {
9016             if(appData.testLegality && whosays >= GE_ENGINE1 ) {
9017                 char claimer;
9018                 ChessMove trueResult = (ChessMove) -1;
9019
9020                 claimer = whosays == GE_ENGINE1 ?      /* color of claimer */
9021                                             first.twoMachinesColor[0] :
9022                                             second.twoMachinesColor[0] ;
9023
9024                 // [HGM] losers: because the logic is becoming a bit hairy, determine true result first
9025                 if((signed char)boards[forwardMostMove][EP_STATUS] == EP_CHECKMATE) {
9026                     /* [HGM] verify: engine mate claims accepted if they were flagged */
9027                     trueResult = WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins;
9028                 } else
9029                 if((signed char)boards[forwardMostMove][EP_STATUS] == EP_WINS) { // added code for games where being mated is a win
9030                     /* [HGM] verify: engine mate claims accepted if they were flagged */
9031                     trueResult = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
9032                 } else
9033                 if((signed char)boards[forwardMostMove][EP_STATUS] == EP_STALEMATE) { // only used to indicate draws now
9034                     trueResult = GameIsDrawn; // default; in variants where stalemate loses, Status is CHECKMATE
9035                 }
9036
9037                 // now verify win claims, but not in drop games, as we don't understand those yet
9038                 if( (gameInfo.holdingsWidth == 0 || gameInfo.variant == VariantSuper
9039                                                  || gameInfo.variant == VariantGreat) &&
9040                     (result == WhiteWins && claimer == 'w' ||
9041                      result == BlackWins && claimer == 'b'   ) ) { // case to verify: engine claims own win
9042                       if (appData.debugMode) {
9043                         fprintf(debugFP, "result=%d sp=%d move=%d\n",
9044                                 result, (signed char)boards[forwardMostMove][EP_STATUS], forwardMostMove);
9045                       }
9046                       if(result != trueResult) {
9047                               sprintf(buf, "False win claim: '%s'", resultDetails);
9048                               result = claimer == 'w' ? BlackWins : WhiteWins;
9049                               resultDetails = buf;
9050                       }
9051                 } else
9052                 if( result == GameIsDrawn && (signed char)boards[forwardMostMove][EP_STATUS] > EP_DRAWS
9053                     && (forwardMostMove <= backwardMostMove ||
9054                         (signed char)boards[forwardMostMove-1][EP_STATUS] > EP_DRAWS ||
9055                         (claimer=='b')==(forwardMostMove&1))
9056                                                                                   ) {
9057                       /* [HGM] verify: draws that were not flagged are false claims */
9058                       sprintf(buf, "False draw claim: '%s'", resultDetails);
9059                       result = claimer == 'w' ? BlackWins : WhiteWins;
9060                       resultDetails = buf;
9061                 }
9062                 /* (Claiming a loss is accepted no questions asked!) */
9063             }
9064             /* [HGM] bare: don't allow bare King to win */
9065             if((gameInfo.holdingsWidth == 0 || gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat)
9066                && gameInfo.variant != VariantLosers && gameInfo.variant != VariantGiveaway
9067                && gameInfo.variant != VariantSuicide // [HGM] losers: except in losers, of course...
9068                && result != GameIsDrawn)
9069             {   int i, j, k=0, color = (result==WhiteWins ? (int)WhitePawn : (int)BlackPawn);
9070                 for(j=BOARD_LEFT; j<BOARD_RGHT; j++) for(i=0; i<BOARD_HEIGHT; i++) {
9071                         int p = (signed char)boards[forwardMostMove][i][j] - color;
9072                         if(p >= 0 && p <= (int)WhiteKing) k++;
9073                 }
9074                 if (appData.debugMode) {
9075                      fprintf(debugFP, "GE(%d, %s, %d) bare king k=%d color=%d\n",
9076                         result, resultDetails ? resultDetails : "(null)", whosays, k, color);
9077                 }
9078                 if(k <= 1) {
9079                         result = GameIsDrawn;
9080                         sprintf(buf, "%s but bare king", resultDetails);
9081                         resultDetails = buf;
9082                 }
9083             }
9084         }
9085
9086
9087         if(serverMoves != NULL && !loadFlag) { char c = '=';
9088             if(result==WhiteWins) c = '+';
9089             if(result==BlackWins) c = '-';
9090             if(resultDetails != NULL)
9091                 fprintf(serverMoves, ";%c;%s\n", c, resultDetails);
9092         }
9093         if (resultDetails != NULL) {
9094             gameInfo.result = result;
9095             gameInfo.resultDetails = StrSave(resultDetails);
9096
9097             /* display last move only if game was not loaded from file */
9098             if ((whosays != GE_FILE) && (currentMove == forwardMostMove))
9099                 DisplayMove(currentMove - 1);
9100
9101             if (forwardMostMove != 0) {
9102                 if (gameMode != PlayFromGameFile && gameMode != EditGame
9103                     && lastSavedGame != GameCheckSum() // [HGM] save: suppress duplicates
9104                                                                 ) {
9105                     if (*appData.saveGameFile != NULLCHAR) {
9106                         SaveGameToFile(appData.saveGameFile, TRUE);
9107                     } else if (appData.autoSaveGames) {
9108                         AutoSaveGame();
9109                     }
9110                     if (*appData.savePositionFile != NULLCHAR) {
9111                         SavePositionToFile(appData.savePositionFile);
9112                     }
9113                 }
9114             }
9115
9116             /* Tell program how game ended in case it is learning */
9117             /* [HGM] Moved this to after saving the PGN, just in case */
9118             /* engine died and we got here through time loss. In that */
9119             /* case we will get a fatal error writing the pipe, which */
9120             /* would otherwise lose us the PGN.                       */
9121             /* [HGM] crash: not needed anymore, but doesn't hurt;     */
9122             /* output during GameEnds should never be fatal anymore   */
9123             if (gameMode == MachinePlaysWhite ||
9124                 gameMode == MachinePlaysBlack ||
9125                 gameMode == TwoMachinesPlay ||
9126                 gameMode == IcsPlayingWhite ||
9127                 gameMode == IcsPlayingBlack ||
9128                 gameMode == BeginningOfGame) {
9129                 char buf[MSG_SIZ];
9130                 sprintf(buf, "result %s {%s}\n", PGNResult(result),
9131                         resultDetails);
9132                 if (first.pr != NoProc) {
9133                     SendToProgram(buf, &first);
9134                 }
9135                 if (second.pr != NoProc &&
9136                     gameMode == TwoMachinesPlay) {
9137                     SendToProgram(buf, &second);
9138                 }
9139             }
9140         }
9141
9142         if (appData.icsActive) {
9143             if (appData.quietPlay &&
9144                 (gameMode == IcsPlayingWhite ||
9145                  gameMode == IcsPlayingBlack)) {
9146                 SendToICS(ics_prefix);
9147                 SendToICS("set shout 1\n");
9148             }
9149             nextGameMode = IcsIdle;
9150             ics_user_moved = FALSE;
9151             /* clean up premove.  It's ugly when the game has ended and the
9152              * premove highlights are still on the board.
9153              */
9154             if (gotPremove) {
9155               gotPremove = FALSE;
9156               ClearPremoveHighlights();
9157               DrawPosition(FALSE, boards[currentMove]);
9158             }
9159             if (whosays == GE_ICS) {
9160                 switch (result) {
9161                 case WhiteWins:
9162                     if (gameMode == IcsPlayingWhite)
9163                         PlayIcsWinSound();
9164                     else if(gameMode == IcsPlayingBlack)
9165                         PlayIcsLossSound();
9166                     break;
9167                 case BlackWins:
9168                     if (gameMode == IcsPlayingBlack)
9169                         PlayIcsWinSound();
9170                     else if(gameMode == IcsPlayingWhite)
9171                         PlayIcsLossSound();
9172                     break;
9173                 case GameIsDrawn:
9174                     PlayIcsDrawSound();
9175                     break;
9176                 default:
9177                     PlayIcsUnfinishedSound();
9178                 }
9179             }
9180         } else if (gameMode == EditGame ||
9181                    gameMode == PlayFromGameFile ||
9182                    gameMode == AnalyzeMode ||
9183                    gameMode == AnalyzeFile) {
9184             nextGameMode = gameMode;
9185         } else {
9186             nextGameMode = EndOfGame;
9187         }
9188         pausing = FALSE;
9189         ModeHighlight();
9190     } else {
9191         nextGameMode = gameMode;
9192     }
9193
9194     if (appData.noChessProgram) {
9195         gameMode = nextGameMode;
9196         ModeHighlight();
9197         endingGame = 0; /* [HGM] crash */
9198         return;
9199     }
9200
9201     if (first.reuse) {
9202         /* Put first chess program into idle state */
9203         if (first.pr != NoProc &&
9204             (gameMode == MachinePlaysWhite ||
9205              gameMode == MachinePlaysBlack ||
9206              gameMode == TwoMachinesPlay ||
9207              gameMode == IcsPlayingWhite ||
9208              gameMode == IcsPlayingBlack ||
9209              gameMode == BeginningOfGame)) {
9210             SendToProgram("force\n", &first);
9211             if (first.usePing) {
9212               char buf[MSG_SIZ];
9213               sprintf(buf, "ping %d\n", ++first.lastPing);
9214               SendToProgram(buf, &first);
9215             }
9216         }
9217     } else if (result != GameUnfinished || nextGameMode == IcsIdle) {
9218         /* Kill off first chess program */
9219         if (first.isr != NULL)
9220           RemoveInputSource(first.isr);
9221         first.isr = NULL;
9222
9223         if (first.pr != NoProc) {
9224             ExitAnalyzeMode();
9225             DoSleep( appData.delayBeforeQuit );
9226             SendToProgram("quit\n", &first);
9227             DoSleep( appData.delayAfterQuit );
9228             DestroyChildProcess(first.pr, first.useSigterm);
9229         }
9230         first.pr = NoProc;
9231     }
9232     if (second.reuse) {
9233         /* Put second chess program into idle state */
9234         if (second.pr != NoProc &&
9235             gameMode == TwoMachinesPlay) {
9236             SendToProgram("force\n", &second);
9237             if (second.usePing) {
9238               char buf[MSG_SIZ];
9239               sprintf(buf, "ping %d\n", ++second.lastPing);
9240               SendToProgram(buf, &second);
9241             }
9242         }
9243     } else if (result != GameUnfinished || nextGameMode == IcsIdle) {
9244         /* Kill off second chess program */
9245         if (second.isr != NULL)
9246           RemoveInputSource(second.isr);
9247         second.isr = NULL;
9248
9249         if (second.pr != NoProc) {
9250             DoSleep( appData.delayBeforeQuit );
9251             SendToProgram("quit\n", &second);
9252             DoSleep( appData.delayAfterQuit );
9253             DestroyChildProcess(second.pr, second.useSigterm);
9254         }
9255         second.pr = NoProc;
9256     }
9257
9258     if (matchMode && gameMode == TwoMachinesPlay) {
9259         switch (result) {
9260         case WhiteWins:
9261           if (first.twoMachinesColor[0] == 'w') {
9262             first.matchWins++;
9263           } else {
9264             second.matchWins++;
9265           }
9266           break;
9267         case BlackWins:
9268           if (first.twoMachinesColor[0] == 'b') {
9269             first.matchWins++;
9270           } else {
9271             second.matchWins++;
9272           }
9273           break;
9274         default:
9275           break;
9276         }
9277         if (matchGame < appData.matchGames) {
9278             char *tmp;
9279             if(appData.sameColorGames <= 1) { /* [HGM] alternate: suppress color swap */
9280                 tmp = first.twoMachinesColor;
9281                 first.twoMachinesColor = second.twoMachinesColor;
9282                 second.twoMachinesColor = tmp;
9283             }
9284             gameMode = nextGameMode;
9285             matchGame++;
9286             if(appData.matchPause>10000 || appData.matchPause<10)
9287                 appData.matchPause = 10000; /* [HGM] make pause adjustable */
9288             ScheduleDelayedEvent(NextMatchGame, appData.matchPause);
9289             endingGame = 0; /* [HGM] crash */
9290             return;
9291         } else {
9292             char buf[MSG_SIZ];
9293             gameMode = nextGameMode;
9294             sprintf(buf, _("Match %s vs. %s: final score %d-%d-%d"),
9295                     first.tidy, second.tidy,
9296                     first.matchWins, second.matchWins,
9297                     appData.matchGames - (first.matchWins + second.matchWins));
9298             DisplayFatalError(buf, 0, 0);
9299         }
9300     }
9301     if ((gameMode == AnalyzeMode || gameMode == AnalyzeFile) &&
9302         !(nextGameMode == AnalyzeMode || nextGameMode == AnalyzeFile))
9303       ExitAnalyzeMode();
9304     gameMode = nextGameMode;
9305     ModeHighlight();
9306     endingGame = 0;  /* [HGM] crash */
9307 }
9308
9309 /* Assumes program was just initialized (initString sent).
9310    Leaves program in force mode. */
9311 void
9312 FeedMovesToProgram(cps, upto)
9313      ChessProgramState *cps;
9314      int upto;
9315 {
9316     int i;
9317
9318     if (appData.debugMode)
9319       fprintf(debugFP, "Feeding %smoves %d through %d to %s chess program\n",
9320               startedFromSetupPosition ? "position and " : "",
9321               backwardMostMove, upto, cps->which);
9322     if(currentlyInitializedVariant != gameInfo.variant) { char buf[MSG_SIZ];
9323         // [HGM] variantswitch: make engine aware of new variant
9324         if(cps->protocolVersion > 1 && StrStr(cps->variants, VariantName(gameInfo.variant)) == NULL)
9325                 return; // [HGM] refrain from feeding moves altogether if variant is unsupported!
9326         sprintf(buf, "variant %s\n", VariantName(gameInfo.variant));
9327         SendToProgram(buf, cps);
9328         currentlyInitializedVariant = gameInfo.variant;
9329     }
9330     SendToProgram("force\n", cps);
9331     if (startedFromSetupPosition) {
9332         SendBoard(cps, backwardMostMove);
9333     if (appData.debugMode) {
9334         fprintf(debugFP, "feedMoves\n");
9335     }
9336     }
9337     for (i = backwardMostMove; i < upto; i++) {
9338         SendMoveToProgram(i, cps);
9339     }
9340 }
9341
9342
9343 void
9344 ResurrectChessProgram()
9345 {
9346      /* The chess program may have exited.
9347         If so, restart it and feed it all the moves made so far. */
9348
9349     if (appData.noChessProgram || first.pr != NoProc) return;
9350
9351     StartChessProgram(&first);
9352     InitChessProgram(&first, FALSE);
9353     FeedMovesToProgram(&first, currentMove);
9354
9355     if (!first.sendTime) {
9356         /* can't tell gnuchess what its clock should read,
9357            so we bow to its notion. */
9358         ResetClocks();
9359         timeRemaining[0][currentMove] = whiteTimeRemaining;
9360         timeRemaining[1][currentMove] = blackTimeRemaining;
9361     }
9362
9363     if ((gameMode == AnalyzeMode || gameMode == AnalyzeFile ||
9364                 appData.icsEngineAnalyze) && first.analysisSupport) {
9365       SendToProgram("analyze\n", &first);
9366       first.analyzing = TRUE;
9367     }
9368 }
9369
9370 /*
9371  * Button procedures
9372  */
9373 void
9374 Reset(redraw, init)
9375      int redraw, init;
9376 {
9377     int i;
9378
9379     if (appData.debugMode) {
9380         fprintf(debugFP, "Reset(%d, %d) from gameMode %d\n",
9381                 redraw, init, gameMode);
9382     }
9383     CleanupTail(); // [HGM] vari: delete any stored variations
9384     pausing = pauseExamInvalid = FALSE;
9385     startedFromSetupPosition = blackPlaysFirst = FALSE;
9386     firstMove = TRUE;
9387     whiteFlag = blackFlag = FALSE;
9388     userOfferedDraw = FALSE;
9389     hintRequested = bookRequested = FALSE;
9390     first.maybeThinking = FALSE;
9391     second.maybeThinking = FALSE;
9392     first.bookSuspend = FALSE; // [HGM] book
9393     second.bookSuspend = FALSE;
9394     thinkOutput[0] = NULLCHAR;
9395     lastHint[0] = NULLCHAR;
9396     ClearGameInfo(&gameInfo);
9397     gameInfo.variant = StringToVariant(appData.variant);
9398     ics_user_moved = ics_clock_paused = FALSE;
9399     ics_getting_history = H_FALSE;
9400     ics_gamenum = -1;
9401     white_holding[0] = black_holding[0] = NULLCHAR;
9402     ClearProgramStats();
9403     opponentKibitzes = FALSE; // [HGM] kibitz: do not reserve space in engine-output window in zippy mode
9404
9405     ResetFrontEnd();
9406     ClearHighlights();
9407     flipView = appData.flipView;
9408     ClearPremoveHighlights();
9409     gotPremove = FALSE;
9410     alarmSounded = FALSE;
9411
9412     GameEnds((ChessMove) 0, NULL, GE_PLAYER);
9413     if(appData.serverMovesName != NULL) {
9414         /* [HGM] prepare to make moves file for broadcasting */
9415         clock_t t = clock();
9416         if(serverMoves != NULL) fclose(serverMoves);
9417         serverMoves = fopen(appData.serverMovesName, "r");
9418         if(serverMoves != NULL) {
9419             fclose(serverMoves);
9420             /* delay 15 sec before overwriting, so all clients can see end */
9421             while(clock()-t < appData.serverPause*CLOCKS_PER_SEC);
9422         }
9423         serverMoves = fopen(appData.serverMovesName, "w");
9424     }
9425
9426     ExitAnalyzeMode();
9427     gameMode = BeginningOfGame;
9428     ModeHighlight();
9429     if(appData.icsActive) gameInfo.variant = VariantNormal;
9430     currentMove = forwardMostMove = backwardMostMove = 0;
9431     InitPosition(redraw);
9432     for (i = 0; i < MAX_MOVES; i++) {
9433         if (commentList[i] != NULL) {
9434             free(commentList[i]);
9435             commentList[i] = NULL;
9436         }
9437     }
9438     ResetClocks();
9439     timeRemaining[0][0] = whiteTimeRemaining;
9440     timeRemaining[1][0] = blackTimeRemaining;
9441     if (first.pr == NULL) {
9442         StartChessProgram(&first);
9443     }
9444     if (init) {
9445             InitChessProgram(&first, startedFromSetupPosition);
9446     }
9447     DisplayTitle("");
9448     DisplayMessage("", "");
9449     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
9450     lastSavedGame = 0; // [HGM] save: make sure next game counts as unsaved
9451 }
9452
9453 void
9454 AutoPlayGameLoop()
9455 {
9456     for (;;) {
9457         if (!AutoPlayOneMove())
9458           return;
9459         if (matchMode || appData.timeDelay == 0)
9460           continue;
9461         if (appData.timeDelay < 0 || gameMode == AnalyzeFile)
9462           return;
9463         StartLoadGameTimer((long)(1000.0 * appData.timeDelay));
9464         break;
9465     }
9466 }
9467
9468
9469 int
9470 AutoPlayOneMove()
9471 {
9472     int fromX, fromY, toX, toY;
9473
9474     if (appData.debugMode) {
9475       fprintf(debugFP, "AutoPlayOneMove(): current %d\n", currentMove);
9476     }
9477
9478     if (gameMode != PlayFromGameFile)
9479       return FALSE;
9480
9481     if (currentMove >= forwardMostMove) {
9482       gameMode = EditGame;
9483       ModeHighlight();
9484
9485       /* [AS] Clear current move marker at the end of a game */
9486       /* HistorySet(parseList, backwardMostMove, forwardMostMove, -1); */
9487
9488       return FALSE;
9489     }
9490
9491     toX = moveList[currentMove][2] - AAA;
9492     toY = moveList[currentMove][3] - ONE;
9493
9494     if (moveList[currentMove][1] == '@') {
9495         if (appData.highlightLastMove) {
9496             SetHighlights(-1, -1, toX, toY);
9497         }
9498     } else {
9499         fromX = moveList[currentMove][0] - AAA;
9500         fromY = moveList[currentMove][1] - ONE;
9501
9502         HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove); /* [AS] */
9503
9504         AnimateMove(boards[currentMove], fromX, fromY, toX, toY);
9505
9506         if (appData.highlightLastMove) {
9507             SetHighlights(fromX, fromY, toX, toY);
9508         }
9509     }
9510     DisplayMove(currentMove);
9511     SendMoveToProgram(currentMove++, &first);
9512     DisplayBothClocks();
9513     DrawPosition(FALSE, boards[currentMove]);
9514     // [HGM] PV info: always display, routine tests if empty
9515     DisplayComment(currentMove - 1, commentList[currentMove]);
9516     return TRUE;
9517 }
9518
9519
9520 int
9521 LoadGameOneMove(readAhead)
9522      ChessMove readAhead;
9523 {
9524     int fromX = 0, fromY = 0, toX = 0, toY = 0, done;
9525     char promoChar = NULLCHAR;
9526     ChessMove moveType;
9527     char move[MSG_SIZ];
9528     char *p, *q;
9529
9530     if (gameMode != PlayFromGameFile && gameMode != AnalyzeFile &&
9531         gameMode != AnalyzeMode && gameMode != Training) {
9532         gameFileFP = NULL;
9533         return FALSE;
9534     }
9535
9536     yyboardindex = forwardMostMove;
9537     if (readAhead != (ChessMove)0) {
9538       moveType = readAhead;
9539     } else {
9540       if (gameFileFP == NULL)
9541           return FALSE;
9542       moveType = (ChessMove) yylex();
9543     }
9544
9545     done = FALSE;
9546     switch (moveType) {
9547       case Comment:
9548         if (appData.debugMode)
9549           fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
9550         p = yy_text;
9551
9552         /* append the comment but don't display it */
9553         AppendComment(currentMove, p, FALSE);
9554         return TRUE;
9555
9556       case WhiteCapturesEnPassant:
9557       case BlackCapturesEnPassant:
9558       case WhitePromotionChancellor:
9559       case BlackPromotionChancellor:
9560       case WhitePromotionArchbishop:
9561       case BlackPromotionArchbishop:
9562       case WhitePromotionCentaur:
9563       case BlackPromotionCentaur:
9564       case WhitePromotionQueen:
9565       case BlackPromotionQueen:
9566       case WhitePromotionRook:
9567       case BlackPromotionRook:
9568       case WhitePromotionBishop:
9569       case BlackPromotionBishop:
9570       case WhitePromotionKnight:
9571       case BlackPromotionKnight:
9572       case WhitePromotionKing:
9573       case BlackPromotionKing:
9574       case NormalMove:
9575       case WhiteKingSideCastle:
9576       case WhiteQueenSideCastle:
9577       case BlackKingSideCastle:
9578       case BlackQueenSideCastle:
9579       case WhiteKingSideCastleWild:
9580       case WhiteQueenSideCastleWild:
9581       case BlackKingSideCastleWild:
9582       case BlackQueenSideCastleWild:
9583       /* PUSH Fabien */
9584       case WhiteHSideCastleFR:
9585       case WhiteASideCastleFR:
9586       case BlackHSideCastleFR:
9587       case BlackASideCastleFR:
9588       /* POP Fabien */
9589         if (appData.debugMode)
9590           fprintf(debugFP, "Parsed %s into %s\n", yy_text, currentMoveString);
9591         fromX = currentMoveString[0] - AAA;
9592         fromY = currentMoveString[1] - ONE;
9593         toX = currentMoveString[2] - AAA;
9594         toY = currentMoveString[3] - ONE;
9595         promoChar = currentMoveString[4];
9596         break;
9597
9598       case WhiteDrop:
9599       case BlackDrop:
9600         if (appData.debugMode)
9601           fprintf(debugFP, "Parsed %s into %s\n", yy_text, currentMoveString);
9602         fromX = moveType == WhiteDrop ?
9603           (int) CharToPiece(ToUpper(currentMoveString[0])) :
9604         (int) CharToPiece(ToLower(currentMoveString[0]));
9605         fromY = DROP_RANK;
9606         toX = currentMoveString[2] - AAA;
9607         toY = currentMoveString[3] - ONE;
9608         break;
9609
9610       case WhiteWins:
9611       case BlackWins:
9612       case GameIsDrawn:
9613       case GameUnfinished:
9614         if (appData.debugMode)
9615           fprintf(debugFP, "Parsed game end: %s\n", yy_text);
9616         p = strchr(yy_text, '{');
9617         if (p == NULL) p = strchr(yy_text, '(');
9618         if (p == NULL) {
9619             p = yy_text;
9620             if (p[0] == '0' || p[0] == '1' || p[0] == '*') p = "";
9621         } else {
9622             q = strchr(p, *p == '{' ? '}' : ')');
9623             if (q != NULL) *q = NULLCHAR;
9624             p++;
9625         }
9626         GameEnds(moveType, p, GE_FILE);
9627         done = TRUE;
9628         if (cmailMsgLoaded) {
9629             ClearHighlights();
9630             flipView = WhiteOnMove(currentMove);
9631             if (moveType == GameUnfinished) flipView = !flipView;
9632             if (appData.debugMode)
9633               fprintf(debugFP, "Setting flipView to %d\n", flipView) ;
9634         }
9635         break;
9636
9637       case (ChessMove) 0:       /* end of file */
9638         if (appData.debugMode)
9639           fprintf(debugFP, "Parser hit end of file\n");
9640         switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
9641           case MT_NONE:
9642           case MT_CHECK:
9643             break;
9644           case MT_CHECKMATE:
9645           case MT_STAINMATE:
9646             if (WhiteOnMove(currentMove)) {
9647                 GameEnds(BlackWins, "Black mates", GE_FILE);
9648             } else {
9649                 GameEnds(WhiteWins, "White mates", GE_FILE);
9650             }
9651             break;
9652           case MT_STALEMATE:
9653             GameEnds(GameIsDrawn, "Stalemate", GE_FILE);
9654             break;
9655         }
9656         done = TRUE;
9657         break;
9658
9659       case MoveNumberOne:
9660         if (lastLoadGameStart == GNUChessGame) {
9661             /* GNUChessGames have numbers, but they aren't move numbers */
9662             if (appData.debugMode)
9663               fprintf(debugFP, "Parser ignoring: '%s' (%d)\n",
9664                       yy_text, (int) moveType);
9665             return LoadGameOneMove((ChessMove)0); /* tail recursion */
9666         }
9667         /* else fall thru */
9668
9669       case XBoardGame:
9670       case GNUChessGame:
9671       case PGNTag:
9672         /* Reached start of next game in file */
9673         if (appData.debugMode)
9674           fprintf(debugFP, "Parsed start of next game: %s\n", yy_text);
9675         switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
9676           case MT_NONE:
9677           case MT_CHECK:
9678             break;
9679           case MT_CHECKMATE:
9680           case MT_STAINMATE:
9681             if (WhiteOnMove(currentMove)) {
9682                 GameEnds(BlackWins, "Black mates", GE_FILE);
9683             } else {
9684                 GameEnds(WhiteWins, "White mates", GE_FILE);
9685             }
9686             break;
9687           case MT_STALEMATE:
9688             GameEnds(GameIsDrawn, "Stalemate", GE_FILE);
9689             break;
9690         }
9691         done = TRUE;
9692         break;
9693
9694       case PositionDiagram:     /* should not happen; ignore */
9695       case ElapsedTime:         /* ignore */
9696       case NAG:                 /* ignore */
9697         if (appData.debugMode)
9698           fprintf(debugFP, "Parser ignoring: '%s' (%d)\n",
9699                   yy_text, (int) moveType);
9700         return LoadGameOneMove((ChessMove)0); /* tail recursion */
9701
9702       case IllegalMove:
9703         if (appData.testLegality) {
9704             if (appData.debugMode)
9705               fprintf(debugFP, "Parsed IllegalMove: %s\n", yy_text);
9706             sprintf(move, _("Illegal move: %d.%s%s"),
9707                     (forwardMostMove / 2) + 1,
9708                     WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
9709             DisplayError(move, 0);
9710             done = TRUE;
9711         } else {
9712             if (appData.debugMode)
9713               fprintf(debugFP, "Parsed %s into IllegalMove %s\n",
9714                       yy_text, currentMoveString);
9715             fromX = currentMoveString[0] - AAA;
9716             fromY = currentMoveString[1] - ONE;
9717             toX = currentMoveString[2] - AAA;
9718             toY = currentMoveString[3] - ONE;
9719             promoChar = currentMoveString[4];
9720         }
9721         break;
9722
9723       case AmbiguousMove:
9724         if (appData.debugMode)
9725           fprintf(debugFP, "Parsed AmbiguousMove: %s\n", yy_text);
9726         sprintf(move, _("Ambiguous move: %d.%s%s"),
9727                 (forwardMostMove / 2) + 1,
9728                 WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
9729         DisplayError(move, 0);
9730         done = TRUE;
9731         break;
9732
9733       default:
9734       case ImpossibleMove:
9735         if (appData.debugMode)
9736           fprintf(debugFP, "Parsed ImpossibleMove (type = %d): %s\n", moveType, yy_text);
9737         sprintf(move, _("Illegal move: %d.%s%s"),
9738                 (forwardMostMove / 2) + 1,
9739                 WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
9740         DisplayError(move, 0);
9741         done = TRUE;
9742         break;
9743     }
9744
9745     if (done) {
9746         if (appData.matchMode || (appData.timeDelay == 0 && !pausing)) {
9747             DrawPosition(FALSE, boards[currentMove]);
9748             DisplayBothClocks();
9749             if (!appData.matchMode) // [HGM] PV info: routine tests if empty
9750               DisplayComment(currentMove - 1, commentList[currentMove]);
9751         }
9752         (void) StopLoadGameTimer();
9753         gameFileFP = NULL;
9754         cmailOldMove = forwardMostMove;
9755         return FALSE;
9756     } else {
9757         /* currentMoveString is set as a side-effect of yylex */
9758         strcat(currentMoveString, "\n");
9759         strcpy(moveList[forwardMostMove], currentMoveString);
9760
9761         thinkOutput[0] = NULLCHAR;
9762         MakeMove(fromX, fromY, toX, toY, promoChar);
9763         currentMove = forwardMostMove;
9764         return TRUE;
9765     }
9766 }
9767
9768 /* Load the nth game from the given file */
9769 int
9770 LoadGameFromFile(filename, n, title, useList)
9771      char *filename;
9772      int n;
9773      char *title;
9774      /*Boolean*/ int useList;
9775 {
9776     FILE *f;
9777     char buf[MSG_SIZ];
9778
9779     if (strcmp(filename, "-") == 0) {
9780         f = stdin;
9781         title = "stdin";
9782     } else {
9783         f = fopen(filename, "rb");
9784         if (f == NULL) {
9785           snprintf(buf, sizeof(buf),  _("Can't open \"%s\""), filename);
9786             DisplayError(buf, errno);
9787             return FALSE;
9788         }
9789     }
9790     if (fseek(f, 0, 0) == -1) {
9791         /* f is not seekable; probably a pipe */
9792         useList = FALSE;
9793     }
9794     if (useList && n == 0) {
9795         int error = GameListBuild(f);
9796         if (error) {
9797             DisplayError(_("Cannot build game list"), error);
9798         } else if (!ListEmpty(&gameList) &&
9799                    ((ListGame *) gameList.tailPred)->number > 1) {
9800             GameListPopUp(f, title);
9801             return TRUE;
9802         }
9803         GameListDestroy();
9804         n = 1;
9805     }
9806     if (n == 0) n = 1;
9807     return LoadGame(f, n, title, FALSE);
9808 }
9809
9810
9811 void
9812 MakeRegisteredMove()
9813 {
9814     int fromX, fromY, toX, toY;
9815     char promoChar;
9816     if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
9817         switch (cmailMoveType[lastLoadGameNumber - 1]) {
9818           case CMAIL_MOVE:
9819           case CMAIL_DRAW:
9820             if (appData.debugMode)
9821               fprintf(debugFP, "Restoring %s for game %d\n",
9822                       cmailMove[lastLoadGameNumber - 1], lastLoadGameNumber);
9823
9824             thinkOutput[0] = NULLCHAR;
9825             strcpy(moveList[currentMove], cmailMove[lastLoadGameNumber - 1]);
9826             fromX = cmailMove[lastLoadGameNumber - 1][0] - AAA;
9827             fromY = cmailMove[lastLoadGameNumber - 1][1] - ONE;
9828             toX = cmailMove[lastLoadGameNumber - 1][2] - AAA;
9829             toY = cmailMove[lastLoadGameNumber - 1][3] - ONE;
9830             promoChar = cmailMove[lastLoadGameNumber - 1][4];
9831             MakeMove(fromX, fromY, toX, toY, promoChar);
9832             ShowMove(fromX, fromY, toX, toY);
9833
9834             switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
9835               case MT_NONE:
9836               case MT_CHECK:
9837                 break;
9838
9839               case MT_CHECKMATE:
9840               case MT_STAINMATE:
9841                 if (WhiteOnMove(currentMove)) {
9842                     GameEnds(BlackWins, "Black mates", GE_PLAYER);
9843                 } else {
9844                     GameEnds(WhiteWins, "White mates", GE_PLAYER);
9845                 }
9846                 break;
9847
9848               case MT_STALEMATE:
9849                 GameEnds(GameIsDrawn, "Stalemate", GE_PLAYER);
9850                 break;
9851             }
9852
9853             break;
9854
9855           case CMAIL_RESIGN:
9856             if (WhiteOnMove(currentMove)) {
9857                 GameEnds(BlackWins, "White resigns", GE_PLAYER);
9858             } else {
9859                 GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
9860             }
9861             break;
9862
9863           case CMAIL_ACCEPT:
9864             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
9865             break;
9866
9867           default:
9868             break;
9869         }
9870     }
9871
9872     return;
9873 }
9874
9875 /* Wrapper around LoadGame for use when a Cmail message is loaded */
9876 int
9877 CmailLoadGame(f, gameNumber, title, useList)
9878      FILE *f;
9879      int gameNumber;
9880      char *title;
9881      int useList;
9882 {
9883     int retVal;
9884
9885     if (gameNumber > nCmailGames) {
9886         DisplayError(_("No more games in this message"), 0);
9887         return FALSE;
9888     }
9889     if (f == lastLoadGameFP) {
9890         int offset = gameNumber - lastLoadGameNumber;
9891         if (offset == 0) {
9892             cmailMsg[0] = NULLCHAR;
9893             if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
9894                 cmailMoveRegistered[lastLoadGameNumber - 1] = FALSE;
9895                 nCmailMovesRegistered--;
9896             }
9897             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
9898             if (cmailResult[lastLoadGameNumber - 1] == CMAIL_NEW_RESULT) {
9899                 cmailResult[lastLoadGameNumber - 1] = CMAIL_NOT_RESULT;
9900             }
9901         } else {
9902             if (! RegisterMove()) return FALSE;
9903         }
9904     }
9905
9906     retVal = LoadGame(f, gameNumber, title, useList);
9907
9908     /* Make move registered during previous look at this game, if any */
9909     MakeRegisteredMove();
9910
9911     if (cmailCommentList[lastLoadGameNumber - 1] != NULL) {
9912         commentList[currentMove]
9913           = StrSave(cmailCommentList[lastLoadGameNumber - 1]);
9914         DisplayComment(currentMove - 1, commentList[currentMove]);
9915     }
9916
9917     return retVal;
9918 }
9919
9920 /* Support for LoadNextGame, LoadPreviousGame, ReloadSameGame */
9921 int
9922 ReloadGame(offset)
9923      int offset;
9924 {
9925     int gameNumber = lastLoadGameNumber + offset;
9926     if (lastLoadGameFP == NULL) {
9927         DisplayError(_("No game has been loaded yet"), 0);
9928         return FALSE;
9929     }
9930     if (gameNumber <= 0) {
9931         DisplayError(_("Can't back up any further"), 0);
9932         return FALSE;
9933     }
9934     if (cmailMsgLoaded) {
9935         return CmailLoadGame(lastLoadGameFP, gameNumber,
9936                              lastLoadGameTitle, lastLoadGameUseList);
9937     } else {
9938         return LoadGame(lastLoadGameFP, gameNumber,
9939                         lastLoadGameTitle, lastLoadGameUseList);
9940     }
9941 }
9942
9943
9944
9945 /* Load the nth game from open file f */
9946 int
9947 LoadGame(f, gameNumber, title, useList)
9948      FILE *f;
9949      int gameNumber;
9950      char *title;
9951      int useList;
9952 {
9953     ChessMove cm;
9954     char buf[MSG_SIZ];
9955     int gn = gameNumber;
9956     ListGame *lg = NULL;
9957     int numPGNTags = 0;
9958     int err;
9959     GameMode oldGameMode;
9960     VariantClass oldVariant = gameInfo.variant; /* [HGM] PGNvariant */
9961
9962     if (appData.debugMode)
9963         fprintf(debugFP, "LoadGame(): on entry, gameMode %d\n", gameMode);
9964
9965     if (gameMode == Training )
9966         SetTrainingModeOff();
9967
9968     oldGameMode = gameMode;
9969     if (gameMode != BeginningOfGame) {
9970       Reset(FALSE, TRUE);
9971     }
9972
9973     gameFileFP = f;
9974     if (lastLoadGameFP != NULL && lastLoadGameFP != f) {
9975         fclose(lastLoadGameFP);
9976     }
9977
9978     if (useList) {
9979         lg = (ListGame *) ListElem(&gameList, gameNumber-1);
9980
9981         if (lg) {
9982             fseek(f, lg->offset, 0);
9983             GameListHighlight(gameNumber);
9984             gn = 1;
9985         }
9986         else {
9987             DisplayError(_("Game number out of range"), 0);
9988             return FALSE;
9989         }
9990     } else {
9991         GameListDestroy();
9992         if (fseek(f, 0, 0) == -1) {
9993             if (f == lastLoadGameFP ?
9994                 gameNumber == lastLoadGameNumber + 1 :
9995                 gameNumber == 1) {
9996                 gn = 1;
9997             } else {
9998                 DisplayError(_("Can't seek on game file"), 0);
9999                 return FALSE;
10000             }
10001         }
10002     }
10003     lastLoadGameFP = f;
10004     lastLoadGameNumber = gameNumber;
10005     strcpy(lastLoadGameTitle, title);
10006     lastLoadGameUseList = useList;
10007
10008     yynewfile(f);
10009
10010     if (lg && lg->gameInfo.white && lg->gameInfo.black) {
10011       snprintf(buf, sizeof(buf), "%s vs. %s", lg->gameInfo.white,
10012                 lg->gameInfo.black);
10013             DisplayTitle(buf);
10014     } else if (*title != NULLCHAR) {
10015         if (gameNumber > 1) {
10016             sprintf(buf, "%s %d", title, gameNumber);
10017             DisplayTitle(buf);
10018         } else {
10019             DisplayTitle(title);
10020         }
10021     }
10022
10023     if (gameMode != AnalyzeFile && gameMode != AnalyzeMode) {
10024         gameMode = PlayFromGameFile;
10025         ModeHighlight();
10026     }
10027
10028     currentMove = forwardMostMove = backwardMostMove = 0;
10029     CopyBoard(boards[0], initialPosition);
10030     StopClocks();
10031
10032     /*
10033      * Skip the first gn-1 games in the file.
10034      * Also skip over anything that precedes an identifiable
10035      * start of game marker, to avoid being confused by
10036      * garbage at the start of the file.  Currently
10037      * recognized start of game markers are the move number "1",
10038      * the pattern "gnuchess .* game", the pattern
10039      * "^[#;%] [^ ]* game file", and a PGN tag block.
10040      * A game that starts with one of the latter two patterns
10041      * will also have a move number 1, possibly
10042      * following a position diagram.
10043      * 5-4-02: Let's try being more lenient and allowing a game to
10044      * start with an unnumbered move.  Does that break anything?
10045      */
10046     cm = lastLoadGameStart = (ChessMove) 0;
10047     while (gn > 0) {
10048         yyboardindex = forwardMostMove;
10049         cm = (ChessMove) yylex();
10050         switch (cm) {
10051           case (ChessMove) 0:
10052             if (cmailMsgLoaded) {
10053                 nCmailGames = CMAIL_MAX_GAMES - gn;
10054             } else {
10055                 Reset(TRUE, TRUE);
10056                 DisplayError(_("Game not found in file"), 0);
10057             }
10058             return FALSE;
10059
10060           case GNUChessGame:
10061           case XBoardGame:
10062             gn--;
10063             lastLoadGameStart = cm;
10064             break;
10065
10066           case MoveNumberOne:
10067             switch (lastLoadGameStart) {
10068               case GNUChessGame:
10069               case XBoardGame:
10070               case PGNTag:
10071                 break;
10072               case MoveNumberOne:
10073               case (ChessMove) 0:
10074                 gn--;           /* count this game */
10075                 lastLoadGameStart = cm;
10076                 break;
10077               default:
10078                 /* impossible */
10079                 break;
10080             }
10081             break;
10082
10083           case PGNTag:
10084             switch (lastLoadGameStart) {
10085               case GNUChessGame:
10086               case PGNTag:
10087               case MoveNumberOne:
10088               case (ChessMove) 0:
10089                 gn--;           /* count this game */
10090                 lastLoadGameStart = cm;
10091                 break;
10092               case XBoardGame:
10093                 lastLoadGameStart = cm; /* game counted already */
10094                 break;
10095               default:
10096                 /* impossible */
10097                 break;
10098             }
10099             if (gn > 0) {
10100                 do {
10101                     yyboardindex = forwardMostMove;
10102                     cm = (ChessMove) yylex();
10103                 } while (cm == PGNTag || cm == Comment);
10104             }
10105             break;
10106
10107           case WhiteWins:
10108           case BlackWins:
10109           case GameIsDrawn:
10110             if (cmailMsgLoaded && (CMAIL_MAX_GAMES == lastLoadGameNumber)) {
10111                 if (   cmailResult[CMAIL_MAX_GAMES - gn - 1]
10112                     != CMAIL_OLD_RESULT) {
10113                     nCmailResults ++ ;
10114                     cmailResult[  CMAIL_MAX_GAMES
10115                                 - gn - 1] = CMAIL_OLD_RESULT;
10116                 }
10117             }
10118             break;
10119
10120           case NormalMove:
10121             /* Only a NormalMove can be at the start of a game
10122              * without a position diagram. */
10123             if (lastLoadGameStart == (ChessMove) 0) {
10124               gn--;
10125               lastLoadGameStart = MoveNumberOne;
10126             }
10127             break;
10128
10129           default:
10130             break;
10131         }
10132     }
10133
10134     if (appData.debugMode)
10135       fprintf(debugFP, "Parsed game start '%s' (%d)\n", yy_text, (int) cm);
10136
10137     if (cm == XBoardGame) {
10138         /* Skip any header junk before position diagram and/or move 1 */
10139         for (;;) {
10140             yyboardindex = forwardMostMove;
10141             cm = (ChessMove) yylex();
10142
10143             if (cm == (ChessMove) 0 ||
10144                 cm == GNUChessGame || cm == XBoardGame) {
10145                 /* Empty game; pretend end-of-file and handle later */
10146                 cm = (ChessMove) 0;
10147                 break;
10148             }
10149
10150             if (cm == MoveNumberOne || cm == PositionDiagram ||
10151                 cm == PGNTag || cm == Comment)
10152               break;
10153         }
10154     } else if (cm == GNUChessGame) {
10155         if (gameInfo.event != NULL) {
10156             free(gameInfo.event);
10157         }
10158         gameInfo.event = StrSave(yy_text);
10159     }
10160
10161     startedFromSetupPosition = FALSE;
10162     while (cm == PGNTag) {
10163         if (appData.debugMode)
10164           fprintf(debugFP, "Parsed PGNTag: %s\n", yy_text);
10165         err = ParsePGNTag(yy_text, &gameInfo);
10166         if (!err) numPGNTags++;
10167
10168         /* [HGM] PGNvariant: automatically switch to variant given in PGN tag */
10169         if(gameInfo.variant != oldVariant) {
10170             startedFromPositionFile = FALSE; /* [HGM] loadPos: variant switch likely makes position invalid */
10171             InitPosition(TRUE);
10172             oldVariant = gameInfo.variant;
10173             if (appData.debugMode)
10174               fprintf(debugFP, "New variant %d\n", (int) oldVariant);
10175         }
10176
10177
10178         if (gameInfo.fen != NULL) {
10179           Board initial_position;
10180           startedFromSetupPosition = TRUE;
10181           if (!ParseFEN(initial_position, &blackPlaysFirst, gameInfo.fen)) {
10182             Reset(TRUE, TRUE);
10183             DisplayError(_("Bad FEN position in file"), 0);
10184             return FALSE;
10185           }
10186           CopyBoard(boards[0], initial_position);
10187           if (blackPlaysFirst) {
10188             currentMove = forwardMostMove = backwardMostMove = 1;
10189             CopyBoard(boards[1], initial_position);
10190             strcpy(moveList[0], "");
10191             strcpy(parseList[0], "");
10192             timeRemaining[0][1] = whiteTimeRemaining;
10193             timeRemaining[1][1] = blackTimeRemaining;
10194             if (commentList[0] != NULL) {
10195               commentList[1] = commentList[0];
10196               commentList[0] = NULL;
10197             }
10198           } else {
10199             currentMove = forwardMostMove = backwardMostMove = 0;
10200           }
10201           /* [HGM] copy FEN attributes as well. Bugfix 4.3.14m and 4.3.15e: moved to after 'blackPlaysFirst' */
10202           {   int i;
10203               initialRulePlies = FENrulePlies;
10204               for( i=0; i< nrCastlingRights; i++ )
10205                   initialRights[i] = initial_position[CASTLING][i];
10206           }
10207           yyboardindex = forwardMostMove;
10208           free(gameInfo.fen);
10209           gameInfo.fen = NULL;
10210         }
10211
10212         yyboardindex = forwardMostMove;
10213         cm = (ChessMove) yylex();
10214
10215         /* Handle comments interspersed among the tags */
10216         while (cm == Comment) {
10217             char *p;
10218             if (appData.debugMode)
10219               fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
10220             p = yy_text;
10221             AppendComment(currentMove, p, FALSE);
10222             yyboardindex = forwardMostMove;
10223             cm = (ChessMove) yylex();
10224         }
10225     }
10226
10227     /* don't rely on existence of Event tag since if game was
10228      * pasted from clipboard the Event tag may not exist
10229      */
10230     if (numPGNTags > 0){
10231         char *tags;
10232         if (gameInfo.variant == VariantNormal) {
10233           VariantClass v = StringToVariant(gameInfo.event);
10234           // [HGM] do not recognize variants from event tag that were introduced after supporting variant tag
10235           if(v < VariantShogi) gameInfo.variant = v;
10236         }
10237         if (!matchMode) {
10238           if( appData.autoDisplayTags ) {
10239             tags = PGNTags(&gameInfo);
10240             TagsPopUp(tags, CmailMsg());
10241             free(tags);
10242           }
10243         }
10244     } else {
10245         /* Make something up, but don't display it now */
10246         SetGameInfo();
10247         TagsPopDown();
10248     }
10249
10250     if (cm == PositionDiagram) {
10251         int i, j;
10252         char *p;
10253         Board initial_position;
10254
10255         if (appData.debugMode)
10256           fprintf(debugFP, "Parsed PositionDiagram: %s\n", yy_text);
10257
10258         if (!startedFromSetupPosition) {
10259             p = yy_text;
10260             for (i = BOARD_HEIGHT - 1; i >= 0; i--)
10261               for (j = BOARD_LEFT; j < BOARD_RGHT; p++)
10262                 switch (*p) {
10263                   case '[':
10264                   case '-':
10265                   case ' ':
10266                   case '\t':
10267                   case '\n':
10268                   case '\r':
10269                     break;
10270                   default:
10271                     initial_position[i][j++] = CharToPiece(*p);
10272                     break;
10273                 }
10274             while (*p == ' ' || *p == '\t' ||
10275                    *p == '\n' || *p == '\r') p++;
10276
10277             if (strncmp(p, "black", strlen("black"))==0)
10278               blackPlaysFirst = TRUE;
10279             else
10280               blackPlaysFirst = FALSE;
10281             startedFromSetupPosition = TRUE;
10282
10283             CopyBoard(boards[0], initial_position);
10284             if (blackPlaysFirst) {
10285                 currentMove = forwardMostMove = backwardMostMove = 1;
10286                 CopyBoard(boards[1], initial_position);
10287                 strcpy(moveList[0], "");
10288                 strcpy(parseList[0], "");
10289                 timeRemaining[0][1] = whiteTimeRemaining;
10290                 timeRemaining[1][1] = blackTimeRemaining;
10291                 if (commentList[0] != NULL) {
10292                     commentList[1] = commentList[0];
10293                     commentList[0] = NULL;
10294                 }
10295             } else {
10296                 currentMove = forwardMostMove = backwardMostMove = 0;
10297             }
10298         }
10299         yyboardindex = forwardMostMove;
10300         cm = (ChessMove) yylex();
10301     }
10302
10303     if (first.pr == NoProc) {
10304         StartChessProgram(&first);
10305     }
10306     InitChessProgram(&first, FALSE);
10307     SendToProgram("force\n", &first);
10308     if (startedFromSetupPosition) {
10309         SendBoard(&first, forwardMostMove);
10310     if (appData.debugMode) {
10311         fprintf(debugFP, "Load Game\n");
10312     }
10313         DisplayBothClocks();
10314     }
10315
10316     /* [HGM] server: flag to write setup moves in broadcast file as one */
10317     loadFlag = appData.suppressLoadMoves;
10318
10319     while (cm == Comment) {
10320         char *p;
10321         if (appData.debugMode)
10322           fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
10323         p = yy_text;
10324         AppendComment(currentMove, p, FALSE);
10325         yyboardindex = forwardMostMove;
10326         cm = (ChessMove) yylex();
10327     }
10328
10329     if ((cm == (ChessMove) 0 && lastLoadGameStart != (ChessMove) 0) ||
10330         cm == WhiteWins || cm == BlackWins ||
10331         cm == GameIsDrawn || cm == GameUnfinished) {
10332         DisplayMessage("", _("No moves in game"));
10333         if (cmailMsgLoaded) {
10334             if (appData.debugMode)
10335               fprintf(debugFP, "Setting flipView to %d.\n", FALSE);
10336             ClearHighlights();
10337             flipView = FALSE;
10338         }
10339         DrawPosition(FALSE, boards[currentMove]);
10340         DisplayBothClocks();
10341         gameMode = EditGame;
10342         ModeHighlight();
10343         gameFileFP = NULL;
10344         cmailOldMove = 0;
10345         return TRUE;
10346     }
10347
10348     // [HGM] PV info: routine tests if comment empty
10349     if (!matchMode && (pausing || appData.timeDelay != 0)) {
10350         DisplayComment(currentMove - 1, commentList[currentMove]);
10351     }
10352     if (!matchMode && appData.timeDelay != 0)
10353       DrawPosition(FALSE, boards[currentMove]);
10354
10355     if (gameMode == AnalyzeFile || gameMode == AnalyzeMode) {
10356       programStats.ok_to_send = 1;
10357     }
10358
10359     /* if the first token after the PGN tags is a move
10360      * and not move number 1, retrieve it from the parser
10361      */
10362     if (cm != MoveNumberOne)
10363         LoadGameOneMove(cm);
10364
10365     /* load the remaining moves from the file */
10366     while (LoadGameOneMove((ChessMove)0)) {
10367       timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
10368       timeRemaining[1][forwardMostMove] = blackTimeRemaining;
10369     }
10370
10371     /* rewind to the start of the game */
10372     currentMove = backwardMostMove;
10373
10374     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
10375
10376     if (oldGameMode == AnalyzeFile ||
10377         oldGameMode == AnalyzeMode) {
10378       AnalyzeFileEvent();
10379     }
10380
10381     if (matchMode || appData.timeDelay == 0) {
10382       ToEndEvent();
10383       gameMode = EditGame;
10384       ModeHighlight();
10385     } else if (appData.timeDelay > 0) {
10386       AutoPlayGameLoop();
10387     }
10388
10389     if (appData.debugMode)
10390         fprintf(debugFP, "LoadGame(): on exit, gameMode %d\n", gameMode);
10391
10392     loadFlag = 0; /* [HGM] true game starts */
10393     return TRUE;
10394 }
10395
10396 /* Support for LoadNextPosition, LoadPreviousPosition, ReloadSamePosition */
10397 int
10398 ReloadPosition(offset)
10399      int offset;
10400 {
10401     int positionNumber = lastLoadPositionNumber + offset;
10402     if (lastLoadPositionFP == NULL) {
10403         DisplayError(_("No position has been loaded yet"), 0);
10404         return FALSE;
10405     }
10406     if (positionNumber <= 0) {
10407         DisplayError(_("Can't back up any further"), 0);
10408         return FALSE;
10409     }
10410     return LoadPosition(lastLoadPositionFP, positionNumber,
10411                         lastLoadPositionTitle);
10412 }
10413
10414 /* Load the nth position from the given file */
10415 int
10416 LoadPositionFromFile(filename, n, title)
10417      char *filename;
10418      int n;
10419      char *title;
10420 {
10421     FILE *f;
10422     char buf[MSG_SIZ];
10423
10424     if (strcmp(filename, "-") == 0) {
10425         return LoadPosition(stdin, n, "stdin");
10426     } else {
10427         f = fopen(filename, "rb");
10428         if (f == NULL) {
10429             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
10430             DisplayError(buf, errno);
10431             return FALSE;
10432         } else {
10433             return LoadPosition(f, n, title);
10434         }
10435     }
10436 }
10437
10438 /* Load the nth position from the given open file, and close it */
10439 int
10440 LoadPosition(f, positionNumber, title)
10441      FILE *f;
10442      int positionNumber;
10443      char *title;
10444 {
10445     char *p, line[MSG_SIZ];
10446     Board initial_position;
10447     int i, j, fenMode, pn;
10448
10449     if (gameMode == Training )
10450         SetTrainingModeOff();
10451
10452     if (gameMode != BeginningOfGame) {
10453         Reset(FALSE, TRUE);
10454     }
10455     if (lastLoadPositionFP != NULL && lastLoadPositionFP != f) {
10456         fclose(lastLoadPositionFP);
10457     }
10458     if (positionNumber == 0) positionNumber = 1;
10459     lastLoadPositionFP = f;
10460     lastLoadPositionNumber = positionNumber;
10461     strcpy(lastLoadPositionTitle, title);
10462     if (first.pr == NoProc) {
10463       StartChessProgram(&first);
10464       InitChessProgram(&first, FALSE);
10465     }
10466     pn = positionNumber;
10467     if (positionNumber < 0) {
10468         /* Negative position number means to seek to that byte offset */
10469         if (fseek(f, -positionNumber, 0) == -1) {
10470             DisplayError(_("Can't seek on position file"), 0);
10471             return FALSE;
10472         };
10473         pn = 1;
10474     } else {
10475         if (fseek(f, 0, 0) == -1) {
10476             if (f == lastLoadPositionFP ?
10477                 positionNumber == lastLoadPositionNumber + 1 :
10478                 positionNumber == 1) {
10479                 pn = 1;
10480             } else {
10481                 DisplayError(_("Can't seek on position file"), 0);
10482                 return FALSE;
10483             }
10484         }
10485     }
10486     /* See if this file is FEN or old-style xboard */
10487     if (fgets(line, MSG_SIZ, f) == NULL) {
10488         DisplayError(_("Position not found in file"), 0);
10489         return FALSE;
10490     }
10491     // [HGM] FEN can begin with digit, any piece letter valid in this variant, or a + for Shogi promoted pieces
10492     fenMode = line[0] >= '0' && line[0] <= '9' || line[0] == '+' || CharToPiece(line[0]) != EmptySquare;
10493
10494     if (pn >= 2) {
10495         if (fenMode || line[0] == '#') pn--;
10496         while (pn > 0) {
10497             /* skip positions before number pn */
10498             if (fgets(line, MSG_SIZ, f) == NULL) {
10499                 Reset(TRUE, TRUE);
10500                 DisplayError(_("Position not found in file"), 0);
10501                 return FALSE;
10502             }
10503             if (fenMode || line[0] == '#') pn--;
10504         }
10505     }
10506
10507     if (fenMode) {
10508         if (!ParseFEN(initial_position, &blackPlaysFirst, line)) {
10509             DisplayError(_("Bad FEN position in file"), 0);
10510             return FALSE;
10511         }
10512     } else {
10513         (void) fgets(line, MSG_SIZ, f);
10514         (void) fgets(line, MSG_SIZ, f);
10515
10516         for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
10517             (void) fgets(line, MSG_SIZ, f);
10518             for (p = line, j = BOARD_LEFT; j < BOARD_RGHT; p++) {
10519                 if (*p == ' ')
10520                   continue;
10521                 initial_position[i][j++] = CharToPiece(*p);
10522             }
10523         }
10524
10525         blackPlaysFirst = FALSE;
10526         if (!feof(f)) {
10527             (void) fgets(line, MSG_SIZ, f);
10528             if (strncmp(line, "black", strlen("black"))==0)
10529               blackPlaysFirst = TRUE;
10530         }
10531     }
10532     startedFromSetupPosition = TRUE;
10533
10534     SendToProgram("force\n", &first);
10535     CopyBoard(boards[0], initial_position);
10536     if (blackPlaysFirst) {
10537         currentMove = forwardMostMove = backwardMostMove = 1;
10538         strcpy(moveList[0], "");
10539         strcpy(parseList[0], "");
10540         CopyBoard(boards[1], initial_position);
10541         DisplayMessage("", _("Black to play"));
10542     } else {
10543         currentMove = forwardMostMove = backwardMostMove = 0;
10544         DisplayMessage("", _("White to play"));
10545     }
10546     initialRulePlies = FENrulePlies; /* [HGM] copy FEN attributes as well */
10547     SendBoard(&first, forwardMostMove);
10548     if (appData.debugMode) {
10549 int i, j;
10550   for(i=0;i<2;i++){for(j=0;j<6;j++)fprintf(debugFP, " %d", boards[i][CASTLING][j]);fprintf(debugFP,"\n");}
10551   for(j=0;j<6;j++)fprintf(debugFP, " %d", initialRights[j]);fprintf(debugFP,"\n");
10552         fprintf(debugFP, "Load Position\n");
10553     }
10554
10555     if (positionNumber > 1) {
10556         sprintf(line, "%s %d", title, positionNumber);
10557         DisplayTitle(line);
10558     } else {
10559         DisplayTitle(title);
10560     }
10561     gameMode = EditGame;
10562     ModeHighlight();
10563     ResetClocks();
10564     timeRemaining[0][1] = whiteTimeRemaining;
10565     timeRemaining[1][1] = blackTimeRemaining;
10566     DrawPosition(FALSE, boards[currentMove]);
10567
10568     return TRUE;
10569 }
10570
10571
10572 void
10573 CopyPlayerNameIntoFileName(dest, src)
10574      char **dest, *src;
10575 {
10576     while (*src != NULLCHAR && *src != ',') {
10577         if (*src == ' ') {
10578             *(*dest)++ = '_';
10579             src++;
10580         } else {
10581             *(*dest)++ = *src++;
10582         }
10583     }
10584 }
10585
10586 char *DefaultFileName(ext)
10587      char *ext;
10588 {
10589     static char def[MSG_SIZ];
10590     char *p;
10591
10592     if (gameInfo.white != NULL && gameInfo.white[0] != '-') {
10593         p = def;
10594         CopyPlayerNameIntoFileName(&p, gameInfo.white);
10595         *p++ = '-';
10596         CopyPlayerNameIntoFileName(&p, gameInfo.black);
10597         *p++ = '.';
10598         strcpy(p, ext);
10599     } else {
10600         def[0] = NULLCHAR;
10601     }
10602     return def;
10603 }
10604
10605 /* Save the current game to the given file */
10606 int
10607 SaveGameToFile(filename, append)
10608      char *filename;
10609      int append;
10610 {
10611     FILE *f;
10612     char buf[MSG_SIZ];
10613
10614     if (strcmp(filename, "-") == 0) {
10615         return SaveGame(stdout, 0, NULL);
10616     } else {
10617         f = fopen(filename, append ? "a" : "w");
10618         if (f == NULL) {
10619             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
10620             DisplayError(buf, errno);
10621             return FALSE;
10622         } else {
10623             return SaveGame(f, 0, NULL);
10624         }
10625     }
10626 }
10627
10628 char *
10629 SavePart(str)
10630      char *str;
10631 {
10632     static char buf[MSG_SIZ];
10633     char *p;
10634
10635     p = strchr(str, ' ');
10636     if (p == NULL) return str;
10637     strncpy(buf, str, p - str);
10638     buf[p - str] = NULLCHAR;
10639     return buf;
10640 }
10641
10642 #define PGN_MAX_LINE 75
10643
10644 #define PGN_SIDE_WHITE  0
10645 #define PGN_SIDE_BLACK  1
10646
10647 /* [AS] */
10648 static int FindFirstMoveOutOfBook( int side )
10649 {
10650     int result = -1;
10651
10652     if( backwardMostMove == 0 && ! startedFromSetupPosition) {
10653         int index = backwardMostMove;
10654         int has_book_hit = 0;
10655
10656         if( (index % 2) != side ) {
10657             index++;
10658         }
10659
10660         while( index < forwardMostMove ) {
10661             /* Check to see if engine is in book */
10662             int depth = pvInfoList[index].depth;
10663             int score = pvInfoList[index].score;
10664             int in_book = 0;
10665
10666             if( depth <= 2 ) {
10667                 in_book = 1;
10668             }
10669             else if( score == 0 && depth == 63 ) {
10670                 in_book = 1; /* Zappa */
10671             }
10672             else if( score == 2 && depth == 99 ) {
10673                 in_book = 1; /* Abrok */
10674             }
10675
10676             has_book_hit += in_book;
10677
10678             if( ! in_book ) {
10679                 result = index;
10680
10681                 break;
10682             }
10683
10684             index += 2;
10685         }
10686     }
10687
10688     return result;
10689 }
10690
10691 /* [AS] */
10692 void GetOutOfBookInfo( char * buf )
10693 {
10694     int oob[2];
10695     int i;
10696     int offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
10697
10698     oob[0] = FindFirstMoveOutOfBook( PGN_SIDE_WHITE );
10699     oob[1] = FindFirstMoveOutOfBook( PGN_SIDE_BLACK );
10700
10701     *buf = '\0';
10702
10703     if( oob[0] >= 0 || oob[1] >= 0 ) {
10704         for( i=0; i<2; i++ ) {
10705             int idx = oob[i];
10706
10707             if( idx >= 0 ) {
10708                 if( i > 0 && oob[0] >= 0 ) {
10709                     strcat( buf, "   " );
10710                 }
10711
10712                 sprintf( buf+strlen(buf), "%d%s. ", (idx - offset)/2 + 1, idx & 1 ? ".." : "" );
10713                 sprintf( buf+strlen(buf), "%s%.2f",
10714                     pvInfoList[idx].score >= 0 ? "+" : "",
10715                     pvInfoList[idx].score / 100.0 );
10716             }
10717         }
10718     }
10719 }
10720
10721 /* Save game in PGN style and close the file */
10722 int
10723 SaveGamePGN(f)
10724      FILE *f;
10725 {
10726     int i, offset, linelen, newblock;
10727     time_t tm;
10728 //    char *movetext;
10729     char numtext[32];
10730     int movelen, numlen, blank;
10731     char move_buffer[100]; /* [AS] Buffer for move+PV info */
10732
10733     offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
10734
10735     tm = time((time_t *) NULL);
10736
10737     PrintPGNTags(f, &gameInfo);
10738
10739     if (backwardMostMove > 0 || startedFromSetupPosition) {
10740         char *fen = PositionToFEN(backwardMostMove, NULL);
10741         fprintf(f, "[FEN \"%s\"]\n[SetUp \"1\"]\n", fen);
10742         fprintf(f, "\n{--------------\n");
10743         PrintPosition(f, backwardMostMove);
10744         fprintf(f, "--------------}\n");
10745         free(fen);
10746     }
10747     else {
10748         /* [AS] Out of book annotation */
10749         if( appData.saveOutOfBookInfo ) {
10750             char buf[64];
10751
10752             GetOutOfBookInfo( buf );
10753
10754             if( buf[0] != '\0' ) {
10755                 fprintf( f, "[%s \"%s\"]\n", PGN_OUT_OF_BOOK, buf );
10756             }
10757         }
10758
10759         fprintf(f, "\n");
10760     }
10761
10762     i = backwardMostMove;
10763     linelen = 0;
10764     newblock = TRUE;
10765
10766     while (i < forwardMostMove) {
10767         /* Print comments preceding this move */
10768         if (commentList[i] != NULL) {
10769             if (linelen > 0) fprintf(f, "\n");
10770             fprintf(f, "%s", commentList[i]);
10771             linelen = 0;
10772             newblock = TRUE;
10773         }
10774
10775         /* Format move number */
10776         if ((i % 2) == 0) {
10777             sprintf(numtext, "%d.", (i - offset)/2 + 1);
10778         } else {
10779             if (newblock) {
10780                 sprintf(numtext, "%d...", (i - offset)/2 + 1);
10781             } else {
10782                 numtext[0] = NULLCHAR;
10783             }
10784         }
10785         numlen = strlen(numtext);
10786         newblock = FALSE;
10787
10788         /* Print move number */
10789         blank = linelen > 0 && numlen > 0;
10790         if (linelen + (blank ? 1 : 0) + numlen > PGN_MAX_LINE) {
10791             fprintf(f, "\n");
10792             linelen = 0;
10793             blank = 0;
10794         }
10795         if (blank) {
10796             fprintf(f, " ");
10797             linelen++;
10798         }
10799         fprintf(f, "%s", numtext);
10800         linelen += numlen;
10801
10802         /* Get move */
10803         strcpy(move_buffer, SavePart(parseList[i])); // [HGM] pgn: print move via buffer, so it can be edited
10804         movelen = strlen(move_buffer); /* [HGM] pgn: line-break point before move */
10805
10806         /* Print move */
10807         blank = linelen > 0 && movelen > 0;
10808         if (linelen + (blank ? 1 : 0) + movelen > PGN_MAX_LINE) {
10809             fprintf(f, "\n");
10810             linelen = 0;
10811             blank = 0;
10812         }
10813         if (blank) {
10814             fprintf(f, " ");
10815             linelen++;
10816         }
10817         fprintf(f, "%s", move_buffer);
10818         linelen += movelen;
10819
10820         /* [AS] Add PV info if present */
10821         if( i >= 0 && appData.saveExtendedInfoInPGN && pvInfoList[i].depth > 0 ) {
10822             /* [HGM] add time */
10823             char buf[MSG_SIZ]; int seconds;
10824
10825             seconds = (pvInfoList[i].time+5)/10; // deci-seconds, rounded to nearest
10826
10827             if( seconds <= 0) buf[0] = 0; else
10828             if( seconds < 30 ) sprintf(buf, " %3.1f%c", seconds/10., 0); else {
10829                 seconds = (seconds + 4)/10; // round to full seconds
10830                 if( seconds < 60 ) sprintf(buf, " %d%c", seconds, 0); else
10831                                    sprintf(buf, " %d:%02d%c", seconds/60, seconds%60, 0);
10832             }
10833
10834             sprintf( move_buffer, "{%s%.2f/%d%s}",
10835                 pvInfoList[i].score >= 0 ? "+" : "",
10836                 pvInfoList[i].score / 100.0,
10837                 pvInfoList[i].depth,
10838                 buf );
10839
10840             movelen = strlen(move_buffer); /* [HGM] pgn: line-break point after move */
10841
10842             /* Print score/depth */
10843             blank = linelen > 0 && movelen > 0;
10844             if (linelen + (blank ? 1 : 0) + movelen > PGN_MAX_LINE) {
10845                 fprintf(f, "\n");
10846                 linelen = 0;
10847                 blank = 0;
10848             }
10849             if (blank) {
10850                 fprintf(f, " ");
10851                 linelen++;
10852             }
10853             fprintf(f, "%s", move_buffer);
10854             linelen += movelen;
10855         }
10856
10857         i++;
10858     }
10859
10860     /* Start a new line */
10861     if (linelen > 0) fprintf(f, "\n");
10862
10863     /* Print comments after last move */
10864     if (commentList[i] != NULL) {
10865         fprintf(f, "%s\n", commentList[i]);
10866     }
10867
10868     /* Print result */
10869     if (gameInfo.resultDetails != NULL &&
10870         gameInfo.resultDetails[0] != NULLCHAR) {
10871         fprintf(f, "{%s} %s\n\n", gameInfo.resultDetails,
10872                 PGNResult(gameInfo.result));
10873     } else {
10874         fprintf(f, "%s\n\n", PGNResult(gameInfo.result));
10875     }
10876
10877     fclose(f);
10878     lastSavedGame = GameCheckSum(); // [HGM] save: remember ID of last saved game to prevent double saving
10879     return TRUE;
10880 }
10881
10882 /* Save game in old style and close the file */
10883 int
10884 SaveGameOldStyle(f)
10885      FILE *f;
10886 {
10887     int i, offset;
10888     time_t tm;
10889
10890     tm = time((time_t *) NULL);
10891
10892     fprintf(f, "# %s game file -- %s", programName, ctime(&tm));
10893     PrintOpponents(f);
10894
10895     if (backwardMostMove > 0 || startedFromSetupPosition) {
10896         fprintf(f, "\n[--------------\n");
10897         PrintPosition(f, backwardMostMove);
10898         fprintf(f, "--------------]\n");
10899     } else {
10900         fprintf(f, "\n");
10901     }
10902
10903     i = backwardMostMove;
10904     offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
10905
10906     while (i < forwardMostMove) {
10907         if (commentList[i] != NULL) {
10908             fprintf(f, "[%s]\n", commentList[i]);
10909         }
10910
10911         if ((i % 2) == 1) {
10912             fprintf(f, "%d. ...  %s\n", (i - offset)/2 + 1, parseList[i]);
10913             i++;
10914         } else {
10915             fprintf(f, "%d. %s  ", (i - offset)/2 + 1, parseList[i]);
10916             i++;
10917             if (commentList[i] != NULL) {
10918                 fprintf(f, "\n");
10919                 continue;
10920             }
10921             if (i >= forwardMostMove) {
10922                 fprintf(f, "\n");
10923                 break;
10924             }
10925             fprintf(f, "%s\n", parseList[i]);
10926             i++;
10927         }
10928     }
10929
10930     if (commentList[i] != NULL) {
10931         fprintf(f, "[%s]\n", commentList[i]);
10932     }
10933
10934     /* This isn't really the old style, but it's close enough */
10935     if (gameInfo.resultDetails != NULL &&
10936         gameInfo.resultDetails[0] != NULLCHAR) {
10937         fprintf(f, "%s (%s)\n\n", PGNResult(gameInfo.result),
10938                 gameInfo.resultDetails);
10939     } else {
10940         fprintf(f, "%s\n\n", PGNResult(gameInfo.result));
10941     }
10942
10943     fclose(f);
10944     return TRUE;
10945 }
10946
10947 /* Save the current game to open file f and close the file */
10948 int
10949 SaveGame(f, dummy, dummy2)
10950      FILE *f;
10951      int dummy;
10952      char *dummy2;
10953 {
10954     if (gameMode == EditPosition) EditPositionDone(TRUE);
10955     lastSavedGame = GameCheckSum(); // [HGM] save: remember ID of last saved game to prevent double saving
10956     if (appData.oldSaveStyle)
10957       return SaveGameOldStyle(f);
10958     else
10959       return SaveGamePGN(f);
10960 }
10961
10962 /* Save the current position to the given file */
10963 int
10964 SavePositionToFile(filename)
10965      char *filename;
10966 {
10967     FILE *f;
10968     char buf[MSG_SIZ];
10969
10970     if (strcmp(filename, "-") == 0) {
10971         return SavePosition(stdout, 0, NULL);
10972     } else {
10973         f = fopen(filename, "a");
10974         if (f == NULL) {
10975             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
10976             DisplayError(buf, errno);
10977             return FALSE;
10978         } else {
10979             SavePosition(f, 0, NULL);
10980             return TRUE;
10981         }
10982     }
10983 }
10984
10985 /* Save the current position to the given open file and close the file */
10986 int
10987 SavePosition(f, dummy, dummy2)
10988      FILE *f;
10989      int dummy;
10990      char *dummy2;
10991 {
10992     time_t tm;
10993     char *fen;
10994
10995     if (gameMode == EditPosition) EditPositionDone(TRUE);
10996     if (appData.oldSaveStyle) {
10997         tm = time((time_t *) NULL);
10998
10999         fprintf(f, "# %s position file -- %s", programName, ctime(&tm));
11000         PrintOpponents(f);
11001         fprintf(f, "[--------------\n");
11002         PrintPosition(f, currentMove);
11003         fprintf(f, "--------------]\n");
11004     } else {
11005         fen = PositionToFEN(currentMove, NULL);
11006         fprintf(f, "%s\n", fen);
11007         free(fen);
11008     }
11009     fclose(f);
11010     return TRUE;
11011 }
11012
11013 void
11014 ReloadCmailMsgEvent(unregister)
11015      int unregister;
11016 {
11017 #if !WIN32
11018     static char *inFilename = NULL;
11019     static char *outFilename;
11020     int i;
11021     struct stat inbuf, outbuf;
11022     int status;
11023
11024     /* Any registered moves are unregistered if unregister is set, */
11025     /* i.e. invoked by the signal handler */
11026     if (unregister) {
11027         for (i = 0; i < CMAIL_MAX_GAMES; i ++) {
11028             cmailMoveRegistered[i] = FALSE;
11029             if (cmailCommentList[i] != NULL) {
11030                 free(cmailCommentList[i]);
11031                 cmailCommentList[i] = NULL;
11032             }
11033         }
11034         nCmailMovesRegistered = 0;
11035     }
11036
11037     for (i = 0; i < CMAIL_MAX_GAMES; i ++) {
11038         cmailResult[i] = CMAIL_NOT_RESULT;
11039     }
11040     nCmailResults = 0;
11041
11042     if (inFilename == NULL) {
11043         /* Because the filenames are static they only get malloced once  */
11044         /* and they never get freed                                      */
11045         inFilename = (char *) malloc(strlen(appData.cmailGameName) + 9);
11046         sprintf(inFilename, "%s.game.in", appData.cmailGameName);
11047
11048         outFilename = (char *) malloc(strlen(appData.cmailGameName) + 5);
11049         sprintf(outFilename, "%s.out", appData.cmailGameName);
11050     }
11051
11052     status = stat(outFilename, &outbuf);
11053     if (status < 0) {
11054         cmailMailedMove = FALSE;
11055     } else {
11056         status = stat(inFilename, &inbuf);
11057         cmailMailedMove = (inbuf.st_mtime < outbuf.st_mtime);
11058     }
11059
11060     /* LoadGameFromFile(CMAIL_MAX_GAMES) with cmailMsgLoaded == TRUE
11061        counts the games, notes how each one terminated, etc.
11062
11063        It would be nice to remove this kludge and instead gather all
11064        the information while building the game list.  (And to keep it
11065        in the game list nodes instead of having a bunch of fixed-size
11066        parallel arrays.)  Note this will require getting each game's
11067        termination from the PGN tags, as the game list builder does
11068        not process the game moves.  --mann
11069        */
11070     cmailMsgLoaded = TRUE;
11071     LoadGameFromFile(inFilename, CMAIL_MAX_GAMES, "", FALSE);
11072
11073     /* Load first game in the file or popup game menu */
11074     LoadGameFromFile(inFilename, 0, appData.cmailGameName, TRUE);
11075
11076 #endif /* !WIN32 */
11077     return;
11078 }
11079
11080 int
11081 RegisterMove()
11082 {
11083     FILE *f;
11084     char string[MSG_SIZ];
11085
11086     if (   cmailMailedMove
11087         || (cmailResult[lastLoadGameNumber - 1] == CMAIL_OLD_RESULT)) {
11088         return TRUE;            /* Allow free viewing  */
11089     }
11090
11091     /* Unregister move to ensure that we don't leave RegisterMove        */
11092     /* with the move registered when the conditions for registering no   */
11093     /* longer hold                                                       */
11094     if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
11095         cmailMoveRegistered[lastLoadGameNumber - 1] = FALSE;
11096         nCmailMovesRegistered --;
11097
11098         if (cmailCommentList[lastLoadGameNumber - 1] != NULL)
11099           {
11100               free(cmailCommentList[lastLoadGameNumber - 1]);
11101               cmailCommentList[lastLoadGameNumber - 1] = NULL;
11102           }
11103     }
11104
11105     if (cmailOldMove == -1) {
11106         DisplayError(_("You have edited the game history.\nUse Reload Same Game and make your move again."), 0);
11107         return FALSE;
11108     }
11109
11110     if (currentMove > cmailOldMove + 1) {
11111         DisplayError(_("You have entered too many moves.\nBack up to the correct position and try again."), 0);
11112         return FALSE;
11113     }
11114
11115     if (currentMove < cmailOldMove) {
11116         DisplayError(_("Displayed position is not current.\nStep forward to the correct position and try again."), 0);
11117         return FALSE;
11118     }
11119
11120     if (forwardMostMove > currentMove) {
11121         /* Silently truncate extra moves */
11122         TruncateGame();
11123     }
11124
11125     if (   (currentMove == cmailOldMove + 1)
11126         || (   (currentMove == cmailOldMove)
11127             && (   (cmailMoveType[lastLoadGameNumber - 1] == CMAIL_ACCEPT)
11128                 || (cmailMoveType[lastLoadGameNumber - 1] == CMAIL_RESIGN)))) {
11129         if (gameInfo.result != GameUnfinished) {
11130             cmailResult[lastLoadGameNumber - 1] = CMAIL_NEW_RESULT;
11131         }
11132
11133         if (commentList[currentMove] != NULL) {
11134             cmailCommentList[lastLoadGameNumber - 1]
11135               = StrSave(commentList[currentMove]);
11136         }
11137         strcpy(cmailMove[lastLoadGameNumber - 1], moveList[currentMove - 1]);
11138
11139         if (appData.debugMode)
11140           fprintf(debugFP, "Saving %s for game %d\n",
11141                   cmailMove[lastLoadGameNumber - 1], lastLoadGameNumber);
11142
11143         sprintf(string,
11144                 "%s.game.out.%d", appData.cmailGameName, lastLoadGameNumber);
11145
11146         f = fopen(string, "w");
11147         if (appData.oldSaveStyle) {
11148             SaveGameOldStyle(f); /* also closes the file */
11149
11150             sprintf(string, "%s.pos.out", appData.cmailGameName);
11151             f = fopen(string, "w");
11152             SavePosition(f, 0, NULL); /* also closes the file */
11153         } else {
11154             fprintf(f, "{--------------\n");
11155             PrintPosition(f, currentMove);
11156             fprintf(f, "--------------}\n\n");
11157
11158             SaveGame(f, 0, NULL); /* also closes the file*/
11159         }
11160
11161         cmailMoveRegistered[lastLoadGameNumber - 1] = TRUE;
11162         nCmailMovesRegistered ++;
11163     } else if (nCmailGames == 1) {
11164         DisplayError(_("You have not made a move yet"), 0);
11165         return FALSE;
11166     }
11167
11168     return TRUE;
11169 }
11170
11171 void
11172 MailMoveEvent()
11173 {
11174 #if !WIN32
11175     static char *partCommandString = "cmail -xv%s -remail -game %s 2>&1";
11176     FILE *commandOutput;
11177     char buffer[MSG_SIZ], msg[MSG_SIZ], string[MSG_SIZ];
11178     int nBytes = 0;             /*  Suppress warnings on uninitialized variables    */
11179     int nBuffers;
11180     int i;
11181     int archived;
11182     char *arcDir;
11183
11184     if (! cmailMsgLoaded) {
11185         DisplayError(_("The cmail message is not loaded.\nUse Reload CMail Message and make your move again."), 0);
11186         return;
11187     }
11188
11189     if (nCmailGames == nCmailResults) {
11190         DisplayError(_("No unfinished games"), 0);
11191         return;
11192     }
11193
11194 #if CMAIL_PROHIBIT_REMAIL
11195     if (cmailMailedMove) {
11196         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);
11197         DisplayError(msg, 0);
11198         return;
11199     }
11200 #endif
11201
11202     if (! (cmailMailedMove || RegisterMove())) return;
11203
11204     if (   cmailMailedMove
11205         || (nCmailMovesRegistered + nCmailResults == nCmailGames)) {
11206         sprintf(string, partCommandString,
11207                 appData.debugMode ? " -v" : "", appData.cmailGameName);
11208         commandOutput = popen(string, "r");
11209
11210         if (commandOutput == NULL) {
11211             DisplayError(_("Failed to invoke cmail"), 0);
11212         } else {
11213             for (nBuffers = 0; (! feof(commandOutput)); nBuffers ++) {
11214                 nBytes = fread(buffer, 1, MSG_SIZ - 1, commandOutput);
11215             }
11216             if (nBuffers > 1) {
11217                 (void) memcpy(msg, buffer + nBytes, MSG_SIZ - nBytes - 1);
11218                 (void) memcpy(msg + MSG_SIZ - nBytes - 1, buffer, nBytes);
11219                 nBytes = MSG_SIZ - 1;
11220             } else {
11221                 (void) memcpy(msg, buffer, nBytes);
11222             }
11223             *(msg + nBytes) = '\0'; /* \0 for end-of-string*/
11224
11225             if(StrStr(msg, "Mailed cmail message to ") != NULL) {
11226                 cmailMailedMove = TRUE; /* Prevent >1 moves    */
11227
11228                 archived = TRUE;
11229                 for (i = 0; i < nCmailGames; i ++) {
11230                     if (cmailResult[i] == CMAIL_NOT_RESULT) {
11231                         archived = FALSE;
11232                     }
11233                 }
11234                 if (   archived
11235                     && (   (arcDir = (char *) getenv("CMAIL_ARCDIR"))
11236                         != NULL)) {
11237                     sprintf(buffer, "%s/%s.%s.archive",
11238                             arcDir,
11239                             appData.cmailGameName,
11240                             gameInfo.date);
11241                     LoadGameFromFile(buffer, 1, buffer, FALSE);
11242                     cmailMsgLoaded = FALSE;
11243                 }
11244             }
11245
11246             DisplayInformation(msg);
11247             pclose(commandOutput);
11248         }
11249     } else {
11250         if ((*cmailMsg) != '\0') {
11251             DisplayInformation(cmailMsg);
11252         }
11253     }
11254
11255     return;
11256 #endif /* !WIN32 */
11257 }
11258
11259 char *
11260 CmailMsg()
11261 {
11262 #if WIN32
11263     return NULL;
11264 #else
11265     int  prependComma = 0;
11266     char number[5];
11267     char string[MSG_SIZ];       /* Space for game-list */
11268     int  i;
11269
11270     if (!cmailMsgLoaded) return "";
11271
11272     if (cmailMailedMove) {
11273         sprintf(cmailMsg, _("Waiting for reply from opponent\n"));
11274     } else {
11275         /* Create a list of games left */
11276         sprintf(string, "[");
11277         for (i = 0; i < nCmailGames; i ++) {
11278             if (! (   cmailMoveRegistered[i]
11279                    || (cmailResult[i] == CMAIL_OLD_RESULT))) {
11280                 if (prependComma) {
11281                     sprintf(number, ",%d", i + 1);
11282                 } else {
11283                     sprintf(number, "%d", i + 1);
11284                     prependComma = 1;
11285                 }
11286
11287                 strcat(string, number);
11288             }
11289         }
11290         strcat(string, "]");
11291
11292         if (nCmailMovesRegistered + nCmailResults == 0) {
11293             switch (nCmailGames) {
11294               case 1:
11295                 sprintf(cmailMsg,
11296                         _("Still need to make move for game\n"));
11297                 break;
11298
11299               case 2:
11300                 sprintf(cmailMsg,
11301                         _("Still need to make moves for both games\n"));
11302                 break;
11303
11304               default:
11305                 sprintf(cmailMsg,
11306                         _("Still need to make moves for all %d games\n"),
11307                         nCmailGames);
11308                 break;
11309             }
11310         } else {
11311             switch (nCmailGames - nCmailMovesRegistered - nCmailResults) {
11312               case 1:
11313                 sprintf(cmailMsg,
11314                         _("Still need to make a move for game %s\n"),
11315                         string);
11316                 break;
11317
11318               case 0:
11319                 if (nCmailResults == nCmailGames) {
11320                     sprintf(cmailMsg, _("No unfinished games\n"));
11321                 } else {
11322                     sprintf(cmailMsg, _("Ready to send mail\n"));
11323                 }
11324                 break;
11325
11326               default:
11327                 sprintf(cmailMsg,
11328                         _("Still need to make moves for games %s\n"),
11329                         string);
11330             }
11331         }
11332     }
11333     return cmailMsg;
11334 #endif /* WIN32 */
11335 }
11336
11337 void
11338 ResetGameEvent()
11339 {
11340     if (gameMode == Training)
11341       SetTrainingModeOff();
11342
11343     Reset(TRUE, TRUE);
11344     cmailMsgLoaded = FALSE;
11345     if (appData.icsActive) {
11346       SendToICS(ics_prefix);
11347       SendToICS("refresh\n");
11348     }
11349 }
11350
11351 void
11352 ExitEvent(status)
11353      int status;
11354 {
11355     exiting++;
11356     if (exiting > 2) {
11357       /* Give up on clean exit */
11358       exit(status);
11359     }
11360     if (exiting > 1) {
11361       /* Keep trying for clean exit */
11362       return;
11363     }
11364
11365     if (appData.icsActive && appData.colorize) Colorize(ColorNone, FALSE);
11366
11367     if (telnetISR != NULL) {
11368       RemoveInputSource(telnetISR);
11369     }
11370     if (icsPR != NoProc) {
11371       DestroyChildProcess(icsPR, TRUE);
11372     }
11373
11374     /* [HGM] crash: leave writing PGN and position entirely to GameEnds() */
11375     GameEnds(gameInfo.result, gameInfo.resultDetails==NULL ? "xboard exit" : gameInfo.resultDetails, GE_PLAYER);
11376
11377     /* [HGM] crash: the above GameEnds() is a dud if another one was running */
11378     /* make sure this other one finishes before killing it!                  */
11379     if(endingGame) { int count = 0;
11380         if(appData.debugMode) fprintf(debugFP, "ExitEvent() during GameEnds(), wait\n");
11381         while(endingGame && count++ < 10) DoSleep(1);
11382         if(appData.debugMode && endingGame) fprintf(debugFP, "GameEnds() seems stuck, proceed exiting\n");
11383     }
11384
11385     /* Kill off chess programs */
11386     if (first.pr != NoProc) {
11387         ExitAnalyzeMode();
11388
11389         DoSleep( appData.delayBeforeQuit );
11390         SendToProgram("quit\n", &first);
11391         DoSleep( appData.delayAfterQuit );
11392         DestroyChildProcess(first.pr, 10 /* [AS] first.useSigterm */ );
11393     }
11394     if (second.pr != NoProc) {
11395         DoSleep( appData.delayBeforeQuit );
11396         SendToProgram("quit\n", &second);
11397         DoSleep( appData.delayAfterQuit );
11398         DestroyChildProcess(second.pr, 10 /* [AS] second.useSigterm */ );
11399     }
11400     if (first.isr != NULL) {
11401         RemoveInputSource(first.isr);
11402     }
11403     if (second.isr != NULL) {
11404         RemoveInputSource(second.isr);
11405     }
11406
11407     ShutDownFrontEnd();
11408     exit(status);
11409 }
11410
11411 void
11412 PauseEvent()
11413 {
11414     if (appData.debugMode)
11415         fprintf(debugFP, "PauseEvent(): pausing %d\n", pausing);
11416     if (pausing) {
11417         pausing = FALSE;
11418         ModeHighlight();
11419         if (gameMode == MachinePlaysWhite ||
11420             gameMode == MachinePlaysBlack) {
11421             StartClocks();
11422         } else {
11423             DisplayBothClocks();
11424         }
11425         if (gameMode == PlayFromGameFile) {
11426             if (appData.timeDelay >= 0)
11427                 AutoPlayGameLoop();
11428         } else if (gameMode == IcsExamining && pauseExamInvalid) {
11429             Reset(FALSE, TRUE);
11430             SendToICS(ics_prefix);
11431             SendToICS("refresh\n");
11432         } else if (currentMove < forwardMostMove) {
11433             ForwardInner(forwardMostMove);
11434         }
11435         pauseExamInvalid = FALSE;
11436     } else {
11437         switch (gameMode) {
11438           default:
11439             return;
11440           case IcsExamining:
11441             pauseExamForwardMostMove = forwardMostMove;
11442             pauseExamInvalid = FALSE;
11443             /* fall through */
11444           case IcsObserving:
11445           case IcsPlayingWhite:
11446           case IcsPlayingBlack:
11447             pausing = TRUE;
11448             ModeHighlight();
11449             return;
11450           case PlayFromGameFile:
11451             (void) StopLoadGameTimer();
11452             pausing = TRUE;
11453             ModeHighlight();
11454             break;
11455           case BeginningOfGame:
11456             if (appData.icsActive) return;
11457             /* else fall through */
11458           case MachinePlaysWhite:
11459           case MachinePlaysBlack:
11460           case TwoMachinesPlay:
11461             if (forwardMostMove == 0)
11462               return;           /* don't pause if no one has moved */
11463             if ((gameMode == MachinePlaysWhite &&
11464                  !WhiteOnMove(forwardMostMove)) ||
11465                 (gameMode == MachinePlaysBlack &&
11466                  WhiteOnMove(forwardMostMove))) {
11467                 StopClocks();
11468             }
11469             pausing = TRUE;
11470             ModeHighlight();
11471             break;
11472         }
11473     }
11474 }
11475
11476 void
11477 EditCommentEvent()
11478 {
11479     char title[MSG_SIZ];
11480
11481     if (currentMove < 1 || parseList[currentMove - 1][0] == NULLCHAR) {
11482         strcpy(title, _("Edit comment"));
11483     } else {
11484         sprintf(title, _("Edit comment on %d.%s%s"), (currentMove - 1) / 2 + 1,
11485                 WhiteOnMove(currentMove - 1) ? " " : ".. ",
11486                 parseList[currentMove - 1]);
11487     }
11488
11489     EditCommentPopUp(currentMove, title, commentList[currentMove]);
11490 }
11491
11492
11493 void
11494 EditTagsEvent()
11495 {
11496     char *tags = PGNTags(&gameInfo);
11497     EditTagsPopUp(tags);
11498     free(tags);
11499 }
11500
11501 void
11502 AnalyzeModeEvent()
11503 {
11504     if (appData.noChessProgram || gameMode == AnalyzeMode)
11505       return;
11506
11507     if (gameMode != AnalyzeFile) {
11508         if (!appData.icsEngineAnalyze) {
11509                EditGameEvent();
11510                if (gameMode != EditGame) return;
11511         }
11512         ResurrectChessProgram();
11513         SendToProgram("analyze\n", &first);
11514         first.analyzing = TRUE;
11515         /*first.maybeThinking = TRUE;*/
11516         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
11517         EngineOutputPopUp();
11518     }
11519     if (!appData.icsEngineAnalyze) gameMode = AnalyzeMode;
11520     pausing = FALSE;
11521     ModeHighlight();
11522     SetGameInfo();
11523
11524     StartAnalysisClock();
11525     GetTimeMark(&lastNodeCountTime);
11526     lastNodeCount = 0;
11527 }
11528
11529 void
11530 AnalyzeFileEvent()
11531 {
11532     if (appData.noChessProgram || gameMode == AnalyzeFile)
11533       return;
11534
11535     if (gameMode != AnalyzeMode) {
11536         EditGameEvent();
11537         if (gameMode != EditGame) return;
11538         ResurrectChessProgram();
11539         SendToProgram("analyze\n", &first);
11540         first.analyzing = TRUE;
11541         /*first.maybeThinking = TRUE;*/
11542         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
11543         EngineOutputPopUp();
11544     }
11545     gameMode = AnalyzeFile;
11546     pausing = FALSE;
11547     ModeHighlight();
11548     SetGameInfo();
11549
11550     StartAnalysisClock();
11551     GetTimeMark(&lastNodeCountTime);
11552     lastNodeCount = 0;
11553 }
11554
11555 void
11556 MachineWhiteEvent()
11557 {
11558     char buf[MSG_SIZ];
11559     char *bookHit = NULL;
11560
11561     if (appData.noChessProgram || (gameMode == MachinePlaysWhite))
11562       return;
11563
11564
11565     if (gameMode == PlayFromGameFile ||
11566         gameMode == TwoMachinesPlay  ||
11567         gameMode == Training         ||
11568         gameMode == AnalyzeMode      ||
11569         gameMode == EndOfGame)
11570         EditGameEvent();
11571
11572     if (gameMode == EditPosition)
11573         EditPositionDone(TRUE);
11574
11575     if (!WhiteOnMove(currentMove)) {
11576         DisplayError(_("It is not White's turn"), 0);
11577         return;
11578     }
11579
11580     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile)
11581       ExitAnalyzeMode();
11582
11583     if (gameMode == EditGame || gameMode == AnalyzeMode ||
11584         gameMode == AnalyzeFile)
11585         TruncateGame();
11586
11587     ResurrectChessProgram();    /* in case it isn't running */
11588     if(gameMode == BeginningOfGame) { /* [HGM] time odds: to get right odds in human mode */
11589         gameMode = MachinePlaysWhite;
11590         ResetClocks();
11591     } else
11592     gameMode = MachinePlaysWhite;
11593     pausing = FALSE;
11594     ModeHighlight();
11595     SetGameInfo();
11596     sprintf(buf, "%s vs. %s", gameInfo.white, gameInfo.black);
11597     DisplayTitle(buf);
11598     if (first.sendName) {
11599       sprintf(buf, "name %s\n", gameInfo.black);
11600       SendToProgram(buf, &first);
11601     }
11602     if (first.sendTime) {
11603       if (first.useColors) {
11604         SendToProgram("black\n", &first); /*gnu kludge*/
11605       }
11606       SendTimeRemaining(&first, TRUE);
11607     }
11608     if (first.useColors) {
11609       SendToProgram("white\n", &first); // [HGM] book: send 'go' separately
11610     }
11611     bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: send go or retrieve book move
11612     SetMachineThinkingEnables();
11613     first.maybeThinking = TRUE;
11614     StartClocks();
11615     firstMove = FALSE;
11616
11617     if (appData.autoFlipView && !flipView) {
11618       flipView = !flipView;
11619       DrawPosition(FALSE, NULL);
11620       DisplayBothClocks();       // [HGM] logo: clocks might have to be exchanged;
11621     }
11622
11623     if(bookHit) { // [HGM] book: simulate book reply
11624         static char bookMove[MSG_SIZ]; // a bit generous?
11625
11626         programStats.nodes = programStats.depth = programStats.time =
11627         programStats.score = programStats.got_only_move = 0;
11628         sprintf(programStats.movelist, "%s (xbook)", bookHit);
11629
11630         strcpy(bookMove, "move ");
11631         strcat(bookMove, bookHit);
11632         HandleMachineMove(bookMove, &first);
11633     }
11634 }
11635
11636 void
11637 MachineBlackEvent()
11638 {
11639     char buf[MSG_SIZ];
11640    char *bookHit = NULL;
11641
11642     if (appData.noChessProgram || (gameMode == MachinePlaysBlack))
11643         return;
11644
11645
11646     if (gameMode == PlayFromGameFile ||
11647         gameMode == TwoMachinesPlay  ||
11648         gameMode == Training         ||
11649         gameMode == AnalyzeMode      ||
11650         gameMode == EndOfGame)
11651         EditGameEvent();
11652
11653     if (gameMode == EditPosition)
11654         EditPositionDone(TRUE);
11655
11656     if (WhiteOnMove(currentMove)) {
11657         DisplayError(_("It is not Black's turn"), 0);
11658         return;
11659     }
11660
11661     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile)
11662       ExitAnalyzeMode();
11663
11664     if (gameMode == EditGame || gameMode == AnalyzeMode ||
11665         gameMode == AnalyzeFile)
11666         TruncateGame();
11667
11668     ResurrectChessProgram();    /* in case it isn't running */
11669     gameMode = MachinePlaysBlack;
11670     pausing = FALSE;
11671     ModeHighlight();
11672     SetGameInfo();
11673     sprintf(buf, "%s vs. %s", gameInfo.white, gameInfo.black);
11674     DisplayTitle(buf);
11675     if (first.sendName) {
11676       sprintf(buf, "name %s\n", gameInfo.white);
11677       SendToProgram(buf, &first);
11678     }
11679     if (first.sendTime) {
11680       if (first.useColors) {
11681         SendToProgram("white\n", &first); /*gnu kludge*/
11682       }
11683       SendTimeRemaining(&first, FALSE);
11684     }
11685     if (first.useColors) {
11686       SendToProgram("black\n", &first); // [HGM] book: 'go' sent separately
11687     }
11688     bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: send go or retrieve book move
11689     SetMachineThinkingEnables();
11690     first.maybeThinking = TRUE;
11691     StartClocks();
11692
11693     if (appData.autoFlipView && flipView) {
11694       flipView = !flipView;
11695       DrawPosition(FALSE, NULL);
11696       DisplayBothClocks();       // [HGM] logo: clocks might have to be exchanged;
11697     }
11698     if(bookHit) { // [HGM] book: simulate book reply
11699         static char bookMove[MSG_SIZ]; // a bit generous?
11700
11701         programStats.nodes = programStats.depth = programStats.time =
11702         programStats.score = programStats.got_only_move = 0;
11703         sprintf(programStats.movelist, "%s (xbook)", bookHit);
11704
11705         strcpy(bookMove, "move ");
11706         strcat(bookMove, bookHit);
11707         HandleMachineMove(bookMove, &first);
11708     }
11709 }
11710
11711
11712 void
11713 DisplayTwoMachinesTitle()
11714 {
11715     char buf[MSG_SIZ];
11716     if (appData.matchGames > 0) {
11717         if (first.twoMachinesColor[0] == 'w') {
11718             sprintf(buf, "%s vs. %s (%d-%d-%d)",
11719                     gameInfo.white, gameInfo.black,
11720                     first.matchWins, second.matchWins,
11721                     matchGame - 1 - (first.matchWins + second.matchWins));
11722         } else {
11723             sprintf(buf, "%s vs. %s (%d-%d-%d)",
11724                     gameInfo.white, gameInfo.black,
11725                     second.matchWins, first.matchWins,
11726                     matchGame - 1 - (first.matchWins + second.matchWins));
11727         }
11728     } else {
11729         sprintf(buf, "%s vs. %s", gameInfo.white, gameInfo.black);
11730     }
11731     DisplayTitle(buf);
11732 }
11733
11734 void
11735 TwoMachinesEvent P((void))
11736 {
11737     int i;
11738     char buf[MSG_SIZ];
11739     ChessProgramState *onmove;
11740     char *bookHit = NULL;
11741
11742     if (appData.noChessProgram) return;
11743
11744     switch (gameMode) {
11745       case TwoMachinesPlay:
11746         return;
11747       case MachinePlaysWhite:
11748       case MachinePlaysBlack:
11749         if (WhiteOnMove(forwardMostMove) == (gameMode == MachinePlaysWhite)) {
11750             DisplayError(_("Wait until your turn,\nor select Move Now"), 0);
11751             return;
11752         }
11753         /* fall through */
11754       case BeginningOfGame:
11755       case PlayFromGameFile:
11756       case EndOfGame:
11757         EditGameEvent();
11758         if (gameMode != EditGame) return;
11759         break;
11760       case EditPosition:
11761         EditPositionDone(TRUE);
11762         break;
11763       case AnalyzeMode:
11764       case AnalyzeFile:
11765         ExitAnalyzeMode();
11766         break;
11767       case EditGame:
11768       default:
11769         break;
11770     }
11771
11772 //    forwardMostMove = currentMove;
11773     TruncateGame(); // [HGM] vari: MachineWhite and MachineBlack do this...
11774     ResurrectChessProgram();    /* in case first program isn't running */
11775
11776     if (second.pr == NULL) {
11777         StartChessProgram(&second);
11778         if (second.protocolVersion == 1) {
11779           TwoMachinesEventIfReady();
11780         } else {
11781           /* kludge: allow timeout for initial "feature" command */
11782           FreezeUI();
11783           DisplayMessage("", _("Starting second chess program"));
11784           ScheduleDelayedEvent(TwoMachinesEventIfReady, FEATURE_TIMEOUT);
11785         }
11786         return;
11787     }
11788     DisplayMessage("", "");
11789     InitChessProgram(&second, FALSE);
11790     SendToProgram("force\n", &second);
11791     if (startedFromSetupPosition) {
11792         SendBoard(&second, backwardMostMove);
11793     if (appData.debugMode) {
11794         fprintf(debugFP, "Two Machines\n");
11795     }
11796     }
11797     for (i = backwardMostMove; i < forwardMostMove; i++) {
11798         SendMoveToProgram(i, &second);
11799     }
11800
11801     gameMode = TwoMachinesPlay;
11802     pausing = FALSE;
11803     ModeHighlight();
11804     SetGameInfo();
11805     DisplayTwoMachinesTitle();
11806     firstMove = TRUE;
11807     if ((first.twoMachinesColor[0] == 'w') == WhiteOnMove(forwardMostMove)) {
11808         onmove = &first;
11809     } else {
11810         onmove = &second;
11811     }
11812
11813     SendToProgram(first.computerString, &first);
11814     if (first.sendName) {
11815       sprintf(buf, "name %s\n", second.tidy);
11816       SendToProgram(buf, &first);
11817     }
11818     SendToProgram(second.computerString, &second);
11819     if (second.sendName) {
11820       sprintf(buf, "name %s\n", first.tidy);
11821       SendToProgram(buf, &second);
11822     }
11823
11824     ResetClocks();
11825     if (!first.sendTime || !second.sendTime) {
11826         timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
11827         timeRemaining[1][forwardMostMove] = blackTimeRemaining;
11828     }
11829     if (onmove->sendTime) {
11830       if (onmove->useColors) {
11831         SendToProgram(onmove->other->twoMachinesColor, onmove); /*gnu kludge*/
11832       }
11833       SendTimeRemaining(onmove, WhiteOnMove(forwardMostMove));
11834     }
11835     if (onmove->useColors) {
11836       SendToProgram(onmove->twoMachinesColor, onmove);
11837     }
11838     bookHit = SendMoveToBookUser(forwardMostMove-1, onmove, TRUE); // [HGM] book: send go or retrieve book move
11839 //    SendToProgram("go\n", onmove);
11840     onmove->maybeThinking = TRUE;
11841     SetMachineThinkingEnables();
11842
11843     StartClocks();
11844
11845     if(bookHit) { // [HGM] book: simulate book reply
11846         static char bookMove[MSG_SIZ]; // a bit generous?
11847
11848         programStats.nodes = programStats.depth = programStats.time =
11849         programStats.score = programStats.got_only_move = 0;
11850         sprintf(programStats.movelist, "%s (xbook)", bookHit);
11851
11852         strcpy(bookMove, "move ");
11853         strcat(bookMove, bookHit);
11854         savedMessage = bookMove; // args for deferred call
11855         savedState = onmove;
11856         ScheduleDelayedEvent(DeferredBookMove, 1);
11857     }
11858 }
11859
11860 void
11861 TrainingEvent()
11862 {
11863     if (gameMode == Training) {
11864       SetTrainingModeOff();
11865       gameMode = PlayFromGameFile;
11866       DisplayMessage("", _("Training mode off"));
11867     } else {
11868       gameMode = Training;
11869       animateTraining = appData.animate;
11870
11871       /* make sure we are not already at the end of the game */
11872       if (currentMove < forwardMostMove) {
11873         SetTrainingModeOn();
11874         DisplayMessage("", _("Training mode on"));
11875       } else {
11876         gameMode = PlayFromGameFile;
11877         DisplayError(_("Already at end of game"), 0);
11878       }
11879     }
11880     ModeHighlight();
11881 }
11882
11883 void
11884 IcsClientEvent()
11885 {
11886     if (!appData.icsActive) return;
11887     switch (gameMode) {
11888       case IcsPlayingWhite:
11889       case IcsPlayingBlack:
11890       case IcsObserving:
11891       case IcsIdle:
11892       case BeginningOfGame:
11893       case IcsExamining:
11894         return;
11895
11896       case EditGame:
11897         break;
11898
11899       case EditPosition:
11900         EditPositionDone(TRUE);
11901         break;
11902
11903       case AnalyzeMode:
11904       case AnalyzeFile:
11905         ExitAnalyzeMode();
11906         break;
11907
11908       default:
11909         EditGameEvent();
11910         break;
11911     }
11912
11913     gameMode = IcsIdle;
11914     ModeHighlight();
11915     return;
11916 }
11917
11918
11919 void
11920 EditGameEvent()
11921 {
11922     int i;
11923
11924     switch (gameMode) {
11925       case Training:
11926         SetTrainingModeOff();
11927         break;
11928       case MachinePlaysWhite:
11929       case MachinePlaysBlack:
11930       case BeginningOfGame:
11931         SendToProgram("force\n", &first);
11932         SetUserThinkingEnables();
11933         break;
11934       case PlayFromGameFile:
11935         (void) StopLoadGameTimer();
11936         if (gameFileFP != NULL) {
11937             gameFileFP = NULL;
11938         }
11939         break;
11940       case EditPosition:
11941         EditPositionDone(TRUE);
11942         break;
11943       case AnalyzeMode:
11944       case AnalyzeFile:
11945         ExitAnalyzeMode();
11946         SendToProgram("force\n", &first);
11947         break;
11948       case TwoMachinesPlay:
11949         GameEnds((ChessMove) 0, NULL, GE_PLAYER);
11950         ResurrectChessProgram();
11951         SetUserThinkingEnables();
11952         break;
11953       case EndOfGame:
11954         ResurrectChessProgram();
11955         break;
11956       case IcsPlayingBlack:
11957       case IcsPlayingWhite:
11958         DisplayError(_("Warning: You are still playing a game"), 0);
11959         break;
11960       case IcsObserving:
11961         DisplayError(_("Warning: You are still observing a game"), 0);
11962         break;
11963       case IcsExamining:
11964         DisplayError(_("Warning: You are still examining a game"), 0);
11965         break;
11966       case IcsIdle:
11967         break;
11968       case EditGame:
11969       default:
11970         return;
11971     }
11972
11973     pausing = FALSE;
11974     StopClocks();
11975     first.offeredDraw = second.offeredDraw = 0;
11976
11977     if (gameMode == PlayFromGameFile) {
11978         whiteTimeRemaining = timeRemaining[0][currentMove];
11979         blackTimeRemaining = timeRemaining[1][currentMove];
11980         DisplayTitle("");
11981     }
11982
11983     if (gameMode == MachinePlaysWhite ||
11984         gameMode == MachinePlaysBlack ||
11985         gameMode == TwoMachinesPlay ||
11986         gameMode == EndOfGame) {
11987         i = forwardMostMove;
11988         while (i > currentMove) {
11989             SendToProgram("undo\n", &first);
11990             i--;
11991         }
11992         whiteTimeRemaining = timeRemaining[0][currentMove];
11993         blackTimeRemaining = timeRemaining[1][currentMove];
11994         DisplayBothClocks();
11995         if (whiteFlag || blackFlag) {
11996             whiteFlag = blackFlag = 0;
11997         }
11998         DisplayTitle("");
11999     }
12000
12001     gameMode = EditGame;
12002     ModeHighlight();
12003     SetGameInfo();
12004 }
12005
12006
12007 void
12008 EditPositionEvent()
12009 {
12010     if (gameMode == EditPosition) {
12011         EditGameEvent();
12012         return;
12013     }
12014
12015     EditGameEvent();
12016     if (gameMode != EditGame) return;
12017
12018     gameMode = EditPosition;
12019     ModeHighlight();
12020     SetGameInfo();
12021     if (currentMove > 0)
12022       CopyBoard(boards[0], boards[currentMove]);
12023
12024     blackPlaysFirst = !WhiteOnMove(currentMove);
12025     ResetClocks();
12026     currentMove = forwardMostMove = backwardMostMove = 0;
12027     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
12028     DisplayMove(-1);
12029 }
12030
12031 void
12032 ExitAnalyzeMode()
12033 {
12034     /* [DM] icsEngineAnalyze - possible call from other functions */
12035     if (appData.icsEngineAnalyze) {
12036         appData.icsEngineAnalyze = FALSE;
12037
12038         DisplayMessage("",_("Close ICS engine analyze..."));
12039     }
12040     if (first.analysisSupport && first.analyzing) {
12041       SendToProgram("exit\n", &first);
12042       first.analyzing = FALSE;
12043     }
12044     thinkOutput[0] = NULLCHAR;
12045 }
12046
12047 void
12048 EditPositionDone(Boolean fakeRights)
12049 {
12050     int king = gameInfo.variant == VariantKnightmate ? WhiteUnicorn : WhiteKing;
12051
12052     startedFromSetupPosition = TRUE;
12053     InitChessProgram(&first, FALSE);
12054     if(fakeRights) { // [HGM] suppress this if we just pasted a FEN.
12055       boards[0][EP_STATUS] = EP_NONE;
12056       boards[0][CASTLING][2] = boards[0][CASTLING][5] = BOARD_WIDTH>>1;
12057     if(boards[0][0][BOARD_WIDTH>>1] == king) {
12058         boards[0][CASTLING][1] = boards[0][0][BOARD_LEFT] == WhiteRook ? 0 : NoRights;
12059         boards[0][CASTLING][0] = boards[0][0][BOARD_RGHT-1] == WhiteRook ? BOARD_RGHT-1 : NoRights;
12060       } else boards[0][CASTLING][2] = NoRights;
12061     if(boards[0][BOARD_HEIGHT-1][BOARD_WIDTH>>1] == WHITE_TO_BLACK king) {
12062         boards[0][CASTLING][4] = boards[0][BOARD_HEIGHT-1][BOARD_LEFT] == BlackRook ? 0 : NoRights;
12063         boards[0][CASTLING][3] = boards[0][BOARD_HEIGHT-1][BOARD_RGHT-1] == BlackRook ? BOARD_RGHT-1 : NoRights;
12064       } else boards[0][CASTLING][5] = NoRights;
12065     }
12066     SendToProgram("force\n", &first);
12067     if (blackPlaysFirst) {
12068         strcpy(moveList[0], "");
12069         strcpy(parseList[0], "");
12070         currentMove = forwardMostMove = backwardMostMove = 1;
12071         CopyBoard(boards[1], boards[0]);
12072     } else {
12073         currentMove = forwardMostMove = backwardMostMove = 0;
12074     }
12075     SendBoard(&first, forwardMostMove);
12076     if (appData.debugMode) {
12077         fprintf(debugFP, "EditPosDone\n");
12078     }
12079     DisplayTitle("");
12080     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
12081     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
12082     gameMode = EditGame;
12083     ModeHighlight();
12084     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
12085     ClearHighlights(); /* [AS] */
12086 }
12087
12088 /* Pause for `ms' milliseconds */
12089 /* !! Ugh, this is a kludge. Fix it sometime. --tpm */
12090 void
12091 TimeDelay(ms)
12092      long ms;
12093 {
12094     TimeMark m1, m2;
12095
12096     GetTimeMark(&m1);
12097     do {
12098         GetTimeMark(&m2);
12099     } while (SubtractTimeMarks(&m2, &m1) < ms);
12100 }
12101
12102 /* !! Ugh, this is a kludge. Fix it sometime. --tpm */
12103 void
12104 SendMultiLineToICS(buf)
12105      char *buf;
12106 {
12107     char temp[MSG_SIZ+1], *p;
12108     int len;
12109
12110     len = strlen(buf);
12111     if (len > MSG_SIZ)
12112       len = MSG_SIZ;
12113
12114     strncpy(temp, buf, len);
12115     temp[len] = 0;
12116
12117     p = temp;
12118     while (*p) {
12119         if (*p == '\n' || *p == '\r')
12120           *p = ' ';
12121         ++p;
12122     }
12123
12124     strcat(temp, "\n");
12125     SendToICS(temp);
12126     SendToPlayer(temp, strlen(temp));
12127 }
12128
12129 void
12130 SetWhiteToPlayEvent()
12131 {
12132     if (gameMode == EditPosition) {
12133         blackPlaysFirst = FALSE;
12134         DisplayBothClocks();    /* works because currentMove is 0 */
12135     } else if (gameMode == IcsExamining) {
12136         SendToICS(ics_prefix);
12137         SendToICS("tomove white\n");
12138     }
12139 }
12140
12141 void
12142 SetBlackToPlayEvent()
12143 {
12144     if (gameMode == EditPosition) {
12145         blackPlaysFirst = TRUE;
12146         currentMove = 1;        /* kludge */
12147         DisplayBothClocks();
12148         currentMove = 0;
12149     } else if (gameMode == IcsExamining) {
12150         SendToICS(ics_prefix);
12151         SendToICS("tomove black\n");
12152     }
12153 }
12154
12155 void
12156 EditPositionMenuEvent(selection, x, y)
12157      ChessSquare selection;
12158      int x, y;
12159 {
12160     char buf[MSG_SIZ];
12161     ChessSquare piece = boards[0][y][x];
12162
12163     if (gameMode != EditPosition && gameMode != IcsExamining) return;
12164
12165     switch (selection) {
12166       case ClearBoard:
12167         if (gameMode == IcsExamining && ics_type == ICS_FICS) {
12168             SendToICS(ics_prefix);
12169             SendToICS("bsetup clear\n");
12170         } else if (gameMode == IcsExamining && ics_type == ICS_ICC) {
12171             SendToICS(ics_prefix);
12172             SendToICS("clearboard\n");
12173         } else {
12174             for (x = 0; x < BOARD_WIDTH; x++) { ChessSquare p = EmptySquare;
12175                 if(x == BOARD_LEFT-1 || x == BOARD_RGHT) p = (ChessSquare) 0; /* [HGM] holdings */
12176                 for (y = 0; y < BOARD_HEIGHT; y++) {
12177                     if (gameMode == IcsExamining) {
12178                         if (boards[currentMove][y][x] != EmptySquare) {
12179                             sprintf(buf, "%sx@%c%c\n", ics_prefix,
12180                                     AAA + x, ONE + y);
12181                             SendToICS(buf);
12182                         }
12183                     } else {
12184                         boards[0][y][x] = p;
12185                     }
12186                 }
12187             }
12188         }
12189         if (gameMode == EditPosition) {
12190             DrawPosition(FALSE, boards[0]);
12191         }
12192         break;
12193
12194       case WhitePlay:
12195         SetWhiteToPlayEvent();
12196         break;
12197
12198       case BlackPlay:
12199         SetBlackToPlayEvent();
12200         break;
12201
12202       case EmptySquare:
12203         if (gameMode == IcsExamining) {
12204             if (x < BOARD_LEFT || x >= BOARD_RGHT) break; // [HGM] holdings
12205             sprintf(buf, "%sx@%c%c\n", ics_prefix, AAA + x, ONE + y);
12206             SendToICS(buf);
12207         } else {
12208             if(x < BOARD_LEFT || x >= BOARD_RGHT) {
12209                 if(x == BOARD_LEFT-2) {
12210                     if(y < BOARD_HEIGHT-1-gameInfo.holdingsSize) break;
12211                     boards[0][y][1] = 0;
12212                 } else
12213                 if(x == BOARD_RGHT+1) {
12214                     if(y >= gameInfo.holdingsSize) break;
12215                     boards[0][y][BOARD_WIDTH-2] = 0;
12216                 } else break;
12217             }
12218             boards[0][y][x] = EmptySquare;
12219             DrawPosition(FALSE, boards[0]);
12220         }
12221         break;
12222
12223       case PromotePiece:
12224         if(piece >= (int)WhitePawn && piece < (int)WhiteMan ||
12225            piece >= (int)BlackPawn && piece < (int)BlackMan   ) {
12226             selection = (ChessSquare) (PROMOTED piece);
12227         } else if(piece == EmptySquare) selection = WhiteSilver;
12228         else selection = (ChessSquare)((int)piece - 1);
12229         goto defaultlabel;
12230
12231       case DemotePiece:
12232         if(piece > (int)WhiteMan && piece <= (int)WhiteKing ||
12233            piece > (int)BlackMan && piece <= (int)BlackKing   ) {
12234             selection = (ChessSquare) (DEMOTED piece);
12235         } else if(piece == EmptySquare) selection = BlackSilver;
12236         else selection = (ChessSquare)((int)piece + 1);
12237         goto defaultlabel;
12238
12239       case WhiteQueen:
12240       case BlackQueen:
12241         if(gameInfo.variant == VariantShatranj ||
12242            gameInfo.variant == VariantXiangqi  ||
12243            gameInfo.variant == VariantCourier  ||
12244            gameInfo.variant == VariantMakruk     )
12245             selection = (ChessSquare)((int)selection - (int)WhiteQueen + (int)WhiteFerz);
12246         goto defaultlabel;
12247
12248       case WhiteKing:
12249       case BlackKing:
12250         if(gameInfo.variant == VariantXiangqi)
12251             selection = (ChessSquare)((int)selection - (int)WhiteKing + (int)WhiteWazir);
12252         if(gameInfo.variant == VariantKnightmate)
12253             selection = (ChessSquare)((int)selection - (int)WhiteKing + (int)WhiteUnicorn);
12254       default:
12255         defaultlabel:
12256         if (gameMode == IcsExamining) {
12257             if (x < BOARD_LEFT || x >= BOARD_RGHT) break; // [HGM] holdings
12258             sprintf(buf, "%s%c@%c%c\n", ics_prefix,
12259                     PieceToChar(selection), AAA + x, ONE + y);
12260             SendToICS(buf);
12261         } else {
12262             if(x < BOARD_LEFT || x >= BOARD_RGHT) {
12263                 int n;
12264                 if(x == BOARD_LEFT-2 && selection >= BlackPawn) {
12265                     n = PieceToNumber(selection - BlackPawn);
12266                     if(n >= gameInfo.holdingsSize) { n = 0; selection = BlackPawn; }
12267                     boards[0][BOARD_HEIGHT-1-n][0] = selection;
12268                     boards[0][BOARD_HEIGHT-1-n][1]++;
12269                 } else
12270                 if(x == BOARD_RGHT+1 && selection < BlackPawn) {
12271                     n = PieceToNumber(selection);
12272                     if(n >= gameInfo.holdingsSize) { n = 0; selection = WhitePawn; }
12273                     boards[0][n][BOARD_WIDTH-1] = selection;
12274                     boards[0][n][BOARD_WIDTH-2]++;
12275                 }
12276             } else
12277             boards[0][y][x] = selection;
12278             DrawPosition(TRUE, boards[0]);
12279         }
12280         break;
12281     }
12282 }
12283
12284
12285 void
12286 DropMenuEvent(selection, x, y)
12287      ChessSquare selection;
12288      int x, y;
12289 {
12290     ChessMove moveType;
12291
12292     switch (gameMode) {
12293       case IcsPlayingWhite:
12294       case MachinePlaysBlack:
12295         if (!WhiteOnMove(currentMove)) {
12296             DisplayMoveError(_("It is Black's turn"));
12297             return;
12298         }
12299         moveType = WhiteDrop;
12300         break;
12301       case IcsPlayingBlack:
12302       case MachinePlaysWhite:
12303         if (WhiteOnMove(currentMove)) {
12304             DisplayMoveError(_("It is White's turn"));
12305             return;
12306         }
12307         moveType = BlackDrop;
12308         break;
12309       case EditGame:
12310         moveType = WhiteOnMove(currentMove) ? WhiteDrop : BlackDrop;
12311         break;
12312       default:
12313         return;
12314     }
12315
12316     if (moveType == BlackDrop && selection < BlackPawn) {
12317       selection = (ChessSquare) ((int) selection
12318                                  + (int) BlackPawn - (int) WhitePawn);
12319     }
12320     if (boards[currentMove][y][x] != EmptySquare) {
12321         DisplayMoveError(_("That square is occupied"));
12322         return;
12323     }
12324
12325     FinishMove(moveType, (int) selection, DROP_RANK, x, y, NULLCHAR);
12326 }
12327
12328 void
12329 AcceptEvent()
12330 {
12331     /* Accept a pending offer of any kind from opponent */
12332
12333     if (appData.icsActive) {
12334         SendToICS(ics_prefix);
12335         SendToICS("accept\n");
12336     } else if (cmailMsgLoaded) {
12337         if (currentMove == cmailOldMove &&
12338             commentList[cmailOldMove] != NULL &&
12339             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
12340                    "Black offers a draw" : "White offers a draw")) {
12341             TruncateGame();
12342             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
12343             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_ACCEPT;
12344         } else {
12345             DisplayError(_("There is no pending offer on this move"), 0);
12346             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
12347         }
12348     } else {
12349         /* Not used for offers from chess program */
12350     }
12351 }
12352
12353 void
12354 DeclineEvent()
12355 {
12356     /* Decline a pending offer of any kind from opponent */
12357
12358     if (appData.icsActive) {
12359         SendToICS(ics_prefix);
12360         SendToICS("decline\n");
12361     } else if (cmailMsgLoaded) {
12362         if (currentMove == cmailOldMove &&
12363             commentList[cmailOldMove] != NULL &&
12364             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
12365                    "Black offers a draw" : "White offers a draw")) {
12366 #ifdef NOTDEF
12367             AppendComment(cmailOldMove, "Draw declined", TRUE);
12368             DisplayComment(cmailOldMove - 1, "Draw declined");
12369 #endif /*NOTDEF*/
12370         } else {
12371             DisplayError(_("There is no pending offer on this move"), 0);
12372         }
12373     } else {
12374         /* Not used for offers from chess program */
12375     }
12376 }
12377
12378 void
12379 RematchEvent()
12380 {
12381     /* Issue ICS rematch command */
12382     if (appData.icsActive) {
12383         SendToICS(ics_prefix);
12384         SendToICS("rematch\n");
12385     }
12386 }
12387
12388 void
12389 CallFlagEvent()
12390 {
12391     /* Call your opponent's flag (claim a win on time) */
12392     if (appData.icsActive) {
12393         SendToICS(ics_prefix);
12394         SendToICS("flag\n");
12395     } else {
12396         switch (gameMode) {
12397           default:
12398             return;
12399           case MachinePlaysWhite:
12400             if (whiteFlag) {
12401                 if (blackFlag)
12402                   GameEnds(GameIsDrawn, "Both players ran out of time",
12403                            GE_PLAYER);
12404                 else
12405                   GameEnds(BlackWins, "Black wins on time", GE_PLAYER);
12406             } else {
12407                 DisplayError(_("Your opponent is not out of time"), 0);
12408             }
12409             break;
12410           case MachinePlaysBlack:
12411             if (blackFlag) {
12412                 if (whiteFlag)
12413                   GameEnds(GameIsDrawn, "Both players ran out of time",
12414                            GE_PLAYER);
12415                 else
12416                   GameEnds(WhiteWins, "White wins on time", GE_PLAYER);
12417             } else {
12418                 DisplayError(_("Your opponent is not out of time"), 0);
12419             }
12420             break;
12421         }
12422     }
12423 }
12424
12425 void
12426 DrawEvent()
12427 {
12428     /* Offer draw or accept pending draw offer from opponent */
12429
12430     if (appData.icsActive) {
12431         /* Note: tournament rules require draw offers to be
12432            made after you make your move but before you punch
12433            your clock.  Currently ICS doesn't let you do that;
12434            instead, you immediately punch your clock after making
12435            a move, but you can offer a draw at any time. */
12436
12437         SendToICS(ics_prefix);
12438         SendToICS("draw\n");
12439         userOfferedDraw = TRUE; // [HGM] drawclaim: also set flag in ICS play
12440     } else if (cmailMsgLoaded) {
12441         if (currentMove == cmailOldMove &&
12442             commentList[cmailOldMove] != NULL &&
12443             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
12444                    "Black offers a draw" : "White offers a draw")) {
12445             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
12446             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_ACCEPT;
12447         } else if (currentMove == cmailOldMove + 1) {
12448             char *offer = WhiteOnMove(cmailOldMove) ?
12449               "White offers a draw" : "Black offers a draw";
12450             AppendComment(currentMove, offer, TRUE);
12451             DisplayComment(currentMove - 1, offer);
12452             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_DRAW;
12453         } else {
12454             DisplayError(_("You must make your move before offering a draw"), 0);
12455             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
12456         }
12457     } else if (first.offeredDraw) {
12458         GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
12459     } else {
12460         if (first.sendDrawOffers) {
12461             SendToProgram("draw\n", &first);
12462             userOfferedDraw = TRUE;
12463         }
12464     }
12465 }
12466
12467 void
12468 AdjournEvent()
12469 {
12470     /* Offer Adjourn or accept pending Adjourn offer from opponent */
12471
12472     if (appData.icsActive) {
12473         SendToICS(ics_prefix);
12474         SendToICS("adjourn\n");
12475     } else {
12476         /* Currently GNU Chess doesn't offer or accept Adjourns */
12477     }
12478 }
12479
12480
12481 void
12482 AbortEvent()
12483 {
12484     /* Offer Abort or accept pending Abort offer from opponent */
12485
12486     if (appData.icsActive) {
12487         SendToICS(ics_prefix);
12488         SendToICS("abort\n");
12489     } else {
12490         GameEnds(GameUnfinished, "Game aborted", GE_PLAYER);
12491     }
12492 }
12493
12494 void
12495 ResignEvent()
12496 {
12497     /* Resign.  You can do this even if it's not your turn. */
12498
12499     if (appData.icsActive) {
12500         SendToICS(ics_prefix);
12501         SendToICS("resign\n");
12502     } else {
12503         switch (gameMode) {
12504           case MachinePlaysWhite:
12505             GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
12506             break;
12507           case MachinePlaysBlack:
12508             GameEnds(BlackWins, "White resigns", GE_PLAYER);
12509             break;
12510           case EditGame:
12511             if (cmailMsgLoaded) {
12512                 TruncateGame();
12513                 if (WhiteOnMove(cmailOldMove)) {
12514                     GameEnds(BlackWins, "White resigns", GE_PLAYER);
12515                 } else {
12516                     GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
12517                 }
12518                 cmailMoveType[lastLoadGameNumber - 1] = CMAIL_RESIGN;
12519             }
12520             break;
12521           default:
12522             break;
12523         }
12524     }
12525 }
12526
12527
12528 void
12529 StopObservingEvent()
12530 {
12531     /* Stop observing current games */
12532     SendToICS(ics_prefix);
12533     SendToICS("unobserve\n");
12534 }
12535
12536 void
12537 StopExaminingEvent()
12538 {
12539     /* Stop observing current game */
12540     SendToICS(ics_prefix);
12541     SendToICS("unexamine\n");
12542 }
12543
12544 void
12545 ForwardInner(target)
12546      int target;
12547 {
12548     int limit;
12549
12550     if (appData.debugMode)
12551         fprintf(debugFP, "ForwardInner(%d), current %d, forward %d\n",
12552                 target, currentMove, forwardMostMove);
12553
12554     if (gameMode == EditPosition)
12555       return;
12556
12557     if (gameMode == PlayFromGameFile && !pausing)
12558       PauseEvent();
12559
12560     if (gameMode == IcsExamining && pausing)
12561       limit = pauseExamForwardMostMove;
12562     else
12563       limit = forwardMostMove;
12564
12565     if (target > limit) target = limit;
12566
12567     if (target > 0 && moveList[target - 1][0]) {
12568         int fromX, fromY, toX, toY;
12569         toX = moveList[target - 1][2] - AAA;
12570         toY = moveList[target - 1][3] - ONE;
12571         if (moveList[target - 1][1] == '@') {
12572             if (appData.highlightLastMove) {
12573                 SetHighlights(-1, -1, toX, toY);
12574             }
12575         } else {
12576             fromX = moveList[target - 1][0] - AAA;
12577             fromY = moveList[target - 1][1] - ONE;
12578             if (target == currentMove + 1) {
12579                 AnimateMove(boards[currentMove], fromX, fromY, toX, toY);
12580             }
12581             if (appData.highlightLastMove) {
12582                 SetHighlights(fromX, fromY, toX, toY);
12583             }
12584         }
12585     }
12586     if (gameMode == EditGame || gameMode == AnalyzeMode ||
12587         gameMode == Training || gameMode == PlayFromGameFile ||
12588         gameMode == AnalyzeFile) {
12589         while (currentMove < target) {
12590             SendMoveToProgram(currentMove++, &first);
12591         }
12592     } else {
12593         currentMove = target;
12594     }
12595
12596     if (gameMode == EditGame || gameMode == EndOfGame) {
12597         whiteTimeRemaining = timeRemaining[0][currentMove];
12598         blackTimeRemaining = timeRemaining[1][currentMove];
12599     }
12600     DisplayBothClocks();
12601     DisplayMove(currentMove - 1);
12602     DrawPosition(FALSE, boards[currentMove]);
12603     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
12604     if ( !matchMode && gameMode != Training) { // [HGM] PV info: routine tests if empty
12605         DisplayComment(currentMove - 1, commentList[currentMove]);
12606     }
12607 }
12608
12609
12610 void
12611 ForwardEvent()
12612 {
12613     if (gameMode == IcsExamining && !pausing) {
12614         SendToICS(ics_prefix);
12615         SendToICS("forward\n");
12616     } else {
12617         ForwardInner(currentMove + 1);
12618     }
12619 }
12620
12621 void
12622 ToEndEvent()
12623 {
12624     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
12625         /* to optimze, we temporarily turn off analysis mode while we feed
12626          * the remaining moves to the engine. Otherwise we get analysis output
12627          * after each move.
12628          */
12629         if (first.analysisSupport) {
12630           SendToProgram("exit\nforce\n", &first);
12631           first.analyzing = FALSE;
12632         }
12633     }
12634
12635     if (gameMode == IcsExamining && !pausing) {
12636         SendToICS(ics_prefix);
12637         SendToICS("forward 999999\n");
12638     } else {
12639         ForwardInner(forwardMostMove);
12640     }
12641
12642     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
12643         /* we have fed all the moves, so reactivate analysis mode */
12644         SendToProgram("analyze\n", &first);
12645         first.analyzing = TRUE;
12646         /*first.maybeThinking = TRUE;*/
12647         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
12648     }
12649 }
12650
12651 void
12652 BackwardInner(target)
12653      int target;
12654 {
12655     int full_redraw = TRUE; /* [AS] Was FALSE, had to change it! */
12656
12657     if (appData.debugMode)
12658         fprintf(debugFP, "BackwardInner(%d), current %d, forward %d\n",
12659                 target, currentMove, forwardMostMove);
12660
12661     if (gameMode == EditPosition) return;
12662     if (currentMove <= backwardMostMove) {
12663         ClearHighlights();
12664         DrawPosition(full_redraw, boards[currentMove]);
12665         return;
12666     }
12667     if (gameMode == PlayFromGameFile && !pausing)
12668       PauseEvent();
12669
12670     if (moveList[target][0]) {
12671         int fromX, fromY, toX, toY;
12672         toX = moveList[target][2] - AAA;
12673         toY = moveList[target][3] - ONE;
12674         if (moveList[target][1] == '@') {
12675             if (appData.highlightLastMove) {
12676                 SetHighlights(-1, -1, toX, toY);
12677             }
12678         } else {
12679             fromX = moveList[target][0] - AAA;
12680             fromY = moveList[target][1] - ONE;
12681             if (target == currentMove - 1) {
12682                 AnimateMove(boards[currentMove], toX, toY, fromX, fromY);
12683             }
12684             if (appData.highlightLastMove) {
12685                 SetHighlights(fromX, fromY, toX, toY);
12686             }
12687         }
12688     }
12689     if (gameMode == EditGame || gameMode==AnalyzeMode ||
12690         gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
12691         while (currentMove > target) {
12692             SendToProgram("undo\n", &first);
12693             currentMove--;
12694         }
12695     } else {
12696         currentMove = target;
12697     }
12698
12699     if (gameMode == EditGame || gameMode == EndOfGame) {
12700         whiteTimeRemaining = timeRemaining[0][currentMove];
12701         blackTimeRemaining = timeRemaining[1][currentMove];
12702     }
12703     DisplayBothClocks();
12704     DisplayMove(currentMove - 1);
12705     DrawPosition(full_redraw, boards[currentMove]);
12706     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
12707     // [HGM] PV info: routine tests if comment empty
12708     DisplayComment(currentMove - 1, commentList[currentMove]);
12709 }
12710
12711 void
12712 BackwardEvent()
12713 {
12714     if (gameMode == IcsExamining && !pausing) {
12715         SendToICS(ics_prefix);
12716         SendToICS("backward\n");
12717     } else {
12718         BackwardInner(currentMove - 1);
12719     }
12720 }
12721
12722 void
12723 ToStartEvent()
12724 {
12725     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
12726         /* to optimize, we temporarily turn off analysis mode while we undo
12727          * all the moves. Otherwise we get analysis output after each undo.
12728          */
12729         if (first.analysisSupport) {
12730           SendToProgram("exit\nforce\n", &first);
12731           first.analyzing = FALSE;
12732         }
12733     }
12734
12735     if (gameMode == IcsExamining && !pausing) {
12736         SendToICS(ics_prefix);
12737         SendToICS("backward 999999\n");
12738     } else {
12739         BackwardInner(backwardMostMove);
12740     }
12741
12742     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
12743         /* we have fed all the moves, so reactivate analysis mode */
12744         SendToProgram("analyze\n", &first);
12745         first.analyzing = TRUE;
12746         /*first.maybeThinking = TRUE;*/
12747         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
12748     }
12749 }
12750
12751 void
12752 ToNrEvent(int to)
12753 {
12754   if (gameMode == PlayFromGameFile && !pausing) PauseEvent();
12755   if (to >= forwardMostMove) to = forwardMostMove;
12756   if (to <= backwardMostMove) to = backwardMostMove;
12757   if (to < currentMove) {
12758     BackwardInner(to);
12759   } else {
12760     ForwardInner(to);
12761   }
12762 }
12763
12764 void
12765 RevertEvent(Boolean annotate)
12766 {
12767     if(PopTail(annotate)) { // [HGM] vari: restore old game tail
12768         return;
12769     }
12770     if (gameMode != IcsExamining) {
12771         DisplayError(_("You are not examining a game"), 0);
12772         return;
12773     }
12774     if (pausing) {
12775         DisplayError(_("You can't revert while pausing"), 0);
12776         return;
12777     }
12778     SendToICS(ics_prefix);
12779     SendToICS("revert\n");
12780 }
12781
12782 void
12783 RetractMoveEvent()
12784 {
12785     switch (gameMode) {
12786       case MachinePlaysWhite:
12787       case MachinePlaysBlack:
12788         if (WhiteOnMove(forwardMostMove) == (gameMode == MachinePlaysWhite)) {
12789             DisplayError(_("Wait until your turn,\nor select Move Now"), 0);
12790             return;
12791         }
12792         if (forwardMostMove < 2) return;
12793         currentMove = forwardMostMove = forwardMostMove - 2;
12794         whiteTimeRemaining = timeRemaining[0][currentMove];
12795         blackTimeRemaining = timeRemaining[1][currentMove];
12796         DisplayBothClocks();
12797         DisplayMove(currentMove - 1);
12798         ClearHighlights();/*!! could figure this out*/
12799         DrawPosition(TRUE, boards[currentMove]); /* [AS] Changed to full redraw! */
12800         SendToProgram("remove\n", &first);
12801         /*first.maybeThinking = TRUE;*/ /* GNU Chess does not ponder here */
12802         break;
12803
12804       case BeginningOfGame:
12805       default:
12806         break;
12807
12808       case IcsPlayingWhite:
12809       case IcsPlayingBlack:
12810         if (WhiteOnMove(forwardMostMove) == (gameMode == IcsPlayingWhite)) {
12811             SendToICS(ics_prefix);
12812             SendToICS("takeback 2\n");
12813         } else {
12814             SendToICS(ics_prefix);
12815             SendToICS("takeback 1\n");
12816         }
12817         break;
12818     }
12819 }
12820
12821 void
12822 MoveNowEvent()
12823 {
12824     ChessProgramState *cps;
12825
12826     switch (gameMode) {
12827       case MachinePlaysWhite:
12828         if (!WhiteOnMove(forwardMostMove)) {
12829             DisplayError(_("It is your turn"), 0);
12830             return;
12831         }
12832         cps = &first;
12833         break;
12834       case MachinePlaysBlack:
12835         if (WhiteOnMove(forwardMostMove)) {
12836             DisplayError(_("It is your turn"), 0);
12837             return;
12838         }
12839         cps = &first;
12840         break;
12841       case TwoMachinesPlay:
12842         if (WhiteOnMove(forwardMostMove) ==
12843             (first.twoMachinesColor[0] == 'w')) {
12844             cps = &first;
12845         } else {
12846             cps = &second;
12847         }
12848         break;
12849       case BeginningOfGame:
12850       default:
12851         return;
12852     }
12853     SendToProgram("?\n", cps);
12854 }
12855
12856 void
12857 TruncateGameEvent()
12858 {
12859     EditGameEvent();
12860     if (gameMode != EditGame) return;
12861     TruncateGame();
12862 }
12863
12864 void
12865 TruncateGame()
12866 {
12867     CleanupTail(); // [HGM] vari: only keep current variation if we explicitly truncate
12868     if (forwardMostMove > currentMove) {
12869         if (gameInfo.resultDetails != NULL) {
12870             free(gameInfo.resultDetails);
12871             gameInfo.resultDetails = NULL;
12872             gameInfo.result = GameUnfinished;
12873         }
12874         forwardMostMove = currentMove;
12875         HistorySet(parseList, backwardMostMove, forwardMostMove,
12876                    currentMove-1);
12877     }
12878 }
12879
12880 void
12881 HintEvent()
12882 {
12883     if (appData.noChessProgram) return;
12884     switch (gameMode) {
12885       case MachinePlaysWhite:
12886         if (WhiteOnMove(forwardMostMove)) {
12887             DisplayError(_("Wait until your turn"), 0);
12888             return;
12889         }
12890         break;
12891       case BeginningOfGame:
12892       case MachinePlaysBlack:
12893         if (!WhiteOnMove(forwardMostMove)) {
12894             DisplayError(_("Wait until your turn"), 0);
12895             return;
12896         }
12897         break;
12898       default:
12899         DisplayError(_("No hint available"), 0);
12900         return;
12901     }
12902     SendToProgram("hint\n", &first);
12903     hintRequested = TRUE;
12904 }
12905
12906 void
12907 BookEvent()
12908 {
12909     if (appData.noChessProgram) return;
12910     switch (gameMode) {
12911       case MachinePlaysWhite:
12912         if (WhiteOnMove(forwardMostMove)) {
12913             DisplayError(_("Wait until your turn"), 0);
12914             return;
12915         }
12916         break;
12917       case BeginningOfGame:
12918       case MachinePlaysBlack:
12919         if (!WhiteOnMove(forwardMostMove)) {
12920             DisplayError(_("Wait until your turn"), 0);
12921             return;
12922         }
12923         break;
12924       case EditPosition:
12925         EditPositionDone(TRUE);
12926         break;
12927       case TwoMachinesPlay:
12928         return;
12929       default:
12930         break;
12931     }
12932     SendToProgram("bk\n", &first);
12933     bookOutput[0] = NULLCHAR;
12934     bookRequested = TRUE;
12935 }
12936
12937 void
12938 AboutGameEvent()
12939 {
12940     char *tags = PGNTags(&gameInfo);
12941     TagsPopUp(tags, CmailMsg());
12942     free(tags);
12943 }
12944
12945 /* end button procedures */
12946
12947 void
12948 PrintPosition(fp, move)
12949      FILE *fp;
12950      int move;
12951 {
12952     int i, j;
12953
12954     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
12955         for (j = BOARD_LEFT; j < BOARD_RGHT; j++) {
12956             char c = PieceToChar(boards[move][i][j]);
12957             fputc(c == 'x' ? '.' : c, fp);
12958             fputc(j == BOARD_RGHT - 1 ? '\n' : ' ', fp);
12959         }
12960     }
12961     if ((gameMode == EditPosition) ? !blackPlaysFirst : (move % 2 == 0))
12962       fprintf(fp, "white to play\n");
12963     else
12964       fprintf(fp, "black to play\n");
12965 }
12966
12967 void
12968 PrintOpponents(fp)
12969      FILE *fp;
12970 {
12971     if (gameInfo.white != NULL) {
12972         fprintf(fp, "\t%s vs. %s\n", gameInfo.white, gameInfo.black);
12973     } else {
12974         fprintf(fp, "\n");
12975     }
12976 }
12977
12978 /* Find last component of program's own name, using some heuristics */
12979 void
12980 TidyProgramName(prog, host, buf)
12981      char *prog, *host, buf[MSG_SIZ];
12982 {
12983     char *p, *q;
12984     int local = (strcmp(host, "localhost") == 0);
12985     while (!local && (p = strchr(prog, ';')) != NULL) {
12986         p++;
12987         while (*p == ' ') p++;
12988         prog = p;
12989     }
12990     if (*prog == '"' || *prog == '\'') {
12991         q = strchr(prog + 1, *prog);
12992     } else {
12993         q = strchr(prog, ' ');
12994     }
12995     if (q == NULL) q = prog + strlen(prog);
12996     p = q;
12997     while (p >= prog && *p != '/' && *p != '\\') p--;
12998     p++;
12999     if(p == prog && *p == '"') p++;
13000     if (q - p >= 4 && StrCaseCmp(q - 4, ".exe") == 0) q -= 4;
13001     memcpy(buf, p, q - p);
13002     buf[q - p] = NULLCHAR;
13003     if (!local) {
13004         strcat(buf, "@");
13005         strcat(buf, host);
13006     }
13007 }
13008
13009 char *
13010 TimeControlTagValue()
13011 {
13012     char buf[MSG_SIZ];
13013     if (!appData.clockMode) {
13014         strcpy(buf, "-");
13015     } else if (movesPerSession > 0) {
13016         sprintf(buf, "%d/%ld", movesPerSession, timeControl/1000);
13017     } else if (timeIncrement == 0) {
13018         sprintf(buf, "%ld", timeControl/1000);
13019     } else {
13020         sprintf(buf, "%ld+%ld", timeControl/1000, timeIncrement/1000);
13021     }
13022     return StrSave(buf);
13023 }
13024
13025 void
13026 SetGameInfo()
13027 {
13028     /* This routine is used only for certain modes */
13029     VariantClass v = gameInfo.variant;
13030     ChessMove r = GameUnfinished;
13031     char *p = NULL;
13032
13033     if(gameMode == EditGame) { // [HGM] vari: do not erase result on EditGame
13034         r = gameInfo.result;
13035         p = gameInfo.resultDetails;
13036         gameInfo.resultDetails = NULL;
13037     }
13038     ClearGameInfo(&gameInfo);
13039     gameInfo.variant = v;
13040
13041     switch (gameMode) {
13042       case MachinePlaysWhite:
13043         gameInfo.event = StrSave( appData.pgnEventHeader );
13044         gameInfo.site = StrSave(HostName());
13045         gameInfo.date = PGNDate();
13046         gameInfo.round = StrSave("-");
13047         gameInfo.white = StrSave(first.tidy);
13048         gameInfo.black = StrSave(UserName());
13049         gameInfo.timeControl = TimeControlTagValue();
13050         break;
13051
13052       case MachinePlaysBlack:
13053         gameInfo.event = StrSave( appData.pgnEventHeader );
13054         gameInfo.site = StrSave(HostName());
13055         gameInfo.date = PGNDate();
13056         gameInfo.round = StrSave("-");
13057         gameInfo.white = StrSave(UserName());
13058         gameInfo.black = StrSave(first.tidy);
13059         gameInfo.timeControl = TimeControlTagValue();
13060         break;
13061
13062       case TwoMachinesPlay:
13063         gameInfo.event = StrSave( appData.pgnEventHeader );
13064         gameInfo.site = StrSave(HostName());
13065         gameInfo.date = PGNDate();
13066         if (matchGame > 0) {
13067             char buf[MSG_SIZ];
13068             sprintf(buf, "%d", matchGame);
13069             gameInfo.round = StrSave(buf);
13070         } else {
13071             gameInfo.round = StrSave("-");
13072         }
13073         if (first.twoMachinesColor[0] == 'w') {
13074             gameInfo.white = StrSave(first.tidy);
13075             gameInfo.black = StrSave(second.tidy);
13076         } else {
13077             gameInfo.white = StrSave(second.tidy);
13078             gameInfo.black = StrSave(first.tidy);
13079         }
13080         gameInfo.timeControl = TimeControlTagValue();
13081         break;
13082
13083       case EditGame:
13084         gameInfo.event = StrSave("Edited game");
13085         gameInfo.site = StrSave(HostName());
13086         gameInfo.date = PGNDate();
13087         gameInfo.round = StrSave("-");
13088         gameInfo.white = StrSave("-");
13089         gameInfo.black = StrSave("-");
13090         gameInfo.result = r;
13091         gameInfo.resultDetails = p;
13092         break;
13093
13094       case EditPosition:
13095         gameInfo.event = StrSave("Edited position");
13096         gameInfo.site = StrSave(HostName());
13097         gameInfo.date = PGNDate();
13098         gameInfo.round = StrSave("-");
13099         gameInfo.white = StrSave("-");
13100         gameInfo.black = StrSave("-");
13101         break;
13102
13103       case IcsPlayingWhite:
13104       case IcsPlayingBlack:
13105       case IcsObserving:
13106       case IcsExamining:
13107         break;
13108
13109       case PlayFromGameFile:
13110         gameInfo.event = StrSave("Game from non-PGN file");
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       default:
13119         break;
13120     }
13121 }
13122
13123 void
13124 ReplaceComment(index, text)
13125      int index;
13126      char *text;
13127 {
13128     int len;
13129
13130     while (*text == '\n') text++;
13131     len = strlen(text);
13132     while (len > 0 && text[len - 1] == '\n') len--;
13133
13134     if (commentList[index] != NULL)
13135       free(commentList[index]);
13136
13137     if (len == 0) {
13138         commentList[index] = NULL;
13139         return;
13140     }
13141   if( *text == '{' && strchr(text, '}') || // [HGM] braces: if certainy malformed, put braces
13142       *text == '[' && strchr(text, ']') || // otherwise hope the user knows what he is doing
13143       *text == '(' && strchr(text, ')')) { // (perhaps check if this parses as comment-only?)
13144     commentList[index] = (char *) malloc(len + 2);
13145     strncpy(commentList[index], text, len);
13146     commentList[index][len] = '\n';
13147     commentList[index][len + 1] = NULLCHAR;
13148   } else {
13149     // [HGM] braces: if text does not start with known OK delimiter, put braces around it.
13150     char *p;
13151     commentList[index] = (char *) malloc(len + 6);
13152     strcpy(commentList[index], "{\n");
13153     strncpy(commentList[index]+2, text, len);
13154     commentList[index][len+2] = NULLCHAR;
13155     while(p = strchr(commentList[index], '}')) *p = ')'; // kill all } to make it one comment
13156     strcat(commentList[index], "\n}\n");
13157   }
13158 }
13159
13160 void
13161 CrushCRs(text)
13162      char *text;
13163 {
13164   char *p = text;
13165   char *q = text;
13166   char ch;
13167
13168   do {
13169     ch = *p++;
13170     if (ch == '\r') continue;
13171     *q++ = ch;
13172   } while (ch != '\0');
13173 }
13174
13175 void
13176 AppendComment(index, text, addBraces)
13177      int index;
13178      char *text;
13179      Boolean addBraces; // [HGM] braces: tells if we should add {}
13180 {
13181     int oldlen, len;
13182     char *old;
13183
13184 if(appData.debugMode) fprintf(debugFP, "Append: in='%s' %d\n", text, addBraces); fflush(debugFP);
13185     text = GetInfoFromComment( index, text ); /* [HGM] PV time: strip PV info from comment */
13186
13187     CrushCRs(text);
13188     while (*text == '\n') text++;
13189     len = strlen(text);
13190     while (len > 0 && text[len - 1] == '\n') len--;
13191
13192     if (len == 0) return;
13193
13194     if (commentList[index] != NULL) {
13195         old = commentList[index];
13196         oldlen = strlen(old);
13197         while(commentList[index][oldlen-1] ==  '\n')
13198           commentList[index][--oldlen] = NULLCHAR;
13199         commentList[index] = (char *) malloc(oldlen + len + 6); // might waste 4
13200         strcpy(commentList[index], old);
13201         free(old);
13202         // [HGM] braces: join "{A\n}\n" + "{\nB}" as "{A\nB\n}"
13203         if(commentList[index][oldlen-1] == '}' && (text[0] == '{' || addBraces)) {
13204           if(addBraces) addBraces = FALSE; else { text++; len--; }
13205           while (*text == '\n') { text++; len--; }
13206           commentList[index][--oldlen] = NULLCHAR;
13207       }
13208         if(addBraces) strcat(commentList[index], "\n{\n");
13209         else          strcat(commentList[index], "\n");
13210         strcat(commentList[index], text);
13211         if(addBraces) strcat(commentList[index], "\n}\n");
13212         else          strcat(commentList[index], "\n");
13213     } else {
13214         commentList[index] = (char *) malloc(len + 6); // perhaps wastes 4...
13215         if(addBraces)
13216              strcpy(commentList[index], "{\n");
13217         else commentList[index][0] = NULLCHAR;
13218         strcat(commentList[index], text);
13219         strcat(commentList[index], "\n");
13220         if(addBraces) strcat(commentList[index], "}\n");
13221     }
13222 }
13223
13224 static char * FindStr( char * text, char * sub_text )
13225 {
13226     char * result = strstr( text, sub_text );
13227
13228     if( result != NULL ) {
13229         result += strlen( sub_text );
13230     }
13231
13232     return result;
13233 }
13234
13235 /* [AS] Try to extract PV info from PGN comment */
13236 /* [HGM] PV time: and then remove it, to prevent it appearing twice */
13237 char *GetInfoFromComment( int index, char * text )
13238 {
13239     char * sep = text;
13240
13241     if( text != NULL && index > 0 ) {
13242         int score = 0;
13243         int depth = 0;
13244         int time = -1, sec = 0, deci;
13245         char * s_eval = FindStr( text, "[%eval " );
13246         char * s_emt = FindStr( text, "[%emt " );
13247
13248         if( s_eval != NULL || s_emt != NULL ) {
13249             /* New style */
13250             char delim;
13251
13252             if( s_eval != NULL ) {
13253                 if( sscanf( s_eval, "%d,%d%c", &score, &depth, &delim ) != 3 ) {
13254                     return text;
13255                 }
13256
13257                 if( delim != ']' ) {
13258                     return text;
13259                 }
13260             }
13261
13262             if( s_emt != NULL ) {
13263             }
13264                 return text;
13265         }
13266         else {
13267             /* We expect something like: [+|-]nnn.nn/dd */
13268             int score_lo = 0;
13269
13270             if(*text != '{') return text; // [HGM] braces: must be normal comment
13271
13272             sep = strchr( text, '/' );
13273             if( sep == NULL || sep < (text+4) ) {
13274                 return text;
13275             }
13276
13277             time = -1; sec = -1; deci = -1;
13278             if( sscanf( text+1, "%d.%d/%d %d:%d", &score, &score_lo, &depth, &time, &sec ) != 5 &&
13279                 sscanf( text+1, "%d.%d/%d %d.%d", &score, &score_lo, &depth, &time, &deci ) != 5 &&
13280                 sscanf( text+1, "%d.%d/%d %d", &score, &score_lo, &depth, &time ) != 4 &&
13281                 sscanf( text+1, "%d.%d/%d", &score, &score_lo, &depth ) != 3   ) {
13282                 return text;
13283             }
13284
13285             if( score_lo < 0 || score_lo >= 100 ) {
13286                 return text;
13287             }
13288
13289             if(sec >= 0) time = 600*time + 10*sec; else
13290             if(deci >= 0) time = 10*time + deci; else time *= 10; // deci-sec
13291
13292             score = score >= 0 ? score*100 + score_lo : score*100 - score_lo;
13293
13294             /* [HGM] PV time: now locate end of PV info */
13295             while( *++sep >= '0' && *sep <= '9'); // strip depth
13296             if(time >= 0)
13297             while( *++sep >= '0' && *sep <= '9'); // strip time
13298             if(sec >= 0)
13299             while( *++sep >= '0' && *sep <= '9'); // strip seconds
13300             if(deci >= 0)
13301             while( *++sep >= '0' && *sep <= '9'); // strip fractional seconds
13302             while(*sep == ' ') sep++;
13303         }
13304
13305         if( depth <= 0 ) {
13306             return text;
13307         }
13308
13309         if( time < 0 ) {
13310             time = -1;
13311         }
13312
13313         pvInfoList[index-1].depth = depth;
13314         pvInfoList[index-1].score = score;
13315         pvInfoList[index-1].time  = 10*time; // centi-sec
13316         if(*sep == '}') *sep = 0; else *--sep = '{';
13317     }
13318     return sep;
13319 }
13320
13321 void
13322 SendToProgram(message, cps)
13323      char *message;
13324      ChessProgramState *cps;
13325 {
13326     int count, outCount, error;
13327     char buf[MSG_SIZ];
13328
13329     if (cps->pr == NULL) return;
13330     Attention(cps);
13331
13332     if (appData.debugMode) {
13333         TimeMark now;
13334         GetTimeMark(&now);
13335         fprintf(debugFP, "%ld >%-6s: %s",
13336                 SubtractTimeMarks(&now, &programStartTime),
13337                 cps->which, message);
13338     }
13339
13340     count = strlen(message);
13341     outCount = OutputToProcess(cps->pr, message, count, &error);
13342     if (outCount < count && !exiting
13343                          && !endingGame) { /* [HGM] crash: to not hang GameEnds() writing to deceased engines */
13344         sprintf(buf, _("Error writing to %s chess program"), cps->which);
13345         if(gameInfo.resultDetails==NULL) { /* [HGM] crash: if game in progress, give reason for abort */
13346             if((signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
13347                 gameInfo.result = GameIsDrawn; /* [HGM] accept exit as draw claim */
13348                 sprintf(buf, "%s program exits in draw position (%s)", cps->which, cps->program);
13349             } else {
13350                 gameInfo.result = cps->twoMachinesColor[0]=='w' ? BlackWins : WhiteWins;
13351             }
13352             gameInfo.resultDetails = StrSave(buf);
13353         }
13354         if(!cps->userError || !appData.popupExitMessage) DisplayFatalError(buf, error, 1); else errorExitStatus = 1;
13355     }
13356 }
13357
13358 void
13359 ReceiveFromProgram(isr, closure, message, count, error)
13360      InputSourceRef isr;
13361      VOIDSTAR closure;
13362      char *message;
13363      int count;
13364      int error;
13365 {
13366     char *end_str;
13367     char buf[MSG_SIZ];
13368     ChessProgramState *cps = (ChessProgramState *)closure;
13369
13370     if (isr != cps->isr) return; /* Killed intentionally */
13371     if (count <= 0) {
13372         if (count == 0) {
13373             sprintf(buf,
13374                     _("Error: %s chess program (%s) exited unexpectedly"),
13375                     cps->which, cps->program);
13376         if(gameInfo.resultDetails==NULL) { /* [HGM] crash: if game in progress, give reason for abort */
13377                 if((signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
13378                     gameInfo.result = GameIsDrawn; /* [HGM] accept exit as draw claim */
13379                     sprintf(buf, _("%s program exits in draw position (%s)"), cps->which, cps->program);
13380                 } else {
13381                     gameInfo.result = cps->twoMachinesColor[0]=='w' ? BlackWins : WhiteWins;
13382                 }
13383                 gameInfo.resultDetails = StrSave(buf);
13384             }
13385             RemoveInputSource(cps->isr);
13386             if(!cps->userError || !appData.popupExitMessage) DisplayFatalError(buf, 0, 1); else errorExitStatus = 1;
13387         } else {
13388             sprintf(buf,
13389                     _("Error reading from %s chess program (%s)"),
13390                     cps->which, cps->program);
13391             RemoveInputSource(cps->isr);
13392
13393             /* [AS] Program is misbehaving badly... kill it */
13394             if( count == -2 ) {
13395                 DestroyChildProcess( cps->pr, 9 );
13396                 cps->pr = NoProc;
13397             }
13398
13399             if(!cps->userError || !appData.popupExitMessage) DisplayFatalError(buf, error, 1); else errorExitStatus = 1;
13400         }
13401         return;
13402     }
13403
13404     if ((end_str = strchr(message, '\r')) != NULL)
13405       *end_str = NULLCHAR;
13406     if ((end_str = strchr(message, '\n')) != NULL)
13407       *end_str = NULLCHAR;
13408
13409     if (appData.debugMode) {
13410         TimeMark now; int print = 1;
13411         char *quote = ""; char c; int i;
13412
13413         if(appData.engineComments != 1) { /* [HGM] debug: decide if protocol-violating output is written */
13414                 char start = message[0];
13415                 if(start >='A' && start <= 'Z') start += 'a' - 'A'; // be tolerant to capitalizing
13416                 if(sscanf(message, "%d%c%d%d%d", &i, &c, &i, &i, &i) != 5 &&
13417                    sscanf(message, "move %c", &c)!=1  && sscanf(message, "offer%c", &c)!=1 &&
13418                    sscanf(message, "resign%c", &c)!=1 && sscanf(message, "feature %c", &c)!=1 &&
13419                    sscanf(message, "error %c", &c)!=1 && sscanf(message, "illegal %c", &c)!=1 &&
13420                    sscanf(message, "tell%c", &c)!=1   && sscanf(message, "0-1 %c", &c)!=1 &&
13421                    sscanf(message, "1-0 %c", &c)!=1   && sscanf(message, "1/2-1/2 %c", &c)!=1 &&
13422                    sscanf(message, "pong %c", &c)!=1   && start != '#') {
13423                     quote = appData.engineComments == 2 ? "# " : "### NON-COMPLIANT! ### ";
13424                     print = (appData.engineComments >= 2);
13425                 }
13426                 message[0] = start; // restore original message
13427         }
13428         if(print) {
13429                 GetTimeMark(&now);
13430                 fprintf(debugFP, "%ld <%-6s: %s%s\n",
13431                         SubtractTimeMarks(&now, &programStartTime), cps->which,
13432                         quote,
13433                         message);
13434         }
13435     }
13436
13437     /* [DM] if icsEngineAnalyze is active we block all whisper and kibitz output, because nobody want to see this */
13438     if (appData.icsEngineAnalyze) {
13439         if (strstr(message, "whisper") != NULL ||
13440              strstr(message, "kibitz") != NULL ||
13441             strstr(message, "tellics") != NULL) return;
13442     }
13443
13444     HandleMachineMove(message, cps);
13445 }
13446
13447
13448 void
13449 SendTimeControl(cps, mps, tc, inc, sd, st)
13450      ChessProgramState *cps;
13451      int mps, inc, sd, st;
13452      long tc;
13453 {
13454     char buf[MSG_SIZ];
13455     int seconds;
13456
13457     if( timeControl_2 > 0 ) {
13458         if( (gameMode == MachinePlaysBlack) || (gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b') ) {
13459             tc = timeControl_2;
13460         }
13461     }
13462     tc  /= cps->timeOdds; /* [HGM] time odds: apply before telling engine */
13463     inc /= cps->timeOdds;
13464     st  /= cps->timeOdds;
13465
13466     seconds = (tc / 1000) % 60; /* [HGM] displaced to after applying odds */
13467
13468     if (st > 0) {
13469       /* Set exact time per move, normally using st command */
13470       if (cps->stKludge) {
13471         /* GNU Chess 4 has no st command; uses level in a nonstandard way */
13472         seconds = st % 60;
13473         if (seconds == 0) {
13474           sprintf(buf, "level 1 %d\n", st/60);
13475         } else {
13476           sprintf(buf, "level 1 %d:%02d\n", st/60, seconds);
13477         }
13478       } else {
13479         sprintf(buf, "st %d\n", st);
13480       }
13481     } else {
13482       /* Set conventional or incremental time control, using level command */
13483       if (seconds == 0) {
13484         /* Note old gnuchess bug -- minutes:seconds used to not work.
13485            Fixed in later versions, but still avoid :seconds
13486            when seconds is 0. */
13487         sprintf(buf, "level %d %ld %d\n", mps, tc/60000, inc/1000);
13488       } else {
13489         sprintf(buf, "level %d %ld:%02d %d\n", mps, tc/60000,
13490                 seconds, inc/1000);
13491       }
13492     }
13493     SendToProgram(buf, cps);
13494
13495     /* Orthoganally (except for GNU Chess 4), limit time to st seconds */
13496     /* Orthogonally, limit search to given depth */
13497     if (sd > 0) {
13498       if (cps->sdKludge) {
13499         sprintf(buf, "depth\n%d\n", sd);
13500       } else {
13501         sprintf(buf, "sd %d\n", sd);
13502       }
13503       SendToProgram(buf, cps);
13504     }
13505
13506     if(cps->nps > 0) { /* [HGM] nps */
13507         if(cps->supportsNPS == FALSE) cps->nps = -1; // don't use if engine explicitly says not supported!
13508         else {
13509                 sprintf(buf, "nps %d\n", cps->nps);
13510               SendToProgram(buf, cps);
13511         }
13512     }
13513 }
13514
13515 ChessProgramState *WhitePlayer()
13516 /* [HGM] return pointer to 'first' or 'second', depending on who plays white */
13517 {
13518     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b' ||
13519        gameMode == BeginningOfGame || gameMode == MachinePlaysBlack)
13520         return &second;
13521     return &first;
13522 }
13523
13524 void
13525 SendTimeRemaining(cps, machineWhite)
13526      ChessProgramState *cps;
13527      int /*boolean*/ machineWhite;
13528 {
13529     char message[MSG_SIZ];
13530     long time, otime;
13531
13532     /* Note: this routine must be called when the clocks are stopped
13533        or when they have *just* been set or switched; otherwise
13534        it will be off by the time since the current tick started.
13535     */
13536     if (machineWhite) {
13537         time = whiteTimeRemaining / 10;
13538         otime = blackTimeRemaining / 10;
13539     } else {
13540         time = blackTimeRemaining / 10;
13541         otime = whiteTimeRemaining / 10;
13542     }
13543     /* [HGM] translate opponent's time by time-odds factor */
13544     otime = (otime * cps->other->timeOdds) / cps->timeOdds;
13545     if (appData.debugMode) {
13546         fprintf(debugFP, "time odds: %f %f \n", cps->timeOdds, cps->other->timeOdds);
13547     }
13548
13549     if (time <= 0) time = 1;
13550     if (otime <= 0) otime = 1;
13551
13552     sprintf(message, "time %ld\n", time);
13553     SendToProgram(message, cps);
13554
13555     sprintf(message, "otim %ld\n", otime);
13556     SendToProgram(message, cps);
13557 }
13558
13559 int
13560 BoolFeature(p, name, loc, cps)
13561      char **p;
13562      char *name;
13563      int *loc;
13564      ChessProgramState *cps;
13565 {
13566   char buf[MSG_SIZ];
13567   int len = strlen(name);
13568   int val;
13569   if (strncmp((*p), name, len) == 0 && (*p)[len] == '=') {
13570     (*p) += len + 1;
13571     sscanf(*p, "%d", &val);
13572     *loc = (val != 0);
13573     while (**p && **p != ' ') (*p)++;
13574     sprintf(buf, "accepted %s\n", name);
13575     SendToProgram(buf, cps);
13576     return TRUE;
13577   }
13578   return FALSE;
13579 }
13580
13581 int
13582 IntFeature(p, name, loc, cps)
13583      char **p;
13584      char *name;
13585      int *loc;
13586      ChessProgramState *cps;
13587 {
13588   char buf[MSG_SIZ];
13589   int len = strlen(name);
13590   if (strncmp((*p), name, len) == 0 && (*p)[len] == '=') {
13591     (*p) += len + 1;
13592     sscanf(*p, "%d", loc);
13593     while (**p && **p != ' ') (*p)++;
13594     sprintf(buf, "accepted %s\n", name);
13595     SendToProgram(buf, cps);
13596     return TRUE;
13597   }
13598   return FALSE;
13599 }
13600
13601 int
13602 StringFeature(p, name, loc, cps)
13603      char **p;
13604      char *name;
13605      char loc[];
13606      ChessProgramState *cps;
13607 {
13608   char buf[MSG_SIZ];
13609   int len = strlen(name);
13610   if (strncmp((*p), name, len) == 0
13611       && (*p)[len] == '=' && (*p)[len+1] == '\"') {
13612     (*p) += len + 2;
13613     sscanf(*p, "%[^\"]", loc);
13614     while (**p && **p != '\"') (*p)++;
13615     if (**p == '\"') (*p)++;
13616     sprintf(buf, "accepted %s\n", name);
13617     SendToProgram(buf, cps);
13618     return TRUE;
13619   }
13620   return FALSE;
13621 }
13622
13623 int
13624 ParseOption(Option *opt, ChessProgramState *cps)
13625 // [HGM] options: process the string that defines an engine option, and determine
13626 // name, type, default value, and allowed value range
13627 {
13628         char *p, *q, buf[MSG_SIZ];
13629         int n, min = (-1)<<31, max = 1<<31, def;
13630
13631         if(p = strstr(opt->name, " -spin ")) {
13632             if((n = sscanf(p, " -spin %d %d %d", &def, &min, &max)) < 3 ) return FALSE;
13633             if(max < min) max = min; // enforce consistency
13634             if(def < min) def = min;
13635             if(def > max) def = max;
13636             opt->value = def;
13637             opt->min = min;
13638             opt->max = max;
13639             opt->type = Spin;
13640         } else if((p = strstr(opt->name, " -slider "))) {
13641             // for now -slider is a synonym for -spin, to already provide compatibility with future polyglots
13642             if((n = sscanf(p, " -slider %d %d %d", &def, &min, &max)) < 3 ) return FALSE;
13643             if(max < min) max = min; // enforce consistency
13644             if(def < min) def = min;
13645             if(def > max) def = max;
13646             opt->value = def;
13647             opt->min = min;
13648             opt->max = max;
13649             opt->type = Spin; // Slider;
13650         } else if((p = strstr(opt->name, " -string "))) {
13651             opt->textValue = p+9;
13652             opt->type = TextBox;
13653         } else if((p = strstr(opt->name, " -file "))) {
13654             // for now -file is a synonym for -string, to already provide compatibility with future polyglots
13655             opt->textValue = p+7;
13656             opt->type = TextBox; // FileName;
13657         } else if((p = strstr(opt->name, " -path "))) {
13658             // for now -file is a synonym for -string, to already provide compatibility with future polyglots
13659             opt->textValue = p+7;
13660             opt->type = TextBox; // PathName;
13661         } else if(p = strstr(opt->name, " -check ")) {
13662             if(sscanf(p, " -check %d", &def) < 1) return FALSE;
13663             opt->value = (def != 0);
13664             opt->type = CheckBox;
13665         } else if(p = strstr(opt->name, " -combo ")) {
13666             opt->textValue = (char*) (&cps->comboList[cps->comboCnt]); // cheat with pointer type
13667             cps->comboList[cps->comboCnt++] = q = p+8; // holds possible choices
13668             if(*q == '*') cps->comboList[cps->comboCnt-1]++;
13669             opt->value = n = 0;
13670             while(q = StrStr(q, " /// ")) {
13671                 n++; *q = 0;    // count choices, and null-terminate each of them
13672                 q += 5;
13673                 if(*q == '*') { // remember default, which is marked with * prefix
13674                     q++;
13675                     opt->value = n;
13676                 }
13677                 cps->comboList[cps->comboCnt++] = q;
13678             }
13679             cps->comboList[cps->comboCnt++] = NULL;
13680             opt->max = n + 1;
13681             opt->type = ComboBox;
13682         } else if(p = strstr(opt->name, " -button")) {
13683             opt->type = Button;
13684         } else if(p = strstr(opt->name, " -save")) {
13685             opt->type = SaveButton;
13686         } else return FALSE;
13687         *p = 0; // terminate option name
13688         // now look if the command-line options define a setting for this engine option.
13689         if(cps->optionSettings && cps->optionSettings[0])
13690             p = strstr(cps->optionSettings, opt->name); else p = NULL;
13691         if(p && (p == cps->optionSettings || p[-1] == ',')) {
13692                 sprintf(buf, "option %s", p);
13693                 if(p = strstr(buf, ",")) *p = 0;
13694                 strcat(buf, "\n");
13695                 SendToProgram(buf, cps);
13696         }
13697         return TRUE;
13698 }
13699
13700 void
13701 FeatureDone(cps, val)
13702      ChessProgramState* cps;
13703      int val;
13704 {
13705   DelayedEventCallback cb = GetDelayedEvent();
13706   if ((cb == InitBackEnd3 && cps == &first) ||
13707       (cb == TwoMachinesEventIfReady && cps == &second)) {
13708     CancelDelayedEvent();
13709     ScheduleDelayedEvent(cb, val ? 1 : 3600000);
13710   }
13711   cps->initDone = val;
13712 }
13713
13714 /* Parse feature command from engine */
13715 void
13716 ParseFeatures(args, cps)
13717      char* args;
13718      ChessProgramState *cps;
13719 {
13720   char *p = args;
13721   char *q;
13722   int val;
13723   char buf[MSG_SIZ];
13724
13725   for (;;) {
13726     while (*p == ' ') p++;
13727     if (*p == NULLCHAR) return;
13728
13729     if (BoolFeature(&p, "setboard", &cps->useSetboard, cps)) continue;
13730     if (BoolFeature(&p, "time", &cps->sendTime, cps)) continue;
13731     if (BoolFeature(&p, "draw", &cps->sendDrawOffers, cps)) continue;
13732     if (BoolFeature(&p, "sigint", &cps->useSigint, cps)) continue;
13733     if (BoolFeature(&p, "sigterm", &cps->useSigterm, cps)) continue;
13734     if (BoolFeature(&p, "reuse", &val, cps)) {
13735       /* Engine can disable reuse, but can't enable it if user said no */
13736       if (!val) cps->reuse = FALSE;
13737       continue;
13738     }
13739     if (BoolFeature(&p, "analyze", &cps->analysisSupport, cps)) continue;
13740     if (StringFeature(&p, "myname", &cps->tidy, cps)) {
13741       if (gameMode == TwoMachinesPlay) {
13742         DisplayTwoMachinesTitle();
13743       } else {
13744         DisplayTitle("");
13745       }
13746       continue;
13747     }
13748     if (StringFeature(&p, "variants", &cps->variants, cps)) continue;
13749     if (BoolFeature(&p, "san", &cps->useSAN, cps)) continue;
13750     if (BoolFeature(&p, "ping", &cps->usePing, cps)) continue;
13751     if (BoolFeature(&p, "playother", &cps->usePlayother, cps)) continue;
13752     if (BoolFeature(&p, "colors", &cps->useColors, cps)) continue;
13753     if (BoolFeature(&p, "usermove", &cps->useUsermove, cps)) continue;
13754     if (BoolFeature(&p, "ics", &cps->sendICS, cps)) continue;
13755     if (BoolFeature(&p, "name", &cps->sendName, cps)) continue;
13756     if (BoolFeature(&p, "pause", &val, cps)) continue; /* unused at present */
13757     if (IntFeature(&p, "done", &val, cps)) {
13758       FeatureDone(cps, val);
13759       continue;
13760     }
13761     /* Added by Tord: */
13762     if (BoolFeature(&p, "fen960", &cps->useFEN960, cps)) continue;
13763     if (BoolFeature(&p, "oocastle", &cps->useOOCastle, cps)) continue;
13764     /* End of additions by Tord */
13765
13766     /* [HGM] added features: */
13767     if (BoolFeature(&p, "debug", &cps->debug, cps)) continue;
13768     if (BoolFeature(&p, "nps", &cps->supportsNPS, cps)) continue;
13769     if (IntFeature(&p, "level", &cps->maxNrOfSessions, cps)) continue;
13770     if (BoolFeature(&p, "memory", &cps->memSize, cps)) continue;
13771     if (BoolFeature(&p, "smp", &cps->maxCores, cps)) continue;
13772     if (StringFeature(&p, "egt", &cps->egtFormats, cps)) continue;
13773     if (StringFeature(&p, "option", &(cps->option[cps->nrOptions].name), cps)) {
13774         if(!ParseOption(&(cps->option[cps->nrOptions++]), cps)) { // [HGM] options: add option feature
13775             sprintf(buf, "rejected option %s\n", cps->option[--cps->nrOptions].name);
13776             SendToProgram(buf, cps);
13777             continue;
13778         }
13779         if(cps->nrOptions >= MAX_OPTIONS) {
13780             cps->nrOptions--;
13781             sprintf(buf, "%s engine has too many options\n", cps->which);
13782             DisplayError(buf, 0);
13783         }
13784         continue;
13785     }
13786     if (BoolFeature(&p, "smp", &cps->maxCores, cps)) continue;
13787     /* End of additions by HGM */
13788
13789     /* unknown feature: complain and skip */
13790     q = p;
13791     while (*q && *q != '=') q++;
13792     sprintf(buf, "rejected %.*s\n", (int)(q-p), p);
13793     SendToProgram(buf, cps);
13794     p = q;
13795     if (*p == '=') {
13796       p++;
13797       if (*p == '\"') {
13798         p++;
13799         while (*p && *p != '\"') p++;
13800         if (*p == '\"') p++;
13801       } else {
13802         while (*p && *p != ' ') p++;
13803       }
13804     }
13805   }
13806
13807 }
13808
13809 void
13810 PeriodicUpdatesEvent(newState)
13811      int newState;
13812 {
13813     if (newState == appData.periodicUpdates)
13814       return;
13815
13816     appData.periodicUpdates=newState;
13817
13818     /* Display type changes, so update it now */
13819 //    DisplayAnalysis();
13820
13821     /* Get the ball rolling again... */
13822     if (newState) {
13823         AnalysisPeriodicEvent(1);
13824         StartAnalysisClock();
13825     }
13826 }
13827
13828 void
13829 PonderNextMoveEvent(newState)
13830      int newState;
13831 {
13832     if (newState == appData.ponderNextMove) return;
13833     if (gameMode == EditPosition) EditPositionDone(TRUE);
13834     if (newState) {
13835         SendToProgram("hard\n", &first);
13836         if (gameMode == TwoMachinesPlay) {
13837             SendToProgram("hard\n", &second);
13838         }
13839     } else {
13840         SendToProgram("easy\n", &first);
13841         thinkOutput[0] = NULLCHAR;
13842         if (gameMode == TwoMachinesPlay) {
13843             SendToProgram("easy\n", &second);
13844         }
13845     }
13846     appData.ponderNextMove = newState;
13847 }
13848
13849 void
13850 NewSettingEvent(option, command, value)
13851      char *command;
13852      int option, value;
13853 {
13854     char buf[MSG_SIZ];
13855
13856     if (gameMode == EditPosition) EditPositionDone(TRUE);
13857     sprintf(buf, "%s%s %d\n", (option ? "option ": ""), command, value);
13858     SendToProgram(buf, &first);
13859     if (gameMode == TwoMachinesPlay) {
13860         SendToProgram(buf, &second);
13861     }
13862 }
13863
13864 void
13865 ShowThinkingEvent()
13866 // [HGM] thinking: this routine is now also called from "Options -> Engine..." popup
13867 {
13868     static int oldState = 2; // kludge alert! Neither true nor fals, so first time oldState is always updated
13869     int newState = appData.showThinking
13870         // [HGM] thinking: other features now need thinking output as well
13871         || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp();
13872
13873     if (oldState == newState) return;
13874     oldState = newState;
13875     if (gameMode == EditPosition) EditPositionDone(TRUE);
13876     if (oldState) {
13877         SendToProgram("post\n", &first);
13878         if (gameMode == TwoMachinesPlay) {
13879             SendToProgram("post\n", &second);
13880         }
13881     } else {
13882         SendToProgram("nopost\n", &first);
13883         thinkOutput[0] = NULLCHAR;
13884         if (gameMode == TwoMachinesPlay) {
13885             SendToProgram("nopost\n", &second);
13886         }
13887     }
13888 //    appData.showThinking = newState; // [HGM] thinking: responsible option should already have be changed when calling this routine!
13889 }
13890
13891 void
13892 AskQuestionEvent(title, question, replyPrefix, which)
13893      char *title; char *question; char *replyPrefix; char *which;
13894 {
13895   ProcRef pr = (which[0] == '1') ? first.pr : second.pr;
13896   if (pr == NoProc) return;
13897   AskQuestion(title, question, replyPrefix, pr);
13898 }
13899
13900 void
13901 DisplayMove(moveNumber)
13902      int moveNumber;
13903 {
13904     char message[MSG_SIZ];
13905     char res[MSG_SIZ];
13906     char cpThinkOutput[MSG_SIZ];
13907
13908     if(appData.noGUI) return; // [HGM] fast: suppress display of moves
13909
13910     if (moveNumber == forwardMostMove - 1 ||
13911         gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
13912
13913         safeStrCpy(cpThinkOutput, thinkOutput, sizeof(cpThinkOutput));
13914
13915         if (strchr(cpThinkOutput, '\n')) {
13916             *strchr(cpThinkOutput, '\n') = NULLCHAR;
13917         }
13918     } else {
13919         *cpThinkOutput = NULLCHAR;
13920     }
13921
13922     /* [AS] Hide thinking from human user */
13923     if( appData.hideThinkingFromHuman && gameMode != TwoMachinesPlay ) {
13924         *cpThinkOutput = NULLCHAR;
13925         if( thinkOutput[0] != NULLCHAR ) {
13926             int i;
13927
13928             for( i=0; i<=hiddenThinkOutputState; i++ ) {
13929                 cpThinkOutput[i] = '.';
13930             }
13931             cpThinkOutput[i] = NULLCHAR;
13932             hiddenThinkOutputState = (hiddenThinkOutputState + 1) % 3;
13933         }
13934     }
13935
13936     if (moveNumber == forwardMostMove - 1 &&
13937         gameInfo.resultDetails != NULL) {
13938         if (gameInfo.resultDetails[0] == NULLCHAR) {
13939             sprintf(res, " %s", PGNResult(gameInfo.result));
13940         } else {
13941             sprintf(res, " {%s} %s",
13942                     gameInfo.resultDetails, PGNResult(gameInfo.result));
13943         }
13944     } else {
13945         res[0] = NULLCHAR;
13946     }
13947
13948     if (moveNumber < 0 || parseList[moveNumber][0] == NULLCHAR) {
13949         DisplayMessage(res, cpThinkOutput);
13950     } else {
13951         sprintf(message, "%d.%s%s%s", moveNumber / 2 + 1,
13952                 WhiteOnMove(moveNumber) ? " " : ".. ",
13953                 parseList[moveNumber], res);
13954         DisplayMessage(message, cpThinkOutput);
13955     }
13956 }
13957
13958 void
13959 DisplayComment(moveNumber, text)
13960      int moveNumber;
13961      char *text;
13962 {
13963     char title[MSG_SIZ];
13964     char buf[8000]; // comment can be long!
13965     int score, depth;
13966
13967     if (moveNumber < 0 || parseList[moveNumber][0] == NULLCHAR) {
13968       strcpy(title, "Comment");
13969     } else {
13970       sprintf(title, "Comment on %d.%s%s", moveNumber / 2 + 1,
13971               WhiteOnMove(moveNumber) ? " " : ".. ",
13972               parseList[moveNumber]);
13973     }
13974     // [HGM] PV info: display PV info together with (or as) comment
13975     if(moveNumber >= 0 && (depth = pvInfoList[moveNumber].depth) > 0) {
13976       if(text == NULL) text = "";
13977       score = pvInfoList[moveNumber].score;
13978       sprintf(buf, "%s%.2f/%d %d\n%s", score>0 ? "+" : "", score/100.,
13979               depth, (pvInfoList[moveNumber].time+50)/100, text);
13980       text = buf;
13981     }
13982     if (text != NULL && (appData.autoDisplayComment || commentUp))
13983         CommentPopUp(title, text);
13984 }
13985
13986 /* This routine sends a ^C interrupt to gnuchess, to awaken it if it
13987  * might be busy thinking or pondering.  It can be omitted if your
13988  * gnuchess is configured to stop thinking immediately on any user
13989  * input.  However, that gnuchess feature depends on the FIONREAD
13990  * ioctl, which does not work properly on some flavors of Unix.
13991  */
13992 void
13993 Attention(cps)
13994      ChessProgramState *cps;
13995 {
13996 #if ATTENTION
13997     if (!cps->useSigint) return;
13998     if (appData.noChessProgram || (cps->pr == NoProc)) return;
13999     switch (gameMode) {
14000       case MachinePlaysWhite:
14001       case MachinePlaysBlack:
14002       case TwoMachinesPlay:
14003       case IcsPlayingWhite:
14004       case IcsPlayingBlack:
14005       case AnalyzeMode:
14006       case AnalyzeFile:
14007         /* Skip if we know it isn't thinking */
14008         if (!cps->maybeThinking) return;
14009         if (appData.debugMode)
14010           fprintf(debugFP, "Interrupting %s\n", cps->which);
14011         InterruptChildProcess(cps->pr);
14012         cps->maybeThinking = FALSE;
14013         break;
14014       default:
14015         break;
14016     }
14017 #endif /*ATTENTION*/
14018 }
14019
14020 int
14021 CheckFlags()
14022 {
14023     if (whiteTimeRemaining <= 0) {
14024         if (!whiteFlag) {
14025             whiteFlag = TRUE;
14026             if (appData.icsActive) {
14027                 if (appData.autoCallFlag &&
14028                     gameMode == IcsPlayingBlack && !blackFlag) {
14029                   SendToICS(ics_prefix);
14030                   SendToICS("flag\n");
14031                 }
14032             } else {
14033                 if (blackFlag) {
14034                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Both flags fell"));
14035                 } else {
14036                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("White's flag fell"));
14037                     if (appData.autoCallFlag) {
14038                         GameEnds(BlackWins, "Black wins on time", GE_XBOARD);
14039                         return TRUE;
14040                     }
14041                 }
14042             }
14043         }
14044     }
14045     if (blackTimeRemaining <= 0) {
14046         if (!blackFlag) {
14047             blackFlag = TRUE;
14048             if (appData.icsActive) {
14049                 if (appData.autoCallFlag &&
14050                     gameMode == IcsPlayingWhite && !whiteFlag) {
14051                   SendToICS(ics_prefix);
14052                   SendToICS("flag\n");
14053                 }
14054             } else {
14055                 if (whiteFlag) {
14056                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Both flags fell"));
14057                 } else {
14058                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Black's flag fell"));
14059                     if (appData.autoCallFlag) {
14060                         GameEnds(WhiteWins, "White wins on time", GE_XBOARD);
14061                         return TRUE;
14062                     }
14063                 }
14064             }
14065         }
14066     }
14067     return FALSE;
14068 }
14069
14070 void
14071 CheckTimeControl()
14072 {
14073     if (!appData.clockMode || appData.icsActive || searchTime || // [HGM] st: no inc in st mode
14074         gameMode == PlayFromGameFile || forwardMostMove == 0) return;
14075
14076     /*
14077      * add time to clocks when time control is achieved ([HGM] now also used for increment)
14078      */
14079     if ( !WhiteOnMove(forwardMostMove) )
14080         /* White made time control */
14081         whiteTimeRemaining += GetTimeQuota((forwardMostMove-1)/2)
14082         /* [HGM] time odds: correct new time quota for time odds! */
14083                                             / WhitePlayer()->timeOdds;
14084       else
14085         /* Black made time control */
14086         blackTimeRemaining += GetTimeQuota((forwardMostMove-1)/2)
14087                                             / WhitePlayer()->other->timeOdds;
14088 }
14089
14090 void
14091 DisplayBothClocks()
14092 {
14093     int wom = gameMode == EditPosition ?
14094       !blackPlaysFirst : WhiteOnMove(currentMove);
14095     DisplayWhiteClock(whiteTimeRemaining, wom);
14096     DisplayBlackClock(blackTimeRemaining, !wom);
14097 }
14098
14099
14100 /* Timekeeping seems to be a portability nightmare.  I think everyone
14101    has ftime(), but I'm really not sure, so I'm including some ifdefs
14102    to use other calls if you don't.  Clocks will be less accurate if
14103    you have neither ftime nor gettimeofday.
14104 */
14105
14106 /* VS 2008 requires the #include outside of the function */
14107 #if !HAVE_GETTIMEOFDAY && HAVE_FTIME
14108 #include <sys/timeb.h>
14109 #endif
14110
14111 /* Get the current time as a TimeMark */
14112 void
14113 GetTimeMark(tm)
14114      TimeMark *tm;
14115 {
14116 #if HAVE_GETTIMEOFDAY
14117
14118     struct timeval timeVal;
14119     struct timezone timeZone;
14120
14121     gettimeofday(&timeVal, &timeZone);
14122     tm->sec = (long) timeVal.tv_sec;
14123     tm->ms = (int) (timeVal.tv_usec / 1000L);
14124
14125 #else /*!HAVE_GETTIMEOFDAY*/
14126 #if HAVE_FTIME
14127
14128 // include <sys/timeb.h> / moved to just above start of function
14129     struct timeb timeB;
14130
14131     ftime(&timeB);
14132     tm->sec = (long) timeB.time;
14133     tm->ms = (int) timeB.millitm;
14134
14135 #else /*!HAVE_FTIME && !HAVE_GETTIMEOFDAY*/
14136     tm->sec = (long) time(NULL);
14137     tm->ms = 0;
14138 #endif
14139 #endif
14140 }
14141
14142 /* Return the difference in milliseconds between two
14143    time marks.  We assume the difference will fit in a long!
14144 */
14145 long
14146 SubtractTimeMarks(tm2, tm1)
14147      TimeMark *tm2, *tm1;
14148 {
14149     return 1000L*(tm2->sec - tm1->sec) +
14150            (long) (tm2->ms - tm1->ms);
14151 }
14152
14153
14154 /*
14155  * Code to manage the game clocks.
14156  *
14157  * In tournament play, black starts the clock and then white makes a move.
14158  * We give the human user a slight advantage if he is playing white---the
14159  * clocks don't run until he makes his first move, so it takes zero time.
14160  * Also, we don't account for network lag, so we could get out of sync
14161  * with GNU Chess's clock -- but then, referees are always right.
14162  */
14163
14164 static TimeMark tickStartTM;
14165 static long intendedTickLength;
14166
14167 long
14168 NextTickLength(timeRemaining)
14169      long timeRemaining;
14170 {
14171     long nominalTickLength, nextTickLength;
14172
14173     if (timeRemaining > 0L && timeRemaining <= 10000L)
14174       nominalTickLength = 100L;
14175     else
14176       nominalTickLength = 1000L;
14177     nextTickLength = timeRemaining % nominalTickLength;
14178     if (nextTickLength <= 0) nextTickLength += nominalTickLength;
14179
14180     return nextTickLength;
14181 }
14182
14183 /* Adjust clock one minute up or down */
14184 void
14185 AdjustClock(Boolean which, int dir)
14186 {
14187     if(which) blackTimeRemaining += 60000*dir;
14188     else      whiteTimeRemaining += 60000*dir;
14189     DisplayBothClocks();
14190 }
14191
14192 /* Stop clocks and reset to a fresh time control */
14193 void
14194 ResetClocks()
14195 {
14196     (void) StopClockTimer();
14197     if (appData.icsActive) {
14198         whiteTimeRemaining = blackTimeRemaining = 0;
14199     } else if (searchTime) {
14200         whiteTimeRemaining = 1000*searchTime / WhitePlayer()->timeOdds;
14201         blackTimeRemaining = 1000*searchTime / WhitePlayer()->other->timeOdds;
14202     } else { /* [HGM] correct new time quote for time odds */
14203         whiteTimeRemaining = GetTimeQuota(-1) / WhitePlayer()->timeOdds;
14204         blackTimeRemaining = GetTimeQuota(-1) / WhitePlayer()->other->timeOdds;
14205     }
14206     if (whiteFlag || blackFlag) {
14207         DisplayTitle("");
14208         whiteFlag = blackFlag = FALSE;
14209     }
14210     DisplayBothClocks();
14211 }
14212
14213 #define FUDGE 25 /* 25ms = 1/40 sec; should be plenty even for 50 Hz clocks */
14214
14215 /* Decrement running clock by amount of time that has passed */
14216 void
14217 DecrementClocks()
14218 {
14219     long timeRemaining;
14220     long lastTickLength, fudge;
14221     TimeMark now;
14222
14223     if (!appData.clockMode) return;
14224     if (gameMode==AnalyzeMode || gameMode == AnalyzeFile) return;
14225
14226     GetTimeMark(&now);
14227
14228     lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
14229
14230     /* Fudge if we woke up a little too soon */
14231     fudge = intendedTickLength - lastTickLength;
14232     if (fudge < 0 || fudge > FUDGE) fudge = 0;
14233
14234     if (WhiteOnMove(forwardMostMove)) {
14235         if(whiteNPS >= 0) lastTickLength = 0;
14236         timeRemaining = whiteTimeRemaining -= lastTickLength;
14237         DisplayWhiteClock(whiteTimeRemaining - fudge,
14238                           WhiteOnMove(currentMove < forwardMostMove ? currentMove : forwardMostMove));
14239     } else {
14240         if(blackNPS >= 0) lastTickLength = 0;
14241         timeRemaining = blackTimeRemaining -= lastTickLength;
14242         DisplayBlackClock(blackTimeRemaining - fudge,
14243                           !WhiteOnMove(currentMove < forwardMostMove ? currentMove : forwardMostMove));
14244     }
14245
14246     if (CheckFlags()) return;
14247
14248     tickStartTM = now;
14249     intendedTickLength = NextTickLength(timeRemaining - fudge) + fudge;
14250     StartClockTimer(intendedTickLength);
14251
14252     /* if the time remaining has fallen below the alarm threshold, sound the
14253      * alarm. if the alarm has sounded and (due to a takeback or time control
14254      * with increment) the time remaining has increased to a level above the
14255      * threshold, reset the alarm so it can sound again.
14256      */
14257
14258     if (appData.icsActive && appData.icsAlarm) {
14259
14260         /* make sure we are dealing with the user's clock */
14261         if (!( ((gameMode == IcsPlayingWhite) && WhiteOnMove(currentMove)) ||
14262                ((gameMode == IcsPlayingBlack) && !WhiteOnMove(currentMove))
14263            )) return;
14264
14265         if (alarmSounded && (timeRemaining > appData.icsAlarmTime)) {
14266             alarmSounded = FALSE;
14267         } else if (!alarmSounded && (timeRemaining <= appData.icsAlarmTime)) {
14268             PlayAlarmSound();
14269             alarmSounded = TRUE;
14270         }
14271     }
14272 }
14273
14274
14275 /* A player has just moved, so stop the previously running
14276    clock and (if in clock mode) start the other one.
14277    We redisplay both clocks in case we're in ICS mode, because
14278    ICS gives us an update to both clocks after every move.
14279    Note that this routine is called *after* forwardMostMove
14280    is updated, so the last fractional tick must be subtracted
14281    from the color that is *not* on move now.
14282 */
14283 void
14284 SwitchClocks(int newMoveNr)
14285 {
14286     long lastTickLength;
14287     TimeMark now;
14288     int flagged = FALSE;
14289
14290     GetTimeMark(&now);
14291
14292     if (StopClockTimer() && appData.clockMode) {
14293         lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
14294         if (!WhiteOnMove(forwardMostMove)) {
14295             if(blackNPS >= 0) lastTickLength = 0;
14296             blackTimeRemaining -= lastTickLength;
14297            /* [HGM] PGNtime: save time for PGN file if engine did not give it */
14298 //         if(pvInfoList[forwardMostMove-1].time == -1)
14299                  pvInfoList[forwardMostMove-1].time =               // use GUI time
14300                       (timeRemaining[1][forwardMostMove-1] - blackTimeRemaining)/10;
14301         } else {
14302            if(whiteNPS >= 0) lastTickLength = 0;
14303            whiteTimeRemaining -= lastTickLength;
14304            /* [HGM] PGNtime: save time for PGN file if engine did not give it */
14305 //         if(pvInfoList[forwardMostMove-1].time == -1)
14306                  pvInfoList[forwardMostMove-1].time =
14307                       (timeRemaining[0][forwardMostMove-1] - whiteTimeRemaining)/10;
14308         }
14309         flagged = CheckFlags();
14310     }
14311     forwardMostMove = newMoveNr; // [HGM] race: change stm when no timer interrupt scheduled
14312     CheckTimeControl();
14313
14314     if (flagged || !appData.clockMode) return;
14315
14316     switch (gameMode) {
14317       case MachinePlaysBlack:
14318       case MachinePlaysWhite:
14319       case BeginningOfGame:
14320         if (pausing) return;
14321         break;
14322
14323       case EditGame:
14324       case PlayFromGameFile:
14325       case IcsExamining:
14326         return;
14327
14328       default:
14329         break;
14330     }
14331
14332     if (searchTime) { // [HGM] st: set clock of player that has to move to max time
14333         if(WhiteOnMove(forwardMostMove))
14334              whiteTimeRemaining = 1000*searchTime / WhitePlayer()->timeOdds;
14335         else blackTimeRemaining = 1000*searchTime / WhitePlayer()->other->timeOdds;
14336     }
14337
14338     tickStartTM = now;
14339     intendedTickLength = NextTickLength(WhiteOnMove(forwardMostMove) ?
14340       whiteTimeRemaining : blackTimeRemaining);
14341     StartClockTimer(intendedTickLength);
14342 }
14343
14344
14345 /* Stop both clocks */
14346 void
14347 StopClocks()
14348 {
14349     long lastTickLength;
14350     TimeMark now;
14351
14352     if (!StopClockTimer()) return;
14353     if (!appData.clockMode) return;
14354
14355     GetTimeMark(&now);
14356
14357     lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
14358     if (WhiteOnMove(forwardMostMove)) {
14359         if(whiteNPS >= 0) lastTickLength = 0;
14360         whiteTimeRemaining -= lastTickLength;
14361         DisplayWhiteClock(whiteTimeRemaining, WhiteOnMove(currentMove));
14362     } else {
14363         if(blackNPS >= 0) lastTickLength = 0;
14364         blackTimeRemaining -= lastTickLength;
14365         DisplayBlackClock(blackTimeRemaining, !WhiteOnMove(currentMove));
14366     }
14367     CheckFlags();
14368 }
14369
14370 /* Start clock of player on move.  Time may have been reset, so
14371    if clock is already running, stop and restart it. */
14372 void
14373 StartClocks()
14374 {
14375     (void) StopClockTimer(); /* in case it was running already */
14376     DisplayBothClocks();
14377     if (CheckFlags()) return;
14378
14379     if (!appData.clockMode) return;
14380     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) return;
14381
14382     GetTimeMark(&tickStartTM);
14383     intendedTickLength = NextTickLength(WhiteOnMove(forwardMostMove) ?
14384       whiteTimeRemaining : blackTimeRemaining);
14385
14386    /* [HGM] nps: figure out nps factors, by determining which engine plays white and/or black once and for all */
14387     whiteNPS = blackNPS = -1;
14388     if(gameMode == MachinePlaysWhite || gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'w'
14389        || appData.zippyPlay && gameMode == IcsPlayingBlack) // first (perhaps only) engine has white
14390         whiteNPS = first.nps;
14391     if(gameMode == MachinePlaysBlack || gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b'
14392        || appData.zippyPlay && gameMode == IcsPlayingWhite) // first (perhaps only) engine has black
14393         blackNPS = first.nps;
14394     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b') // second only used in Two-Machines mode
14395         whiteNPS = second.nps;
14396     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'w')
14397         blackNPS = second.nps;
14398     if(appData.debugMode) fprintf(debugFP, "nps: w=%d, b=%d\n", whiteNPS, blackNPS);
14399
14400     StartClockTimer(intendedTickLength);
14401 }
14402
14403 char *
14404 TimeString(ms)
14405      long ms;
14406 {
14407     long second, minute, hour, day;
14408     char *sign = "";
14409     static char buf[32];
14410
14411     if (ms > 0 && ms <= 9900) {
14412       /* convert milliseconds to tenths, rounding up */
14413       double tenths = floor( ((double)(ms + 99L)) / 100.00 );
14414
14415       sprintf(buf, " %03.1f ", tenths/10.0);
14416       return buf;
14417     }
14418
14419     /* convert milliseconds to seconds, rounding up */
14420     /* use floating point to avoid strangeness of integer division
14421        with negative dividends on many machines */
14422     second = (long) floor(((double) (ms + 999L)) / 1000.0);
14423
14424     if (second < 0) {
14425         sign = "-";
14426         second = -second;
14427     }
14428
14429     day = second / (60 * 60 * 24);
14430     second = second % (60 * 60 * 24);
14431     hour = second / (60 * 60);
14432     second = second % (60 * 60);
14433     minute = second / 60;
14434     second = second % 60;
14435
14436     if (day > 0)
14437       sprintf(buf, " %s%ld:%02ld:%02ld:%02ld ",
14438               sign, day, hour, minute, second);
14439     else if (hour > 0)
14440       sprintf(buf, " %s%ld:%02ld:%02ld ", sign, hour, minute, second);
14441     else
14442       sprintf(buf, " %s%2ld:%02ld ", sign, minute, second);
14443
14444     return buf;
14445 }
14446
14447
14448 /*
14449  * This is necessary because some C libraries aren't ANSI C compliant yet.
14450  */
14451 char *
14452 StrStr(string, match)
14453      char *string, *match;
14454 {
14455     int i, length;
14456
14457     length = strlen(match);
14458
14459     for (i = strlen(string) - length; i >= 0; i--, string++)
14460       if (!strncmp(match, string, length))
14461         return string;
14462
14463     return NULL;
14464 }
14465
14466 char *
14467 StrCaseStr(string, match)
14468      char *string, *match;
14469 {
14470     int i, j, length;
14471
14472     length = strlen(match);
14473
14474     for (i = strlen(string) - length; i >= 0; i--, string++) {
14475         for (j = 0; j < length; j++) {
14476             if (ToLower(match[j]) != ToLower(string[j]))
14477               break;
14478         }
14479         if (j == length) return string;
14480     }
14481
14482     return NULL;
14483 }
14484
14485 #ifndef _amigados
14486 int
14487 StrCaseCmp(s1, s2)
14488      char *s1, *s2;
14489 {
14490     char c1, c2;
14491
14492     for (;;) {
14493         c1 = ToLower(*s1++);
14494         c2 = ToLower(*s2++);
14495         if (c1 > c2) return 1;
14496         if (c1 < c2) return -1;
14497         if (c1 == NULLCHAR) return 0;
14498     }
14499 }
14500
14501
14502 int
14503 ToLower(c)
14504      int c;
14505 {
14506     return isupper(c) ? tolower(c) : c;
14507 }
14508
14509
14510 int
14511 ToUpper(c)
14512      int c;
14513 {
14514     return islower(c) ? toupper(c) : c;
14515 }
14516 #endif /* !_amigados    */
14517
14518 char *
14519 StrSave(s)
14520      char *s;
14521 {
14522     char *ret;
14523
14524     if ((ret = (char *) malloc(strlen(s) + 1))) {
14525         strcpy(ret, s);
14526     }
14527     return ret;
14528 }
14529
14530 char *
14531 StrSavePtr(s, savePtr)
14532      char *s, **savePtr;
14533 {
14534     if (*savePtr) {
14535         free(*savePtr);
14536     }
14537     if ((*savePtr = (char *) malloc(strlen(s) + 1))) {
14538         strcpy(*savePtr, s);
14539     }
14540     return(*savePtr);
14541 }
14542
14543 char *
14544 PGNDate()
14545 {
14546     time_t clock;
14547     struct tm *tm;
14548     char buf[MSG_SIZ];
14549
14550     clock = time((time_t *)NULL);
14551     tm = localtime(&clock);
14552     sprintf(buf, "%04d.%02d.%02d",
14553             tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday);
14554     return StrSave(buf);
14555 }
14556
14557
14558 char *
14559 PositionToFEN(move, overrideCastling)
14560      int move;
14561      char *overrideCastling;
14562 {
14563     int i, j, fromX, fromY, toX, toY;
14564     int whiteToPlay;
14565     char buf[128];
14566     char *p, *q;
14567     int emptycount;
14568     ChessSquare piece;
14569
14570     whiteToPlay = (gameMode == EditPosition) ?
14571       !blackPlaysFirst : (move % 2 == 0);
14572     p = buf;
14573
14574     /* Piece placement data */
14575     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
14576         emptycount = 0;
14577         for (j = BOARD_LEFT; j < BOARD_RGHT; j++) {
14578             if (boards[move][i][j] == EmptySquare) {
14579                 emptycount++;
14580             } else { ChessSquare piece = boards[move][i][j];
14581                 if (emptycount > 0) {
14582                     if(emptycount<10) /* [HGM] can be >= 10 */
14583                         *p++ = '0' + emptycount;
14584                     else { *p++ = '0' + emptycount/10; *p++ = '0' + emptycount%10; }
14585                     emptycount = 0;
14586                 }
14587                 if(PieceToChar(piece) == '+') {
14588                     /* [HGM] write promoted pieces as '+<unpromoted>' (Shogi) */
14589                     *p++ = '+';
14590                     piece = (ChessSquare)(DEMOTED piece);
14591                 }
14592                 *p++ = PieceToChar(piece);
14593                 if(p[-1] == '~') {
14594                     /* [HGM] flag promoted pieces as '<promoted>~' (Crazyhouse) */
14595                     p[-1] = PieceToChar((ChessSquare)(DEMOTED piece));
14596                     *p++ = '~';
14597                 }
14598             }
14599         }
14600         if (emptycount > 0) {
14601             if(emptycount<10) /* [HGM] can be >= 10 */
14602                 *p++ = '0' + emptycount;
14603             else { *p++ = '0' + emptycount/10; *p++ = '0' + emptycount%10; }
14604             emptycount = 0;
14605         }
14606         *p++ = '/';
14607     }
14608     *(p - 1) = ' ';
14609
14610     /* [HGM] print Crazyhouse or Shogi holdings */
14611     if( gameInfo.holdingsWidth ) {
14612         *(p-1) = '['; /* if we wanted to support BFEN, this could be '/' */
14613         q = p;
14614         for(i=0; i<gameInfo.holdingsSize; i++) { /* white holdings */
14615             piece = boards[move][i][BOARD_WIDTH-1];
14616             if( piece != EmptySquare )
14617               for(j=0; j<(int) boards[move][i][BOARD_WIDTH-2]; j++)
14618                   *p++ = PieceToChar(piece);
14619         }
14620         for(i=0; i<gameInfo.holdingsSize; i++) { /* black holdings */
14621             piece = boards[move][BOARD_HEIGHT-i-1][0];
14622             if( piece != EmptySquare )
14623               for(j=0; j<(int) boards[move][BOARD_HEIGHT-i-1][1]; j++)
14624                   *p++ = PieceToChar(piece);
14625         }
14626
14627         if( q == p ) *p++ = '-';
14628         *p++ = ']';
14629         *p++ = ' ';
14630     }
14631
14632     /* Active color */
14633     *p++ = whiteToPlay ? 'w' : 'b';
14634     *p++ = ' ';
14635
14636   if(q = overrideCastling) { // [HGM] FRC: override castling & e.p fields for non-compliant engines
14637     while(*p++ = *q++); if(q != overrideCastling+1) p[-1] = ' '; else --p;
14638   } else {
14639   if(nrCastlingRights) {
14640      q = p;
14641      if(gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom) {
14642        /* [HGM] write directly from rights */
14643            if(boards[move][CASTLING][2] != NoRights &&
14644               boards[move][CASTLING][0] != NoRights   )
14645                 *p++ = boards[move][CASTLING][0] + AAA + 'A' - 'a';
14646            if(boards[move][CASTLING][2] != NoRights &&
14647               boards[move][CASTLING][1] != NoRights   )
14648                 *p++ = boards[move][CASTLING][1] + AAA + 'A' - 'a';
14649            if(boards[move][CASTLING][5] != NoRights &&
14650               boards[move][CASTLING][3] != NoRights   )
14651                 *p++ = boards[move][CASTLING][3] + AAA;
14652            if(boards[move][CASTLING][5] != NoRights &&
14653               boards[move][CASTLING][4] != NoRights   )
14654                 *p++ = boards[move][CASTLING][4] + AAA;
14655      } else {
14656
14657         /* [HGM] write true castling rights */
14658         if( nrCastlingRights == 6 ) {
14659             if(boards[move][CASTLING][0] == BOARD_RGHT-1 &&
14660                boards[move][CASTLING][2] != NoRights  ) *p++ = 'K';
14661             if(boards[move][CASTLING][1] == BOARD_LEFT &&
14662                boards[move][CASTLING][2] != NoRights  ) *p++ = 'Q';
14663             if(boards[move][CASTLING][3] == BOARD_RGHT-1 &&
14664                boards[move][CASTLING][5] != NoRights  ) *p++ = 'k';
14665             if(boards[move][CASTLING][4] == BOARD_LEFT &&
14666                boards[move][CASTLING][5] != NoRights  ) *p++ = 'q';
14667         }
14668      }
14669      if (q == p) *p++ = '-'; /* No castling rights */
14670      *p++ = ' ';
14671   }
14672
14673   if(gameInfo.variant != VariantShogi    && gameInfo.variant != VariantXiangqi &&
14674      gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier && gameInfo.variant != VariantMakruk ) {
14675     /* En passant target square */
14676     if (move > backwardMostMove) {
14677         fromX = moveList[move - 1][0] - AAA;
14678         fromY = moveList[move - 1][1] - ONE;
14679         toX = moveList[move - 1][2] - AAA;
14680         toY = moveList[move - 1][3] - ONE;
14681         if (fromY == (whiteToPlay ? BOARD_HEIGHT-2 : 1) &&
14682             toY == (whiteToPlay ? BOARD_HEIGHT-4 : 3) &&
14683             boards[move][toY][toX] == (whiteToPlay ? BlackPawn : WhitePawn) &&
14684             fromX == toX) {
14685             /* 2-square pawn move just happened */
14686             *p++ = toX + AAA;
14687             *p++ = whiteToPlay ? '6'+BOARD_HEIGHT-8 : '3';
14688         } else {
14689             *p++ = '-';
14690         }
14691     } else if(move == backwardMostMove) {
14692         // [HGM] perhaps we should always do it like this, and forget the above?
14693         if((signed char)boards[move][EP_STATUS] >= 0) {
14694             *p++ = boards[move][EP_STATUS] + AAA;
14695             *p++ = whiteToPlay ? '6'+BOARD_HEIGHT-8 : '3';
14696         } else {
14697             *p++ = '-';
14698         }
14699     } else {
14700         *p++ = '-';
14701     }
14702     *p++ = ' ';
14703   }
14704   }
14705
14706     /* [HGM] find reversible plies */
14707     {   int i = 0, j=move;
14708
14709         if (appData.debugMode) { int k;
14710             fprintf(debugFP, "write FEN 50-move: %d %d %d\n", initialRulePlies, forwardMostMove, backwardMostMove);
14711             for(k=backwardMostMove; k<=forwardMostMove; k++)
14712                 fprintf(debugFP, "e%d. p=%d\n", k, (signed char)boards[k][EP_STATUS]);
14713
14714         }
14715
14716         while(j > backwardMostMove && (signed char)boards[j][EP_STATUS] <= EP_NONE) j--,i++;
14717         if( j == backwardMostMove ) i += initialRulePlies;
14718         sprintf(p, "%d ", i);
14719         p += i>=100 ? 4 : i >= 10 ? 3 : 2;
14720     }
14721     /* Fullmove number */
14722     sprintf(p, "%d", (move / 2) + 1);
14723
14724     return StrSave(buf);
14725 }
14726
14727 Boolean
14728 ParseFEN(board, blackPlaysFirst, fen)
14729     Board board;
14730      int *blackPlaysFirst;
14731      char *fen;
14732 {
14733     int i, j;
14734     char *p;
14735     int emptycount;
14736     ChessSquare piece;
14737
14738     p = fen;
14739
14740     /* [HGM] by default clear Crazyhouse holdings, if present */
14741     if(gameInfo.holdingsWidth) {
14742        for(i=0; i<BOARD_HEIGHT; i++) {
14743            board[i][0]             = EmptySquare; /* black holdings */
14744            board[i][BOARD_WIDTH-1] = EmptySquare; /* white holdings */
14745            board[i][1]             = (ChessSquare) 0; /* black counts */
14746            board[i][BOARD_WIDTH-2] = (ChessSquare) 0; /* white counts */
14747        }
14748     }
14749
14750     /* Piece placement data */
14751     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
14752         j = 0;
14753         for (;;) {
14754             if (*p == '/' || *p == ' ' || (*p == '[' && i == 0) ) {
14755                 if (*p == '/') p++;
14756                 emptycount = gameInfo.boardWidth - j;
14757                 while (emptycount--)
14758                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
14759                 break;
14760 #if(BOARD_FILES >= 10)
14761             } else if(*p=='x' || *p=='X') { /* [HGM] X means 10 */
14762                 p++; emptycount=10;
14763                 if (j + emptycount > gameInfo.boardWidth) return FALSE;
14764                 while (emptycount--)
14765                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
14766 #endif
14767             } else if (isdigit(*p)) {
14768                 emptycount = *p++ - '0';
14769                 while(isdigit(*p)) emptycount = 10*emptycount + *p++ - '0'; /* [HGM] allow > 9 */
14770                 if (j + emptycount > gameInfo.boardWidth) return FALSE;
14771                 while (emptycount--)
14772                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
14773             } else if (*p == '+' || isalpha(*p)) {
14774                 if (j >= gameInfo.boardWidth) return FALSE;
14775                 if(*p=='+') {
14776                     piece = CharToPiece(*++p);
14777                     if(piece == EmptySquare) return FALSE; /* unknown piece */
14778                     piece = (ChessSquare) (PROMOTED piece ); p++;
14779                     if(PieceToChar(piece) != '+') return FALSE; /* unpromotable piece */
14780                 } else piece = CharToPiece(*p++);
14781
14782                 if(piece==EmptySquare) return FALSE; /* unknown piece */
14783                 if(*p == '~') { /* [HGM] make it a promoted piece for Crazyhouse */
14784                     piece = (ChessSquare) (PROMOTED piece);
14785                     if(PieceToChar(piece) != '~') return FALSE; /* cannot be a promoted piece */
14786                     p++;
14787                 }
14788                 board[i][(j++)+gameInfo.holdingsWidth] = piece;
14789             } else {
14790                 return FALSE;
14791             }
14792         }
14793     }
14794     while (*p == '/' || *p == ' ') p++;
14795
14796     /* [HGM] look for Crazyhouse holdings here */
14797     while(*p==' ') p++;
14798     if( gameInfo.holdingsWidth && p[-1] == '/' || *p == '[') {
14799         if(*p == '[') p++;
14800         if(*p == '-' ) *p++; /* empty holdings */ else {
14801             if( !gameInfo.holdingsWidth ) return FALSE; /* no room to put holdings! */
14802             /* if we would allow FEN reading to set board size, we would   */
14803             /* have to add holdings and shift the board read so far here   */
14804             while( (piece = CharToPiece(*p) ) != EmptySquare ) {
14805                 *p++;
14806                 if((int) piece >= (int) BlackPawn ) {
14807                     i = (int)piece - (int)BlackPawn;
14808                     i = PieceToNumber((ChessSquare)i);
14809                     if( i >= gameInfo.holdingsSize ) return FALSE;
14810                     board[BOARD_HEIGHT-1-i][0] = piece; /* black holdings */
14811                     board[BOARD_HEIGHT-1-i][1]++;       /* black counts   */
14812                 } else {
14813                     i = (int)piece - (int)WhitePawn;
14814                     i = PieceToNumber((ChessSquare)i);
14815                     if( i >= gameInfo.holdingsSize ) return FALSE;
14816                     board[i][BOARD_WIDTH-1] = piece;    /* white holdings */
14817                     board[i][BOARD_WIDTH-2]++;          /* black holdings */
14818                 }
14819             }
14820         }
14821         if(*p == ']') *p++;
14822     }
14823
14824     while(*p == ' ') p++;
14825
14826     /* Active color */
14827     switch (*p++) {
14828       case 'w':
14829         *blackPlaysFirst = FALSE;
14830         break;
14831       case 'b':
14832         *blackPlaysFirst = TRUE;
14833         break;
14834       default:
14835         return FALSE;
14836     }
14837
14838     /* [HGM] We NO LONGER ignore the rest of the FEN notation */
14839     /* return the extra info in global variiables             */
14840
14841     /* set defaults in case FEN is incomplete */
14842     board[EP_STATUS] = EP_UNKNOWN;
14843     for(i=0; i<nrCastlingRights; i++ ) {
14844         board[CASTLING][i] =
14845             gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom ? NoRights : initialRights[i];
14846     }   /* assume possible unless obviously impossible */
14847     if(initialRights[0]!=NoRights && board[castlingRank[0]][initialRights[0]] != WhiteRook) board[CASTLING][0] = NoRights;
14848     if(initialRights[1]!=NoRights && board[castlingRank[1]][initialRights[1]] != WhiteRook) board[CASTLING][1] = NoRights;
14849     if(initialRights[2]!=NoRights && board[castlingRank[2]][initialRights[2]] != WhiteUnicorn
14850                                   && board[castlingRank[2]][initialRights[2]] != WhiteKing) board[CASTLING][2] = NoRights;
14851     if(initialRights[3]!=NoRights && board[castlingRank[3]][initialRights[3]] != BlackRook) board[CASTLING][3] = NoRights;
14852     if(initialRights[4]!=NoRights && board[castlingRank[4]][initialRights[4]] != BlackRook) board[CASTLING][4] = NoRights;
14853     if(initialRights[5]!=NoRights && board[castlingRank[5]][initialRights[5]] != BlackUnicorn
14854                                   && board[castlingRank[5]][initialRights[5]] != BlackKing) board[CASTLING][5] = NoRights;
14855     FENrulePlies = 0;
14856
14857     while(*p==' ') p++;
14858     if(nrCastlingRights) {
14859       if(*p=='K' || *p=='Q' || *p=='k' || *p=='q' || *p=='-') {
14860           /* castling indicator present, so default becomes no castlings */
14861           for(i=0; i<nrCastlingRights; i++ ) {
14862                  board[CASTLING][i] = NoRights;
14863           }
14864       }
14865       while(*p=='K' || *p=='Q' || *p=='k' || *p=='q' || *p=='-' ||
14866              (gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom) &&
14867              ( *p >= 'a' && *p < 'a' + gameInfo.boardWidth) ||
14868              ( *p >= 'A' && *p < 'A' + gameInfo.boardWidth)   ) {
14869         char c = *p++; int whiteKingFile=NoRights, blackKingFile=NoRights;
14870
14871         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) {
14872             if(board[BOARD_HEIGHT-1][i] == BlackKing) blackKingFile = i;
14873             if(board[0             ][i] == WhiteKing) whiteKingFile = i;
14874         }
14875         if(gameInfo.variant == VariantTwoKings || gameInfo.variant == VariantKnightmate)
14876             whiteKingFile = blackKingFile = BOARD_WIDTH >> 1; // for these variant scanning fails
14877         if(whiteKingFile == NoRights || board[0][whiteKingFile] != WhiteUnicorn
14878                                      && board[0][whiteKingFile] != WhiteKing) whiteKingFile = NoRights;
14879         if(blackKingFile == NoRights || board[BOARD_HEIGHT-1][blackKingFile] != BlackUnicorn
14880                                      && board[BOARD_HEIGHT-1][blackKingFile] != BlackKing) blackKingFile = NoRights;
14881         switch(c) {
14882           case'K':
14883               for(i=BOARD_RGHT-1; board[0][i]!=WhiteRook && i>whiteKingFile; i--);
14884               board[CASTLING][0] = i != whiteKingFile ? i : NoRights;
14885               board[CASTLING][2] = whiteKingFile;
14886               break;
14887           case'Q':
14888               for(i=BOARD_LEFT;  i<BOARD_RGHT && board[0][i]!=WhiteRook && i<whiteKingFile; i++);
14889               board[CASTLING][1] = i != whiteKingFile ? i : NoRights;
14890               board[CASTLING][2] = whiteKingFile;
14891               break;
14892           case'k':
14893               for(i=BOARD_RGHT-1; board[BOARD_HEIGHT-1][i]!=BlackRook && i>blackKingFile; i--);
14894               board[CASTLING][3] = i != blackKingFile ? i : NoRights;
14895               board[CASTLING][5] = blackKingFile;
14896               break;
14897           case'q':
14898               for(i=BOARD_LEFT; i<BOARD_RGHT && board[BOARD_HEIGHT-1][i]!=BlackRook && i<blackKingFile; i++);
14899               board[CASTLING][4] = i != blackKingFile ? i : NoRights;
14900               board[CASTLING][5] = blackKingFile;
14901           case '-':
14902               break;
14903           default: /* FRC castlings */
14904               if(c >= 'a') { /* black rights */
14905                   for(i=BOARD_LEFT; i<BOARD_RGHT; i++)
14906                     if(board[BOARD_HEIGHT-1][i] == BlackKing) break;
14907                   if(i == BOARD_RGHT) break;
14908                   board[CASTLING][5] = i;
14909                   c -= AAA;
14910                   if(board[BOARD_HEIGHT-1][c] <  BlackPawn ||
14911                      board[BOARD_HEIGHT-1][c] >= BlackKing   ) break;
14912                   if(c > i)
14913                       board[CASTLING][3] = c;
14914                   else
14915                       board[CASTLING][4] = c;
14916               } else { /* white rights */
14917                   for(i=BOARD_LEFT; i<BOARD_RGHT; i++)
14918                     if(board[0][i] == WhiteKing) break;
14919                   if(i == BOARD_RGHT) break;
14920                   board[CASTLING][2] = i;
14921                   c -= AAA - 'a' + 'A';
14922                   if(board[0][c] >= WhiteKing) break;
14923                   if(c > i)
14924                       board[CASTLING][0] = c;
14925                   else
14926                       board[CASTLING][1] = c;
14927               }
14928         }
14929       }
14930       for(i=0; i<nrCastlingRights; i++)
14931         if(board[CASTLING][i] != NoRights) initialRights[i] = board[CASTLING][i];
14932     if (appData.debugMode) {
14933         fprintf(debugFP, "FEN castling rights:");
14934         for(i=0; i<nrCastlingRights; i++)
14935         fprintf(debugFP, " %d", board[CASTLING][i]);
14936         fprintf(debugFP, "\n");
14937     }
14938
14939       while(*p==' ') p++;
14940     }
14941
14942     /* read e.p. field in games that know e.p. capture */
14943     if(gameInfo.variant != VariantShogi    && gameInfo.variant != VariantXiangqi &&
14944        gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier && gameInfo.variant != VariantMakruk ) {
14945       if(*p=='-') {
14946         p++; board[EP_STATUS] = EP_NONE;
14947       } else {
14948          char c = *p++ - AAA;
14949
14950          if(c < BOARD_LEFT || c >= BOARD_RGHT) return TRUE;
14951          if(*p >= '0' && *p <='9') *p++;
14952          board[EP_STATUS] = c;
14953       }
14954     }
14955
14956
14957     if(sscanf(p, "%d", &i) == 1) {
14958         FENrulePlies = i; /* 50-move ply counter */
14959         /* (The move number is still ignored)    */
14960     }
14961
14962     return TRUE;
14963 }
14964
14965 void
14966 EditPositionPasteFEN(char *fen)
14967 {
14968   if (fen != NULL) {
14969     Board initial_position;
14970
14971     if (!ParseFEN(initial_position, &blackPlaysFirst, fen)) {
14972       DisplayError(_("Bad FEN position in clipboard"), 0);
14973       return ;
14974     } else {
14975       int savedBlackPlaysFirst = blackPlaysFirst;
14976       EditPositionEvent();
14977       blackPlaysFirst = savedBlackPlaysFirst;
14978       CopyBoard(boards[0], initial_position);
14979       initialRulePlies = FENrulePlies; /* [HGM] copy FEN attributes as well */
14980       EditPositionDone(FALSE); // [HGM] fake: do not fake rights if we had FEN
14981       DisplayBothClocks();
14982       DrawPosition(FALSE, boards[currentMove]);
14983     }
14984   }
14985 }
14986
14987 static char cseq[12] = "\\   ";
14988
14989 Boolean set_cont_sequence(char *new_seq)
14990 {
14991     int len;
14992     Boolean ret;
14993
14994     // handle bad attempts to set the sequence
14995         if (!new_seq)
14996                 return 0; // acceptable error - no debug
14997
14998     len = strlen(new_seq);
14999     ret = (len > 0) && (len < sizeof(cseq));
15000     if (ret)
15001         strcpy(cseq, new_seq);
15002     else if (appData.debugMode)
15003         fprintf(debugFP, "Invalid continuation sequence \"%s\"  (maximum length is: %u)\n", new_seq, (unsigned) sizeof(cseq)-1);
15004     return ret;
15005 }
15006
15007 /*
15008     reformat a source message so words don't cross the width boundary.  internal
15009     newlines are not removed.  returns the wrapped size (no null character unless
15010     included in source message).  If dest is NULL, only calculate the size required
15011     for the dest buffer.  lp argument indicats line position upon entry, and it's
15012     passed back upon exit.
15013 */
15014 int wrap(char *dest, char *src, int count, int width, int *lp)
15015 {
15016     int len, i, ansi, cseq_len, line, old_line, old_i, old_len, clen;
15017
15018     cseq_len = strlen(cseq);
15019     old_line = line = *lp;
15020     ansi = len = clen = 0;
15021
15022     for (i=0; i < count; i++)
15023     {
15024         if (src[i] == '\033')
15025             ansi = 1;
15026
15027         // if we hit the width, back up
15028         if (!ansi && (line >= width) && src[i] != '\n' && src[i] != ' ')
15029         {
15030             // store i & len in case the word is too long
15031             old_i = i, old_len = len;
15032
15033             // find the end of the last word
15034             while (i && src[i] != ' ' && src[i] != '\n')
15035             {
15036                 i--;
15037                 len--;
15038             }
15039
15040             // word too long?  restore i & len before splitting it
15041             if ((old_i-i+clen) >= width)
15042             {
15043                 i = old_i;
15044                 len = old_len;
15045             }
15046
15047             // extra space?
15048             if (i && src[i-1] == ' ')
15049                 len--;
15050
15051             if (src[i] != ' ' && src[i] != '\n')
15052             {
15053                 i--;
15054                 if (len)
15055                     len--;
15056             }
15057
15058             // now append the newline and continuation sequence
15059             if (dest)
15060                 dest[len] = '\n';
15061             len++;
15062             if (dest)
15063                 strncpy(dest+len, cseq, cseq_len);
15064             len += cseq_len;
15065             line = cseq_len;
15066             clen = cseq_len;
15067             continue;
15068         }
15069
15070         if (dest)
15071             dest[len] = src[i];
15072         len++;
15073         if (!ansi)
15074             line++;
15075         if (src[i] == '\n')
15076             line = 0;
15077         if (src[i] == 'm')
15078             ansi = 0;
15079     }
15080     if (dest && appData.debugMode)
15081     {
15082         fprintf(debugFP, "wrap(count:%d,width:%d,line:%d,len:%d,*lp:%d,src: ",
15083             count, width, line, len, *lp);
15084         show_bytes(debugFP, src, count);
15085         fprintf(debugFP, "\ndest: ");
15086         show_bytes(debugFP, dest, len);
15087         fprintf(debugFP, "\n");
15088     }
15089     *lp = dest ? line : old_line;
15090
15091     return len;
15092 }
15093
15094 // [HGM] vari: routines for shelving variations
15095
15096 void
15097 PushTail(int firstMove, int lastMove)
15098 {
15099         int i, j, nrMoves = lastMove - firstMove;
15100
15101         if(appData.icsActive) { // only in local mode
15102                 forwardMostMove = currentMove; // mimic old ICS behavior
15103                 return;
15104         }
15105         if(storedGames >= MAX_VARIATIONS-1) return;
15106
15107         // push current tail of game on stack
15108         savedResult[storedGames] = gameInfo.result;
15109         savedDetails[storedGames] = gameInfo.resultDetails;
15110         gameInfo.resultDetails = NULL;
15111         savedFirst[storedGames] = firstMove;
15112         savedLast [storedGames] = lastMove;
15113         savedFramePtr[storedGames] = framePtr;
15114         framePtr -= nrMoves; // reserve space for the boards
15115         for(i=nrMoves; i>=1; i--) { // copy boards to stack, working downwards, in case of overlap
15116             CopyBoard(boards[framePtr+i], boards[firstMove+i]);
15117             for(j=0; j<MOVE_LEN; j++)
15118                 moveList[framePtr+i][j] = moveList[firstMove+i-1][j];
15119             for(j=0; j<2*MOVE_LEN; j++)
15120                 parseList[framePtr+i][j] = parseList[firstMove+i-1][j];
15121             timeRemaining[0][framePtr+i] = timeRemaining[0][firstMove+i];
15122             timeRemaining[1][framePtr+i] = timeRemaining[1][firstMove+i];
15123             pvInfoList[framePtr+i] = pvInfoList[firstMove+i-1];
15124             pvInfoList[firstMove+i-1].depth = 0;
15125             commentList[framePtr+i] = commentList[firstMove+i];
15126             commentList[firstMove+i] = NULL;
15127         }
15128
15129         storedGames++;
15130         forwardMostMove = firstMove; // truncate game so we can start variation
15131         if(storedGames == 1) GreyRevert(FALSE);
15132 }
15133
15134 Boolean
15135 PopTail(Boolean annotate)
15136 {
15137         int i, j, nrMoves;
15138         char buf[8000], moveBuf[20];
15139
15140         if(appData.icsActive) return FALSE; // only in local mode
15141         if(!storedGames) return FALSE; // sanity
15142         CommentPopDown(); // make sure no stale variation comments to the destroyed line can remain open
15143
15144         storedGames--;
15145         ToNrEvent(savedFirst[storedGames]); // sets currentMove
15146         nrMoves = savedLast[storedGames] - currentMove;
15147         if(annotate) {
15148                 int cnt = 10;
15149                 if(!WhiteOnMove(currentMove)) sprintf(buf, "(%d...", currentMove+2>>1);
15150                 else strcpy(buf, "(");
15151                 for(i=currentMove; i<forwardMostMove; i++) {
15152                         if(WhiteOnMove(i))
15153                              sprintf(moveBuf, " %d. %s", i+2>>1, SavePart(parseList[i]));
15154                         else sprintf(moveBuf, " %s", SavePart(parseList[i]));
15155                         strcat(buf, moveBuf);
15156                         if(commentList[i]) { strcat(buf, " "); strcat(buf, commentList[i]); }
15157                         if(!--cnt) { strcat(buf, "\n"); cnt = 10; }
15158                 }
15159                 strcat(buf, ")");
15160         }
15161         for(i=1; i<=nrMoves; i++) { // copy last variation back
15162             CopyBoard(boards[currentMove+i], boards[framePtr+i]);
15163             for(j=0; j<MOVE_LEN; j++)
15164                 moveList[currentMove+i-1][j] = moveList[framePtr+i][j];
15165             for(j=0; j<2*MOVE_LEN; j++)
15166                 parseList[currentMove+i-1][j] = parseList[framePtr+i][j];
15167             timeRemaining[0][currentMove+i] = timeRemaining[0][framePtr+i];
15168             timeRemaining[1][currentMove+i] = timeRemaining[1][framePtr+i];
15169             pvInfoList[currentMove+i-1] = pvInfoList[framePtr+i];
15170             if(commentList[currentMove+i]) free(commentList[currentMove+i]);
15171             commentList[currentMove+i] = commentList[framePtr+i];
15172             commentList[framePtr+i] = NULL;
15173         }
15174         if(annotate) AppendComment(currentMove+1, buf, FALSE);
15175         framePtr = savedFramePtr[storedGames];
15176         gameInfo.result = savedResult[storedGames];
15177         if(gameInfo.resultDetails != NULL) {
15178             free(gameInfo.resultDetails);
15179       }
15180         gameInfo.resultDetails = savedDetails[storedGames];
15181         forwardMostMove = currentMove + nrMoves;
15182         if(storedGames == 0) GreyRevert(TRUE);
15183         return TRUE;
15184 }
15185
15186 void
15187 CleanupTail()
15188 {       // remove all shelved variations
15189         int i;
15190         for(i=0; i<storedGames; i++) {
15191             if(savedDetails[i])
15192                 free(savedDetails[i]);
15193             savedDetails[i] = NULL;
15194         }
15195         for(i=framePtr; i<MAX_MOVES; i++) {
15196                 if(commentList[i]) free(commentList[i]);
15197                 commentList[i] = NULL;
15198         }
15199         framePtr = MAX_MOVES-1;
15200         storedGames = 0;
15201 }
15202
15203 void
15204 LoadVariation(int index, char *text)
15205 {       // [HGM] vari: shelve previous line and load new variation, parsed from text around text[index]
15206         char *p = text, *start = NULL, *end = NULL, wait = NULLCHAR;
15207         int level = 0, move;
15208
15209         if(gameMode != EditGame && gameMode != AnalyzeMode) return;
15210         // first find outermost bracketing variation
15211         while(*p) { // hope I got this right... Non-nesting {} and [] can screen each other and nesting ()
15212             if(!wait) { // while inside [] pr {}, ignore everyting except matching closing ]}
15213                 if(*p == '{') wait = '}'; else
15214                 if(*p == '[') wait = ']'; else
15215                 if(*p == '(' && level++ == 0 && p-text < index) start = p+1;
15216                 if(*p == ')' && level > 0 && --level == 0 && p-text > index && end == NULL) end = p-1;
15217             }
15218             if(*p == wait) wait = NULLCHAR; // closing ]} found
15219             p++;
15220         }
15221         if(!start || !end) return; // no variation found, or syntax error in PGN: ignore click
15222         if(appData.debugMode) fprintf(debugFP, "at move %d load variation '%s'\n", currentMove, start);
15223         end[1] = NULLCHAR; // clip off comment beyond variation
15224         ToNrEvent(currentMove-1);
15225         PushTail(currentMove, forwardMostMove); // shelve main variation. This truncates game
15226         // kludge: use ParsePV() to append variation to game
15227         move = currentMove;
15228         ParsePV(start, TRUE);
15229         forwardMostMove = endPV; endPV = -1; currentMove = move; // cleanup what ParsePV did
15230         ClearPremoveHighlights();
15231         CommentPopDown();
15232         ToNrEvent(currentMove+1);
15233 }
15234