backend.c

   1 /*
   2  * backend.c -- Common back end for X and Windows NT versions of
   3  *
   4  * Copyright 1991 by Digital Equipment Corporation, Maynard,
   5  * Massachusetts.
   6  *
   7  * Enhancements Copyright 1992-2001, 2002, 2003, 2004, 2005, 2006,
   8  * 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   9  *
  10  * Enhancements Copyright 2005 Alessandro Scotti
  11  *
  12  * The following terms apply to Digital Equipment Corporation's copyright
  13  * interest in XBoard:
  14  * ------------------------------------------------------------------------
  15  * All Rights Reserved
  16  *
  17  * Permission to use, copy, modify, and distribute this software and its
  18  * documentation for any purpose and without fee is hereby granted,
  19  * provided that the above copyright notice appear in all copies and that
  20  * both that copyright notice and this permission notice appear in
  21  * supporting documentation, and that the name of Digital not be
  22  * used in advertising or publicity pertaining to distribution of the
  23  * software without specific, written prior permission.
  24  *
  25  * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  26  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  27  * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  28  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  29  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  30  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  31  * SOFTWARE.
  32  * ------------------------------------------------------------------------
  33  *
  34  * The following terms apply to the enhanced version of XBoard
  35  * distributed by the Free Software Foundation:
  36  * ------------------------------------------------------------------------
  37  *
  38  * GNU XBoard is free software: you can redistribute it and/or modify
  39  * it under the terms of the GNU General Public License as published by
  40  * the Free Software Foundation, either version 3 of the License, or (at
  41  * your option) any later version.
  42  *
  43  * GNU XBoard is distributed in the hope that it will be useful, but
  44  * WITHOUT ANY WARRANTY; without even the implied warranty of
  45  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  46  * General Public License for more details.
  47  *
  48  * You should have received a copy of the GNU General Public License
  49  * along with this program. If not, see http://www.gnu.org/licenses/.  *
  50  *
  51  *------------------------------------------------------------------------
  52  ** See the file ChangeLog for a revision history.  */
  53
  54 /* [AS] Also useful here for debugging */
  55 #ifdef WIN32
  56 #include <windows.h>
  57
  58 #define DoSleep( n ) if( (n) != 0 ) Sleep( (n) );
  59
  60 #else
  61
  62 #define DoSleep( n ) if( (n) >= 0) sleep(n)
  63
  64 #endif
  65
  66 #include "config.h"
  67
  68 #include <assert.h>
  69 #include <stdio.h>
  70 #include <ctype.h>
  71 #include <errno.h>
  72 #include <sys/types.h>
  73 #include <sys/stat.h>
  74 #include <math.h>
  75 #include <ctype.h>
  76
  77 #if STDC_HEADERS
  78 # include <stdlib.h>
  79 # include <string.h>
  80 # include <stdarg.h>
  81 #else /* not STDC_HEADERS */
  82 # if HAVE_STRING_H
  83 #  include <string.h>
  84 # else /* not HAVE_STRING_H */
  85 #  include <strings.h>
  86 # endif /* not HAVE_STRING_H */
  87 #endif /* not STDC_HEADERS */
  88
  89 #if HAVE_SYS_FCNTL_H
  90 # include <sys/fcntl.h>
  91 #else /* not HAVE_SYS_FCNTL_H */
  92 # if HAVE_FCNTL_H
  93 #  include <fcntl.h>
  94 # endif /* HAVE_FCNTL_H */
  95 #endif /* not HAVE_SYS_FCNTL_H */
  96
  97 #if TIME_WITH_SYS_TIME
  98 # include <sys/time.h>
  99 # include <time.h>
 100 #else
 101 # if HAVE_SYS_TIME_H
 102 #  include <sys/time.h>
 103 # else
 104 #  include <time.h>
 105 # endif
 106 #endif
 107
 108 #if defined(_amigados) && !defined(__GNUC__)
 109 struct timezone {
 110     int tz_minuteswest;
 111     int tz_dsttime;
 112 };
 113 extern int gettimeofday(struct timeval *, struct timezone *);
 114 #endif
 115
 116 #if HAVE_UNISTD_H
 117 # include <unistd.h>
 118 #endif
 119
 120 #include "common.h"
 121 #include "frontend.h"
 122 #include "backend.h"
 123 #include "parser.h"
 124 #include "moves.h"
 125 #if ZIPPY
 126 # include "zippy.h"
 127 #endif
 128 #include "backendz.h"
 129 #include "gettext.h"
 130
 131 #ifdef ENABLE_NLS
 132 # define _(s) gettext (s)
 133 # define N_(s) gettext_noop (s)
 134 #else
 135 # define _(s) (s)
 136 # define N_(s) s
 137 #endif
 138
 139
 140 /* A point in time */
 141 typedef struct {
 142     long sec;  /* Assuming this is >= 32 bits */
 143     int ms;    /* Assuming this is >= 16 bits */
 144 } TimeMark;
 145
 146 int establish P((void));
 147 void read_from_player P((InputSourceRef isr, VOIDSTAR closure,
 148                          char *buf, int count, int error));
 149 void read_from_ics P((InputSourceRef isr, VOIDSTAR closure,
 150                       char *buf, int count, int error));
 151 void ics_printf P((char *format, ...));
 152 void SendToICS P((char *s));
 153 void SendToICSDelayed P((char *s, long msdelay));
 154 void SendMoveToICS P((ChessMove moveType, int fromX, int fromY,
 155                       int toX, int toY));
 156 void HandleMachineMove P((char *message, ChessProgramState *cps));
 157 int AutoPlayOneMove P((void));
 158 int LoadGameOneMove P((ChessMove readAhead));
 159 int LoadGameFromFile P((char *filename, int n, char *title, int useList));
 160 int LoadPositionFromFile P((char *filename, int n, char *title));
 161 int SavePositionToFile P((char *filename));
 162 void ApplyMove P((int fromX, int fromY, int toX, int toY, int promoChar,
 163                                                                                 Board board));
 164 void MakeMove P((int fromX, int fromY, int toX, int toY, int promoChar));
 165 void ShowMove P((int fromX, int fromY, int toX, int toY));
 166 int FinishMove P((ChessMove moveType, int fromX, int fromY, int toX, int toY,
 167                    /*char*/int promoChar));
 168 void BackwardInner P((int target));
 169 void ForwardInner P((int target));
 170 int Adjudicate P((ChessProgramState *cps));
 171 void GameEnds P((ChessMove result, char *resultDetails, int whosays));
 172 void EditPositionDone P((Boolean fakeRights));
 173 void PrintOpponents P((FILE *fp));
 174 void PrintPosition P((FILE *fp, int move));
 175 void StartChessProgram P((ChessProgramState *cps));
 176 void SendToProgram P((char *message, ChessProgramState *cps));
 177 void SendMoveToProgram P((int moveNum, ChessProgramState *cps));
 178 void ReceiveFromProgram P((InputSourceRef isr, VOIDSTAR closure,
 179                            char *buf, int count, int error));
 180 void SendTimeControl P((ChessProgramState *cps,
 181                         int mps, long tc, int inc, int sd, int st));
 182 char *TimeControlTagValue P((void));
 183 void Attention P((ChessProgramState *cps));
 184 void FeedMovesToProgram P((ChessProgramState *cps, int upto));
 185 void ResurrectChessProgram P((void));
 186 void DisplayComment P((int moveNumber, char *text));
 187 void DisplayMove P((int moveNumber));
 188
 189 void ParseGameHistory P((char *game));
 190 void ParseBoard12 P((char *string));
 191 void KeepAlive P((void));
 192 void StartClocks P((void));
 193 void SwitchClocks P((int nr));
 194 void StopClocks P((void));
 195 void ResetClocks P((void));
 196 char *PGNDate P((void));
 197 void SetGameInfo P((void));
 198 Boolean ParseFEN P((Board board, int *blackPlaysFirst, char *fen));
 199 int RegisterMove P((void));
 200 void MakeRegisteredMove P((void));
 201 void TruncateGame P((void));
 202 int looking_at P((char *, int *, char *));
 203 void CopyPlayerNameIntoFileName P((char **, char *));
 204 char *SavePart P((char *));
 205 int SaveGameOldStyle P((FILE *));
 206 int SaveGamePGN P((FILE *));
 207 void GetTimeMark P((TimeMark *));
 208 long SubtractTimeMarks P((TimeMark *, TimeMark *));
 209 int CheckFlags P((void));
 210 long NextTickLength P((long));
 211 void CheckTimeControl P((void));
 212 void show_bytes P((FILE *, char *, int));
 213 int string_to_rating P((char *str));
 214 void ParseFeatures P((char* args, ChessProgramState *cps));
 215 void InitBackEnd3 P((void));
 216 void FeatureDone P((ChessProgramState* cps, int val));
 217 void InitChessProgram P((ChessProgramState *cps, int setup));
 218 void OutputKibitz(int window, char *text);
 219 int PerpetualChase(int first, int last);
 220 int EngineOutputIsUp();
 221 void InitDrawingSizes(int x, int y);
 222
 223 #ifdef WIN32
 224        extern void ConsoleCreate();
 225 #endif
 226
 227 ChessProgramState *WhitePlayer();
 228 void InsertIntoMemo P((int which, char *text)); // [HGM] kibitz: in engineo.c
 229 int VerifyDisplayMode P(());
 230
 231 char *GetInfoFromComment( int, char * ); // [HGM] PV time: returns stripped comment
 232 void InitEngineUCI( const char * iniDir, ChessProgramState * cps ); // [HGM] moved here from winboard.c
 233 char *ProbeBook P((int moveNr, char *book)); // [HGM] book: returns a book move
 234 char *SendMoveToBookUser P((int nr, ChessProgramState *cps, int initial)); // [HGM] book
 235 void ics_update_width P((int new_width));
 236 extern char installDir[MSG_SIZ];
 237
 238 extern int tinyLayout, smallLayout;
 239 ChessProgramStats programStats;
 240 char lastPV[2][2*MSG_SIZ]; /* [HGM] pv: last PV in thinking output of each engine */
 241 int endPV = -1;
 242 static int exiting = 0; /* [HGM] moved to top */
 243 static int setboardSpoiledMachineBlack = 0 /*, errorExitFlag = 0*/;
 244 int startedFromPositionFile = FALSE; Board filePosition;       /* [HGM] loadPos */
 245 Board partnerBoard;     /* [HGM] bughouse: for peeking at partner game          */
 246 int partnerHighlight[2];
 247 Boolean partnerBoardValid = 0;
 248 char partnerStatus[MSG_SIZ];
 249 Boolean partnerUp;
 250 Boolean originalFlip;
 251 Boolean twoBoards = 0;
 252 char endingGame = 0;    /* [HGM] crash: flag to prevent recursion of GameEnds() */
 253 int whiteNPS, blackNPS; /* [HGM] nps: for easily making clocks aware of NPS     */
 254 VariantClass currentlyInitializedVariant; /* [HGM] variantswitch */
 255 int lastIndex = 0;      /* [HGM] autoinc: last game/position used in match mode */
 256 Boolean connectionAlive;/* [HGM] alive: ICS connection status from probing      */
 257 int opponentKibitzes;
 258 int lastSavedGame; /* [HGM] save: ID of game */
 259 char chatPartner[MAX_CHAT][MSG_SIZ]; /* [HGM] chat: list of chatting partners */
 260 extern int chatCount;
 261 int chattingPartner;
 262 char marker[BOARD_RANKS][BOARD_FILES]; /* [HGM] marks for target squares */
 263
 264 /* States for ics_getting_history */
 265 #define H_FALSE 0
 266 #define H_REQUESTED 1
 267 #define H_GOT_REQ_HEADER 2
 268 #define H_GOT_UNREQ_HEADER 3
 269 #define H_GETTING_MOVES 4
 270 #define H_GOT_UNWANTED_HEADER 5
 271
 272 /* whosays values for GameEnds */
 273 #define GE_ICS 0
 274 #define GE_ENGINE 1
 275 #define GE_PLAYER 2
 276 #define GE_FILE 3
 277 #define GE_XBOARD 4
 278 #define GE_ENGINE1 5
 279 #define GE_ENGINE2 6
 280
 281 /* Maximum number of games in a cmail message */
 282 #define CMAIL_MAX_GAMES 20
 283
 284 /* Different types of move when calling RegisterMove */
 285 #define CMAIL_MOVE   0
 286 #define CMAIL_RESIGN 1
 287 #define CMAIL_DRAW   2
 288 #define CMAIL_ACCEPT 3
 289
 290 /* Different types of result to remember for each game */
 291 #define CMAIL_NOT_RESULT 0
 292 #define CMAIL_OLD_RESULT 1
 293 #define CMAIL_NEW_RESULT 2
 294
 295 /* Telnet protocol constants */
 296 #define TN_WILL 0373
 297 #define TN_WONT 0374
 298 #define TN_DO   0375
 299 #define TN_DONT 0376
 300 #define TN_IAC  0377
 301 #define TN_ECHO 0001
 302 #define TN_SGA  0003
 303 #define TN_PORT 23
 304
 305 /* [AS] */
 306 static char * safeStrCpy( char * dst, const char * src, size_t count )
 307 {
 308     assert( dst != NULL );
 309     assert( src != NULL );
 310     assert( count > 0 );
 311
 312     strncpy( dst, src, count );
 313     dst[ count-1 ] = '\0';
 314     return dst;
 315 }
 316
 317 /* Some compiler can't cast u64 to double
 318  * This function do the job for us:
 319
 320  * We use the highest bit for cast, this only
 321  * works if the highest bit is not
 322  * in use (This should not happen)
 323  *
 324  * We used this for all compiler
 325  */
 326 double
 327 u64ToDouble(u64 value)
 328 {
 329   double r;
 330   u64 tmp = value & u64Const(0x7fffffffffffffff);
 331   r = (double)(s64)tmp;
 332   if (value & u64Const(0x8000000000000000))
 333        r +=  9.2233720368547758080e18; /* 2^63 */
 334  return r;
 335 }
 336
 337 /* Fake up flags for now, as we aren't keeping track of castling
 338    availability yet. [HGM] Change of logic: the flag now only
 339    indicates the type of castlings allowed by the rule of the game.
 340    The actual rights themselves are maintained in the array
 341    castlingRights, as part of the game history, and are not probed
 342    by this function.
 343  */
 344 int
 345 PosFlags(index)
 346 {
 347   int flags = F_ALL_CASTLE_OK;
 348   if ((index % 2) == 0) flags |= F_WHITE_ON_MOVE;
 349   switch (gameInfo.variant) {
 350   case VariantSuicide:
 351     flags &= ~F_ALL_CASTLE_OK;
 352   case VariantGiveaway:         // [HGM] moved this case label one down: seems Giveaway does have castling on ICC!
 353     flags |= F_IGNORE_CHECK;
 354   case VariantLosers:
 355     flags |= F_MANDATORY_CAPTURE; //[HGM] losers: sets flag so TestLegality rejects non-capts if capts exist
 356     break;
 357   case VariantAtomic:
 358     flags |= F_IGNORE_CHECK | F_ATOMIC_CAPTURE;
 359     break;
 360   case VariantKriegspiel:
 361     flags |= F_KRIEGSPIEL_CAPTURE;
 362     break;
 363   case VariantCapaRandom:
 364   case VariantFischeRandom:
 365     flags |= F_FRC_TYPE_CASTLING; /* [HGM] enable this through flag */
 366   case VariantNoCastle:
 367   case VariantShatranj:
 368   case VariantCourier:
 369   case VariantMakruk:
 370     flags &= ~F_ALL_CASTLE_OK;
 371     break;
 372   default:
 373     break;
 374   }
 375   return flags;
 376 }
 377
 378 FILE *gameFileFP, *debugFP;
 379
 380 /*
 381     [AS] Note: sometimes, the sscanf() function is used to parse the input
 382     into a fixed-size buffer. Because of this, we must be prepared to
 383     receive strings as long as the size of the input buffer, which is currently
 384     set to 4K for Windows and 8K for the rest.
 385     So, we must either allocate sufficiently large buffers here, or
 386     reduce the size of the input buffer in the input reading part.
 387 */
 388
 389 char cmailMove[CMAIL_MAX_GAMES][MOVE_LEN], cmailMsg[MSG_SIZ];
 390 char bookOutput[MSG_SIZ*10], thinkOutput[MSG_SIZ*10], lastHint[MSG_SIZ];
 391 char thinkOutput1[MSG_SIZ*10];
 392
 393 ChessProgramState first, second;
 394
 395 /* premove variables */
 396 int premoveToX = 0;
 397 int premoveToY = 0;
 398 int premoveFromX = 0;
 399 int premoveFromY = 0;
 400 int premovePromoChar = 0;
 401 int gotPremove = 0;
 402 Boolean alarmSounded;
 403 /* end premove variables */
 404
 405 char *ics_prefix = "$";
 406 int ics_type = ICS_GENERIC;
 407
 408 int currentMove = 0, forwardMostMove = 0, backwardMostMove = 0;
 409 int pauseExamForwardMostMove = 0;
 410 int nCmailGames = 0, nCmailResults = 0, nCmailMovesRegistered = 0;
 411 int cmailMoveRegistered[CMAIL_MAX_GAMES], cmailResult[CMAIL_MAX_GAMES];
 412 int cmailMsgLoaded = FALSE, cmailMailedMove = FALSE;
 413 int cmailOldMove = -1, firstMove = TRUE, flipView = FALSE;
 414 int blackPlaysFirst = FALSE, startedFromSetupPosition = FALSE;
 415 int searchTime = 0, pausing = FALSE, pauseExamInvalid = FALSE;
 416 int whiteFlag = FALSE, blackFlag = FALSE;
 417 int userOfferedDraw = FALSE;
 418 int ics_user_moved = 0, ics_gamenum = -1, ics_getting_history = H_FALSE;
 419 int matchMode = FALSE, hintRequested = FALSE, bookRequested = FALSE;
 420 int cmailMoveType[CMAIL_MAX_GAMES];
 421 long ics_clock_paused = 0;
 422 ProcRef icsPR = NoProc, cmailPR = NoProc;
 423 InputSourceRef telnetISR = NULL, fromUserISR = NULL, cmailISR = NULL;
 424 GameMode gameMode = BeginningOfGame;
 425 char moveList[MAX_MOVES][MOVE_LEN], parseList[MAX_MOVES][MOVE_LEN * 2];
 426 char *commentList[MAX_MOVES], *cmailCommentList[CMAIL_MAX_GAMES];
 427 ChessProgramStats_Move pvInfoList[MAX_MOVES]; /* [AS] Info about engine thinking */
 428 int hiddenThinkOutputState = 0; /* [AS] */
 429 int adjudicateLossThreshold = 0; /* [AS] Automatic adjudication */
 430 int adjudicateLossPlies = 6;
 431 char white_holding[64], black_holding[64];
 432 TimeMark lastNodeCountTime;
 433 long lastNodeCount=0;
 434 int have_sent_ICS_logon = 0;
 435 int movesPerSession;
 436 long whiteTimeRemaining, blackTimeRemaining, timeControl, timeIncrement;
 437 long timeControl_2; /* [AS] Allow separate time controls */
 438 char *fullTimeControlString = NULL; /* [HGM] secondary TC: merge of MPS, TC and inc */
 439 long timeRemaining[2][MAX_MOVES];
 440 int matchGame = 0;
 441 TimeMark programStartTime;
 442 char ics_handle[MSG_SIZ];
 443 int have_set_title = 0;
 444
 445 /* animateTraining preserves the state of appData.animate
 446  * when Training mode is activated. This allows the
 447  * response to be animated when appData.animate == TRUE and
 448  * appData.animateDragging == TRUE.
 449  */
 450 Boolean animateTraining;
 451
 452 GameInfo gameInfo;
 453
 454 AppData appData;
 455
 456 Board boards[MAX_MOVES];
 457 /* [HGM] Following 7 needed for accurate legality tests: */
 458 signed char  castlingRank[BOARD_FILES]; // and corresponding ranks
 459 signed char  initialRights[BOARD_FILES];
 460 int   nrCastlingRights; // For TwoKings, or to implement castling-unknown status
 461 int   initialRulePlies, FENrulePlies;
 462 FILE  *serverMoves = NULL; // next two for broadcasting (/serverMoves option)
 463 int loadFlag = 0;
 464 int shuffleOpenings;
 465 int mute; // mute all sounds
 466
 467 // [HGM] vari: next 12 to save and restore variations
 468 #define MAX_VARIATIONS 10
 469 int framePtr = MAX_MOVES-1; // points to free stack entry
 470 int storedGames = 0;
 471 int savedFirst[MAX_VARIATIONS];
 472 int savedLast[MAX_VARIATIONS];
 473 int savedFramePtr[MAX_VARIATIONS];
 474 char *savedDetails[MAX_VARIATIONS];
 475 ChessMove savedResult[MAX_VARIATIONS];
 476
 477 void PushTail P((int firstMove, int lastMove));
 478 Boolean PopTail P((Boolean annotate));
 479 void CleanupTail P((void));
 480
 481 ChessSquare  FIDEArray[2][BOARD_FILES] = {
 482     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 483         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 484     { BlackRook, BlackKnight, BlackBishop, BlackQueen,
 485         BlackKing, BlackBishop, BlackKnight, BlackRook }
 486 };
 487
 488 ChessSquare twoKingsArray[2][BOARD_FILES] = {
 489     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 490         WhiteKing, WhiteKing, WhiteKnight, WhiteRook },
 491     { BlackRook, BlackKnight, BlackBishop, BlackQueen,
 492         BlackKing, BlackKing, BlackKnight, BlackRook }
 493 };
 494
 495 ChessSquare  KnightmateArray[2][BOARD_FILES] = {
 496     { WhiteRook, WhiteMan, WhiteBishop, WhiteQueen,
 497         WhiteUnicorn, WhiteBishop, WhiteMan, WhiteRook },
 498     { BlackRook, BlackMan, BlackBishop, BlackQueen,
 499         BlackUnicorn, BlackBishop, BlackMan, BlackRook }
 500 };
 501
 502 ChessSquare fairyArray[2][BOARD_FILES] = { /* [HGM] Queen side differs from King side */
 503     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen,
 504         WhiteKing, WhiteBishop, WhiteKnight, WhiteRook },
 505     { BlackLance, BlackAlfil, BlackMarshall, BlackAngel,
 506         BlackKing, BlackMarshall, BlackAlfil, BlackLance }
 507 };
 508
 509 ChessSquare ShatranjArray[2][BOARD_FILES] = { /* [HGM] (movGen knows about Shatranj Q and P) */
 510     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteKing,
 511         WhiteFerz, WhiteAlfil, WhiteKnight, WhiteRook },
 512     { BlackRook, BlackKnight, BlackAlfil, BlackKing,
 513         BlackFerz, BlackAlfil, BlackKnight, BlackRook }
 514 };
 515
 516 ChessSquare makrukArray[2][BOARD_FILES] = { /* [HGM] (movGen knows about Shatranj Q and P) */
 517     { WhiteRook, WhiteKnight, WhiteMan, WhiteKing,
 518         WhiteFerz, WhiteMan, WhiteKnight, WhiteRook },
 519     { BlackRook, BlackKnight, BlackMan, BlackFerz,
 520         BlackKing, BlackMan, BlackKnight, BlackRook }
 521 };
 522
 523
 524 #if (BOARD_FILES>=10)
 525 ChessSquare ShogiArray[2][BOARD_FILES] = {
 526     { WhiteQueen, WhiteKnight, WhiteFerz, WhiteWazir,
 527         WhiteKing, WhiteWazir, WhiteFerz, WhiteKnight, WhiteQueen },
 528     { BlackQueen, BlackKnight, BlackFerz, BlackWazir,
 529         BlackKing, BlackWazir, BlackFerz, BlackKnight, BlackQueen }
 530 };
 531
 532 ChessSquare XiangqiArray[2][BOARD_FILES] = {
 533     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteFerz,
 534         WhiteWazir, WhiteFerz, WhiteAlfil, WhiteKnight, WhiteRook },
 535     { BlackRook, BlackKnight, BlackAlfil, BlackFerz,
 536         BlackWazir, BlackFerz, BlackAlfil, BlackKnight, BlackRook }
 537 };
 538
 539 ChessSquare CapablancaArray[2][BOARD_FILES] = {
 540     { WhiteRook, WhiteKnight, WhiteAngel, WhiteBishop, WhiteQueen,
 541         WhiteKing, WhiteBishop, WhiteMarshall, WhiteKnight, WhiteRook },
 542     { BlackRook, BlackKnight, BlackAngel, BlackBishop, BlackQueen,
 543         BlackKing, BlackBishop, BlackMarshall, BlackKnight, BlackRook }
 544 };
 545
 546 ChessSquare GreatArray[2][BOARD_FILES] = {
 547     { WhiteDragon, WhiteKnight, WhiteAlfil, WhiteGrasshopper, WhiteKing,
 548         WhiteSilver, WhiteCardinal, WhiteAlfil, WhiteKnight, WhiteDragon },
 549     { BlackDragon, BlackKnight, BlackAlfil, BlackGrasshopper, BlackKing,
 550         BlackSilver, BlackCardinal, BlackAlfil, BlackKnight, BlackDragon },
 551 };
 552
 553 ChessSquare JanusArray[2][BOARD_FILES] = {
 554     { WhiteRook, WhiteAngel, WhiteKnight, WhiteBishop, WhiteKing,
 555         WhiteQueen, WhiteBishop, WhiteKnight, WhiteAngel, WhiteRook },
 556     { BlackRook, BlackAngel, BlackKnight, BlackBishop, BlackKing,
 557         BlackQueen, BlackBishop, BlackKnight, BlackAngel, BlackRook }
 558 };
 559
 560 #ifdef GOTHIC
 561 ChessSquare GothicArray[2][BOARD_FILES] = {
 562     { WhiteRook, WhiteKnight, WhiteBishop, WhiteQueen, WhiteMarshall,
 563         WhiteKing, WhiteAngel, WhiteBishop, WhiteKnight, WhiteRook },
 564     { BlackRook, BlackKnight, BlackBishop, BlackQueen, BlackMarshall,
 565         BlackKing, BlackAngel, BlackBishop, BlackKnight, BlackRook }
 566 };
 567 #else // !GOTHIC
 568 #define GothicArray CapablancaArray
 569 #endif // !GOTHIC
 570
 571 #ifdef FALCON
 572 ChessSquare FalconArray[2][BOARD_FILES] = {
 573     { WhiteRook, WhiteKnight, WhiteBishop, WhiteLance, WhiteQueen,
 574         WhiteKing, WhiteLance, WhiteBishop, WhiteKnight, WhiteRook },
 575     { BlackRook, BlackKnight, BlackBishop, BlackLance, BlackQueen,
 576         BlackKing, BlackLance, BlackBishop, BlackKnight, BlackRook }
 577 };
 578 #else // !FALCON
 579 #define FalconArray CapablancaArray
 580 #endif // !FALCON
 581
 582 #else // !(BOARD_FILES>=10)
 583 #define XiangqiPosition FIDEArray
 584 #define CapablancaArray FIDEArray
 585 #define GothicArray FIDEArray
 586 #define GreatArray FIDEArray
 587 #endif // !(BOARD_FILES>=10)
 588
 589 #if (BOARD_FILES>=12)
 590 ChessSquare CourierArray[2][BOARD_FILES] = {
 591     { WhiteRook, WhiteKnight, WhiteAlfil, WhiteBishop, WhiteMan, WhiteKing,
 592         WhiteFerz, WhiteWazir, WhiteBishop, WhiteAlfil, WhiteKnight, WhiteRook },
 593     { BlackRook, BlackKnight, BlackAlfil, BlackBishop, BlackMan, BlackKing,
 594         BlackFerz, BlackWazir, BlackBishop, BlackAlfil, BlackKnight, BlackRook }
 595 };
 596 #else // !(BOARD_FILES>=12)
 597 #define CourierArray CapablancaArray
 598 #endif // !(BOARD_FILES>=12)
 599
 600
 601 Board initialPosition;
 602
 603
 604 /* Convert str to a rating. Checks for special cases of "----",
 605
 606    "++++", etc. Also strips ()'s */
 607 int
 608 string_to_rating(str)
 609   char *str;
 610 {
 611   while(*str && !isdigit(*str)) ++str;
 612   if (!*str)
 613     return 0;   /* One of the special "no rating" cases */
 614   else
 615     return atoi(str);
 616 }
 617
 618 void
 619 ClearProgramStats()
 620 {
 621     /* Init programStats */
 622     programStats.movelist[0] = 0;
 623     programStats.depth = 0;
 624     programStats.nr_moves = 0;
 625     programStats.moves_left = 0;
 626     programStats.nodes = 0;
 627     programStats.time = -1;        // [HGM] PGNtime: make invalid to recognize engine output
 628     programStats.score = 0;
 629     programStats.got_only_move = 0;
 630     programStats.got_fail = 0;
 631     programStats.line_is_book = 0;
 632 }
 633
 634 void
 635 InitBackEnd1()
 636 {
 637     int matched, min, sec;
 638
 639     ShowThinkingEvent(); // [HGM] thinking: make sure post/nopost state is set according to options
 640
 641     GetTimeMark(&programStartTime);
 642     srandom((programStartTime.ms + 1000*programStartTime.sec)*0x1001001); // [HGM] book: makes sure random is unpredictabe to msec level
 643
 644     ClearProgramStats();
 645     programStats.ok_to_send = 1;
 646     programStats.seen_stat = 0;
 647
 648     /*
 649      * Initialize game list
 650      */
 651     ListNew(&gameList);
 652
 653
 654     /*
 655      * Internet chess server status
 656      */
 657     if (appData.icsActive) {
 658         appData.matchMode = FALSE;
 659         appData.matchGames = 0;
 660 #if ZIPPY
 661         appData.noChessProgram = !appData.zippyPlay;
 662 #else
 663         appData.zippyPlay = FALSE;
 664         appData.zippyTalk = FALSE;
 665         appData.noChessProgram = TRUE;
 666 #endif
 667         if (*appData.icsHelper != NULLCHAR) {
 668             appData.useTelnet = TRUE;
 669             appData.telnetProgram = appData.icsHelper;
 670         }
 671     } else {
 672         appData.zippyTalk = appData.zippyPlay = FALSE;
 673     }
 674
 675     /* [AS] Initialize pv info list [HGM] and game state */
 676     {
 677         int i, j;
 678
 679         for( i=0; i<=framePtr; i++ ) {
 680             pvInfoList[i].depth = -1;
 681             boards[i][EP_STATUS] = EP_NONE;
 682             for( j=0; j<BOARD_FILES-2; j++ ) boards[i][CASTLING][j] = NoRights;
 683         }
 684     }
 685
 686     /*
 687      * Parse timeControl resource
 688      */
 689     if (!ParseTimeControl(appData.timeControl, appData.timeIncrement,
 690                           appData.movesPerSession)) {
 691         char buf[MSG_SIZ];
 692         snprintf(buf, sizeof(buf), _("bad timeControl option %s"), appData.timeControl);
 693         DisplayFatalError(buf, 0, 2);
 694     }
 695
 696     /*
 697      * Parse searchTime resource
 698      */
 699     if (*appData.searchTime != NULLCHAR) {
 700         matched = sscanf(appData.searchTime, "%d:%d", &min, &sec);
 701         if (matched == 1) {
 702             searchTime = min * 60;
 703         } else if (matched == 2) {
 704             searchTime = min * 60 + sec;
 705         } else {
 706             char buf[MSG_SIZ];
 707             snprintf(buf, sizeof(buf), _("bad searchTime option %s"), appData.searchTime);
 708             DisplayFatalError(buf, 0, 2);
 709         }
 710     }
 711
 712     /* [AS] Adjudication threshold */
 713     adjudicateLossThreshold = appData.adjudicateLossThreshold;
 714
 715     first.which = "first";
 716     second.which = "second";
 717     first.maybeThinking = second.maybeThinking = FALSE;
 718     first.pr = second.pr = NoProc;
 719     first.isr = second.isr = NULL;
 720     first.sendTime = second.sendTime = 2;
 721     first.sendDrawOffers = 1;
 722     if (appData.firstPlaysBlack) {
 723         first.twoMachinesColor = "black\n";
 724         second.twoMachinesColor = "white\n";
 725     } else {
 726         first.twoMachinesColor = "white\n";
 727         second.twoMachinesColor = "black\n";
 728     }
 729     first.program = appData.firstChessProgram;
 730     second.program = appData.secondChessProgram;
 731     first.host = appData.firstHost;
 732     second.host = appData.secondHost;
 733     first.dir = appData.firstDirectory;
 734     second.dir = appData.secondDirectory;
 735     first.other = &second;
 736     second.other = &first;
 737     first.initString = appData.initString;
 738     second.initString = appData.secondInitString;
 739     first.computerString = appData.firstComputerString;
 740     second.computerString = appData.secondComputerString;
 741     first.useSigint = second.useSigint = TRUE;
 742     first.useSigterm = second.useSigterm = TRUE;
 743     first.reuse = appData.reuseFirst;
 744     second.reuse = appData.reuseSecond;
 745     first.nps = appData.firstNPS;   // [HGM] nps: copy nodes per second
 746     second.nps = appData.secondNPS;
 747     first.useSetboard = second.useSetboard = FALSE;
 748     first.useSAN = second.useSAN = FALSE;
 749     first.usePing = second.usePing = FALSE;
 750     first.lastPing = second.lastPing = 0;
 751     first.lastPong = second.lastPong = 0;
 752     first.usePlayother = second.usePlayother = FALSE;
 753     first.useColors = second.useColors = TRUE;
 754     first.useUsermove = second.useUsermove = FALSE;
 755     first.sendICS = second.sendICS = FALSE;
 756     first.sendName = second.sendName = appData.icsActive;
 757     first.sdKludge = second.sdKludge = FALSE;
 758     first.stKludge = second.stKludge = FALSE;
 759     TidyProgramName(first.program, first.host, first.tidy);
 760     TidyProgramName(second.program, second.host, second.tidy);
 761     first.matchWins = second.matchWins = 0;
 762     strcpy(first.variants, appData.variant);
 763     strcpy(second.variants, appData.variant);
 764     first.analysisSupport = second.analysisSupport = 2; /* detect */
 765     first.analyzing = second.analyzing = FALSE;
 766     first.initDone = second.initDone = FALSE;
 767
 768     /* New features added by Tord: */
 769     first.useFEN960 = FALSE; second.useFEN960 = FALSE;
 770     first.useOOCastle = TRUE; second.useOOCastle = TRUE;
 771     /* End of new features added by Tord. */
 772     first.fenOverride  = appData.fenOverride1;
 773     second.fenOverride = appData.fenOverride2;
 774
 775     /* [HGM] time odds: set factor for each machine */
 776     first.timeOdds  = appData.firstTimeOdds;
 777     second.timeOdds = appData.secondTimeOdds;
 778     { float norm = 1;
 779         if(appData.timeOddsMode) {
 780             norm = first.timeOdds;
 781             if(norm > second.timeOdds) norm = second.timeOdds;
 782         }
 783         first.timeOdds /= norm;
 784         second.timeOdds /= norm;
 785     }
 786
 787     /* [HGM] secondary TC: how to handle sessions that do not fit in 'level'*/
 788     first.accumulateTC = appData.firstAccumulateTC;
 789     second.accumulateTC = appData.secondAccumulateTC;
 790     first.maxNrOfSessions = second.maxNrOfSessions = 1;
 791
 792     /* [HGM] debug */
 793     first.debug = second.debug = FALSE;
 794     first.supportsNPS = second.supportsNPS = UNKNOWN;
 795
 796     /* [HGM] options */
 797     first.optionSettings  = appData.firstOptions;
 798     second.optionSettings = appData.secondOptions;
 799
 800     first.scoreIsAbsolute = appData.firstScoreIsAbsolute; /* [AS] */
 801     second.scoreIsAbsolute = appData.secondScoreIsAbsolute; /* [AS] */
 802     first.isUCI = appData.firstIsUCI; /* [AS] */
 803     second.isUCI = appData.secondIsUCI; /* [AS] */
 804     first.hasOwnBookUCI = appData.firstHasOwnBookUCI; /* [AS] */
 805     second.hasOwnBookUCI = appData.secondHasOwnBookUCI; /* [AS] */
 806
 807     if (appData.firstProtocolVersion > PROTOVER ||
 808         appData.firstProtocolVersion < 1) {
 809       char buf[MSG_SIZ];
 810       sprintf(buf, _("protocol version %d not supported"),
 811               appData.firstProtocolVersion);
 812       DisplayFatalError(buf, 0, 2);
 813     } else {
 814       first.protocolVersion = appData.firstProtocolVersion;
 815     }
 816
 817     if (appData.secondProtocolVersion > PROTOVER ||
 818         appData.secondProtocolVersion < 1) {
 819       char buf[MSG_SIZ];
 820       sprintf(buf, _("protocol version %d not supported"),
 821               appData.secondProtocolVersion);
 822       DisplayFatalError(buf, 0, 2);
 823     } else {
 824       second.protocolVersion = appData.secondProtocolVersion;
 825     }
 826
 827     if (appData.icsActive) {
 828         appData.clockMode = TRUE;  /* changes dynamically in ICS mode */
 829 //    } else if (*appData.searchTime != NULLCHAR || appData.noChessProgram) {
 830     } else if (appData.noChessProgram) { // [HGM] st: searchTime mode now also is clockMode
 831         appData.clockMode = FALSE;
 832         first.sendTime = second.sendTime = 0;
 833     }
 834
 835 #if ZIPPY
 836     /* Override some settings from environment variables, for backward
 837        compatibility.  Unfortunately it's not feasible to have the env
 838        vars just set defaults, at least in xboard.  Ugh.
 839     */
 840     if (appData.icsActive && (appData.zippyPlay || appData.zippyTalk)) {
 841       ZippyInit();
 842     }
 843 #endif
 844
 845     if (appData.noChessProgram) {
 846         programVersion = (char*) malloc(5 + strlen(PACKAGE_STRING));
 847         sprintf(programVersion, "%s", PACKAGE_STRING);
 848     } else {
 849       /* [HGM] tidy: use tidy name, in stead of full pathname (which was probably a bug due to / vs \ ) */
 850       programVersion = (char*) malloc(8 + strlen(PACKAGE_STRING) + strlen(first.tidy));
 851       sprintf(programVersion, "%s + %s", PACKAGE_STRING, first.tidy);
 852     }
 853
 854     if (!appData.icsActive) {
 855       char buf[MSG_SIZ];
 856       /* Check for variants that are supported only in ICS mode,
 857          or not at all.  Some that are accepted here nevertheless
 858          have bugs; see comments below.
 859       */
 860       VariantClass variant = StringToVariant(appData.variant);
 861       switch (variant) {
 862       case VariantBughouse:     /* need four players and two boards */
 863       case VariantKriegspiel:   /* need to hide pieces and move details */
 864       /* case VariantFischeRandom: (Fabien: moved below) */
 865         sprintf(buf, _("Variant %s supported only in ICS mode"), appData.variant);
 866         DisplayFatalError(buf, 0, 2);
 867         return;
 868
 869       case VariantUnknown:
 870       case VariantLoadable:
 871       case Variant29:
 872       case Variant30:
 873       case Variant31:
 874       case Variant32:
 875       case Variant33:
 876       case Variant34:
 877       case Variant35:
 878       case Variant36:
 879       default:
 880         sprintf(buf, _("Unknown variant name %s"), appData.variant);
 881         DisplayFatalError(buf, 0, 2);
 882         return;
 883
 884       case VariantXiangqi:    /* [HGM] repetition rules not implemented */
 885       case VariantFairy:      /* [HGM] TestLegality definitely off! */
 886       case VariantGothic:     /* [HGM] should work */
 887       case VariantCapablanca: /* [HGM] should work */
 888       case VariantCourier:    /* [HGM] initial forced moves not implemented */
 889       case VariantShogi:      /* [HGM] drops not tested for legality */
 890       case VariantKnightmate: /* [HGM] should work */
 891       case VariantCylinder:   /* [HGM] untested */
 892       case VariantFalcon:     /* [HGM] untested */
 893       case VariantCrazyhouse: /* holdings not shown, ([HGM] fixed that!)
 894                                  offboard interposition not understood */
 895       case VariantNormal:     /* definitely works! */
 896       case VariantWildCastle: /* pieces not automatically shuffled */
 897       case VariantNoCastle:   /* pieces not automatically shuffled */
 898       case VariantFischeRandom: /* [HGM] works and shuffles pieces */
 899       case VariantLosers:     /* should work except for win condition,
 900                                  and doesn't know captures are mandatory */
 901       case VariantSuicide:    /* should work except for win condition,
 902                                  and doesn't know captures are mandatory */
 903       case VariantGiveaway:   /* should work except for win condition,
 904                                  and doesn't know captures are mandatory */
 905       case VariantTwoKings:   /* should work */
 906       case VariantAtomic:     /* should work except for win condition */
 907       case Variant3Check:     /* should work except for win condition */
 908       case VariantShatranj:   /* should work except for all win conditions */
 909       case VariantMakruk:     /* should work except for daw countdown */
 910       case VariantBerolina:   /* might work if TestLegality is off */
 911       case VariantCapaRandom: /* should work */
 912       case VariantJanus:      /* should work */
 913       case VariantSuper:      /* experimental */
 914       case VariantGreat:      /* experimental, requires legality testing to be off */
 915         break;
 916       }
 917     }
 918
 919     InitEngineUCI( installDir, &first );  // [HGM] moved here from winboard.c, to make available in xboard
 920     InitEngineUCI( installDir, &second );
 921 }
 922
 923 int NextIntegerFromString( char ** str, long * value )
 924 {
 925     int result = -1;
 926     char * s = *str;
 927
 928     while( *s == ' ' || *s == '\t' ) {
 929         s++;
 930     }
 931
 932     *value = 0;
 933
 934     if( *s >= '0' && *s <= '9' ) {
 935         while( *s >= '0' && *s <= '9' ) {
 936             *value = *value * 10 + (*s - '0');
 937             s++;
 938         }
 939
 940         result = 0;
 941     }
 942
 943     *str = s;
 944
 945     return result;
 946 }
 947
 948 int NextTimeControlFromString( char ** str, long * value )
 949 {
 950     long temp;
 951     int result = NextIntegerFromString( str, &temp );
 952
 953     if( result == 0 ) {
 954         *value = temp * 60; /* Minutes */
 955         if( **str == ':' ) {
 956             (*str)++;
 957             result = NextIntegerFromString( str, &temp );
 958             *value += temp; /* Seconds */
 959         }
 960     }
 961
 962     return result;
 963 }
 964
 965 int NextSessionFromString( char ** str, int *moves, long * tc, long *inc)
 966 {   /* [HGM] routine added to read '+moves/time' for secondary time control */
 967     int result = -1; long temp, temp2;
 968
 969     if(**str != '+') return -1; // old params remain in force!
 970     (*str)++;
 971     if( NextTimeControlFromString( str, &temp ) ) return -1;
 972
 973     if(**str != '/') {
 974         /* time only: incremental or sudden-death time control */
 975         if(**str == '+') { /* increment follows; read it */
 976             (*str)++;
 977             if(result = NextIntegerFromString( str, &temp2)) return -1;
 978             *inc = temp2 * 1000;
 979         } else *inc = 0;
 980         *moves = 0; *tc = temp * 1000;
 981         return 0;
 982     } else if(temp % 60 != 0) return -1;     /* moves was given as min:sec */
 983
 984     (*str)++; /* classical time control */
 985     result = NextTimeControlFromString( str, &temp2);
 986     if(result == 0) {
 987         *moves = temp/60;
 988         *tc    = temp2 * 1000;
 989         *inc   = 0;
 990     }
 991     return result;
 992 }
 993
 994 int GetTimeQuota(int movenr)
 995 {   /* [HGM] get time to add from the multi-session time-control string */
 996     int moves=1; /* kludge to force reading of first session */
 997     long time, increment;
 998     char *s = fullTimeControlString;
 999
1000     if(appData.debugMode) fprintf(debugFP, "TC string = '%s'\n", fullTimeControlString);
1001     do {
1002         if(moves) NextSessionFromString(&s, &moves, &time, &increment);
1003         if(appData.debugMode) fprintf(debugFP, "mps=%d tc=%d inc=%d\n", moves, (int) time, (int) increment);
1004         if(movenr == -1) return time;    /* last move before new session     */
1005         if(!moves) return increment;     /* current session is incremental   */
1006         if(movenr >= 0) movenr -= moves; /* we already finished this session */
1007     } while(movenr >= -1);               /* try again for next session       */
1008
1009     return 0; // no new time quota on this move
1010 }
1011
1012 int
1013 ParseTimeControl(tc, ti, mps)
1014      char *tc;
1015      int ti;
1016      int mps;
1017 {
1018   long tc1;
1019   long tc2;
1020   char buf[MSG_SIZ];
1021
1022   if(ti >= 0 && !strchr(tc, '+') && !strchr(tc, '/') ) mps = 0;
1023   if(ti > 0) {
1024     if(mps)
1025       sprintf(buf, "+%d/%s+%d", mps, tc, ti);
1026     else sprintf(buf, "+%s+%d", tc, ti);
1027   } else {
1028     if(mps)
1029              sprintf(buf, "+%d/%s", mps, tc);
1030     else sprintf(buf, "+%s", tc);
1031   }
1032   fullTimeControlString = StrSave(buf);
1033
1034   if( NextTimeControlFromString( &tc, &tc1 ) != 0 ) {
1035     return FALSE;
1036   }
1037
1038   if( *tc == '/' ) {
1039     /* Parse second time control */
1040     tc++;
1041
1042     if( NextTimeControlFromString( &tc, &tc2 ) != 0 ) {
1043       return FALSE;
1044     }
1045
1046     if( tc2 == 0 ) {
1047       return FALSE;
1048     }
1049
1050     timeControl_2 = tc2 * 1000;
1051   }
1052   else {
1053     timeControl_2 = 0;
1054   }
1055
1056   if( tc1 == 0 ) {
1057     return FALSE;
1058   }
1059
1060   timeControl = tc1 * 1000;
1061
1062   if (ti >= 0) {
1063     timeIncrement = ti * 1000;  /* convert to ms */
1064     movesPerSession = 0;
1065   } else {
1066     timeIncrement = 0;
1067     movesPerSession = mps;
1068   }
1069   return TRUE;
1070 }
1071
1072 void
1073 InitBackEnd2()
1074 {
1075     if (appData.debugMode) {
1076         fprintf(debugFP, "%s\n", programVersion);
1077     }
1078
1079     set_cont_sequence(appData.wrapContSeq);
1080     if (appData.matchGames > 0) {
1081         appData.matchMode = TRUE;
1082     } else if (appData.matchMode) {
1083         appData.matchGames = 1;
1084     }
1085     if(appData.matchMode && appData.sameColorGames > 0) /* [HGM] alternate: overrule matchGames */
1086         appData.matchGames = appData.sameColorGames;
1087     if(appData.rewindIndex > 1) { /* [HGM] autoinc: rewind implies auto-increment and overrules given index */
1088         if(appData.loadPositionIndex >= 0) appData.loadPositionIndex = -1;
1089         if(appData.loadGameIndex >= 0) appData.loadGameIndex = -1;
1090     }
1091     Reset(TRUE, FALSE);
1092     if (appData.noChessProgram || first.protocolVersion == 1) {
1093       InitBackEnd3();
1094     } else {
1095       /* kludge: allow timeout for initial "feature" commands */
1096       FreezeUI();
1097       DisplayMessage("", _("Starting chess program"));
1098       ScheduleDelayedEvent(InitBackEnd3, FEATURE_TIMEOUT);
1099     }
1100 }
1101
1102 void
1103 InitBackEnd3 P((void))
1104 {
1105     GameMode initialMode;
1106     char buf[MSG_SIZ];
1107     int err;
1108
1109     InitChessProgram(&first, startedFromSetupPosition);
1110
1111     if(!appData.noChessProgram) {  /* [HGM] tidy: redo program version to use name from myname feature */
1112         free(programVersion);
1113         programVersion = (char*) malloc(8 + strlen(PACKAGE_STRING) + strlen(first.tidy));
1114         sprintf(programVersion, "%s + %s", PACKAGE_STRING, first.tidy);
1115     }
1116
1117     if (appData.icsActive) {
1118 #ifdef WIN32
1119         /* [DM] Make a console window if needed [HGM] merged ifs */
1120         ConsoleCreate();
1121 #endif
1122         err = establish();
1123         if (err != 0) {
1124             if (*appData.icsCommPort != NULLCHAR) {
1125                 sprintf(buf, _("Could not open comm port %s"),
1126                         appData.icsCommPort);
1127             } else {
1128                 snprintf(buf, sizeof(buf), _("Could not connect to host %s, port %s"),
1129                         appData.icsHost, appData.icsPort);
1130             }
1131             DisplayFatalError(buf, err, 1);
1132             return;
1133         }
1134         SetICSMode();
1135         telnetISR =
1136           AddInputSource(icsPR, FALSE, read_from_ics, &telnetISR);
1137         fromUserISR =
1138           AddInputSource(NoProc, FALSE, read_from_player, &fromUserISR);
1139         if(appData.keepAlive) // [HGM] alive: schedule sending of dummy 'date' command
1140             ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
1141     } else if (appData.noChessProgram) {
1142         SetNCPMode();
1143     } else {
1144         SetGNUMode();
1145     }
1146
1147     if (*appData.cmailGameName != NULLCHAR) {
1148         SetCmailMode();
1149         OpenLoopback(&cmailPR);
1150         cmailISR =
1151           AddInputSource(cmailPR, FALSE, CmailSigHandlerCallBack, &cmailISR);
1152     }
1153
1154     ThawUI();
1155     DisplayMessage("", "");
1156     if (StrCaseCmp(appData.initialMode, "") == 0) {
1157       initialMode = BeginningOfGame;
1158     } else if (StrCaseCmp(appData.initialMode, "TwoMachines") == 0) {
1159       initialMode = TwoMachinesPlay;
1160     } else if (StrCaseCmp(appData.initialMode, "AnalyzeFile") == 0) {
1161       initialMode = AnalyzeFile;
1162     } else if (StrCaseCmp(appData.initialMode, "Analysis") == 0) {
1163       initialMode = AnalyzeMode;
1164     } else if (StrCaseCmp(appData.initialMode, "MachineWhite") == 0) {
1165       initialMode = MachinePlaysWhite;
1166     } else if (StrCaseCmp(appData.initialMode, "MachineBlack") == 0) {
1167       initialMode = MachinePlaysBlack;
1168     } else if (StrCaseCmp(appData.initialMode, "EditGame") == 0) {
1169       initialMode = EditGame;
1170     } else if (StrCaseCmp(appData.initialMode, "EditPosition") == 0) {
1171       initialMode = EditPosition;
1172     } else if (StrCaseCmp(appData.initialMode, "Training") == 0) {
1173       initialMode = Training;
1174     } else {
1175       sprintf(buf, _("Unknown initialMode %s"), appData.initialMode);
1176       DisplayFatalError(buf, 0, 2);
1177       return;
1178     }
1179
1180     if (appData.matchMode) {
1181         /* Set up machine vs. machine match */
1182         if (appData.noChessProgram) {
1183             DisplayFatalError(_("Can't have a match with no chess programs"),
1184                               0, 2);
1185             return;
1186         }
1187         matchMode = TRUE;
1188         matchGame = 1;
1189         if (*appData.loadGameFile != NULLCHAR) {
1190             int index = appData.loadGameIndex; // [HGM] autoinc
1191             if(index<0) lastIndex = index = 1;
1192             if (!LoadGameFromFile(appData.loadGameFile,
1193                                   index,
1194                                   appData.loadGameFile, FALSE)) {
1195                 DisplayFatalError(_("Bad game file"), 0, 1);
1196                 return;
1197             }
1198         } else if (*appData.loadPositionFile != NULLCHAR) {
1199             int index = appData.loadPositionIndex; // [HGM] autoinc
1200             if(index<0) lastIndex = index = 1;
1201             if (!LoadPositionFromFile(appData.loadPositionFile,
1202                                       index,
1203                                       appData.loadPositionFile)) {
1204                 DisplayFatalError(_("Bad position file"), 0, 1);
1205                 return;
1206             }
1207         }
1208         TwoMachinesEvent();
1209     } else if (*appData.cmailGameName != NULLCHAR) {
1210         /* Set up cmail mode */
1211         ReloadCmailMsgEvent(TRUE);
1212     } else {
1213         /* Set up other modes */
1214         if (initialMode == AnalyzeFile) {
1215           if (*appData.loadGameFile == NULLCHAR) {
1216             DisplayFatalError(_("AnalyzeFile mode requires a game file"), 0, 1);
1217             return;
1218           }
1219         }
1220         if (*appData.loadGameFile != NULLCHAR) {
1221             (void) LoadGameFromFile(appData.loadGameFile,
1222                                     appData.loadGameIndex,
1223                                     appData.loadGameFile, TRUE);
1224         } else if (*appData.loadPositionFile != NULLCHAR) {
1225             (void) LoadPositionFromFile(appData.loadPositionFile,
1226                                         appData.loadPositionIndex,
1227                                         appData.loadPositionFile);
1228             /* [HGM] try to make self-starting even after FEN load */
1229             /* to allow automatic setup of fairy variants with wtm */
1230             if(initialMode == BeginningOfGame && !blackPlaysFirst) {
1231                 gameMode = BeginningOfGame;
1232                 setboardSpoiledMachineBlack = 1;
1233             }
1234             /* [HGM] loadPos: make that every new game uses the setup */
1235             /* from file as long as we do not switch variant          */
1236             if(!blackPlaysFirst) {
1237                 startedFromPositionFile = TRUE;
1238                 CopyBoard(filePosition, boards[0]);
1239             }
1240         }
1241         if (initialMode == AnalyzeMode) {
1242           if (appData.noChessProgram) {
1243             DisplayFatalError(_("Analysis mode requires a chess engine"), 0, 2);
1244             return;
1245           }
1246           if (appData.icsActive) {
1247             DisplayFatalError(_("Analysis mode does not work with ICS mode"),0,2);
1248             return;
1249           }
1250           AnalyzeModeEvent();
1251         } else if (initialMode == AnalyzeFile) {
1252           appData.showThinking = TRUE; // [HGM] thinking: moved out of ShowThinkingEvent
1253           ShowThinkingEvent();
1254           AnalyzeFileEvent();
1255           AnalysisPeriodicEvent(1);
1256         } else if (initialMode == MachinePlaysWhite) {
1257           if (appData.noChessProgram) {
1258             DisplayFatalError(_("MachineWhite mode requires a chess engine"),
1259                               0, 2);
1260             return;
1261           }
1262           if (appData.icsActive) {
1263             DisplayFatalError(_("MachineWhite mode does not work with ICS mode"),
1264                               0, 2);
1265             return;
1266           }
1267           MachineWhiteEvent();
1268         } else if (initialMode == MachinePlaysBlack) {
1269           if (appData.noChessProgram) {
1270             DisplayFatalError(_("MachineBlack mode requires a chess engine"),
1271                               0, 2);
1272             return;
1273           }
1274           if (appData.icsActive) {
1275             DisplayFatalError(_("MachineBlack mode does not work with ICS mode"),
1276                               0, 2);
1277             return;
1278           }
1279           MachineBlackEvent();
1280         } else if (initialMode == TwoMachinesPlay) {
1281           if (appData.noChessProgram) {
1282             DisplayFatalError(_("TwoMachines mode requires a chess engine"),
1283                               0, 2);
1284             return;
1285           }
1286           if (appData.icsActive) {
1287             DisplayFatalError(_("TwoMachines mode does not work with ICS mode"),
1288                               0, 2);
1289             return;
1290           }
1291           TwoMachinesEvent();
1292         } else if (initialMode == EditGame) {
1293           EditGameEvent();
1294         } else if (initialMode == EditPosition) {
1295           EditPositionEvent();
1296         } else if (initialMode == Training) {
1297           if (*appData.loadGameFile == NULLCHAR) {
1298             DisplayFatalError(_("Training mode requires a game file"), 0, 2);
1299             return;
1300           }
1301           TrainingEvent();
1302         }
1303     }
1304 }
1305
1306 /*
1307  * Establish will establish a contact to a remote host.port.
1308  * Sets icsPR to a ProcRef for a process (or pseudo-process)
1309  *  used to talk to the host.
1310  * Returns 0 if okay, error code if not.
1311  */
1312 int
1313 establish()
1314 {
1315     char buf[MSG_SIZ];
1316
1317     if (*appData.icsCommPort != NULLCHAR) {
1318         /* Talk to the host through a serial comm port */
1319         return OpenCommPort(appData.icsCommPort, &icsPR);
1320
1321     } else if (*appData.gateway != NULLCHAR) {
1322         if (*appData.remoteShell == NULLCHAR) {
1323             /* Use the rcmd protocol to run telnet program on a gateway host */
1324             snprintf(buf, sizeof(buf), "%s %s %s",
1325                     appData.telnetProgram, appData.icsHost, appData.icsPort);
1326             return OpenRcmd(appData.gateway, appData.remoteUser, buf, &icsPR);
1327
1328         } else {
1329             /* Use the rsh program to run telnet program on a gateway host */
1330             if (*appData.remoteUser == NULLCHAR) {
1331                 snprintf(buf, sizeof(buf), "%s %s %s %s %s", appData.remoteShell,
1332                         appData.gateway, appData.telnetProgram,
1333                         appData.icsHost, appData.icsPort);
1334             } else {
1335                 snprintf(buf, sizeof(buf), "%s %s -l %s %s %s %s",
1336                         appData.remoteShell, appData.gateway,
1337                         appData.remoteUser, appData.telnetProgram,
1338                         appData.icsHost, appData.icsPort);
1339             }
1340             return StartChildProcess(buf, "", &icsPR);
1341
1342         }
1343     } else if (appData.useTelnet) {
1344         return OpenTelnet(appData.icsHost, appData.icsPort, &icsPR);
1345
1346     } else {
1347         /* TCP socket interface differs somewhat between
1348            Unix and NT; handle details in the front end.
1349            */
1350         return OpenTCP(appData.icsHost, appData.icsPort, &icsPR);
1351     }
1352 }
1353
1354 void EscapeExpand(char *p, char *q)
1355 {       // [HGM] initstring: routine to shape up string arguments
1356         while(*p++ = *q++) if(p[-1] == '\\')
1357             switch(*q++) {
1358                 case 'n': p[-1] = '\n'; break;
1359                 case 'r': p[-1] = '\r'; break;
1360                 case 't': p[-1] = '\t'; break;
1361                 case '\\': p[-1] = '\\'; break;
1362                 case 0: *p = 0; return;
1363                 default: p[-1] = q[-1]; break;
1364             }
1365 }
1366
1367 void
1368 show_bytes(fp, buf, count)
1369      FILE *fp;
1370      char *buf;
1371      int count;
1372 {
1373     while (count--) {
1374         if (*buf < 040 || *(unsigned char *) buf > 0177) {
1375             fprintf(fp, "\\%03o", *buf & 0xff);
1376         } else {
1377             putc(*buf, fp);
1378         }
1379         buf++;
1380     }
1381     fflush(fp);
1382 }
1383
1384 /* Returns an errno value */
1385 int
1386 OutputMaybeTelnet(pr, message, count, outError)
1387      ProcRef pr;
1388      char *message;
1389      int count;
1390      int *outError;
1391 {
1392     char buf[8192], *p, *q, *buflim;
1393     int left, newcount, outcount;
1394
1395     if (*appData.icsCommPort != NULLCHAR || appData.useTelnet ||
1396         *appData.gateway != NULLCHAR) {
1397         if (appData.debugMode) {
1398             fprintf(debugFP, ">ICS: ");
1399             show_bytes(debugFP, message, count);
1400             fprintf(debugFP, "\n");
1401         }
1402         return OutputToProcess(pr, message, count, outError);
1403     }
1404
1405     buflim = &buf[sizeof(buf)-1]; /* allow 1 byte for expanding last char */
1406     p = message;
1407     q = buf;
1408     left = count;
1409     newcount = 0;
1410     while (left) {
1411         if (q >= buflim) {
1412             if (appData.debugMode) {
1413                 fprintf(debugFP, ">ICS: ");
1414                 show_bytes(debugFP, buf, newcount);
1415                 fprintf(debugFP, "\n");
1416             }
1417             outcount = OutputToProcess(pr, buf, newcount, outError);
1418             if (outcount < newcount) return -1; /* to be sure */
1419             q = buf;
1420             newcount = 0;
1421         }
1422         if (*p == '\n') {
1423             *q++ = '\r';
1424             newcount++;
1425         } else if (((unsigned char) *p) == TN_IAC) {
1426             *q++ = (char) TN_IAC;
1427             newcount ++;
1428         }
1429         *q++ = *p++;
1430         newcount++;
1431         left--;
1432     }
1433     if (appData.debugMode) {
1434         fprintf(debugFP, ">ICS: ");
1435         show_bytes(debugFP, buf, newcount);
1436         fprintf(debugFP, "\n");
1437     }
1438     outcount = OutputToProcess(pr, buf, newcount, outError);
1439     if (outcount < newcount) return -1; /* to be sure */
1440     return count;
1441 }
1442
1443 void
1444 read_from_player(isr, closure, message, count, error)
1445      InputSourceRef isr;
1446      VOIDSTAR closure;
1447      char *message;
1448      int count;
1449      int error;
1450 {
1451     int outError, outCount;
1452     static int gotEof = 0;
1453
1454     /* Pass data read from player on to ICS */
1455     if (count > 0) {
1456         gotEof = 0;
1457         outCount = OutputMaybeTelnet(icsPR, message, count, &outError);
1458         if (outCount < count) {
1459             DisplayFatalError(_("Error writing to ICS"), outError, 1);
1460         }
1461     } else if (count < 0) {
1462         RemoveInputSource(isr);
1463         DisplayFatalError(_("Error reading from keyboard"), error, 1);
1464     } else if (gotEof++ > 0) {
1465         RemoveInputSource(isr);
1466         DisplayFatalError(_("Got end of file from keyboard"), 0, 0);
1467     }
1468 }
1469
1470 void
1471 KeepAlive()
1472 {   // [HGM] alive: periodically send dummy (date) command to ICS to prevent time-out
1473     if(!connectionAlive) DisplayFatalError("No response from ICS", 0, 1);
1474     connectionAlive = FALSE; // only sticks if no response to 'date' command.
1475     SendToICS("date\n");
1476     if(appData.keepAlive) ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
1477 }
1478
1479 /* added routine for printf style output to ics */
1480 void ics_printf(char *format, ...)
1481 {
1482     char buffer[MSG_SIZ];
1483     va_list args;
1484
1485     va_start(args, format);
1486     vsnprintf(buffer, sizeof(buffer), format, args);
1487     buffer[sizeof(buffer)-1] = '\0';
1488     SendToICS(buffer);
1489     va_end(args);
1490 }
1491
1492 void
1493 SendToICS(s)
1494      char *s;
1495 {
1496     int count, outCount, outError;
1497
1498     if (icsPR == NULL) return;
1499
1500     count = strlen(s);
1501     outCount = OutputMaybeTelnet(icsPR, s, count, &outError);
1502     if (outCount < count) {
1503         DisplayFatalError(_("Error writing to ICS"), outError, 1);
1504     }
1505 }
1506
1507 /* This is used for sending logon scripts to the ICS. Sending
1508    without a delay causes problems when using timestamp on ICC
1509    (at least on my machine). */
1510 void
1511 SendToICSDelayed(s,msdelay)
1512      char *s;
1513      long msdelay;
1514 {
1515     int count, outCount, outError;
1516
1517     if (icsPR == NULL) return;
1518
1519     count = strlen(s);
1520     if (appData.debugMode) {
1521         fprintf(debugFP, ">ICS: ");
1522         show_bytes(debugFP, s, count);
1523         fprintf(debugFP, "\n");
1524     }
1525     outCount = OutputToProcessDelayed(icsPR, s, count, &outError,
1526                                       msdelay);
1527     if (outCount < count) {
1528         DisplayFatalError(_("Error writing to ICS"), outError, 1);
1529     }
1530 }
1531
1532
1533 /* Remove all highlighting escape sequences in s
1534    Also deletes any suffix starting with '('
1535    */
1536 char *
1537 StripHighlightAndTitle(s)
1538      char *s;
1539 {
1540     static char retbuf[MSG_SIZ];
1541     char *p = retbuf;
1542
1543     while (*s != NULLCHAR) {
1544         while (*s == '\033') {
1545             while (*s != NULLCHAR && !isalpha(*s)) s++;
1546             if (*s != NULLCHAR) s++;
1547         }
1548         while (*s != NULLCHAR && *s != '\033') {
1549             if (*s == '(' || *s == '[') {
1550                 *p = NULLCHAR;
1551                 return retbuf;
1552             }
1553             *p++ = *s++;
1554         }
1555     }
1556     *p = NULLCHAR;
1557     return retbuf;
1558 }
1559
1560 /* Remove all highlighting escape sequences in s */
1561 char *
1562 StripHighlight(s)
1563      char *s;
1564 {
1565     static char retbuf[MSG_SIZ];
1566     char *p = retbuf;
1567
1568     while (*s != NULLCHAR) {
1569         while (*s == '\033') {
1570             while (*s != NULLCHAR && !isalpha(*s)) s++;
1571             if (*s != NULLCHAR) s++;
1572         }
1573         while (*s != NULLCHAR && *s != '\033') {
1574             *p++ = *s++;
1575         }
1576     }
1577     *p = NULLCHAR;
1578     return retbuf;
1579 }
1580
1581 char *variantNames[] = VARIANT_NAMES;
1582 char *
1583 VariantName(v)
1584      VariantClass v;
1585 {
1586     return variantNames[v];
1587 }
1588
1589
1590 /* Identify a variant from the strings the chess servers use or the
1591    PGN Variant tag names we use. */
1592 VariantClass
1593 StringToVariant(e)
1594      char *e;
1595 {
1596     char *p;
1597     int wnum = -1;
1598     VariantClass v = VariantNormal;
1599     int i, found = FALSE;
1600     char buf[MSG_SIZ];
1601
1602     if (!e) return v;
1603
1604     /* [HGM] skip over optional board-size prefixes */
1605     if( sscanf(e, "%dx%d_", &i, &i) == 2 ||
1606         sscanf(e, "%dx%d+%d_", &i, &i, &i) == 3 ) {
1607         while( *e++ != '_');
1608     }
1609
1610     if(StrCaseStr(e, "misc/")) { // [HGM] on FICS, misc/shogi is not shogi
1611         v = VariantNormal;
1612         found = TRUE;
1613     } else
1614     for (i=0; i<sizeof(variantNames)/sizeof(char*); i++) {
1615       if (StrCaseStr(e, variantNames[i])) {
1616         v = (VariantClass) i;
1617         found = TRUE;
1618         break;
1619       }
1620     }
1621
1622     if (!found) {
1623       if ((StrCaseStr(e, "fischer") && StrCaseStr(e, "random"))
1624           || StrCaseStr(e, "wild/fr")
1625           || StrCaseStr(e, "frc") || StrCaseStr(e, "960")) {
1626         v = VariantFischeRandom;
1627       } else if ((i = 4, p = StrCaseStr(e, "wild")) ||
1628                  (i = 1, p = StrCaseStr(e, "w"))) {
1629         p += i;
1630         while (*p && (isspace(*p) || *p == '(' || *p == '/')) p++;
1631         if (isdigit(*p)) {
1632           wnum = atoi(p);
1633         } else {
1634           wnum = -1;
1635         }
1636         switch (wnum) {
1637         case 0: /* FICS only, actually */
1638         case 1:
1639           /* Castling legal even if K starts on d-file */
1640           v = VariantWildCastle;
1641           break;
1642         case 2:
1643         case 3:
1644         case 4:
1645           /* Castling illegal even if K & R happen to start in
1646              normal positions. */
1647           v = VariantNoCastle;
1648           break;
1649         case 5:
1650         case 7:
1651         case 8:
1652         case 10:
1653         case 11:
1654         case 12:
1655         case 13:
1656         case 14:
1657         case 15:
1658         case 18:
1659         case 19:
1660           /* Castling legal iff K & R start in normal positions */
1661           v = VariantNormal;
1662           break;
1663         case 6:
1664         case 20:
1665         case 21:
1666           /* Special wilds for position setup; unclear what to do here */
1667           v = VariantLoadable;
1668           break;
1669         case 9:
1670           /* Bizarre ICC game */
1671           v = VariantTwoKings;
1672           break;
1673         case 16:
1674           v = VariantKriegspiel;
1675           break;
1676         case 17:
1677           v = VariantLosers;
1678           break;
1679         case 22:
1680           v = VariantFischeRandom;
1681           break;
1682         case 23:
1683           v = VariantCrazyhouse;
1684           break;
1685         case 24:
1686           v = VariantBughouse;
1687           break;
1688         case 25:
1689           v = Variant3Check;
1690           break;
1691         case 26:
1692           /* Not quite the same as FICS suicide! */
1693           v = VariantGiveaway;
1694           break;
1695         case 27:
1696           v = VariantAtomic;
1697           break;
1698         case 28:
1699           v = VariantShatranj;
1700           break;
1701
1702         /* Temporary names for future ICC types.  The name *will* change in
1703            the next xboard/WinBoard release after ICC defines it. */
1704         case 29:
1705           v = Variant29;
1706           break;
1707         case 30:
1708           v = Variant30;
1709           break;
1710         case 31:
1711           v = Variant31;
1712           break;
1713         case 32:
1714           v = Variant32;
1715           break;
1716         case 33:
1717           v = Variant33;
1718           break;
1719         case 34:
1720           v = Variant34;
1721           break;
1722         case 35:
1723           v = Variant35;
1724           break;
1725         case 36:
1726           v = Variant36;
1727           break;
1728         case 37:
1729           v = VariantShogi;
1730           break;
1731         case 38:
1732           v = VariantXiangqi;
1733           break;
1734         case 39:
1735           v = VariantCourier;
1736           break;
1737         case 40:
1738           v = VariantGothic;
1739           break;
1740         case 41:
1741           v = VariantCapablanca;
1742           break;
1743         case 42:
1744           v = VariantKnightmate;
1745           break;
1746         case 43:
1747           v = VariantFairy;
1748           break;
1749         case 44:
1750           v = VariantCylinder;
1751           break;
1752         case 45:
1753           v = VariantFalcon;
1754           break;
1755         case 46:
1756           v = VariantCapaRandom;
1757           break;
1758         case 47:
1759           v = VariantBerolina;
1760           break;
1761         case 48:
1762           v = VariantJanus;
1763           break;
1764         case 49:
1765           v = VariantSuper;
1766           break;
1767         case 50:
1768           v = VariantGreat;
1769           break;
1770         case -1:
1771           /* Found "wild" or "w" in the string but no number;
1772              must assume it's normal chess. */
1773           v = VariantNormal;
1774           break;
1775         default:
1776           sprintf(buf, _("Unknown wild type %d"), wnum);
1777           DisplayError(buf, 0);
1778           v = VariantUnknown;
1779           break;
1780         }
1781       }
1782     }
1783     if (appData.debugMode) {
1784       fprintf(debugFP, _("recognized '%s' (%d) as variant %s\n"),
1785               e, wnum, VariantName(v));
1786     }
1787     return v;
1788 }
1789
1790 static int leftover_start = 0, leftover_len = 0;
1791 char star_match[STAR_MATCH_N][MSG_SIZ];
1792
1793 /* Test whether pattern is present at &buf[*index]; if so, return TRUE,
1794    advance *index beyond it, and set leftover_start to the new value of
1795    *index; else return FALSE.  If pattern contains the character '*', it
1796    matches any sequence of characters not containing '\r', '\n', or the
1797    character following the '*' (if any), and the matched sequence(s) are
1798    copied into star_match.
1799    */
1800 int
1801 looking_at(buf, index, pattern)
1802      char *buf;
1803      int *index;
1804      char *pattern;
1805 {
1806     char *bufp = &buf[*index], *patternp = pattern;
1807     int star_count = 0;
1808     char *matchp = star_match[0];
1809
1810     for (;;) {
1811         if (*patternp == NULLCHAR) {
1812             *index = leftover_start = bufp - buf;
1813             *matchp = NULLCHAR;
1814             return TRUE;
1815         }
1816         if (*bufp == NULLCHAR) return FALSE;
1817         if (*patternp == '*') {
1818             if (*bufp == *(patternp + 1)) {
1819                 *matchp = NULLCHAR;
1820                 matchp = star_match[++star_count];
1821                 patternp += 2;
1822                 bufp++;
1823                 continue;
1824             } else if (*bufp == '\n' || *bufp == '\r') {
1825                 patternp++;
1826                 if (*patternp == NULLCHAR)
1827                   continue;
1828                 else
1829                   return FALSE;
1830             } else {
1831                 *matchp++ = *bufp++;
1832                 continue;
1833             }
1834         }
1835         if (*patternp != *bufp) return FALSE;
1836         patternp++;
1837         bufp++;
1838     }
1839 }
1840
1841 void
1842 SendToPlayer(data, length)
1843      char *data;
1844      int length;
1845 {
1846     int error, outCount;
1847     outCount = OutputToProcess(NoProc, data, length, &error);
1848     if (outCount < length) {
1849         DisplayFatalError(_("Error writing to display"), error, 1);
1850     }
1851 }
1852
1853 void
1854 PackHolding(packed, holding)
1855      char packed[];
1856      char *holding;
1857 {
1858     char *p = holding;
1859     char *q = packed;
1860     int runlength = 0;
1861     int curr = 9999;
1862     do {
1863         if (*p == curr) {
1864             runlength++;
1865         } else {
1866             switch (runlength) {
1867               case 0:
1868                 break;
1869               case 1:
1870                 *q++ = curr;
1871                 break;
1872               case 2:
1873                 *q++ = curr;
1874                 *q++ = curr;
1875                 break;
1876               default:
1877                 sprintf(q, "%d", runlength);
1878                 while (*q) q++;
1879                 *q++ = curr;
1880                 break;
1881             }
1882             runlength = 1;
1883             curr = *p;
1884         }
1885     } while (*p++);
1886     *q = NULLCHAR;
1887 }
1888
1889 /* Telnet protocol requests from the front end */
1890 void
1891 TelnetRequest(ddww, option)
1892      unsigned char ddww, option;
1893 {
1894     unsigned char msg[3];
1895     int outCount, outError;
1896
1897     if (*appData.icsCommPort != NULLCHAR || appData.useTelnet) return;
1898
1899     if (appData.debugMode) {
1900         char buf1[8], buf2[8], *ddwwStr, *optionStr;
1901         switch (ddww) {
1902           case TN_DO:
1903             ddwwStr = "DO";
1904             break;
1905           case TN_DONT:
1906             ddwwStr = "DONT";
1907             break;
1908           case TN_WILL:
1909             ddwwStr = "WILL";
1910             break;
1911           case TN_WONT:
1912             ddwwStr = "WONT";
1913             break;
1914           default:
1915             ddwwStr = buf1;
1916             sprintf(buf1, "%d", ddww);
1917             break;
1918         }
1919         switch (option) {
1920           case TN_ECHO:
1921             optionStr = "ECHO";
1922             break;
1923           default:
1924             optionStr = buf2;
1925             sprintf(buf2, "%d", option);
1926             break;
1927         }
1928         fprintf(debugFP, ">%s %s ", ddwwStr, optionStr);
1929     }
1930     msg[0] = TN_IAC;
1931     msg[1] = ddww;
1932     msg[2] = option;
1933     outCount = OutputToProcess(icsPR, (char *)msg, 3, &outError);
1934     if (outCount < 3) {
1935         DisplayFatalError(_("Error writing to ICS"), outError, 1);
1936     }
1937 }
1938
1939 void
1940 DoEcho()
1941 {
1942     if (!appData.icsActive) return;
1943     TelnetRequest(TN_DO, TN_ECHO);
1944 }
1945
1946 void
1947 DontEcho()
1948 {
1949     if (!appData.icsActive) return;
1950     TelnetRequest(TN_DONT, TN_ECHO);
1951 }
1952
1953 void
1954 CopyHoldings(Board board, char *holdings, ChessSquare lowestPiece)
1955 {
1956     /* put the holdings sent to us by the server on the board holdings area */
1957     int i, j, holdingsColumn, holdingsStartRow, direction, countsColumn;
1958     char p;
1959     ChessSquare piece;
1960
1961     if(gameInfo.holdingsWidth < 2)  return;
1962     if(gameInfo.variant != VariantBughouse && board[HOLDINGS_SET])
1963         return; // prevent overwriting by pre-board holdings
1964
1965     if( (int)lowestPiece >= BlackPawn ) {
1966         holdingsColumn = 0;
1967         countsColumn = 1;
1968         holdingsStartRow = BOARD_HEIGHT-1;
1969         direction = -1;
1970     } else {
1971         holdingsColumn = BOARD_WIDTH-1;
1972         countsColumn = BOARD_WIDTH-2;
1973         holdingsStartRow = 0;
1974         direction = 1;
1975     }
1976
1977     for(i=0; i<BOARD_HEIGHT; i++) { /* clear holdings */
1978         board[i][holdingsColumn] = EmptySquare;
1979         board[i][countsColumn]   = (ChessSquare) 0;
1980     }
1981     while( (p=*holdings++) != NULLCHAR ) {
1982         piece = CharToPiece( ToUpper(p) );
1983         if(piece == EmptySquare) continue;
1984         /*j = (int) piece - (int) WhitePawn;*/
1985         j = PieceToNumber(piece);
1986         if(j >= gameInfo.holdingsSize) continue; /* ignore pieces that do not fit */
1987         if(j < 0) continue;               /* should not happen */
1988         piece = (ChessSquare) ( (int)piece + (int)lowestPiece );
1989         board[holdingsStartRow+j*direction][holdingsColumn] = piece;
1990         board[holdingsStartRow+j*direction][countsColumn]++;
1991     }
1992 }
1993
1994
1995 void
1996 VariantSwitch(Board board, VariantClass newVariant)
1997 {
1998    int newHoldingsWidth, newWidth = 8, newHeight = 8, i, j;
1999    static Board oldBoard;
2000
2001    startedFromPositionFile = FALSE;
2002    if(gameInfo.variant == newVariant) return;
2003
2004    /* [HGM] This routine is called each time an assignment is made to
2005     * gameInfo.variant during a game, to make sure the board sizes
2006     * are set to match the new variant. If that means adding or deleting
2007     * holdings, we shift the playing board accordingly
2008     * This kludge is needed because in ICS observe mode, we get boards
2009     * of an ongoing game without knowing the variant, and learn about the
2010     * latter only later. This can be because of the move list we requested,
2011     * in which case the game history is refilled from the beginning anyway,
2012     * but also when receiving holdings of a crazyhouse game. In the latter
2013     * case we want to add those holdings to the already received position.
2014     */
2015
2016
2017    if (appData.debugMode) {
2018      fprintf(debugFP, "Switch board from %s to %s\n",
2019              VariantName(gameInfo.variant), VariantName(newVariant));
2020      setbuf(debugFP, NULL);
2021    }
2022    shuffleOpenings = 0;       /* [HGM] shuffle */
2023    gameInfo.holdingsSize = 5; /* [HGM] prepare holdings */
2024    switch(newVariant)
2025      {
2026      case VariantShogi:
2027        newWidth = 9;  newHeight = 9;
2028        gameInfo.holdingsSize = 7;
2029      case VariantBughouse:
2030      case VariantCrazyhouse:
2031        newHoldingsWidth = 2; break;
2032      case VariantGreat:
2033        newWidth = 10;
2034      case VariantSuper:
2035        newHoldingsWidth = 2;
2036        gameInfo.holdingsSize = 8;
2037        break;
2038      case VariantGothic:
2039      case VariantCapablanca:
2040      case VariantCapaRandom:
2041        newWidth = 10;
2042      default:
2043        newHoldingsWidth = gameInfo.holdingsSize = 0;
2044      };
2045
2046    if(newWidth  != gameInfo.boardWidth  ||
2047       newHeight != gameInfo.boardHeight ||
2048       newHoldingsWidth != gameInfo.holdingsWidth ) {
2049
2050      /* shift position to new playing area, if needed */
2051      if(newHoldingsWidth > gameInfo.holdingsWidth) {
2052        for(i=0; i<BOARD_HEIGHT; i++)
2053          for(j=BOARD_RGHT-1; j>=BOARD_LEFT; j--)
2054            board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
2055              board[i][j];
2056        for(i=0; i<newHeight; i++) {
2057          board[i][0] = board[i][newWidth+2*newHoldingsWidth-1] = EmptySquare;
2058          board[i][1] = board[i][newWidth+2*newHoldingsWidth-2] = (ChessSquare) 0;
2059        }
2060      } else if(newHoldingsWidth < gameInfo.holdingsWidth) {
2061        for(i=0; i<BOARD_HEIGHT; i++)
2062          for(j=BOARD_LEFT; j<BOARD_RGHT; j++)
2063            board[i][j+newHoldingsWidth-gameInfo.holdingsWidth] =
2064              board[i][j];
2065      }
2066      gameInfo.boardWidth  = newWidth;
2067      gameInfo.boardHeight = newHeight;
2068      gameInfo.holdingsWidth = newHoldingsWidth;
2069      gameInfo.variant = newVariant;
2070      InitDrawingSizes(-2, 0);
2071    } else gameInfo.variant = newVariant;
2072    CopyBoard(oldBoard, board);   // remember correctly formatted board
2073      InitPosition(FALSE);          /* this sets up board[0], but also other stuff        */
2074    DrawPosition(TRUE, currentMove ? boards[currentMove] : oldBoard);
2075 }
2076
2077 static int loggedOn = FALSE;
2078
2079 /*-- Game start info cache: --*/
2080 int gs_gamenum;
2081 char gs_kind[MSG_SIZ];
2082 static char player1Name[128] = "";
2083 static char player2Name[128] = "";
2084 static char cont_seq[] = "\n\\   ";
2085 static int player1Rating = -1;
2086 static int player2Rating = -1;
2087 /*----------------------------*/
2088
2089 ColorClass curColor = ColorNormal;
2090 int suppressKibitz = 0;
2091
2092 // [HGM] seekgraph
2093 Boolean soughtPending = FALSE;
2094 Boolean seekGraphUp;
2095 #define MAX_SEEK_ADS 200
2096 #define SQUARE 0x80
2097 char *seekAdList[MAX_SEEK_ADS];
2098 int ratingList[MAX_SEEK_ADS], xList[MAX_SEEK_ADS], yList[MAX_SEEK_ADS], seekNrList[MAX_SEEK_ADS], zList[MAX_SEEK_ADS];
2099 float tcList[MAX_SEEK_ADS];
2100 char colorList[MAX_SEEK_ADS];
2101 int nrOfSeekAds = 0;
2102 int minRating = 1010, maxRating = 2800;
2103 int hMargin = 10, vMargin = 20, h, w;
2104 extern int squareSize, lineGap;
2105
2106 void
2107 PlotSeekAd(int i)
2108 {
2109         int x, y, color = 0, r = ratingList[i]; float tc = tcList[i];
2110         xList[i] = yList[i] = -100; // outside graph, so cannot be clicked
2111         if(r < minRating+100 && r >=0 ) r = minRating+100;
2112         if(r > maxRating) r = maxRating;
2113         if(tc < 1.) tc = 1.;
2114         if(tc > 95.) tc = 95.;
2115         x = (w-hMargin-squareSize/8-7)* log(tc)/log(95.) + hMargin;
2116         y = ((double)r - minRating)/(maxRating - minRating)
2117             * (h-vMargin-squareSize/8-1) + vMargin;
2118         if(ratingList[i] < 0) y = vMargin + squareSize/4;
2119         if(strstr(seekAdList[i], " u ")) color = 1;
2120         if(!strstr(seekAdList[i], "lightning") && // for now all wilds same color
2121            !strstr(seekAdList[i], "bullet") &&
2122            !strstr(seekAdList[i], "blitz") &&
2123            !strstr(seekAdList[i], "standard") ) color = 2;
2124         if(strstr(seekAdList[i], "(C) ")) color |= SQUARE; // plot computer seeks as squares
2125         DrawSeekDot(xList[i]=x+3*(color&~SQUARE), yList[i]=h-1-y, colorList[i]=color);
2126 }
2127
2128 void
2129 AddAd(char *handle, char *rating, int base, int inc,  char rated, char *type, int nr, Boolean plot)
2130 {
2131         char buf[MSG_SIZ], *ext = "";
2132         VariantClass v = StringToVariant(type);
2133         if(strstr(type, "wild")) {
2134             ext = type + 4; // append wild number
2135             if(v == VariantFischeRandom) type = "chess960"; else
2136             if(v == VariantLoadable) type = "setup"; else
2137             type = VariantName(v);
2138         }
2139         sprintf(buf, "%s (%s) %d %d %c %s%s", handle, rating, base, inc, rated, type, ext);
2140         if(nrOfSeekAds < MAX_SEEK_ADS-1) {
2141             if(seekAdList[nrOfSeekAds]) free(seekAdList[nrOfSeekAds]);
2142             ratingList[nrOfSeekAds] = -1; // for if seeker has no rating
2143             sscanf(rating, "%d", &ratingList[nrOfSeekAds]);
2144             tcList[nrOfSeekAds] = base + (2./3.)*inc;
2145             seekNrList[nrOfSeekAds] = nr;
2146             zList[nrOfSeekAds] = 0;
2147             seekAdList[nrOfSeekAds++] = StrSave(buf);
2148             if(plot) PlotSeekAd(nrOfSeekAds-1);
2149         }
2150 }
2151
2152 void
2153 EraseSeekDot(int i)
2154 {
2155     int x = xList[i], y = yList[i], d=squareSize/4, k;
2156     DrawSeekBackground(x-squareSize/8, y-squareSize/8, x+squareSize/8+1, y+squareSize/8+1);
2157     if(x < hMargin+d) DrawSeekAxis(hMargin, y-squareSize/8, hMargin, y+squareSize/8+1);
2158     // now replot every dot that overlapped
2159     for(k=0; k<nrOfSeekAds; k++) if(k != i) {
2160         int xx = xList[k], yy = yList[k];
2161         if(xx <= x+d && xx > x-d && yy <= y+d && yy > y-d)
2162             DrawSeekDot(xx, yy, colorList[k]);
2163     }
2164 }
2165
2166 void
2167 RemoveSeekAd(int nr)
2168 {
2169         int i;
2170         for(i=0; i<nrOfSeekAds; i++) if(seekNrList[i] == nr) {
2171             EraseSeekDot(i);
2172             if(seekAdList[i]) free(seekAdList[i]);
2173             seekAdList[i] = seekAdList[--nrOfSeekAds];
2174             seekNrList[i] = seekNrList[nrOfSeekAds];
2175             ratingList[i] = ratingList[nrOfSeekAds];
2176             colorList[i]  = colorList[nrOfSeekAds];
2177             tcList[i] = tcList[nrOfSeekAds];
2178             xList[i]  = xList[nrOfSeekAds];
2179             yList[i]  = yList[nrOfSeekAds];
2180             zList[i]  = zList[nrOfSeekAds];
2181             seekAdList[nrOfSeekAds] = NULL;
2182             break;
2183         }
2184 }
2185
2186 Boolean
2187 MatchSoughtLine(char *line)
2188 {
2189     char handle[MSG_SIZ], rating[MSG_SIZ], type[MSG_SIZ];
2190     int nr, base, inc, u=0; char dummy;
2191
2192     if(sscanf(line, "%d %s %s %d %d rated %s", &nr, rating, handle, &base, &inc, type) == 6 ||
2193        sscanf(line, "%d %s %s %s %d %d rated %c", &nr, rating, handle, type, &base, &inc, &dummy) == 7 ||
2194        (u=1) &&
2195        (sscanf(line, "%d %s %s %d %d unrated %s", &nr, rating, handle, &base, &inc, type) == 6 ||
2196         sscanf(line, "%d %s %s %s %d %d unrated %c", &nr, rating, handle, type, &base, &inc, &dummy) == 7)  ) {
2197         // match: compact and save the line
2198         AddAd(handle, rating, base, inc, u ? 'u' : 'r', type, nr, FALSE);
2199         return TRUE;
2200     }
2201     return FALSE;
2202 }
2203
2204 int
2205 DrawSeekGraph()
2206 {
2207     if(!seekGraphUp) return FALSE;
2208     int i;
2209     h = BOARD_HEIGHT * (squareSize + lineGap) + lineGap;
2210     w = BOARD_WIDTH  * (squareSize + lineGap) + lineGap;
2211
2212     DrawSeekBackground(0, 0, w, h);
2213     DrawSeekAxis(hMargin, h-1-vMargin, w-5, h-1-vMargin);
2214     DrawSeekAxis(hMargin, h-1-vMargin, hMargin, 5);
2215     for(i=0; i<4000; i+= 100) if(i>=minRating && i<maxRating) {
2216         int yy =((double)i - minRating)/(maxRating - minRating)*(h-vMargin-squareSize/8-1) + vMargin;
2217         yy = h-1-yy;
2218         DrawSeekAxis(hMargin+5*(i%500==0), yy, hMargin-5, yy); // rating ticks
2219         if(i%500 == 0) {
2220             char buf[MSG_SIZ];
2221             sprintf(buf, "%d", i);
2222             DrawSeekText(buf, hMargin+squareSize/8+7, yy);
2223         }
2224     }
2225     DrawSeekText("unrated", hMargin+squareSize/8+7, h-1-vMargin-squareSize/4);
2226     for(i=1; i<100; i+=(i<10?1:5)) {
2227         int xx = (w-hMargin-squareSize/8-7)* log((double)i)/log(95.) + hMargin;
2228         DrawSeekAxis(xx, h-1-vMargin, xx, h-6-vMargin-3*(i%10==0)); // TC ticks
2229         if(i<=5 || (i>40 ? i%20 : i%10) == 0) {
2230             char buf[MSG_SIZ];
2231             sprintf(buf, "%d", i);
2232             DrawSeekText(buf, xx-2-3*(i>9), h-1-vMargin/2);
2233         }
2234     }
2235     for(i=0; i<nrOfSeekAds; i++) PlotSeekAd(i);
2236     return TRUE;
2237 }
2238
2239 int SeekGraphClick(ClickType click, int x, int y, int moving)
2240 {
2241     static int lastDown = 0, displayed = 0, lastSecond;
2242     if(!seekGraphUp) { // initiate cration of seek graph by requesting seek-ad list
2243         if(click == Release || moving) return FALSE;
2244         nrOfSeekAds = 0;
2245         soughtPending = TRUE;
2246         SendToICS(ics_prefix);
2247         SendToICS("sought\n"); // should this be "sought all"?
2248     } else { // issue challenge based on clicked ad
2249         int dist = 10000; int i, closest = 0, second = 0;
2250         for(i=0; i<nrOfSeekAds; i++) {
2251             int d = (x-xList[i])*(x-xList[i]) +  (y-yList[i])*(y-yList[i]) + zList[i];
2252             if(d < dist) { dist = d; closest = i; }
2253             second += (d - zList[i] < 120); // count in-range ads
2254             if(click == Press && moving != 1 && zList[i]>0) zList[i] *= 0.8; // age priority
2255         }
2256         if(dist < 120) {
2257             char buf[MSG_SIZ];
2258             second = (second > 1);
2259             if(displayed != closest || second != lastSecond) {
2260                 DisplayMessage(second ? "!" : "", seekAdList[closest]);
2261                 lastSecond = second; displayed = closest;
2262             }
2263             if(click == Press) {
2264                 if(moving == 2) zList[closest] = 100; // right-click; push to back on press
2265                 lastDown = closest;
2266                 return TRUE;
2267             } // on press 'hit', only show info
2268             if(moving == 2) return TRUE; // ignore right up-clicks on dot
2269             sprintf(buf, "play %d\n", seekNrList[closest]);
2270             SendToICS(ics_prefix);
2271             SendToICS(buf);
2272             return TRUE; // let incoming board of started game pop down the graph
2273         } else if(click == Release) { // release 'miss' is ignored
2274             zList[lastDown] = 100; // make future selection of the rejected ad more difficult
2275             if(moving == 2) { // right up-click
2276                 nrOfSeekAds = 0; // refresh graph
2277                 soughtPending = TRUE;
2278                 SendToICS(ics_prefix);
2279                 SendToICS("sought\n"); // should this be "sought all"?
2280             }
2281             return TRUE;
2282         } else if(moving) { if(displayed >= 0) DisplayMessage("", ""); displayed = -1; return TRUE; }
2283         // press miss or release hit 'pop down' seek graph
2284         seekGraphUp = FALSE;
2285         DrawPosition(TRUE, NULL);
2286     }
2287     return TRUE;
2288 }
2289
2290 void
2291 read_from_ics(isr, closure, data, count, error)
2292      InputSourceRef isr;
2293      VOIDSTAR closure;
2294      char *data;
2295      int count;
2296      int error;
2297 {
2298 #define BUF_SIZE (16*1024) /* overflowed at 8K with "inchannel 1" on FICS? */
2299 #define STARTED_NONE 0
2300 #define STARTED_MOVES 1
2301 #define STARTED_BOARD 2
2302 #define STARTED_OBSERVE 3
2303 #define STARTED_HOLDINGS 4
2304 #define STARTED_CHATTER 5
2305 #define STARTED_COMMENT 6
2306 #define STARTED_MOVES_NOHIDE 7
2307
2308     static int started = STARTED_NONE;
2309     static char parse[20000];
2310     static int parse_pos = 0;
2311     static char buf[BUF_SIZE + 1];
2312     static int firstTime = TRUE, intfSet = FALSE;
2313     static ColorClass prevColor = ColorNormal;
2314     static int savingComment = FALSE;
2315     static int cmatch = 0; // continuation sequence match
2316     char *bp;
2317     char str[500];
2318     int i, oldi;
2319     int buf_len;
2320     int next_out;
2321     int tkind;
2322     int backup;    /* [DM] For zippy color lines */
2323     char *p;
2324     char talker[MSG_SIZ]; // [HGM] chat
2325     int channel;
2326
2327     connectionAlive = TRUE; // [HGM] alive: I think, therefore I am...
2328
2329     if (appData.debugMode) {
2330       if (!error) {
2331         fprintf(debugFP, "<ICS: ");
2332         show_bytes(debugFP, data, count);
2333         fprintf(debugFP, "\n");
2334       }
2335     }
2336
2337     if (appData.debugMode) { int f = forwardMostMove;
2338         fprintf(debugFP, "ics input %d, castling = %d %d %d %d %d %d\n", f,
2339                 boards[f][CASTLING][0],boards[f][CASTLING][1],boards[f][CASTLING][2],
2340                 boards[f][CASTLING][3],boards[f][CASTLING][4],boards[f][CASTLING][5]);
2341     }
2342     if (count > 0) {
2343         /* If last read ended with a partial line that we couldn't parse,
2344            prepend it to the new read and try again. */
2345         if (leftover_len > 0) {
2346             for (i=0; i<leftover_len; i++)
2347               buf[i] = buf[leftover_start + i];
2348         }
2349
2350     /* copy new characters into the buffer */
2351     bp = buf + leftover_len;
2352     buf_len=leftover_len;
2353     for (i=0; i<count; i++)
2354     {
2355         // ignore these
2356         if (data[i] == '\r')
2357             continue;
2358
2359         // join lines split by ICS?
2360         if (!appData.noJoin)
2361         {
2362             /*
2363                 Joining just consists of finding matches against the
2364                 continuation sequence, and discarding that sequence
2365                 if found instead of copying it.  So, until a match
2366                 fails, there's nothing to do since it might be the
2367                 complete sequence, and thus, something we don't want
2368                 copied.
2369             */
2370             if (data[i] == cont_seq[cmatch])
2371             {
2372                 cmatch++;
2373                 if (cmatch == strlen(cont_seq))
2374                 {
2375                     cmatch = 0; // complete match.  just reset the counter
2376
2377                     /*
2378                         it's possible for the ICS to not include the space
2379                         at the end of the last word, making our [correct]
2380                         join operation fuse two separate words.  the server
2381                         does this when the space occurs at the width setting.
2382                     */
2383                     if (!buf_len || buf[buf_len-1] != ' ')
2384                     {
2385                         *bp++ = ' ';
2386                         buf_len++;
2387                     }
2388                 }
2389                 continue;
2390             }
2391             else if (cmatch)
2392             {
2393                 /*
2394                     match failed, so we have to copy what matched before
2395                     falling through and copying this character.  In reality,
2396                     this will only ever be just the newline character, but
2397                     it doesn't hurt to be precise.
2398                 */
2399                 strncpy(bp, cont_seq, cmatch);
2400                 bp += cmatch;
2401                 buf_len += cmatch;
2402                 cmatch = 0;
2403             }
2404         }
2405
2406         // copy this char
2407         *bp++ = data[i];
2408         buf_len++;
2409     }
2410
2411         buf[buf_len] = NULLCHAR;
2412 //      next_out = leftover_len; // [HGM] should we set this to 0, and not print it in advance?
2413         next_out = 0;
2414         leftover_start = 0;
2415
2416         i = 0;
2417         while (i < buf_len) {
2418             /* Deal with part of the TELNET option negotiation
2419                protocol.  We refuse to do anything beyond the
2420                defaults, except that we allow the WILL ECHO option,
2421                which ICS uses to turn off password echoing when we are
2422                directly connected to it.  We reject this option
2423                if localLineEditing mode is on (always on in xboard)
2424                and we are talking to port 23, which might be a real
2425                telnet server that will try to keep WILL ECHO on permanently.
2426              */
2427             if (buf_len - i >= 3 && (unsigned char) buf[i] == TN_IAC) {
2428                 static int remoteEchoOption = FALSE; /* telnet ECHO option */
2429                 unsigned char option;
2430                 oldi = i;
2431                 switch ((unsigned char) buf[++i]) {
2432                   case TN_WILL:
2433                     if (appData.debugMode)
2434                       fprintf(debugFP, "\n<WILL ");
2435                     switch (option = (unsigned char) buf[++i]) {
2436                       case TN_ECHO:
2437                         if (appData.debugMode)
2438                           fprintf(debugFP, "ECHO ");
2439                         /* Reply only if this is a change, according
2440                            to the protocol rules. */
2441                         if (remoteEchoOption) break;
2442                         if (appData.localLineEditing &&
2443                             atoi(appData.icsPort) == TN_PORT) {
2444                             TelnetRequest(TN_DONT, TN_ECHO);
2445                         } else {
2446                             EchoOff();
2447                             TelnetRequest(TN_DO, TN_ECHO);
2448                             remoteEchoOption = TRUE;
2449                         }
2450                         break;
2451                       default:
2452                         if (appData.debugMode)
2453                           fprintf(debugFP, "%d ", option);
2454                         /* Whatever this is, we don't want it. */
2455                         TelnetRequest(TN_DONT, option);
2456                         break;
2457                     }
2458                     break;
2459                   case TN_WONT:
2460                     if (appData.debugMode)
2461                       fprintf(debugFP, "\n<WONT ");
2462                     switch (option = (unsigned char) buf[++i]) {
2463                       case TN_ECHO:
2464                         if (appData.debugMode)
2465                           fprintf(debugFP, "ECHO ");
2466                         /* Reply only if this is a change, according
2467                            to the protocol rules. */
2468                         if (!remoteEchoOption) break;
2469                         EchoOn();
2470                         TelnetRequest(TN_DONT, TN_ECHO);
2471                         remoteEchoOption = FALSE;
2472                         break;
2473                       default:
2474                         if (appData.debugMode)
2475                           fprintf(debugFP, "%d ", (unsigned char) option);
2476                         /* Whatever this is, it must already be turned
2477                            off, because we never agree to turn on
2478                            anything non-default, so according to the
2479                            protocol rules, we don't reply. */
2480                         break;
2481                     }
2482                     break;
2483                   case TN_DO:
2484                     if (appData.debugMode)
2485                       fprintf(debugFP, "\n<DO ");
2486                     switch (option = (unsigned char) buf[++i]) {
2487                       default:
2488                         /* Whatever this is, we refuse to do it. */
2489                         if (appData.debugMode)
2490                           fprintf(debugFP, "%d ", option);
2491                         TelnetRequest(TN_WONT, option);
2492                         break;
2493                     }
2494                     break;
2495                   case TN_DONT:
2496                     if (appData.debugMode)
2497                       fprintf(debugFP, "\n<DONT ");
2498                     switch (option = (unsigned char) buf[++i]) {
2499                       default:
2500                         if (appData.debugMode)
2501                           fprintf(debugFP, "%d ", option);
2502                         /* Whatever this is, we are already not doing
2503                            it, because we never agree to do anything
2504                            non-default, so according to the protocol
2505                            rules, we don't reply. */
2506                         break;
2507                     }
2508                     break;
2509                   case TN_IAC:
2510                     if (appData.debugMode)
2511                       fprintf(debugFP, "\n<IAC ");
2512                     /* Doubled IAC; pass it through */
2513                     i--;
2514                     break;
2515                   default:
2516                     if (appData.debugMode)
2517                       fprintf(debugFP, "\n<%d ", (unsigned char) buf[i]);
2518                     /* Drop all other telnet commands on the floor */
2519                     break;
2520                 }
2521                 if (oldi > next_out)
2522                   SendToPlayer(&buf[next_out], oldi - next_out);
2523                 if (++i > next_out)
2524                   next_out = i;
2525                 continue;
2526             }
2527
2528             /* OK, this at least will *usually* work */
2529             if (!loggedOn && looking_at(buf, &i, "ics%")) {
2530                 loggedOn = TRUE;
2531             }
2532
2533             if (loggedOn && !intfSet) {
2534                 if (ics_type == ICS_ICC) {
2535                   sprintf(str,
2536                           "/set-quietly interface %s\n/set-quietly style 12\n",
2537                           programVersion);
2538                   if(appData.seekGraph && appData.autoRefresh) // [HGM] seekgraph
2539                       strcat(str, "/set-2 51 1\n/set seek 1\n");
2540                 } else if (ics_type == ICS_CHESSNET) {
2541                   sprintf(str, "/style 12\n");
2542                 } else {
2543                   strcpy(str, "alias $ @\n$set interface ");
2544                   strcat(str, programVersion);
2545                   strcat(str, "\n$iset startpos 1\n$iset ms 1\n");
2546                   if(appData.seekGraph && appData.autoRefresh) // [HGM] seekgraph
2547                       strcat(str, "$iset seekremove 1\n$set seek 1\n");
2548 #ifdef WIN32
2549                   strcat(str, "$iset nohighlight 1\n");
2550 #endif
2551                   strcat(str, "$iset lock 1\n$style 12\n");
2552                 }
2553                 SendToICS(str);
2554                 NotifyFrontendLogin();
2555                 intfSet = TRUE;
2556             }
2557
2558             if (started == STARTED_COMMENT) {
2559                 /* Accumulate characters in comment */
2560                 parse[parse_pos++] = buf[i];
2561                 if (buf[i] == '\n') {
2562                     parse[parse_pos] = NULLCHAR;
2563                     if(chattingPartner>=0) {
2564                         char mess[MSG_SIZ];
2565                         sprintf(mess, "%s%s", talker, parse);
2566                         OutputChatMessage(chattingPartner, mess);
2567                         chattingPartner = -1;
2568                         next_out = i+1; // [HGM] suppress printing in ICS window
2569                     } else
2570                     if(!suppressKibitz) // [HGM] kibitz
2571                         AppendComment(forwardMostMove, StripHighlight(parse), TRUE);
2572                     else { // [HGM kibitz: divert memorized engine kibitz to engine-output window
2573                         int nrDigit = 0, nrAlph = 0, j;
2574                         if(parse_pos > MSG_SIZ - 30) // defuse unreasonably long input
2575                         { parse_pos = MSG_SIZ-30; parse[parse_pos - 1] = '\n'; }
2576                         parse[parse_pos] = NULLCHAR;
2577                         // try to be smart: if it does not look like search info, it should go to
2578                         // ICS interaction window after all, not to engine-output window.
2579                         for(j=0; j<parse_pos; j++) { // count letters and digits
2580                             nrDigit += (parse[j] >= '0' && parse[j] <= '9');
2581                             nrAlph  += (parse[j] >= 'a' && parse[j] <= 'z');
2582                             nrAlph  += (parse[j] >= 'A' && parse[j] <= 'Z');
2583                         }
2584                         if(nrAlph < 9*nrDigit) { // if more than 10% digit we assume search info
2585                             int depth=0; float score;
2586                             if(sscanf(parse, "!!! %f/%d", &score, &depth) == 2 && depth>0) {
2587                                 // [HGM] kibitz: save kibitzed opponent info for PGN and eval graph
2588                                 pvInfoList[forwardMostMove-1].depth = depth;
2589                                 pvInfoList[forwardMostMove-1].score = 100*score;
2590                             }
2591                             OutputKibitz(suppressKibitz, parse);
2592                         } else {
2593                             char tmp[MSG_SIZ];
2594                             sprintf(tmp, _("your opponent kibitzes: %s"), parse);
2595                             SendToPlayer(tmp, strlen(tmp));
2596                         }
2597                         next_out = i+1; // [HGM] suppress printing in ICS window
2598                     }
2599                     started = STARTED_NONE;
2600                 } else {
2601                     /* Don't match patterns against characters in comment */
2602                     i++;
2603                     continue;
2604                 }
2605             }
2606             if (started == STARTED_CHATTER) {
2607                 if (buf[i] != '\n') {
2608                     /* Don't match patterns against characters in chatter */
2609                     i++;
2610                     continue;
2611                 }
2612                 started = STARTED_NONE;
2613                 if(suppressKibitz) next_out = i+1;
2614             }
2615
2616             /* Kludge to deal with rcmd protocol */
2617             if (firstTime && looking_at(buf, &i, "\001*")) {
2618                 DisplayFatalError(&buf[1], 0, 1);
2619                 continue;
2620             } else {
2621                 firstTime = FALSE;
2622             }
2623
2624             if (!loggedOn && looking_at(buf, &i, "chessclub.com")) {
2625                 ics_type = ICS_ICC;
2626                 ics_prefix = "/";
2627                 if (appData.debugMode)
2628                   fprintf(debugFP, "ics_type %d\n", ics_type);
2629                 continue;
2630             }
2631             if (!loggedOn && looking_at(buf, &i, "freechess.org")) {
2632                 ics_type = ICS_FICS;
2633                 ics_prefix = "$";
2634                 if (appData.debugMode)
2635                   fprintf(debugFP, "ics_type %d\n", ics_type);
2636                 continue;
2637             }
2638             if (!loggedOn && looking_at(buf, &i, "chess.net")) {
2639                 ics_type = ICS_CHESSNET;
2640                 ics_prefix = "/";
2641                 if (appData.debugMode)
2642                   fprintf(debugFP, "ics_type %d\n", ics_type);
2643                 continue;
2644             }
2645
2646             if (!loggedOn &&
2647                 (looking_at(buf, &i, "\"*\" is *a registered name") ||
2648                  looking_at(buf, &i, "Logging you in as \"*\"") ||
2649                  looking_at(buf, &i, "will be \"*\""))) {
2650               strcpy(ics_handle, star_match[0]);
2651               continue;
2652             }
2653
2654             if (loggedOn && !have_set_title && ics_handle[0] != NULLCHAR) {
2655               char buf[MSG_SIZ];
2656               snprintf(buf, sizeof(buf), "%s@%s", ics_handle, appData.icsHost);
2657               DisplayIcsInteractionTitle(buf);
2658               have_set_title = TRUE;
2659             }
2660
2661             /* skip finger notes */
2662             if (started == STARTED_NONE &&
2663                 ((buf[i] == ' ' && isdigit(buf[i+1])) ||
2664                  (buf[i] == '1' && buf[i+1] == '0')) &&
2665                 buf[i+2] == ':' && buf[i+3] == ' ') {
2666               started = STARTED_CHATTER;
2667               i += 3;
2668               continue;
2669             }
2670
2671             oldi = i;
2672             // [HGM] seekgraph: recognize sought lines and end-of-sought message
2673             if(appData.seekGraph) {
2674                 if(soughtPending && MatchSoughtLine(buf+i)) {
2675                     i = strstr(buf+i, "rated") - buf;
2676                     if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
2677                     next_out = leftover_start = i;
2678                     started = STARTED_CHATTER;
2679                     suppressKibitz = TRUE;
2680                     continue;
2681                 }
2682                 if((gameMode == IcsIdle || gameMode == BeginningOfGame)
2683                         && looking_at(buf, &i, "* ads displayed")) {
2684                     soughtPending = FALSE;
2685                     seekGraphUp = TRUE;
2686                     DrawSeekGraph();
2687                     continue;
2688                 }
2689                 if(appData.autoRefresh) {
2690                     if(looking_at(buf, &i, "* (*) seeking * * * * *\"play *\" to respond)\n")) {
2691                         int s = (ics_type == ICS_ICC); // ICC format differs
2692                         if(seekGraphUp)
2693                         AddAd(star_match[0], star_match[1], atoi(star_match[2+s]), atoi(star_match[3+s]),
2694                               star_match[4+s][0], star_match[5-3*s], atoi(star_match[7]), TRUE);
2695                         looking_at(buf, &i, "*% "); // eat prompt
2696                         if(oldi > 0 && buf[oldi-1] == '\n') oldi--; // suppress preceding LF, if any
2697                         if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
2698                         next_out = i; // suppress
2699                         continue;
2700                     }
2701                     if(looking_at(buf, &i, "\nAds removed: *\n") || looking_at(buf, &i, "\031(51 * *\031)")) {
2702                         char *p = star_match[0];
2703                         while(*p) {
2704                             if(seekGraphUp) RemoveSeekAd(atoi(p));
2705                             while(*p && *p++ != ' '); // next
2706                         }
2707                         looking_at(buf, &i, "*% "); // eat prompt
2708                         if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
2709                         next_out = i;
2710                         continue;
2711                     }
2712                 }
2713             }
2714
2715             /* skip formula vars */
2716             if (started == STARTED_NONE &&
2717                 buf[i] == 'f' && isdigit(buf[i+1]) && buf[i+2] == ':') {
2718               started = STARTED_CHATTER;
2719               i += 3;
2720               continue;
2721             }
2722
2723             // [HGM] kibitz: try to recognize opponent engine-score kibitzes, to divert them to engine-output window
2724             if (appData.autoKibitz && started == STARTED_NONE &&
2725                 !appData.icsEngineAnalyze &&                     // [HGM] [DM] ICS analyze
2726                 (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack || gameMode == IcsObserving)) {
2727                 if((looking_at(buf, &i, "* kibitzes: ") || looking_at(buf, &i, "* whispers: ")) &&
2728                    (StrStr(star_match[0], gameInfo.white) == star_match[0] ||
2729                     StrStr(star_match[0], gameInfo.black) == star_match[0]   )) { // kibitz of self or opponent
2730                         suppressKibitz = TRUE;
2731                         if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
2732                         next_out = i;
2733                         if((StrStr(star_match[0], gameInfo.white) == star_match[0]
2734                                 && (gameMode == IcsPlayingWhite)) ||
2735                            (StrStr(star_match[0], gameInfo.black) == star_match[0]
2736                                 && (gameMode == IcsPlayingBlack))   ) // opponent kibitz
2737                             started = STARTED_CHATTER; // own kibitz we simply discard
2738                         else {
2739                             started = STARTED_COMMENT; // make sure it will be collected in parse[]
2740                             parse_pos = 0; parse[0] = NULLCHAR;
2741                             savingComment = TRUE;
2742                             suppressKibitz = gameMode != IcsObserving ? 2 :
2743                                 (StrStr(star_match[0], gameInfo.white) == NULL) + 1;
2744                         }
2745                         continue;
2746                 } else
2747                 if((looking_at(buf, &i, "\nkibitzed to *\n") || looking_at(buf, &i, "kibitzed to *\n") ||
2748                     looking_at(buf, &i, "\n(kibitzed to *\n") || looking_at(buf, &i, "(kibitzed to *\n"))
2749                          && atoi(star_match[0])) {
2750                     // suppress the acknowledgements of our own autoKibitz
2751                     char *p;
2752                     if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
2753                     if(p = strchr(star_match[0], ' ')) p[1] = NULLCHAR; // clip off "players)" on FICS
2754                     SendToPlayer(star_match[0], strlen(star_match[0]));
2755                     if(looking_at(buf, &i, "*% ")) // eat prompt
2756                         suppressKibitz = FALSE;
2757                     next_out = i;
2758                     continue;
2759                 }
2760             } // [HGM] kibitz: end of patch
2761
2762             // [HGM] chat: intercept tells by users for which we have an open chat window
2763             channel = -1;
2764             if(started == STARTED_NONE && (looking_at(buf, &i, "* tells you:") || looking_at(buf, &i, "* says:") ||
2765                                            looking_at(buf, &i, "* whispers:") ||
2766                                            looking_at(buf, &i, "* kibitzes:") ||
2767                                            looking_at(buf, &i, "* shouts:") ||
2768                                            looking_at(buf, &i, "* c-shouts:") ||
2769                                            looking_at(buf, &i, "--> * ") ||
2770                                            looking_at(buf, &i, "*(*):") && (sscanf(star_match[1], "%d", &channel),1) ||
2771                                            looking_at(buf, &i, "*(*)(*):") && (sscanf(star_match[2], "%d", &channel),1) ||
2772                                            looking_at(buf, &i, "*(*)(*)(*):") && (sscanf(star_match[3], "%d", &channel),1) ||
2773                                            looking_at(buf, &i, "*(*)(*)(*)(*):") && sscanf(star_match[4], "%d", &channel) == 1 )) {
2774                 int p;
2775                 sscanf(star_match[0], "%[^(]", talker+1); // strip (C) or (U) off ICS handle
2776                 chattingPartner = -1;
2777
2778                 if(channel >= 0) // channel broadcast; look if there is a chatbox for this channel
2779                 for(p=0; p<MAX_CHAT; p++) {
2780                     if(channel == atoi(chatPartner[p])) {
2781                     talker[0] = '['; strcat(talker, "] ");
2782                     Colorize(channel == 1 ? ColorChannel1 : ColorChannel, FALSE);
2783                     chattingPartner = p; break;
2784                     }
2785                 } else
2786                 if(buf[i-3] == 'e') // kibitz; look if there is a KIBITZ chatbox
2787                 for(p=0; p<MAX_CHAT; p++) {
2788                     if(!strcmp("kibitzes", chatPartner[p])) {
2789                         talker[0] = '['; strcat(talker, "] ");
2790                         chattingPartner = p; break;
2791                     }
2792                 } else
2793                 if(buf[i-3] == 'r') // whisper; look if there is a WHISPER chatbox
2794                 for(p=0; p<MAX_CHAT; p++) {
2795                     if(!strcmp("whispers", chatPartner[p])) {
2796                         talker[0] = '['; strcat(talker, "] ");
2797                         chattingPartner = p; break;
2798                     }
2799                 } else
2800                 if(buf[i-3] == 't' || buf[oldi+2] == '>') {// shout, c-shout or it; look if there is a 'shouts' chatbox
2801                   if(buf[i-8] == '-' && buf[i-3] == 't')
2802                   for(p=0; p<MAX_CHAT; p++) { // c-shout; check if dedicatesd c-shout box exists
2803                     if(!strcmp("c-shouts", chatPartner[p])) {
2804                         talker[0] = '('; strcat(talker, ") "); Colorize(ColorSShout, FALSE);
2805                         chattingPartner = p; break;
2806                     }
2807                   }
2808                   if(chattingPartner < 0)
2809                   for(p=0; p<MAX_CHAT; p++) {
2810                     if(!strcmp("shouts", chatPartner[p])) {
2811                         if(buf[oldi+2] == '>') { talker[0] = '<'; strcat(talker, "> "); Colorize(ColorShout, FALSE); }
2812                         else if(buf[i-8] == '-') { talker[0] = '('; strcat(talker, ") "); Colorize(ColorSShout, FALSE); }
2813                         else { talker[0] = '['; strcat(talker, "] "); Colorize(ColorShout, FALSE); }
2814                         chattingPartner = p; break;
2815                     }
2816                   }
2817                 }
2818                 if(chattingPartner<0) // if not, look if there is a chatbox for this indivdual
2819                 for(p=0; p<MAX_CHAT; p++) if(!StrCaseCmp(talker+1, chatPartner[p])) {
2820                     talker[0] = 0; Colorize(ColorTell, FALSE);
2821                     chattingPartner = p; break;
2822                 }
2823                 if(chattingPartner<0) i = oldi; else {
2824                     Colorize(curColor, TRUE); // undo the bogus colorations we just made to trigger the souds
2825                     if(oldi > 0 && buf[oldi-1] == '\n') oldi--;
2826                     if (oldi > next_out) SendToPlayer(&buf[next_out], oldi - next_out);
2827                     started = STARTED_COMMENT;
2828                     parse_pos = 0; parse[0] = NULLCHAR;
2829                     savingComment = 3 + chattingPartner; // counts as TRUE
2830                     suppressKibitz = TRUE;
2831                     continue;
2832                 }
2833             } // [HGM] chat: end of patch
2834
2835             if (appData.zippyTalk || appData.zippyPlay) {
2836                 /* [DM] Backup address for color zippy lines */
2837                 backup = i;
2838 #if ZIPPY
2839        #ifdef WIN32
2840                if (loggedOn == TRUE)
2841                        if (ZippyControl(buf, &backup) || ZippyConverse(buf, &backup) ||
2842                           (appData.zippyPlay && ZippyMatch(buf, &backup)));
2843        #else
2844                 if (ZippyControl(buf, &i) ||
2845                     ZippyConverse(buf, &i) ||
2846                     (appData.zippyPlay && ZippyMatch(buf, &i))) {
2847                       loggedOn = TRUE;
2848                       if (!appData.colorize) continue;
2849                 }
2850        #endif
2851 #endif
2852             } // [DM] 'else { ' deleted
2853                 if (
2854                     /* Regular tells and says */
2855                     (tkind = 1, looking_at(buf, &i, "* tells you: ")) ||
2856                     looking_at(buf, &i, "* (your partner) tells you: ") ||
2857                     looking_at(buf, &i, "* says: ") ||
2858                     /* Don't color "message" or "messages" output */
2859                     (tkind = 5, looking_at(buf, &i, "*. * (*:*): ")) ||
2860                     looking_at(buf, &i, "*. * at *:*: ") ||
2861                     looking_at(buf, &i, "--* (*:*): ") ||
2862                     /* Message notifications (same color as tells) */
2863                     looking_at(buf, &i, "* has left a message ") ||
2864                     looking_at(buf, &i, "* just sent you a message:\n") ||
2865                     /* Whispers and kibitzes */
2866                     (tkind = 2, looking_at(buf, &i, "* whispers: ")) ||
2867                     looking_at(buf, &i, "* kibitzes: ") ||
2868                     /* Channel tells */
2869                     (tkind = 3, looking_at(buf, &i, "*(*: "))) {
2870
2871                   if (tkind == 1 && strchr(star_match[0], ':')) {
2872                       /* Avoid "tells you:" spoofs in channels */
2873                      tkind = 3;
2874                   }
2875                   if (star_match[0][0] == NULLCHAR ||
2876                       strchr(star_match[0], ' ') ||
2877                       (tkind == 3 && strchr(star_match[1], ' '))) {
2878                     /* Reject bogus matches */
2879                     i = oldi;
2880                   } else {
2881                     if (appData.colorize) {
2882                       if (oldi > next_out) {
2883                         SendToPlayer(&buf[next_out], oldi - next_out);
2884                         next_out = oldi;
2885                       }
2886                       switch (tkind) {
2887                       case 1:
2888                         Colorize(ColorTell, FALSE);
2889                         curColor = ColorTell;
2890                         break;
2891                       case 2:
2892                         Colorize(ColorKibitz, FALSE);
2893                         curColor = ColorKibitz;
2894                         break;
2895                       case 3:
2896                         p = strrchr(star_match[1], '(');
2897                         if (p == NULL) {
2898                           p = star_match[1];
2899                         } else {
2900                           p++;
2901                         }
2902                         if (atoi(p) == 1) {
2903                           Colorize(ColorChannel1, FALSE);
2904                           curColor = ColorChannel1;
2905                         } else {
2906                           Colorize(ColorChannel, FALSE);
2907                           curColor = ColorChannel;
2908                         }
2909                         break;
2910                       case 5:
2911                         curColor = ColorNormal;
2912                         break;
2913                       }
2914                     }
2915                     if (started == STARTED_NONE && appData.autoComment &&
2916                         (gameMode == IcsObserving ||
2917                          gameMode == IcsPlayingWhite ||
2918                          gameMode == IcsPlayingBlack)) {
2919                       parse_pos = i - oldi;
2920                       memcpy(parse, &buf[oldi], parse_pos);
2921                       parse[parse_pos] = NULLCHAR;
2922                       started = STARTED_COMMENT;
2923                       savingComment = TRUE;
2924                     } else {
2925                       started = STARTED_CHATTER;
2926                       savingComment = FALSE;
2927                     }
2928                     loggedOn = TRUE;
2929                     continue;
2930                   }
2931                 }
2932
2933                 if (looking_at(buf, &i, "* s-shouts: ") ||
2934                     looking_at(buf, &i, "* c-shouts: ")) {
2935                     if (appData.colorize) {
2936                         if (oldi > next_out) {
2937                             SendToPlayer(&buf[next_out], oldi - next_out);
2938                             next_out = oldi;
2939                         }
2940                         Colorize(ColorSShout, FALSE);
2941                         curColor = ColorSShout;
2942                     }
2943                     loggedOn = TRUE;
2944                     started = STARTED_CHATTER;
2945                     continue;
2946                 }
2947
2948                 if (looking_at(buf, &i, "--->")) {
2949                     loggedOn = TRUE;
2950                     continue;
2951                 }
2952
2953                 if (looking_at(buf, &i, "* shouts: ") ||
2954                     looking_at(buf, &i, "--> ")) {
2955                     if (appData.colorize) {
2956                         if (oldi > next_out) {
2957                             SendToPlayer(&buf[next_out], oldi - next_out);
2958                             next_out = oldi;
2959                         }
2960                         Colorize(ColorShout, FALSE);
2961                         curColor = ColorShout;
2962                     }
2963                     loggedOn = TRUE;
2964                     started = STARTED_CHATTER;
2965                     continue;
2966                 }
2967
2968                 if (looking_at( buf, &i, "Challenge:")) {
2969                     if (appData.colorize) {
2970                         if (oldi > next_out) {
2971                             SendToPlayer(&buf[next_out], oldi - next_out);
2972                             next_out = oldi;
2973                         }
2974                         Colorize(ColorChallenge, FALSE);
2975                         curColor = ColorChallenge;
2976                     }
2977                     loggedOn = TRUE;
2978                     continue;
2979                 }
2980
2981                 if (looking_at(buf, &i, "* offers you") ||
2982                     looking_at(buf, &i, "* offers to be") ||
2983                     looking_at(buf, &i, "* would like to") ||
2984                     looking_at(buf, &i, "* requests to") ||
2985                     looking_at(buf, &i, "Your opponent offers") ||
2986                     looking_at(buf, &i, "Your opponent requests")) {
2987
2988                     if (appData.colorize) {
2989                         if (oldi > next_out) {
2990                             SendToPlayer(&buf[next_out], oldi - next_out);
2991                             next_out = oldi;
2992                         }
2993                         Colorize(ColorRequest, FALSE);
2994                         curColor = ColorRequest;
2995                     }
2996                     continue;
2997                 }
2998
2999                 if (looking_at(buf, &i, "* (*) seeking")) {
3000                     if (appData.colorize) {
3001                         if (oldi > next_out) {
3002                             SendToPlayer(&buf[next_out], oldi - next_out);
3003                             next_out = oldi;
3004                         }
3005                         Colorize(ColorSeek, FALSE);
3006                         curColor = ColorSeek;
3007                     }
3008                     continue;
3009             }
3010
3011             if (looking_at(buf, &i, "\\   ")) {
3012                 if (prevColor != ColorNormal) {
3013                     if (oldi > next_out) {
3014                         SendToPlayer(&buf[next_out], oldi - next_out);
3015                         next_out = oldi;
3016                     }
3017                     Colorize(prevColor, TRUE);
3018                     curColor = prevColor;
3019                 }
3020                 if (savingComment) {
3021                     parse_pos = i - oldi;
3022                     memcpy(parse, &buf[oldi], parse_pos);
3023                     parse[parse_pos] = NULLCHAR;
3024                     started = STARTED_COMMENT;
3025                     if(savingComment >= 3) // [HGM] chat: continuation of line for chat box
3026                         chattingPartner = savingComment - 3; // kludge to remember the box
3027                 } else {
3028                     started = STARTED_CHATTER;
3029                 }
3030                 continue;
3031             }
3032
3033             if (looking_at(buf, &i, "Black Strength :") ||
3034                 looking_at(buf, &i, "<<< style 10 board >>>") ||
3035                 looking_at(buf, &i, "<10>") ||
3036                 looking_at(buf, &i, "#@#")) {
3037                 /* Wrong board style */
3038                 loggedOn = TRUE;
3039                 SendToICS(ics_prefix);
3040                 SendToICS("set style 12\n");
3041                 SendToICS(ics_prefix);
3042                 SendToICS("refresh\n");
3043                 continue;
3044             }
3045
3046             if (!have_sent_ICS_logon && looking_at(buf, &i, "login:")) {
3047                 ICSInitScript();
3048                 have_sent_ICS_logon = 1;
3049                 continue;
3050             }
3051
3052             if (ics_getting_history != H_GETTING_MOVES /*smpos kludge*/ &&
3053                 (looking_at(buf, &i, "\n<12> ") ||
3054                  looking_at(buf, &i, "<12> "))) {
3055                 loggedOn = TRUE;
3056                 if (oldi > next_out) {
3057                     SendToPlayer(&buf[next_out], oldi - next_out);
3058                 }
3059                 next_out = i;
3060                 started = STARTED_BOARD;
3061                 parse_pos = 0;
3062                 continue;
3063             }
3064
3065             if ((started == STARTED_NONE && looking_at(buf, &i, "\n<b1> ")) ||
3066                 looking_at(buf, &i, "<b1> ")) {
3067                 if (oldi > next_out) {
3068                     SendToPlayer(&buf[next_out], oldi - next_out);
3069                 }
3070                 next_out = i;
3071                 started = STARTED_HOLDINGS;
3072                 parse_pos = 0;
3073                 continue;
3074             }
3075
3076             if (looking_at(buf, &i, "* *vs. * *--- *")) {
3077                 loggedOn = TRUE;
3078                 /* Header for a move list -- first line */
3079
3080                 switch (ics_getting_history) {
3081                   case H_FALSE:
3082                     switch (gameMode) {
3083                       case IcsIdle:
3084                       case BeginningOfGame:
3085                         /* User typed "moves" or "oldmoves" while we
3086                            were idle.  Pretend we asked for these
3087                            moves and soak them up so user can step
3088                            through them and/or save them.
3089                            */
3090                         Reset(FALSE, TRUE);
3091                         gameMode = IcsObserving;
3092                         ModeHighlight();
3093                         ics_gamenum = -1;
3094                         ics_getting_history = H_GOT_UNREQ_HEADER;
3095                         break;
3096                       case EditGame: /*?*/
3097                       case EditPosition: /*?*/
3098                         /* Should above feature work in these modes too? */
3099                         /* For now it doesn't */
3100                         ics_getting_history = H_GOT_UNWANTED_HEADER;
3101                         break;
3102                       default:
3103                         ics_getting_history = H_GOT_UNWANTED_HEADER;
3104                         break;
3105                     }
3106                     break;
3107                   case H_REQUESTED:
3108                     /* Is this the right one? */
3109                     if (gameInfo.white && gameInfo.black &&
3110                         strcmp(gameInfo.white, star_match[0]) == 0 &&
3111                         strcmp(gameInfo.black, star_match[2]) == 0) {
3112                         /* All is well */
3113                         ics_getting_history = H_GOT_REQ_HEADER;
3114                     }
3115                     break;
3116                   case H_GOT_REQ_HEADER:
3117                   case H_GOT_UNREQ_HEADER:
3118                   case H_GOT_UNWANTED_HEADER:
3119                   case H_GETTING_MOVES:
3120                     /* Should not happen */
3121                     DisplayError(_("Error gathering move list: two headers"), 0);
3122                     ics_getting_history = H_FALSE;
3123                     break;
3124                 }
3125
3126                 /* Save player ratings into gameInfo if needed */
3127                 if ((ics_getting_history == H_GOT_REQ_HEADER ||
3128                      ics_getting_history == H_GOT_UNREQ_HEADER) &&
3129                     (gameInfo.whiteRating == -1 ||
3130                      gameInfo.blackRating == -1)) {
3131
3132                     gameInfo.whiteRating = string_to_rating(star_match[1]);
3133                     gameInfo.blackRating = string_to_rating(star_match[3]);
3134                     if (appData.debugMode)
3135                       fprintf(debugFP, _("Ratings from header: W %d, B %d\n"),
3136                               gameInfo.whiteRating, gameInfo.blackRating);
3137                 }
3138                 continue;
3139             }
3140
3141             if (looking_at(buf, &i,
3142               "* * match, initial time: * minute*, increment: * second")) {
3143                 /* Header for a move list -- second line */
3144                 /* Initial board will follow if this is a wild game */
3145                 if (gameInfo.event != NULL) free(gameInfo.event);
3146                 sprintf(str, "ICS %s %s match", star_match[0], star_match[1]);
3147                 gameInfo.event = StrSave(str);
3148                 /* [HGM] we switched variant. Translate boards if needed. */
3149                 VariantSwitch(boards[currentMove], StringToVariant(gameInfo.event));
3150                 continue;
3151             }
3152
3153             if (looking_at(buf, &i, "Move  ")) {
3154                 /* Beginning of a move list */
3155                 switch (ics_getting_history) {
3156                   case H_FALSE:
3157                     /* Normally should not happen */
3158                     /* Maybe user hit reset while we were parsing */
3159                     break;
3160                   case H_REQUESTED:
3161                     /* Happens if we are ignoring a move list that is not
3162                      * the one we just requested.  Common if the user
3163                      * tries to observe two games without turning off
3164                      * getMoveList */
3165                     break;
3166                   case H_GETTING_MOVES:
3167                     /* Should not happen */
3168                     DisplayError(_("Error gathering move list: nested"), 0);
3169                     ics_getting_history = H_FALSE;
3170                     break;
3171                   case H_GOT_REQ_HEADER:
3172                     ics_getting_history = H_GETTING_MOVES;
3173                     started = STARTED_MOVES;
3174                     parse_pos = 0;
3175                     if (oldi > next_out) {
3176                         SendToPlayer(&buf[next_out], oldi - next_out);
3177                     }
3178                     break;
3179                   case H_GOT_UNREQ_HEADER:
3180                     ics_getting_history = H_GETTING_MOVES;
3181                     started = STARTED_MOVES_NOHIDE;
3182                     parse_pos = 0;
3183                     break;
3184                   case H_GOT_UNWANTED_HEADER:
3185                     ics_getting_history = H_FALSE;
3186                     break;
3187                 }
3188                 continue;
3189             }
3190
3191             if (looking_at(buf, &i, "% ") ||
3192                 ((started == STARTED_MOVES || started == STARTED_MOVES_NOHIDE)
3193                  && looking_at(buf, &i, "}*"))) { char *bookHit = NULL; // [HGM] book
3194                 if(ics_type == ICS_ICC && soughtPending) { // [HGM] seekgraph: on ICC sought-list has no termination line
3195                     soughtPending = FALSE;
3196                     seekGraphUp = TRUE;
3197                     DrawSeekGraph();
3198                 }
3199                 if(suppressKibitz) next_out = i;
3200                 savingComment = FALSE;
3201                 suppressKibitz = 0;
3202                 switch (started) {
3203                   case STARTED_MOVES:
3204                   case STARTED_MOVES_NOHIDE:
3205                     memcpy(&parse[parse_pos], &buf[oldi], i - oldi);
3206                     parse[parse_pos + i - oldi] = NULLCHAR;
3207                     ParseGameHistory(parse);
3208 #if ZIPPY
3209                     if (appData.zippyPlay && first.initDone) {
3210                         FeedMovesToProgram(&first, forwardMostMove);
3211                         if (gameMode == IcsPlayingWhite) {
3212                             if (WhiteOnMove(forwardMostMove)) {
3213                                 if (first.sendTime) {
3214                                   if (first.useColors) {
3215                                     SendToProgram("black\n", &first);
3216                                   }
3217                                   SendTimeRemaining(&first, TRUE);
3218                                 }
3219                                 if (first.useColors) {
3220                                   SendToProgram("white\n", &first); // [HGM] book: made sending of "go\n" book dependent
3221                                 }
3222                                 bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: probe book for initial pos
3223                                 first.maybeThinking = TRUE;
3224                             } else {
3225                                 if (first.usePlayother) {
3226                                   if (first.sendTime) {
3227                                     SendTimeRemaining(&first, TRUE);
3228                                   }
3229                                   SendToProgram("playother\n", &first);
3230                                   firstMove = FALSE;
3231                                 } else {
3232                                   firstMove = TRUE;
3233                                 }
3234                             }
3235                         } else if (gameMode == IcsPlayingBlack) {
3236                             if (!WhiteOnMove(forwardMostMove)) {
3237                                 if (first.sendTime) {
3238                                   if (first.useColors) {
3239                                     SendToProgram("white\n", &first);
3240                                   }
3241                                   SendTimeRemaining(&first, FALSE);
3242                                 }
3243                                 if (first.useColors) {
3244                                   SendToProgram("black\n", &first);
3245                                 }
3246                                 bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE);
3247                                 first.maybeThinking = TRUE;
3248                             } else {
3249                                 if (first.usePlayother) {
3250                                   if (first.sendTime) {
3251                                     SendTimeRemaining(&first, FALSE);
3252                                   }
3253                                   SendToProgram("playother\n", &first);
3254                                   firstMove = FALSE;
3255                                 } else {
3256                                   firstMove = TRUE;
3257                                 }
3258                             }
3259                         }
3260                     }
3261 #endif
3262                     if (gameMode == IcsObserving && ics_gamenum == -1) {
3263                         /* Moves came from oldmoves or moves command
3264                            while we weren't doing anything else.
3265                            */
3266                         currentMove = forwardMostMove;
3267                         ClearHighlights();/*!!could figure this out*/
3268                         flipView = appData.flipView;
3269                         DrawPosition(TRUE, boards[currentMove]);
3270                         DisplayBothClocks();
3271                         sprintf(str, "%s vs. %s",
3272                                 gameInfo.white, gameInfo.black);
3273                         DisplayTitle(str);
3274                         gameMode = IcsIdle;
3275                     } else {
3276                         /* Moves were history of an active game */
3277                         if (gameInfo.resultDetails != NULL) {
3278                             free(gameInfo.resultDetails);
3279                             gameInfo.resultDetails = NULL;
3280                         }
3281                     }
3282                     HistorySet(parseList, backwardMostMove,
3283                                forwardMostMove, currentMove-1);
3284                     DisplayMove(currentMove - 1);
3285                     if (started == STARTED_MOVES) next_out = i;
3286                     started = STARTED_NONE;
3287                     ics_getting_history = H_FALSE;
3288                     break;
3289
3290                   case STARTED_OBSERVE:
3291                     started = STARTED_NONE;
3292                     SendToICS(ics_prefix);
3293                     SendToICS("refresh\n");
3294                     break;
3295
3296                   default:
3297                     break;
3298                 }
3299                 if(bookHit) { // [HGM] book: simulate book reply
3300                     static char bookMove[MSG_SIZ]; // a bit generous?
3301
3302                     programStats.nodes = programStats.depth = programStats.time =
3303                     programStats.score = programStats.got_only_move = 0;
3304                     sprintf(programStats.movelist, "%s (xbook)", bookHit);
3305
3306                     strcpy(bookMove, "move ");
3307                     strcat(bookMove, bookHit);
3308                     HandleMachineMove(bookMove, &first);
3309                 }
3310                 continue;
3311             }
3312
3313             if ((started == STARTED_MOVES || started == STARTED_BOARD ||
3314                  started == STARTED_HOLDINGS ||
3315                  started == STARTED_MOVES_NOHIDE) && i >= leftover_len) {
3316                 /* Accumulate characters in move list or board */
3317                 parse[parse_pos++] = buf[i];
3318             }
3319
3320             /* Start of game messages.  Mostly we detect start of game
3321                when the first board image arrives.  On some versions
3322                of the ICS, though, we need to do a "refresh" after starting
3323                to observe in order to get the current board right away. */
3324             if (looking_at(buf, &i, "Adding game * to observation list")) {
3325                 started = STARTED_OBSERVE;
3326                 continue;
3327             }
3328
3329             /* Handle auto-observe */
3330             if (appData.autoObserve &&
3331                 (gameMode == IcsIdle || gameMode == BeginningOfGame) &&
3332                 looking_at(buf, &i, "Game notification: * (*) vs. * (*)")) {
3333                 char *player;
3334                 /* Choose the player that was highlighted, if any. */
3335                 if (star_match[0][0] == '\033' ||
3336                     star_match[1][0] != '\033') {
3337                     player = star_match[0];
3338                 } else {
3339                     player = star_match[2];
3340                 }
3341                 sprintf(str, "%sobserve %s\n",
3342                         ics_prefix, StripHighlightAndTitle(player));
3343                 SendToICS(str);
3344
3345                 /* Save ratings from notify string */
3346                 strcpy(player1Name, star_match[0]);
3347                 player1Rating = string_to_rating(star_match[1]);
3348                 strcpy(player2Name, star_match[2]);
3349                 player2Rating = string_to_rating(star_match[3]);
3350
3351                 if (appData.debugMode)
3352                   fprintf(debugFP,
3353                           "Ratings from 'Game notification:' %s %d, %s %d\n",
3354                           player1Name, player1Rating,
3355                           player2Name, player2Rating);
3356
3357                 continue;
3358             }
3359
3360             /* Deal with automatic examine mode after a game,
3361                and with IcsObserving -> IcsExamining transition */
3362             if (looking_at(buf, &i, "Entering examine mode for game *") ||
3363                 looking_at(buf, &i, "has made you an examiner of game *")) {
3364
3365                 int gamenum = atoi(star_match[0]);
3366                 if ((gameMode == IcsIdle || gameMode == IcsObserving) &&
3367                     gamenum == ics_gamenum) {
3368                     /* We were already playing or observing this game;
3369                        no need to refetch history */
3370                     gameMode = IcsExamining;
3371                     if (pausing) {
3372                         pauseExamForwardMostMove = forwardMostMove;
3373                     } else if (currentMove < forwardMostMove) {
3374                         ForwardInner(forwardMostMove);
3375                     }
3376                 } else {
3377                     /* I don't think this case really can happen */
3378                     SendToICS(ics_prefix);
3379                     SendToICS("refresh\n");
3380                 }
3381                 continue;
3382             }
3383
3384             /* Error messages */
3385 //          if (ics_user_moved) {
3386             if (1) { // [HGM] old way ignored error after move type in; ics_user_moved is not set then!
3387                 if (looking_at(buf, &i, "Illegal move") ||
3388                     looking_at(buf, &i, "Not a legal move") ||
3389                     looking_at(buf, &i, "Your king is in check") ||
3390                     looking_at(buf, &i, "It isn't your turn") ||
3391                     looking_at(buf, &i, "It is not your move")) {
3392                     /* Illegal move */
3393                     if (ics_user_moved && forwardMostMove > backwardMostMove) { // only backup if we already moved
3394                         currentMove = forwardMostMove-1;
3395                         DisplayMove(currentMove - 1); /* before DMError */
3396                         DrawPosition(FALSE, boards[currentMove]);
3397                         SwitchClocks(forwardMostMove-1); // [HGM] race
3398                         DisplayBothClocks();
3399                     }
3400                     DisplayMoveError(_("Illegal move (rejected by ICS)")); // [HGM] but always relay error msg
3401                     ics_user_moved = 0;
3402                     continue;
3403                 }
3404             }
3405
3406             if (looking_at(buf, &i, "still have time") ||
3407                 looking_at(buf, &i, "not out of time") ||
3408                 looking_at(buf, &i, "either player is out of time") ||
3409                 looking_at(buf, &i, "has timeseal; checking")) {
3410                 /* We must have called his flag a little too soon */
3411                 whiteFlag = blackFlag = FALSE;
3412                 continue;
3413             }
3414
3415             if (looking_at(buf, &i, "added * seconds to") ||
3416                 looking_at(buf, &i, "seconds were added to")) {
3417                 /* Update the clocks */
3418                 SendToICS(ics_prefix);
3419                 SendToICS("refresh\n");
3420                 continue;
3421             }
3422
3423             if (!ics_clock_paused && looking_at(buf, &i, "clock paused")) {
3424                 ics_clock_paused = TRUE;
3425                 StopClocks();
3426                 continue;
3427             }
3428
3429             if (ics_clock_paused && looking_at(buf, &i, "clock resumed")) {
3430                 ics_clock_paused = FALSE;
3431                 StartClocks();
3432                 continue;
3433             }
3434
3435             /* Grab player ratings from the Creating: message.
3436                Note we have to check for the special case when
3437                the ICS inserts things like [white] or [black]. */
3438             if (looking_at(buf, &i, "Creating: * (*)* * (*)") ||
3439                 looking_at(buf, &i, "Creating: * (*) [*] * (*)")) {
3440                 /* star_matches:
3441                    0    player 1 name (not necessarily white)
3442                    1    player 1 rating
3443                    2    empty, white, or black (IGNORED)
3444                    3    player 2 name (not necessarily black)
3445                    4    player 2 rating
3446
3447                    The names/ratings are sorted out when the game
3448                    actually starts (below).
3449                 */
3450                 strcpy(player1Name, StripHighlightAndTitle(star_match[0]));
3451                 player1Rating = string_to_rating(star_match[1]);
3452                 strcpy(player2Name, StripHighlightAndTitle(star_match[3]));
3453                 player2Rating = string_to_rating(star_match[4]);
3454
3455                 if (appData.debugMode)
3456                   fprintf(debugFP,
3457                           "Ratings from 'Creating:' %s %d, %s %d\n",
3458                           player1Name, player1Rating,
3459                           player2Name, player2Rating);
3460
3461                 continue;
3462             }
3463
3464             /* Improved generic start/end-of-game messages */
3465             if ((tkind=0, looking_at(buf, &i, "{Game * (* vs. *) *}*")) ||
3466                 (tkind=1, looking_at(buf, &i, "{Game * (*(*) vs. *(*)) *}*"))){
3467                 /* If tkind == 0: */
3468                 /* star_match[0] is the game number */
3469                 /*           [1] is the white player's name */
3470                 /*           [2] is the black player's name */
3471                 /* For end-of-game: */
3472                 /*           [3] is the reason for the game end */
3473                 /*           [4] is a PGN end game-token, preceded by " " */
3474                 /* For start-of-game: */
3475                 /*           [3] begins with "Creating" or "Continuing" */
3476                 /*           [4] is " *" or empty (don't care). */
3477                 int gamenum = atoi(star_match[0]);
3478                 char *whitename, *blackname, *why, *endtoken;
3479                 ChessMove endtype = (ChessMove) 0;
3480
3481                 if (tkind == 0) {
3482                   whitename = star_match[1];
3483                   blackname = star_match[2];
3484                   why = star_match[3];
3485                   endtoken = star_match[4];
3486                 } else {
3487                   whitename = star_match[1];
3488                   blackname = star_match[3];
3489                   why = star_match[5];
3490                   endtoken = star_match[6];
3491                 }
3492
3493                 /* Game start messages */
3494                 if (strncmp(why, "Creating ", 9) == 0 ||
3495                     strncmp(why, "Continuing ", 11) == 0) {
3496                     gs_gamenum = gamenum;
3497                     strcpy(gs_kind, strchr(why, ' ') + 1);
3498                     VariantSwitch(boards[currentMove], StringToVariant(gs_kind)); // [HGM] variantswitch: even before we get first board
3499 #if ZIPPY
3500                     if (appData.zippyPlay) {
3501                         ZippyGameStart(whitename, blackname);
3502                     }
3503 #endif /*ZIPPY*/
3504                     partnerBoardValid = FALSE; // [HGM] bughouse
3505                     continue;
3506                 }
3507
3508                 /* Game end messages */
3509                 if (gameMode == IcsIdle || gameMode == BeginningOfGame ||
3510                     ics_gamenum != gamenum) {
3511                     continue;
3512                 }
3513                 while (endtoken[0] == ' ') endtoken++;
3514                 switch (endtoken[0]) {
3515                   case '*':
3516                   default:
3517                     endtype = GameUnfinished;
3518                     break;
3519                   case '0':
3520                     endtype = BlackWins;
3521                     break;
3522                   case '1':
3523                     if (endtoken[1] == '/')
3524                       endtype = GameIsDrawn;
3525                     else
3526                       endtype = WhiteWins;
3527                     break;
3528                 }
3529                 GameEnds(endtype, why, GE_ICS);
3530 #if ZIPPY
3531                 if (appData.zippyPlay && first.initDone) {
3532                     ZippyGameEnd(endtype, why);
3533                     if (first.pr == NULL) {
3534                       /* Start the next process early so that we'll
3535                          be ready for the next challenge */
3536                       StartChessProgram(&first);
3537                     }
3538                     /* Send "new" early, in case this command takes
3539                        a long time to finish, so that we'll be ready
3540                        for the next challenge. */
3541                     gameInfo.variant = VariantNormal; // [HGM] variantswitch: suppress sending of 'variant'
3542                     Reset(TRUE, TRUE);
3543                 }
3544 #endif /*ZIPPY*/
3545                 if(appData.bgObserve && partnerBoardValid) DrawPosition(TRUE, partnerBoard);
3546                 continue;
3547             }
3548
3549             if (looking_at(buf, &i, "Removing game * from observation") ||
3550                 looking_at(buf, &i, "no longer observing game *") ||
3551                 looking_at(buf, &i, "Game * (*) has no examiners")) {
3552                 if (gameMode == IcsObserving &&
3553                     atoi(star_match[0]) == ics_gamenum)
3554                   {
3555                       /* icsEngineAnalyze */
3556                       if (appData.icsEngineAnalyze) {
3557                             ExitAnalyzeMode();
3558                             ModeHighlight();
3559                       }
3560                       StopClocks();
3561                       gameMode = IcsIdle;
3562                       ics_gamenum = -1;
3563                       ics_user_moved = FALSE;
3564                   }
3565                 continue;
3566             }
3567
3568             if (looking_at(buf, &i, "no longer examining game *")) {
3569                 if (gameMode == IcsExamining &&
3570                     atoi(star_match[0]) == ics_gamenum)
3571                   {
3572                       gameMode = IcsIdle;
3573                       ics_gamenum = -1;
3574                       ics_user_moved = FALSE;
3575                   }
3576                 continue;
3577             }
3578
3579             /* Advance leftover_start past any newlines we find,
3580                so only partial lines can get reparsed */
3581             if (looking_at(buf, &i, "\n")) {
3582                 prevColor = curColor;
3583                 if (curColor != ColorNormal) {
3584                     if (oldi > next_out) {
3585                         SendToPlayer(&buf[next_out], oldi - next_out);
3586                         next_out = oldi;
3587                     }
3588                     Colorize(ColorNormal, FALSE);
3589                     curColor = ColorNormal;
3590                 }
3591                 if (started == STARTED_BOARD) {
3592                     started = STARTED_NONE;
3593                     parse[parse_pos] = NULLCHAR;
3594                     ParseBoard12(parse);
3595                     ics_user_moved = 0;
3596
3597                     /* Send premove here */
3598                     if (appData.premove) {
3599                       char str[MSG_SIZ];
3600                       if (currentMove == 0 &&
3601                           gameMode == IcsPlayingWhite &&
3602                           appData.premoveWhite) {
3603                         sprintf(str, "%s\n", appData.premoveWhiteText);
3604                         if (appData.debugMode)
3605                           fprintf(debugFP, "Sending premove:\n");
3606                         SendToICS(str);
3607                       } else if (currentMove == 1 &&
3608                                  gameMode == IcsPlayingBlack &&
3609                                  appData.premoveBlack) {
3610                         sprintf(str, "%s\n", appData.premoveBlackText);
3611                         if (appData.debugMode)
3612                           fprintf(debugFP, "Sending premove:\n");
3613                         SendToICS(str);
3614                       } else if (gotPremove) {
3615                         gotPremove = 0;
3616                         ClearPremoveHighlights();
3617                         if (appData.debugMode)
3618                           fprintf(debugFP, "Sending premove:\n");
3619                           UserMoveEvent(premoveFromX, premoveFromY,
3620                                         premoveToX, premoveToY,
3621                                         premovePromoChar);
3622                       }
3623                     }
3624
3625                     /* Usually suppress following prompt */
3626                     if (!(forwardMostMove == 0 && gameMode == IcsExamining)) {
3627                         while(looking_at(buf, &i, "\n")); // [HGM] skip empty lines
3628                         if (looking_at(buf, &i, "*% ")) {
3629                             savingComment = FALSE;
3630                             suppressKibitz = 0;
3631                         }
3632                     }
3633                     next_out = i;
3634                 } else if (started == STARTED_HOLDINGS) {
3635                     int gamenum;
3636                     char new_piece[MSG_SIZ];
3637                     started = STARTED_NONE;
3638                     parse[parse_pos] = NULLCHAR;
3639                     if (appData.debugMode)
3640                       fprintf(debugFP, "Parsing holdings: %s, currentMove = %d\n",
3641                                                         parse, currentMove);
3642                     if (sscanf(parse, " game %d", &gamenum) == 1) {
3643                       if(gamenum == ics_gamenum) { // [HGM] bughouse: old code if part of foreground game
3644                         if (gameInfo.variant == VariantNormal) {
3645                           /* [HGM] We seem to switch variant during a game!
3646                            * Presumably no holdings were displayed, so we have
3647                            * to move the position two files to the right to
3648                            * create room for them!
3649                            */
3650                           VariantClass newVariant;
3651                           switch(gameInfo.boardWidth) { // base guess on board width
3652                                 case 9:  newVariant = VariantShogi; break;
3653                                 case 10: newVariant = VariantGreat; break;
3654                                 default: newVariant = VariantCrazyhouse; break;
3655                           }
3656                           VariantSwitch(boards[currentMove], newVariant); /* temp guess */
3657                           /* Get a move list just to see the header, which
3658                              will tell us whether this is really bug or zh */
3659                           if (ics_getting_history == H_FALSE) {
3660                             ics_getting_history = H_REQUESTED;
3661                             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3662                             SendToICS(str);
3663                           }
3664                         }
3665                         new_piece[0] = NULLCHAR;
3666                         sscanf(parse, "game %d white [%s black [%s <- %s",
3667                                &gamenum, white_holding, black_holding,
3668                                new_piece);
3669                         white_holding[strlen(white_holding)-1] = NULLCHAR;
3670                         black_holding[strlen(black_holding)-1] = NULLCHAR;
3671                         /* [HGM] copy holdings to board holdings area */
3672                         CopyHoldings(boards[forwardMostMove], white_holding, WhitePawn);
3673                         CopyHoldings(boards[forwardMostMove], black_holding, BlackPawn);
3674                         boards[forwardMostMove][HOLDINGS_SET] = 1; // flag holdings as set
3675 #if ZIPPY
3676                         if (appData.zippyPlay && first.initDone) {
3677                             ZippyHoldings(white_holding, black_holding,
3678                                           new_piece);
3679                         }
3680 #endif /*ZIPPY*/
3681                         if (tinyLayout || smallLayout) {
3682                             char wh[16], bh[16];
3683                             PackHolding(wh, white_holding);
3684                             PackHolding(bh, black_holding);
3685                             sprintf(str, "[%s-%s] %s-%s", wh, bh,
3686                                     gameInfo.white, gameInfo.black);
3687                         } else {
3688                             sprintf(str, "%s [%s] vs. %s [%s]",
3689                                     gameInfo.white, white_holding,
3690                                     gameInfo.black, black_holding);
3691                         }
3692                         if(!partnerUp) // [HGM] bughouse: when peeking at partner game we already know what he captured...
3693                         DrawPosition(FALSE, boards[currentMove]);
3694                         DisplayTitle(str);
3695                       } else if(appData.bgObserve) { // [HGM] bughouse: holdings of other game => background
3696                         sscanf(parse, "game %d white [%s black [%s <- %s",
3697                                &gamenum, white_holding, black_holding,
3698                                new_piece);
3699                         white_holding[strlen(white_holding)-1] = NULLCHAR;
3700                         black_holding[strlen(black_holding)-1] = NULLCHAR;
3701                         /* [HGM] copy holdings to partner-board holdings area */
3702                         CopyHoldings(partnerBoard, white_holding, WhitePawn);
3703                         CopyHoldings(partnerBoard, black_holding, BlackPawn);
3704                         if(twoBoards) { partnerUp = 1; flipView = !flipView; } // [HGM] dual: always draw
3705                         if(partnerUp) DrawPosition(FALSE, partnerBoard);
3706                         if(twoBoards) { partnerUp = 0; flipView = !flipView; }
3707                       }
3708                     }
3709                     /* Suppress following prompt */
3710                     if (looking_at(buf, &i, "*% ")) {
3711                         if(strchr(star_match[0], 7)) SendToPlayer("\007", 1); // Bell(); // FICS fuses bell for next board with prompt in zh captures
3712                         savingComment = FALSE;
3713                         suppressKibitz = 0;
3714                     }
3715                     next_out = i;
3716                 }
3717                 continue;
3718             }
3719
3720             i++;                /* skip unparsed character and loop back */
3721         }
3722
3723         if (started != STARTED_MOVES && started != STARTED_BOARD && !suppressKibitz && // [HGM] kibitz
3724 //          started != STARTED_HOLDINGS && i > next_out) { // [HGM] should we compare to leftover_start in stead of i?
3725 //          SendToPlayer(&buf[next_out], i - next_out);
3726             started != STARTED_HOLDINGS && leftover_start > next_out) {
3727             SendToPlayer(&buf[next_out], leftover_start - next_out);
3728             next_out = i;
3729         }
3730
3731         leftover_len = buf_len - leftover_start;
3732         /* if buffer ends with something we couldn't parse,
3733            reparse it after appending the next read */
3734
3735     } else if (count == 0) {
3736         RemoveInputSource(isr);
3737         DisplayFatalError(_("Connection closed by ICS"), 0, 0);
3738     } else {
3739         DisplayFatalError(_("Error reading from ICS"), error, 1);
3740     }
3741 }
3742
3743
3744 /* Board style 12 looks like this:
3745
3746    <12> r-b---k- pp----pp ---bP--- ---p---- q------- ------P- P--Q--BP -----R-K W -1 0 0 0 0 0 0 paf MaxII 0 2 12 21 25 234 174 24 Q/d7-a4 (0:06) Qxa4 0 0
3747
3748  * The "<12> " is stripped before it gets to this routine.  The two
3749  * trailing 0's (flip state and clock ticking) are later addition, and
3750  * some chess servers may not have them, or may have only the first.
3751  * Additional trailing fields may be added in the future.
3752  */
3753
3754 #define PATTERN "%c%d%d%d%d%d%d%d%s%s%d%d%d%d%d%d%d%d%s%s%s%d%d"
3755
3756 #define RELATION_OBSERVING_PLAYED    0
3757 #define RELATION_OBSERVING_STATIC   -2   /* examined, oldmoves, or smoves */
3758 #define RELATION_PLAYING_MYMOVE      1
3759 #define RELATION_PLAYING_NOTMYMOVE  -1
3760 #define RELATION_EXAMINING           2
3761 #define RELATION_ISOLATED_BOARD     -3
3762 #define RELATION_STARTING_POSITION  -4   /* FICS only */
3763
3764 void
3765 ParseBoard12(string)
3766      char *string;
3767 {
3768     GameMode newGameMode;
3769     int gamenum, newGame, newMove, relation, basetime, increment, ics_flip = 0, i;
3770     int j, k, n, moveNum, white_stren, black_stren, white_time, black_time, takeback;
3771     int double_push, castle_ws, castle_wl, castle_bs, castle_bl, irrev_count;
3772     char to_play, board_chars[200];
3773     char move_str[500], str[500], elapsed_time[500];
3774     char black[32], white[32];
3775     Board board;
3776     int prevMove = currentMove;
3777     int ticking = 2;
3778     ChessMove moveType;
3779     int fromX, fromY, toX, toY;
3780     char promoChar;
3781     int ranks=1, files=0; /* [HGM] ICS80: allow variable board size */
3782     char *bookHit = NULL; // [HGM] book
3783     Boolean weird = FALSE, reqFlag = FALSE;
3784
3785     fromX = fromY = toX = toY = -1;
3786
3787     newGame = FALSE;
3788
3789     if (appData.debugMode)
3790       fprintf(debugFP, _("Parsing board: %s\n"), string);
3791
3792     move_str[0] = NULLCHAR;
3793     elapsed_time[0] = NULLCHAR;
3794     {   /* [HGM] figure out how many ranks and files the board has, for ICS extension used by Capablanca server */
3795         int  i = 0, j;
3796         while(i < 199 && (string[i] != ' ' || string[i+2] != ' ')) {
3797             if(string[i] == ' ') { ranks++; files = 0; }
3798             else files++;
3799             if(!strchr(" -pnbrqkPNBRQK" , string[i])) weird = TRUE; // test for fairies
3800             i++;
3801         }
3802         for(j = 0; j <i; j++) board_chars[j] = string[j];
3803         board_chars[i] = '\0';
3804         string += i + 1;
3805     }
3806     n = sscanf(string, PATTERN, &to_play, &double_push,
3807                &castle_ws, &castle_wl, &castle_bs, &castle_bl, &irrev_count,
3808                &gamenum, white, black, &relation, &basetime, &increment,
3809                &white_stren, &black_stren, &white_time, &black_time,
3810                &moveNum, str, elapsed_time, move_str, &ics_flip,
3811                &ticking);
3812
3813     if (n < 21) {
3814         snprintf(str, sizeof(str), _("Failed to parse board string:\n\"%s\""), string);
3815         DisplayError(str, 0);
3816         return;
3817     }
3818
3819     /* Convert the move number to internal form */
3820     moveNum = (moveNum - 1) * 2;
3821     if (to_play == 'B') moveNum++;
3822     if (moveNum > framePtr) { // [HGM] vari: do not run into saved variations
3823       DisplayFatalError(_("Game too long; increase MAX_MOVES and recompile"),
3824                         0, 1);
3825       return;
3826     }
3827
3828     switch (relation) {
3829       case RELATION_OBSERVING_PLAYED:
3830       case RELATION_OBSERVING_STATIC:
3831         if (gamenum == -1) {
3832             /* Old ICC buglet */
3833             relation = RELATION_OBSERVING_STATIC;
3834         }
3835         newGameMode = IcsObserving;
3836         break;
3837       case RELATION_PLAYING_MYMOVE:
3838       case RELATION_PLAYING_NOTMYMOVE:
3839         newGameMode =
3840           ((relation == RELATION_PLAYING_MYMOVE) == (to_play == 'W')) ?
3841             IcsPlayingWhite : IcsPlayingBlack;
3842         break;
3843       case RELATION_EXAMINING:
3844         newGameMode = IcsExamining;
3845         break;
3846       case RELATION_ISOLATED_BOARD:
3847       default:
3848         /* Just display this board.  If user was doing something else,
3849            we will forget about it until the next board comes. */
3850         newGameMode = IcsIdle;
3851         break;
3852       case RELATION_STARTING_POSITION:
3853         newGameMode = gameMode;
3854         break;
3855     }
3856
3857     if((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack)
3858          && newGameMode == IcsObserving && gamenum != ics_gamenum && appData.bgObserve) {
3859       // [HGM] bughouse: don't act on alien boards while we play. Just parse the board and save it */
3860       char *toSqr;
3861       for (k = 0; k < ranks; k++) {
3862         for (j = 0; j < files; j++)
3863           board[k][j+gameInfo.holdingsWidth] = CharToPiece(board_chars[(ranks-1-k)*(files+1) + j]);
3864         if(gameInfo.holdingsWidth > 1) {
3865              board[k][0] = board[k][BOARD_WIDTH-1] = EmptySquare;
3866              board[k][1] = board[k][BOARD_WIDTH-2] = (ChessSquare) 0;;
3867         }
3868       }
3869       CopyBoard(partnerBoard, board);
3870       if(toSqr = strchr(str, '/')) { // extract highlights from long move
3871         partnerBoard[EP_STATUS-3] = toSqr[1] - AAA; // kludge: hide highlighting info in board
3872         partnerBoard[EP_STATUS-4] = toSqr[2] - ONE;
3873       } else partnerBoard[EP_STATUS-4] = partnerBoard[EP_STATUS-3] = -1;
3874       if(toSqr = strchr(str, '-')) {
3875         partnerBoard[EP_STATUS-1] = toSqr[1] - AAA;
3876         partnerBoard[EP_STATUS-2] = toSqr[2] - ONE;
3877       } else partnerBoard[EP_STATUS-1] = partnerBoard[EP_STATUS-2] = -1;
3878       if(appData.dualBoard && !twoBoards) { twoBoards = 1; InitDrawingSizes(-2,0); }
3879       if(twoBoards) { partnerUp = 1; flipView = !flipView; } // [HGM] dual
3880       if(partnerUp) DrawPosition(FALSE, partnerBoard);
3881       if(twoBoards) { partnerUp = 0; flipView = !flipView; } // [HGM] dual
3882       sprintf(partnerStatus, "W: %d:%02d B: %d:%02d (%d-%d) %c", white_time/60000, (white_time%60000)/1000,
3883                  (black_time/60000), (black_time%60000)/1000, white_stren, black_stren, to_play);
3884       DisplayMessage(partnerStatus, "");
3885         partnerBoardValid = TRUE;
3886       return;
3887     }
3888
3889     /* Modify behavior for initial board display on move listing
3890        of wild games.
3891        */
3892     switch (ics_getting_history) {
3893       case H_FALSE:
3894       case H_REQUESTED:
3895         break;
3896       case H_GOT_REQ_HEADER:
3897       case H_GOT_UNREQ_HEADER:
3898         /* This is the initial position of the current game */
3899         gamenum = ics_gamenum;
3900         moveNum = 0;            /* old ICS bug workaround */
3901         if (to_play == 'B') {
3902           startedFromSetupPosition = TRUE;
3903           blackPlaysFirst = TRUE;
3904           moveNum = 1;
3905           if (forwardMostMove == 0) forwardMostMove = 1;
3906           if (backwardMostMove == 0) backwardMostMove = 1;
3907           if (currentMove == 0) currentMove = 1;
3908         }
3909         newGameMode = gameMode;
3910         relation = RELATION_STARTING_POSITION; /* ICC needs this */
3911         break;
3912       case H_GOT_UNWANTED_HEADER:
3913         /* This is an initial board that we don't want */
3914         return;
3915       case H_GETTING_MOVES:
3916         /* Should not happen */
3917         DisplayError(_("Error gathering move list: extra board"), 0);
3918         ics_getting_history = H_FALSE;
3919         return;
3920     }
3921
3922    if (gameInfo.boardHeight != ranks || gameInfo.boardWidth != files ||
3923                                         weird && (int)gameInfo.variant <= (int)VariantShogi) {
3924      /* [HGM] We seem to have switched variant unexpectedly
3925       * Try to guess new variant from board size
3926       */
3927           VariantClass newVariant = VariantFairy; // if 8x8, but fairies present
3928           if(ranks == 8 && files == 10) newVariant = VariantCapablanca; else
3929           if(ranks == 10 && files == 9) newVariant = VariantXiangqi; else
3930           if(ranks == 8 && files == 12) newVariant = VariantCourier; else
3931           if(ranks == 9 && files == 9)  newVariant = VariantShogi; else
3932           if(!weird) newVariant = VariantNormal;
3933           VariantSwitch(boards[currentMove], newVariant); /* temp guess */
3934           /* Get a move list just to see the header, which
3935              will tell us whether this is really bug or zh */
3936           if (ics_getting_history == H_FALSE) {
3937             ics_getting_history = H_REQUESTED; reqFlag = TRUE;
3938             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3939             SendToICS(str);
3940           }
3941     }
3942
3943     /* Take action if this is the first board of a new game, or of a
3944        different game than is currently being displayed.  */
3945     if (gamenum != ics_gamenum || newGameMode != gameMode ||
3946         relation == RELATION_ISOLATED_BOARD) {
3947
3948         /* Forget the old game and get the history (if any) of the new one */
3949         if (gameMode != BeginningOfGame) {
3950           Reset(TRUE, TRUE);
3951         }
3952         newGame = TRUE;
3953         if (appData.autoRaiseBoard) BoardToTop();
3954         prevMove = -3;
3955         if (gamenum == -1) {
3956             newGameMode = IcsIdle;
3957         } else if ((moveNum > 0 || newGameMode == IcsObserving) && newGameMode != IcsIdle &&
3958                    appData.getMoveList && !reqFlag) {
3959             /* Need to get game history */
3960             ics_getting_history = H_REQUESTED;
3961             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
3962             SendToICS(str);
3963         }
3964
3965         /* Initially flip the board to have black on the bottom if playing
3966            black or if the ICS flip flag is set, but let the user change
3967            it with the Flip View button. */
3968         flipView = appData.autoFlipView ?
3969           (newGameMode == IcsPlayingBlack) || ics_flip :
3970           appData.flipView;
3971
3972         /* Done with values from previous mode; copy in new ones */
3973         gameMode = newGameMode;
3974         ModeHighlight();
3975         ics_gamenum = gamenum;
3976         if (gamenum == gs_gamenum) {
3977             int klen = strlen(gs_kind);
3978             if (gs_kind[klen - 1] == '.') gs_kind[klen - 1] = NULLCHAR;
3979             sprintf(str, "ICS %s", gs_kind);
3980             gameInfo.event = StrSave(str);
3981         } else {
3982             gameInfo.event = StrSave("ICS game");
3983         }
3984         gameInfo.site = StrSave(appData.icsHost);
3985         gameInfo.date = PGNDate();
3986         gameInfo.round = StrSave("-");
3987         gameInfo.white = StrSave(white);
3988         gameInfo.black = StrSave(black);
3989         timeControl = basetime * 60 * 1000;
3990         timeControl_2 = 0;
3991         timeIncrement = increment * 1000;
3992         movesPerSession = 0;
3993         gameInfo.timeControl = TimeControlTagValue();
3994         VariantSwitch(boards[currentMove], StringToVariant(gameInfo.event) );
3995   if (appData.debugMode) {
3996     fprintf(debugFP, "ParseBoard says variant = '%s'\n", gameInfo.event);
3997     fprintf(debugFP, "recognized as %s\n", VariantName(gameInfo.variant));
3998     setbuf(debugFP, NULL);
3999   }
4000
4001         gameInfo.outOfBook = NULL;
4002
4003         /* Do we have the ratings? */
4004         if (strcmp(player1Name, white) == 0 &&
4005             strcmp(player2Name, black) == 0) {
4006             if (appData.debugMode)
4007               fprintf(debugFP, "Remembered ratings: W %d, B %d\n",
4008                       player1Rating, player2Rating);
4009             gameInfo.whiteRating = player1Rating;
4010             gameInfo.blackRating = player2Rating;
4011         } else if (strcmp(player2Name, white) == 0 &&
4012                    strcmp(player1Name, black) == 0) {
4013             if (appData.debugMode)
4014               fprintf(debugFP, "Remembered ratings: W %d, B %d\n",
4015                       player2Rating, player1Rating);
4016             gameInfo.whiteRating = player2Rating;
4017             gameInfo.blackRating = player1Rating;
4018         }
4019         player1Name[0] = player2Name[0] = NULLCHAR;
4020
4021         /* Silence shouts if requested */
4022         if (appData.quietPlay &&
4023             (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack)) {
4024             SendToICS(ics_prefix);
4025             SendToICS("set shout 0\n");
4026         }
4027     }
4028
4029     /* Deal with midgame name changes */
4030     if (!newGame) {
4031         if (!gameInfo.white || strcmp(gameInfo.white, white) != 0) {
4032             if (gameInfo.white) free(gameInfo.white);
4033             gameInfo.white = StrSave(white);
4034         }
4035         if (!gameInfo.black || strcmp(gameInfo.black, black) != 0) {
4036             if (gameInfo.black) free(gameInfo.black);
4037             gameInfo.black = StrSave(black);
4038         }
4039     }
4040
4041     /* Throw away game result if anything actually changes in examine mode */
4042     if (gameMode == IcsExamining && !newGame) {
4043         gameInfo.result = GameUnfinished;
4044         if (gameInfo.resultDetails != NULL) {
4045             free(gameInfo.resultDetails);
4046             gameInfo.resultDetails = NULL;
4047         }
4048     }
4049
4050     /* In pausing && IcsExamining mode, we ignore boards coming
4051        in if they are in a different variation than we are. */
4052     if (pauseExamInvalid) return;
4053     if (pausing && gameMode == IcsExamining) {
4054         if (moveNum <= pauseExamForwardMostMove) {
4055             pauseExamInvalid = TRUE;
4056             forwardMostMove = pauseExamForwardMostMove;
4057             return;
4058         }
4059     }
4060
4061   if (appData.debugMode) {
4062     fprintf(debugFP, "load %dx%d board\n", files, ranks);
4063   }
4064     /* Parse the board */
4065     for (k = 0; k < ranks; k++) {
4066       for (j = 0; j < files; j++)
4067         board[k][j+gameInfo.holdingsWidth] = CharToPiece(board_chars[(ranks-1-k)*(files+1) + j]);
4068       if(gameInfo.holdingsWidth > 1) {
4069            board[k][0] = board[k][BOARD_WIDTH-1] = EmptySquare;
4070            board[k][1] = board[k][BOARD_WIDTH-2] = (ChessSquare) 0;;
4071       }
4072     }
4073     CopyBoard(boards[moveNum], board);
4074     boards[moveNum][HOLDINGS_SET] = 0; // [HGM] indicate holdings not set
4075     if (moveNum == 0) {
4076         startedFromSetupPosition =
4077           !CompareBoards(board, initialPosition);
4078         if(startedFromSetupPosition)
4079             initialRulePlies = irrev_count; /* [HGM] 50-move counter offset */
4080     }
4081
4082     /* [HGM] Set castling rights. Take the outermost Rooks,
4083        to make it also work for FRC opening positions. Note that board12
4084        is really defective for later FRC positions, as it has no way to
4085        indicate which Rook can castle if they are on the same side of King.
4086        For the initial position we grant rights to the outermost Rooks,
4087        and remember thos rights, and we then copy them on positions
4088        later in an FRC game. This means WB might not recognize castlings with
4089        Rooks that have moved back to their original position as illegal,
4090        but in ICS mode that is not its job anyway.
4091     */
4092     if(moveNum == 0 || gameInfo.variant != VariantFischeRandom)
4093     { int i, j; ChessSquare wKing = WhiteKing, bKing = BlackKing;
4094
4095         for(i=BOARD_LEFT, j=NoRights; i<BOARD_RGHT; i++)
4096             if(board[0][i] == WhiteRook) j = i;
4097         initialRights[0] = boards[moveNum][CASTLING][0] = (castle_ws == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
4098         for(i=BOARD_RGHT-1, j=NoRights; i>=BOARD_LEFT; i--)
4099             if(board[0][i] == WhiteRook) j = i;
4100         initialRights[1] = boards[moveNum][CASTLING][1] = (castle_wl == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
4101         for(i=BOARD_LEFT, j=NoRights; i<BOARD_RGHT; i++)
4102             if(board[BOARD_HEIGHT-1][i] == BlackRook) j = i;
4103         initialRights[3] = boards[moveNum][CASTLING][3] = (castle_bs == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
4104         for(i=BOARD_RGHT-1, j=NoRights; i>=BOARD_LEFT; i--)
4105             if(board[BOARD_HEIGHT-1][i] == BlackRook) j = i;
4106         initialRights[4] = boards[moveNum][CASTLING][4] = (castle_bl == 0 && gameInfo.variant != VariantFischeRandom ? NoRights : j);
4107
4108         if(gameInfo.variant == VariantKnightmate) { wKing = WhiteUnicorn; bKing = BlackUnicorn; }
4109         for(k=BOARD_LEFT; k<BOARD_RGHT; k++)
4110             if(board[0][k] == wKing) initialRights[2] = boards[moveNum][CASTLING][2] = k;
4111         for(k=BOARD_LEFT; k<BOARD_RGHT; k++)
4112             if(board[BOARD_HEIGHT-1][k] == bKing)
4113                 initialRights[5] = boards[moveNum][CASTLING][5] = k;
4114         if(gameInfo.variant == VariantTwoKings) {
4115             // In TwoKings looking for a King does not work, so always give castling rights to a King on e1/e8
4116             if(board[0][4] == wKing) initialRights[2] = boards[moveNum][CASTLING][2] = 4;
4117             if(board[BOARD_HEIGHT-1][4] == bKing) initialRights[5] = boards[moveNum][CASTLING][5] = 4;
4118         }
4119     } else { int r;
4120         r = boards[moveNum][CASTLING][0] = initialRights[0];
4121         if(board[0][r] != WhiteRook) boards[moveNum][CASTLING][0] = NoRights;
4122         r = boards[moveNum][CASTLING][1] = initialRights[1];
4123         if(board[0][r] != WhiteRook) boards[moveNum][CASTLING][1] = NoRights;
4124         r = boards[moveNum][CASTLING][3] = initialRights[3];
4125         if(board[BOARD_HEIGHT-1][r] != BlackRook) boards[moveNum][CASTLING][3] = NoRights;
4126         r = boards[moveNum][CASTLING][4] = initialRights[4];
4127         if(board[BOARD_HEIGHT-1][r] != BlackRook) boards[moveNum][CASTLING][4] = NoRights;
4128         /* wildcastle kludge: always assume King has rights */
4129         r = boards[moveNum][CASTLING][2] = initialRights[2];
4130         r = boards[moveNum][CASTLING][5] = initialRights[5];
4131     }
4132     /* [HGM] e.p. rights. Assume that ICS sends file number here? */
4133     boards[moveNum][EP_STATUS] = double_push == -1 ? EP_NONE : double_push + BOARD_LEFT;
4134
4135
4136     if (ics_getting_history == H_GOT_REQ_HEADER ||
4137         ics_getting_history == H_GOT_UNREQ_HEADER) {
4138         /* This was an initial position from a move list, not
4139            the current position */
4140         return;
4141     }
4142
4143     /* Update currentMove and known move number limits */
4144     newMove = newGame || moveNum > forwardMostMove;
4145
4146     if (newGame) {
4147         forwardMostMove = backwardMostMove = currentMove = moveNum;
4148         if (gameMode == IcsExamining && moveNum == 0) {
4149           /* Workaround for ICS limitation: we are not told the wild
4150              type when starting to examine a game.  But if we ask for
4151              the move list, the move list header will tell us */
4152             ics_getting_history = H_REQUESTED;
4153             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
4154             SendToICS(str);
4155         }
4156     } else if (moveNum == forwardMostMove + 1 || moveNum == forwardMostMove
4157                || (moveNum < forwardMostMove && moveNum >= backwardMostMove)) {
4158 #if ZIPPY
4159         /* [DM] If we found takebacks during icsEngineAnalyze try send to engine */
4160         /* [HGM] applied this also to an engine that is silently watching        */
4161         if (appData.zippyPlay && moveNum < forwardMostMove && first.initDone &&
4162             (gameMode == IcsObserving || gameMode == IcsExamining) &&
4163             gameInfo.variant == currentlyInitializedVariant) {
4164           takeback = forwardMostMove - moveNum;
4165           for (i = 0; i < takeback; i++) {
4166             if (appData.debugMode) fprintf(debugFP, "take back move\n");
4167             SendToProgram("undo\n", &first);
4168           }
4169         }
4170 #endif
4171
4172         forwardMostMove = moveNum;
4173         if (!pausing || currentMove > forwardMostMove)
4174           currentMove = forwardMostMove;
4175     } else {
4176         /* New part of history that is not contiguous with old part */
4177         if (pausing && gameMode == IcsExamining) {
4178             pauseExamInvalid = TRUE;
4179             forwardMostMove = pauseExamForwardMostMove;
4180             return;
4181         }
4182         if (gameMode == IcsExamining && moveNum > 0 && appData.getMoveList) {
4183 #if ZIPPY
4184             if(appData.zippyPlay && forwardMostMove > 0 && first.initDone) {
4185                 // [HGM] when we will receive the move list we now request, it will be
4186                 // fed to the engine from the first move on. So if the engine is not
4187                 // in the initial position now, bring it there.
4188                 InitChessProgram(&first, 0);
4189             }
4190 #endif
4191             ics_getting_history = H_REQUESTED;
4192             sprintf(str, "%smoves %d\n", ics_prefix, gamenum);
4193             SendToICS(str);
4194         }
4195         forwardMostMove = backwardMostMove = currentMove = moveNum;
4196     }
4197
4198     /* Update the clocks */
4199     if (strchr(elapsed_time, '.')) {
4200       /* Time is in ms */
4201       timeRemaining[0][moveNum] = whiteTimeRemaining = white_time;
4202       timeRemaining[1][moveNum] = blackTimeRemaining = black_time;
4203     } else {
4204       /* Time is in seconds */
4205       timeRemaining[0][moveNum] = whiteTimeRemaining = white_time * 1000;
4206       timeRemaining[1][moveNum] = blackTimeRemaining = black_time * 1000;
4207     }
4208
4209
4210 #if ZIPPY
4211     if (appData.zippyPlay && newGame &&
4212         gameMode != IcsObserving && gameMode != IcsIdle &&
4213         gameMode != IcsExamining)
4214       ZippyFirstBoard(moveNum, basetime, increment);
4215 #endif
4216
4217     /* Put the move on the move list, first converting
4218        to canonical algebraic form. */
4219     if (moveNum > 0) {
4220   if (appData.debugMode) {
4221     if (appData.debugMode) { int f = forwardMostMove;
4222         fprintf(debugFP, "parseboard %d, castling = %d %d %d %d %d %d\n", f,
4223                 boards[f][CASTLING][0],boards[f][CASTLING][1],boards[f][CASTLING][2],
4224                 boards[f][CASTLING][3],boards[f][CASTLING][4],boards[f][CASTLING][5]);
4225     }
4226     fprintf(debugFP, "accepted move %s from ICS, parse it.\n", move_str);
4227     fprintf(debugFP, "moveNum = %d\n", moveNum);
4228     fprintf(debugFP, "board = %d-%d x %d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT);
4229     setbuf(debugFP, NULL);
4230   }
4231         if (moveNum <= backwardMostMove) {
4232             /* We don't know what the board looked like before
4233                this move.  Punt. */
4234             strcpy(parseList[moveNum - 1], move_str);
4235             strcat(parseList[moveNum - 1], " ");
4236             strcat(parseList[moveNum - 1], elapsed_time);
4237             moveList[moveNum - 1][0] = NULLCHAR;
4238         } else if (strcmp(move_str, "none") == 0) {
4239             // [HGM] long SAN: swapped order; test for 'none' before parsing move
4240             /* Again, we don't know what the board looked like;
4241                this is really the start of the game. */
4242             parseList[moveNum - 1][0] = NULLCHAR;
4243             moveList[moveNum - 1][0] = NULLCHAR;
4244             backwardMostMove = moveNum;
4245             startedFromSetupPosition = TRUE;
4246             fromX = fromY = toX = toY = -1;
4247         } else {
4248           // [HGM] long SAN: if legality-testing is off, disambiguation might not work or give wrong move.
4249           //                 So we parse the long-algebraic move string in stead of the SAN move
4250           int valid; char buf[MSG_SIZ], *prom;
4251
4252           // str looks something like "Q/a1-a2"; kill the slash
4253           if(str[1] == '/')
4254                 sprintf(buf, "%c%s", str[0], str+2);
4255           else  strcpy(buf, str); // might be castling
4256           if((prom = strstr(move_str, "=")) && !strstr(buf, "="))
4257                 strcat(buf, prom); // long move lacks promo specification!
4258           if(!appData.testLegality && move_str[1] != '@') { // drops never ambiguous (parser chokes on long form!)
4259                 if(appData.debugMode)
4260                         fprintf(debugFP, "replaced ICS move '%s' by '%s'\n", move_str, buf);
4261                 strcpy(move_str, buf);
4262           }
4263           valid = ParseOneMove(move_str, moveNum - 1, &moveType,
4264                                 &fromX, &fromY, &toX, &toY, &promoChar)
4265                || ParseOneMove(buf, moveNum - 1, &moveType,
4266                                 &fromX, &fromY, &toX, &toY, &promoChar);
4267           // end of long SAN patch
4268           if (valid) {
4269             (void) CoordsToAlgebraic(boards[moveNum - 1],
4270                                      PosFlags(moveNum - 1),
4271                                      fromY, fromX, toY, toX, promoChar,
4272                                      parseList[moveNum-1]);
4273             switch (MateTest(boards[moveNum], PosFlags(moveNum)) ) {
4274               case MT_NONE:
4275               case MT_STALEMATE:
4276               default:
4277                 break;
4278               case MT_CHECK:
4279                 if(gameInfo.variant != VariantShogi)
4280                     strcat(parseList[moveNum - 1], "+");
4281                 break;
4282               case MT_CHECKMATE:
4283               case MT_STAINMATE: // [HGM] xq: for notation stalemate that wins counts as checkmate
4284                 strcat(parseList[moveNum - 1], "#");
4285                 break;
4286             }
4287             strcat(parseList[moveNum - 1], " ");
4288             strcat(parseList[moveNum - 1], elapsed_time);
4289             /* currentMoveString is set as a side-effect of ParseOneMove */
4290             strcpy(moveList[moveNum - 1], currentMoveString);
4291             strcat(moveList[moveNum - 1], "\n");
4292           } else {
4293             /* Move from ICS was illegal!?  Punt. */
4294   if (appData.debugMode) {
4295     fprintf(debugFP, "Illegal move from ICS '%s'\n", move_str);
4296     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
4297   }
4298             strcpy(parseList[moveNum - 1], move_str);
4299             strcat(parseList[moveNum - 1], " ");
4300             strcat(parseList[moveNum - 1], elapsed_time);
4301             moveList[moveNum - 1][0] = NULLCHAR;
4302             fromX = fromY = toX = toY = -1;
4303           }
4304         }
4305   if (appData.debugMode) {
4306     fprintf(debugFP, "Move parsed to '%s'\n", parseList[moveNum - 1]);
4307     setbuf(debugFP, NULL);
4308   }
4309
4310 #if ZIPPY
4311         /* Send move to chess program (BEFORE animating it). */
4312         if (appData.zippyPlay && !newGame && newMove &&
4313            (!appData.getMoveList || backwardMostMove == 0) && first.initDone) {
4314
4315             if ((gameMode == IcsPlayingWhite && WhiteOnMove(moveNum)) ||
4316                 (gameMode == IcsPlayingBlack && !WhiteOnMove(moveNum))) {
4317                 if (moveList[moveNum - 1][0] == NULLCHAR) {
4318                     sprintf(str, _("Couldn't parse move \"%s\" from ICS"),
4319                             move_str);
4320                     DisplayError(str, 0);
4321                 } else {
4322                     if (first.sendTime) {
4323                         SendTimeRemaining(&first, gameMode == IcsPlayingWhite);
4324                     }
4325                     bookHit = SendMoveToBookUser(moveNum - 1, &first, FALSE); // [HGM] book
4326                     if (firstMove && !bookHit) {
4327                         firstMove = FALSE;
4328                         if (first.useColors) {
4329                           SendToProgram(gameMode == IcsPlayingWhite ?
4330                                         "white\ngo\n" :
4331                                         "black\ngo\n", &first);
4332                         } else {
4333                           SendToProgram("go\n", &first);
4334                         }
4335                         first.maybeThinking = TRUE;
4336                     }
4337                 }
4338             } else if (gameMode == IcsObserving || gameMode == IcsExamining) {
4339               if (moveList[moveNum - 1][0] == NULLCHAR) {
4340                 sprintf(str, _("Couldn't parse move \"%s\" from ICS"), move_str);
4341                 DisplayError(str, 0);
4342               } else {
4343                 if(gameInfo.variant == currentlyInitializedVariant) // [HGM] refrain sending moves engine can't understand!
4344                 SendMoveToProgram(moveNum - 1, &first);
4345               }
4346             }
4347         }
4348 #endif
4349     }
4350
4351     if (moveNum > 0 && !gotPremove && !appData.noGUI) {
4352         /* If move comes from a remote source, animate it.  If it
4353            isn't remote, it will have already been animated. */
4354         if (!pausing && !ics_user_moved && prevMove == moveNum - 1) {
4355             AnimateMove(boards[moveNum - 1], fromX, fromY, toX, toY);
4356         }
4357         if (!pausing && appData.highlightLastMove) {
4358             SetHighlights(fromX, fromY, toX, toY);
4359         }
4360     }
4361
4362     /* Start the clocks */
4363     whiteFlag = blackFlag = FALSE;
4364     appData.clockMode = !(basetime == 0 && increment == 0);
4365     if (ticking == 0) {
4366       ics_clock_paused = TRUE;
4367       StopClocks();
4368     } else if (ticking == 1) {
4369       ics_clock_paused = FALSE;
4370     }
4371     if (gameMode == IcsIdle ||
4372         relation == RELATION_OBSERVING_STATIC ||
4373         relation == RELATION_EXAMINING ||
4374         ics_clock_paused)
4375       DisplayBothClocks();
4376     else
4377       StartClocks();
4378
4379     /* Display opponents and material strengths */
4380     if (gameInfo.variant != VariantBughouse &&
4381         gameInfo.variant != VariantCrazyhouse && !appData.noGUI) {
4382         if (tinyLayout || smallLayout) {
4383             if(gameInfo.variant == VariantNormal)
4384                 sprintf(str, "%s(%d) %s(%d) {%d %d}",
4385                     gameInfo.white, white_stren, gameInfo.black, black_stren,
4386                     basetime, increment);
4387             else
4388                 sprintf(str, "%s(%d) %s(%d) {%d %d w%d}",
4389                     gameInfo.white, white_stren, gameInfo.black, black_stren,
4390                     basetime, increment, (int) gameInfo.variant);
4391         } else {
4392             if(gameInfo.variant == VariantNormal)
4393                 sprintf(str, "%s (%d) vs. %s (%d) {%d %d}",
4394                     gameInfo.white, white_stren, gameInfo.black, black_stren,
4395                     basetime, increment);
4396             else
4397                 sprintf(str, "%s (%d) vs. %s (%d) {%d %d %s}",
4398                     gameInfo.white, white_stren, gameInfo.black, black_stren,
4399                     basetime, increment, VariantName(gameInfo.variant));
4400         }
4401         DisplayTitle(str);
4402   if (appData.debugMode) {
4403     fprintf(debugFP, "Display title '%s, gameInfo.variant = %d'\n", str, gameInfo.variant);
4404   }
4405     }
4406
4407
4408     /* Display the board */
4409     if (!pausing && !appData.noGUI) {
4410
4411       if (appData.premove)
4412           if (!gotPremove ||
4413              ((gameMode == IcsPlayingWhite) && (WhiteOnMove(currentMove))) ||
4414              ((gameMode == IcsPlayingBlack) && (!WhiteOnMove(currentMove))))
4415               ClearPremoveHighlights();
4416
4417       j = seekGraphUp; seekGraphUp = FALSE; // [HGM] seekgraph: when we draw a board, it overwrites the seek graph
4418         if(partnerUp) { flipView = originalFlip; partnerUp = FALSE; j = TRUE; } // [HGM] bughouse: restore view
4419       DrawPosition(j, boards[currentMove]);
4420
4421       DisplayMove(moveNum - 1);
4422       if (appData.ringBellAfterMoves && /*!ics_user_moved*/ // [HGM] use absolute method to recognize own move
4423             !((gameMode == IcsPlayingWhite) && (!WhiteOnMove(moveNum)) ||
4424               (gameMode == IcsPlayingBlack) &&  (WhiteOnMove(moveNum))   ) ) {
4425         if(newMove) RingBell(); else PlayIcsUnfinishedSound();
4426       }
4427     }
4428
4429     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
4430 #if ZIPPY
4431     if(bookHit) { // [HGM] book: simulate book reply
4432         static char bookMove[MSG_SIZ]; // a bit generous?
4433
4434         programStats.nodes = programStats.depth = programStats.time =
4435         programStats.score = programStats.got_only_move = 0;
4436         sprintf(programStats.movelist, "%s (xbook)", bookHit);
4437
4438         strcpy(bookMove, "move ");
4439         strcat(bookMove, bookHit);
4440         HandleMachineMove(bookMove, &first);
4441     }
4442 #endif
4443 }
4444
4445 void
4446 GetMoveListEvent()
4447 {
4448     char buf[MSG_SIZ];
4449     if (appData.icsActive && gameMode != IcsIdle && ics_gamenum > 0) {
4450         ics_getting_history = H_REQUESTED;
4451         sprintf(buf, "%smoves %d\n", ics_prefix, ics_gamenum);
4452         SendToICS(buf);
4453     }
4454 }
4455
4456 void
4457 AnalysisPeriodicEvent(force)
4458      int force;
4459 {
4460     if (((programStats.ok_to_send == 0 || programStats.line_is_book)
4461          && !force) || !appData.periodicUpdates)
4462       return;
4463
4464     /* Send . command to Crafty to collect stats */
4465     SendToProgram(".\n", &first);
4466
4467     /* Don't send another until we get a response (this makes
4468        us stop sending to old Crafty's which don't understand
4469        the "." command (sending illegal cmds resets node count & time,
4470        which looks bad)) */
4471     programStats.ok_to_send = 0;
4472 }
4473
4474 void ics_update_width(new_width)
4475         int new_width;
4476 {
4477         ics_printf("set width %d\n", new_width);
4478 }
4479
4480 void
4481 SendMoveToProgram(moveNum, cps)
4482      int moveNum;
4483      ChessProgramState *cps;
4484 {
4485     char buf[MSG_SIZ];
4486
4487     if (cps->useUsermove) {
4488       SendToProgram("usermove ", cps);
4489     }
4490     if (cps->useSAN) {
4491       char *space;
4492       if ((space = strchr(parseList[moveNum], ' ')) != NULL) {
4493         int len = space - parseList[moveNum];
4494         memcpy(buf, parseList[moveNum], len);
4495         buf[len++] = '\n';
4496         buf[len] = NULLCHAR;
4497       } else {
4498         sprintf(buf, "%s\n", parseList[moveNum]);
4499       }
4500       SendToProgram(buf, cps);
4501     } else {
4502       if(cps->alphaRank) { /* [HGM] shogi: temporarily convert to shogi coordinates before sending */
4503         AlphaRank(moveList[moveNum], 4);
4504         SendToProgram(moveList[moveNum], cps);
4505         AlphaRank(moveList[moveNum], 4); // and back
4506       } else
4507       /* Added by Tord: Send castle moves in "O-O" in FRC games if required by
4508        * the engine. It would be nice to have a better way to identify castle
4509        * moves here. */
4510       if((gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom)
4511                                                                          && cps->useOOCastle) {
4512         int fromX = moveList[moveNum][0] - AAA;
4513         int fromY = moveList[moveNum][1] - ONE;
4514         int toX = moveList[moveNum][2] - AAA;
4515         int toY = moveList[moveNum][3] - ONE;
4516         if((boards[moveNum][fromY][fromX] == WhiteKing
4517             && boards[moveNum][toY][toX] == WhiteRook)
4518            || (boards[moveNum][fromY][fromX] == BlackKing
4519                && boards[moveNum][toY][toX] == BlackRook)) {
4520           if(toX > fromX) SendToProgram("O-O\n", cps);
4521           else SendToProgram("O-O-O\n", cps);
4522         }
4523         else SendToProgram(moveList[moveNum], cps);
4524       }
4525       else SendToProgram(moveList[moveNum], cps);
4526       /* End of additions by Tord */
4527     }
4528
4529     /* [HGM] setting up the opening has brought engine in force mode! */
4530     /*       Send 'go' if we are in a mode where machine should play. */
4531     if( (moveNum == 0 && setboardSpoiledMachineBlack && cps == &first) &&
4532         (gameMode == TwoMachinesPlay   ||
4533 #ifdef ZIPPY
4534          gameMode == IcsPlayingBlack     || gameMode == IcsPlayingWhite ||
4535 #endif
4536          gameMode == MachinePlaysBlack || gameMode == MachinePlaysWhite) ) {
4537         SendToProgram("go\n", cps);
4538   if (appData.debugMode) {
4539     fprintf(debugFP, "(extra)\n");
4540   }
4541     }
4542     setboardSpoiledMachineBlack = 0;
4543 }
4544
4545 void
4546 SendMoveToICS(moveType, fromX, fromY, toX, toY)
4547      ChessMove moveType;
4548      int fromX, fromY, toX, toY;
4549 {
4550     char user_move[MSG_SIZ];
4551
4552     switch (moveType) {
4553       default:
4554         sprintf(user_move, _("say Internal error; bad moveType %d (%d,%d-%d,%d)"),
4555                 (int)moveType, fromX, fromY, toX, toY);
4556         DisplayError(user_move + strlen("say "), 0);
4557         break;
4558       case WhiteKingSideCastle:
4559       case BlackKingSideCastle:
4560       case WhiteQueenSideCastleWild:
4561       case BlackQueenSideCastleWild:
4562       /* PUSH Fabien */
4563       case WhiteHSideCastleFR:
4564       case BlackHSideCastleFR:
4565       /* POP Fabien */
4566         sprintf(user_move, "o-o\n");
4567         break;
4568       case WhiteQueenSideCastle:
4569       case BlackQueenSideCastle:
4570       case WhiteKingSideCastleWild:
4571       case BlackKingSideCastleWild:
4572       /* PUSH Fabien */
4573       case WhiteASideCastleFR:
4574       case BlackASideCastleFR:
4575       /* POP Fabien */
4576         sprintf(user_move, "o-o-o\n");
4577         break;
4578       case WhitePromotionQueen:
4579       case BlackPromotionQueen:
4580       case WhitePromotionRook:
4581       case BlackPromotionRook:
4582       case WhitePromotionBishop:
4583       case BlackPromotionBishop:
4584       case WhitePromotionKnight:
4585       case BlackPromotionKnight:
4586       case WhitePromotionKing:
4587       case BlackPromotionKing:
4588       case WhitePromotionChancellor:
4589       case BlackPromotionChancellor:
4590       case WhitePromotionArchbishop:
4591       case BlackPromotionArchbishop:
4592         if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier || gameInfo.variant == VariantMakruk)
4593             sprintf(user_move, "%c%c%c%c=%c\n",
4594                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
4595                 PieceToChar(WhiteFerz));
4596         else if(gameInfo.variant == VariantGreat)
4597             sprintf(user_move, "%c%c%c%c=%c\n",
4598                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
4599                 PieceToChar(WhiteMan));
4600         else
4601             sprintf(user_move, "%c%c%c%c=%c\n",
4602                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY,
4603                 PieceToChar(PromoPiece(moveType)));
4604         break;
4605       case WhiteDrop:
4606       case BlackDrop:
4607         sprintf(user_move, "%c@%c%c\n",
4608                 ToUpper(PieceToChar((ChessSquare) fromX)),
4609                 AAA + toX, ONE + toY);
4610         break;
4611       case NormalMove:
4612       case WhiteCapturesEnPassant:
4613       case BlackCapturesEnPassant:
4614       case IllegalMove:  /* could be a variant we don't quite understand */
4615         sprintf(user_move, "%c%c%c%c\n",
4616                 AAA + fromX, ONE + fromY, AAA + toX, ONE + toY);
4617         break;
4618     }
4619     SendToICS(user_move);
4620     if(appData.keepAlive) // [HGM] alive: schedule sending of dummy 'date' command
4621         ScheduleDelayedEvent(KeepAlive, appData.keepAlive*60*1000);
4622 }
4623
4624 void
4625 UploadGameEvent()
4626 {   // [HGM] upload: send entire stored game to ICS as long-algebraic moves.
4627     int i, last = forwardMostMove; // make sure ICS reply cannot pre-empt us by clearing fmm
4628     static char *castlingStrings[4] = { "none", "kside", "qside", "both" };
4629     if(gameMode == IcsObserving || gameMode == IcsPlayingBlack || gameMode == IcsPlayingWhite) {
4630         DisplayError("You cannot do this while you are playing or observing", 0);
4631         return;
4632     }
4633     if(gameMode != IcsExamining) { // is this ever not the case?
4634         char buf[MSG_SIZ], *p, *fen, command[MSG_SIZ], bsetup = 0;
4635
4636         if(ics_type == ICS_ICC) { // on ICC match ourselves in applicable variant
4637             sprintf(command, "match %s", ics_handle);
4638         } else { // on FICS we must first go to general examine mode
4639             strcpy(command, "examine\nbsetup"); // and specify variant within it with bsetups
4640         }
4641         if(gameInfo.variant != VariantNormal) {
4642             // try figure out wild number, as xboard names are not always valid on ICS
4643             for(i=1; i<=36; i++) {
4644                 sprintf(buf, "wild/%d", i);
4645                 if(StringToVariant(buf) == gameInfo.variant) break;
4646             }
4647             if(i<=36 && ics_type == ICS_ICC) sprintf(buf, "%s w%d\n", command, i);
4648             else if(i == 22) sprintf(buf, "%s fr\n", command);
4649             else sprintf(buf, "%s %s\n", command, VariantName(gameInfo.variant));
4650         } else sprintf(buf, "%s\n", ics_type == ICS_ICC ? command : "examine\n"); // match yourself or examine
4651         SendToICS(ics_prefix);
4652         SendToICS(buf);
4653         if(startedFromSetupPosition || backwardMostMove != 0) {
4654           fen = PositionToFEN(backwardMostMove, NULL);
4655           if(ics_type == ICS_ICC) { // on ICC we can simply send a complete FEN to set everything
4656             sprintf(buf, "loadfen %s\n", fen);
4657             SendToICS(buf);
4658           } else { // FICS: everything has to set by separate bsetup commands
4659             p = strchr(fen, ' '); p[0] = NULLCHAR; // cut after board
4660             sprintf(buf, "bsetup fen %s\n", fen);
4661             SendToICS(buf);
4662             if(!WhiteOnMove(backwardMostMove)) {
4663                 SendToICS("bsetup tomove black\n");
4664             }
4665             i = (strchr(p+3, 'K') != NULL) + 2*(strchr(p+3, 'Q') != NULL);
4666             sprintf(buf, "bsetup wcastle %s\n", castlingStrings[i]);
4667             SendToICS(buf);
4668             i = (strchr(p+3, 'k') != NULL) + 2*(strchr(p+3, 'q') != NULL);
4669             sprintf(buf, "bsetup bcastle %s\n", castlingStrings[i]);
4670             SendToICS(buf);
4671             i = boards[backwardMostMove][EP_STATUS];
4672             if(i >= 0) { // set e.p.
4673                 sprintf(buf, "bsetup eppos %c\n", i+AAA);
4674                 SendToICS(buf);
4675             }
4676             bsetup++;
4677           }
4678         }
4679       if(bsetup || ics_type != ICS_ICC && gameInfo.variant != VariantNormal)
4680             SendToICS("bsetup done\n"); // switch to normal examining.
4681     }
4682     for(i = backwardMostMove; i<last; i++) {
4683         char buf[20];
4684         sprintf(buf, "%s\n", parseList[i]);
4685         SendToICS(buf);
4686     }
4687     SendToICS(ics_prefix);
4688     SendToICS(ics_type == ICS_ICC ? "tag result Game in progress\n" : "commit\n");
4689 }
4690
4691 void
4692 CoordsToComputerAlgebraic(rf, ff, rt, ft, promoChar, move)
4693      int rf, ff, rt, ft;
4694      char promoChar;
4695      char move[7];
4696 {
4697     if (rf == DROP_RANK) {
4698         sprintf(move, "%c@%c%c\n",
4699                 ToUpper(PieceToChar((ChessSquare) ff)), AAA + ft, ONE + rt);
4700     } else {
4701         if (promoChar == 'x' || promoChar == NULLCHAR) {
4702             sprintf(move, "%c%c%c%c\n",
4703                     AAA + ff, ONE + rf, AAA + ft, ONE + rt);
4704         } else {
4705             sprintf(move, "%c%c%c%c%c\n",
4706                     AAA + ff, ONE + rf, AAA + ft, ONE + rt, promoChar);
4707         }
4708     }
4709 }
4710
4711 void
4712 ProcessICSInitScript(f)
4713      FILE *f;
4714 {
4715     char buf[MSG_SIZ];
4716
4717     while (fgets(buf, MSG_SIZ, f)) {
4718         SendToICSDelayed(buf,(long)appData.msLoginDelay);
4719     }
4720
4721     fclose(f);
4722 }
4723
4724
4725 /* [HGM] Shogi move preprocessor: swap digits for letters, vice versa */
4726 void
4727 AlphaRank(char *move, int n)
4728 {
4729 //    char *p = move, c; int x, y;
4730
4731     if (appData.debugMode) {
4732         fprintf(debugFP, "alphaRank(%s,%d)\n", move, n);
4733     }
4734
4735     if(move[1]=='*' &&
4736        move[2]>='0' && move[2]<='9' &&
4737        move[3]>='a' && move[3]<='x'    ) {
4738         move[1] = '@';
4739         move[2] = BOARD_RGHT  -1 - (move[2]-'1') + AAA;
4740         move[3] = BOARD_HEIGHT-1 - (move[3]-'a') + ONE;
4741     } else
4742     if(move[0]>='0' && move[0]<='9' &&
4743        move[1]>='a' && move[1]<='x' &&
4744        move[2]>='0' && move[2]<='9' &&
4745        move[3]>='a' && move[3]<='x'    ) {
4746         /* input move, Shogi -> normal */
4747         move[0] = BOARD_RGHT  -1 - (move[0]-'1') + AAA;
4748         move[1] = BOARD_HEIGHT-1 - (move[1]-'a') + ONE;
4749         move[2] = BOARD_RGHT  -1 - (move[2]-'1') + AAA;
4750         move[3] = BOARD_HEIGHT-1 - (move[3]-'a') + ONE;
4751     } else
4752     if(move[1]=='@' &&
4753        move[3]>='0' && move[3]<='9' &&
4754        move[2]>='a' && move[2]<='x'    ) {
4755         move[1] = '*';
4756         move[2] = BOARD_RGHT - 1 - (move[2]-AAA) + '1';
4757         move[3] = BOARD_HEIGHT-1 - (move[3]-ONE) + 'a';
4758     } else
4759     if(
4760        move[0]>='a' && move[0]<='x' &&
4761        move[3]>='0' && move[3]<='9' &&
4762        move[2]>='a' && move[2]<='x'    ) {
4763          /* output move, normal -> Shogi */
4764         move[0] = BOARD_RGHT - 1 - (move[0]-AAA) + '1';
4765         move[1] = BOARD_HEIGHT-1 - (move[1]-ONE) + 'a';
4766         move[2] = BOARD_RGHT - 1 - (move[2]-AAA) + '1';
4767         move[3] = BOARD_HEIGHT-1 - (move[3]-ONE) + 'a';
4768         if(move[4] == PieceToChar(BlackQueen)) move[4] = '+';
4769     }
4770     if (appData.debugMode) {
4771         fprintf(debugFP, "   out = '%s'\n", move);
4772     }
4773 }
4774
4775 char yy_textstr[8000];
4776
4777 /* Parser for moves from gnuchess, ICS, or user typein box */
4778 Boolean
4779 ParseOneMove(move, moveNum, moveType, fromX, fromY, toX, toY, promoChar)
4780      char *move;
4781      int moveNum;
4782      ChessMove *moveType;
4783      int *fromX, *fromY, *toX, *toY;
4784      char *promoChar;
4785 {
4786     if (appData.debugMode) {
4787         fprintf(debugFP, "move to parse: %s\n", move);
4788     }
4789     *moveType = yylexstr(moveNum, move, yy_textstr, sizeof yy_textstr);
4790
4791     switch (*moveType) {
4792       case WhitePromotionChancellor:
4793       case BlackPromotionChancellor:
4794       case WhitePromotionArchbishop:
4795       case BlackPromotionArchbishop:
4796       case WhitePromotionQueen:
4797       case BlackPromotionQueen:
4798       case WhitePromotionRook:
4799       case BlackPromotionRook:
4800       case WhitePromotionBishop:
4801       case BlackPromotionBishop:
4802       case WhitePromotionKnight:
4803       case BlackPromotionKnight:
4804       case WhitePromotionKing:
4805       case BlackPromotionKing:
4806       case NormalMove:
4807       case WhiteCapturesEnPassant:
4808       case BlackCapturesEnPassant:
4809       case WhiteKingSideCastle:
4810       case WhiteQueenSideCastle:
4811       case BlackKingSideCastle:
4812       case BlackQueenSideCastle:
4813       case WhiteKingSideCastleWild:
4814       case WhiteQueenSideCastleWild:
4815       case BlackKingSideCastleWild:
4816       case BlackQueenSideCastleWild:
4817       /* Code added by Tord: */
4818       case WhiteHSideCastleFR:
4819       case WhiteASideCastleFR:
4820       case BlackHSideCastleFR:
4821       case BlackASideCastleFR:
4822       /* End of code added by Tord */
4823       case IllegalMove:         /* bug or odd chess variant */
4824         *fromX = currentMoveString[0] - AAA;
4825         *fromY = currentMoveString[1] - ONE;
4826         *toX = currentMoveString[2] - AAA;
4827         *toY = currentMoveString[3] - ONE;
4828         *promoChar = currentMoveString[4];
4829         if (*fromX < BOARD_LEFT || *fromX >= BOARD_RGHT || *fromY < 0 || *fromY >= BOARD_HEIGHT ||
4830             *toX < BOARD_LEFT || *toX >= BOARD_RGHT || *toY < 0 || *toY >= BOARD_HEIGHT) {
4831     if (appData.debugMode) {
4832         fprintf(debugFP, "Off-board move (%d,%d)-(%d,%d)%c, type = %d\n", *fromX, *fromY, *toX, *toY, *promoChar, *moveType);
4833     }
4834             *fromX = *fromY = *toX = *toY = 0;
4835             return FALSE;
4836         }
4837         if (appData.testLegality) {
4838           return (*moveType != IllegalMove);
4839         } else {
4840           return !(*fromX == *toX && *fromY == *toY) && boards[moveNum][*fromY][*fromX] != EmptySquare &&
4841                         WhiteOnMove(moveNum) == (boards[moveNum][*fromY][*fromX] < BlackPawn);
4842         }
4843
4844       case WhiteDrop:
4845       case BlackDrop:
4846         *fromX = *moveType == WhiteDrop ?
4847           (int) CharToPiece(ToUpper(currentMoveString[0])) :
4848           (int) CharToPiece(ToLower(currentMoveString[0]));
4849         *fromY = DROP_RANK;
4850         *toX = currentMoveString[2] - AAA;
4851         *toY = currentMoveString[3] - ONE;
4852         *promoChar = NULLCHAR;
4853         return TRUE;
4854
4855       case AmbiguousMove:
4856       case ImpossibleMove:
4857       case (ChessMove) 0:       /* end of file */
4858       case ElapsedTime:
4859       case Comment:
4860       case PGNTag:
4861       case NAG:
4862       case WhiteWins:
4863       case BlackWins:
4864       case GameIsDrawn:
4865       default:
4866     if (appData.debugMode) {
4867         fprintf(debugFP, "Impossible move %s, type = %d\n", currentMoveString, *moveType);
4868     }
4869         /* bug? */
4870         *fromX = *fromY = *toX = *toY = 0;
4871         *promoChar = NULLCHAR;
4872         return FALSE;
4873     }
4874 }
4875
4876
4877 void
4878 ParsePV(char *pv, Boolean storeComments)
4879 { // Parse a string of PV moves, and append to current game, behind forwardMostMove
4880   int fromX, fromY, toX, toY; char promoChar;
4881   ChessMove moveType;
4882   Boolean valid;
4883   int nr = 0;
4884
4885   endPV = forwardMostMove;
4886   do {
4887     while(*pv == ' ' || *pv == '\n' || *pv == '\t') pv++; // must still read away whitespace
4888     if(nr == 0 && !storeComments && *pv == '(') pv++; // first (ponder) move can be in parentheses
4889     valid = ParseOneMove(pv, endPV, &moveType, &fromX, &fromY, &toX, &toY, &promoChar);
4890 if(appData.debugMode){
4891 fprintf(debugFP,"parsePV: %d %c%c%c%c yy='%s'\nPV = '%s'\n", valid, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, yy_textstr, pv);
4892 }
4893     if(!valid && nr == 0 &&
4894        ParseOneMove(pv, endPV-1, &moveType, &fromX, &fromY, &toX, &toY, &promoChar)){
4895         nr++; moveType = Comment; // First move has been played; kludge to make sure we continue
4896         // Hande case where played move is different from leading PV move
4897         CopyBoard(boards[endPV+1], boards[endPV-1]); // tentatively unplay last game move
4898         CopyBoard(boards[endPV+2], boards[endPV-1]); // and play first move of PV
4899         ApplyMove(fromX, fromY, toX, toY, promoChar, boards[endPV+2]);
4900         if(!CompareBoards(boards[endPV], boards[endPV+2])) {
4901           endPV += 2; // if position different, keep this
4902           moveList[endPV-1][0] = fromX + AAA;
4903           moveList[endPV-1][1] = fromY + ONE;
4904           moveList[endPV-1][2] = toX + AAA;
4905           moveList[endPV-1][3] = toY + ONE;
4906           parseList[endPV-1][0] = NULLCHAR;
4907           strcpy(moveList[endPV-2], "_0_0"); // suppress premove highlight on takeback move
4908         }
4909       }
4910     pv = strstr(pv, yy_textstr) + strlen(yy_textstr); // skip what we parsed
4911     if(nr == 0 && !storeComments && *pv == ')') pv++; // closing parenthesis of ponder move;
4912     if(moveType == Comment && storeComments) AppendComment(endPV, yy_textstr, FALSE);
4913     if(moveType == Comment || moveType == NAG || moveType == ElapsedTime) {
4914         valid++; // allow comments in PV
4915         continue;
4916     }
4917     nr++;
4918     if(endPV+1 > framePtr) break; // no space, truncate
4919     if(!valid) break;
4920     endPV++;
4921     CopyBoard(boards[endPV], boards[endPV-1]);
4922     ApplyMove(fromX, fromY, toX, toY, promoChar, boards[endPV]);
4923     moveList[endPV-1][0] = fromX + AAA;
4924     moveList[endPV-1][1] = fromY + ONE;
4925     moveList[endPV-1][2] = toX + AAA;
4926     moveList[endPV-1][3] = toY + ONE;
4927     if(storeComments)
4928         CoordsToAlgebraic(boards[endPV - 1],
4929                              PosFlags(endPV - 1),
4930                              fromY, fromX, toY, toX, promoChar,
4931                              parseList[endPV - 1]);
4932     else
4933         parseList[endPV-1][0] = NULLCHAR;
4934   } while(valid);
4935   currentMove = endPV;
4936   if(currentMove == forwardMostMove) ClearPremoveHighlights(); else
4937   SetPremoveHighlights(moveList[currentMove-1][0]-AAA, moveList[currentMove-1][1]-ONE,
4938                        moveList[currentMove-1][2]-AAA, moveList[currentMove-1][3]-ONE);
4939   DrawPosition(TRUE, boards[currentMove]);
4940 }
4941
4942 static int lastX, lastY;
4943
4944 Boolean
4945 LoadMultiPV(int x, int y, char *buf, int index, int *start, int *end)
4946 {
4947         int startPV;
4948         char *p;
4949
4950         if(index < 0 || index >= strlen(buf)) return FALSE; // sanity
4951         lastX = x; lastY = y;
4952         while(index > 0 && buf[index-1] != '\n') index--; // beginning of line
4953         startPV = index;
4954         while(buf[index] != '\n') if(buf[index++] == '\t') startPV = index;
4955         if(index == startPV && (p = StrCaseStr(buf+index, "PV="))) startPV = p - buf + 3;
4956         index = startPV;
4957         do{ while(buf[index] && buf[index] != '\n') index++;
4958         } while(buf[index] == '\n' && buf[index+1] == '\\' && buf[index+2] == ' ' && index++); // join kibitzed PV continuation line
4959         buf[index] = 0;
4960         ParsePV(buf+startPV, FALSE);
4961         *start = startPV; *end = index-1;
4962         return TRUE;
4963 }
4964
4965 Boolean
4966 LoadPV(int x, int y)
4967 { // called on right mouse click to load PV
4968   int which = gameMode == TwoMachinesPlay && (WhiteOnMove(forwardMostMove) == (second.twoMachinesColor[0] == 'w'));
4969   lastX = x; lastY = y;
4970   ParsePV(lastPV[which], FALSE); // load the PV of the thinking engine in the boards array.
4971   return TRUE;
4972 }
4973
4974 void
4975 UnLoadPV()
4976 {
4977   if(endPV < 0) return;
4978   endPV = -1;
4979   currentMove = forwardMostMove;
4980   ClearPremoveHighlights();
4981   DrawPosition(TRUE, boards[currentMove]);
4982 }
4983
4984 void
4985 MovePV(int x, int y, int h)
4986 { // step through PV based on mouse coordinates (called on mouse move)
4987   int margin = h>>3, step = 0;
4988
4989   if(endPV < 0) return;
4990   // we must somehow check if right button is still down (might be released off board!)
4991   if(y < margin && (abs(x - lastX) > 6 || abs(y - lastY) > 6)) step = 1; else
4992   if(y > h - margin && (abs(x - lastX) > 6 || abs(y - lastY) > 6)) step = -1; else
4993   if( y > lastY + 6 ) step = -1; else if(y < lastY - 6) step = 1;
4994   if(!step) return;
4995   lastX = x; lastY = y;
4996   if(currentMove + step > endPV || currentMove + step < forwardMostMove) step = 0;
4997   currentMove += step;
4998   if(currentMove == forwardMostMove) ClearPremoveHighlights(); else
4999   SetPremoveHighlights(moveList[currentMove-1][0]-AAA, moveList[currentMove-1][1]-ONE,
5000                        moveList[currentMove-1][2]-AAA, moveList[currentMove-1][3]-ONE);
5001   DrawPosition(FALSE, boards[currentMove]);
5002 }
5003
5004
5005 // [HGM] shuffle: a general way to suffle opening setups, applicable to arbitrary variants.
5006 // All positions will have equal probability, but the current method will not provide a unique
5007 // numbering scheme for arrays that contain 3 or more pieces of the same kind.
5008 #define DARK 1
5009 #define LITE 2
5010 #define ANY 3
5011
5012 int squaresLeft[4];
5013 int piecesLeft[(int)BlackPawn];
5014 int seed, nrOfShuffles;
5015
5016 void GetPositionNumber()
5017 {       // sets global variable seed
5018         int i;
5019
5020         seed = appData.defaultFrcPosition;
5021         if(seed < 0) { // randomize based on time for negative FRC position numbers
5022                 for(i=0; i<50; i++) seed += random();
5023                 seed = random() ^ random() >> 8 ^ random() << 8;
5024                 if(seed<0) seed = -seed;
5025         }
5026 }
5027
5028 int put(Board board, int pieceType, int rank, int n, int shade)
5029 // put the piece on the (n-1)-th empty squares of the given shade
5030 {
5031         int i;
5032
5033         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) {
5034                 if( (((i-BOARD_LEFT)&1)+1) & shade && board[rank][i] == EmptySquare && n-- == 0) {
5035                         board[rank][i] = (ChessSquare) pieceType;
5036                         squaresLeft[((i-BOARD_LEFT)&1) + 1]--;
5037                         squaresLeft[ANY]--;
5038                         piecesLeft[pieceType]--;
5039                         return i;
5040                 }
5041         }
5042         return -1;
5043 }
5044
5045
5046 void AddOnePiece(Board board, int pieceType, int rank, int shade)
5047 // calculate where the next piece goes, (any empty square), and put it there
5048 {
5049         int i;
5050
5051         i = seed % squaresLeft[shade];
5052         nrOfShuffles *= squaresLeft[shade];
5053         seed /= squaresLeft[shade];
5054         put(board, pieceType, rank, i, shade);
5055 }
5056
5057 void AddTwoPieces(Board board, int pieceType, int rank)
5058 // calculate where the next 2 identical pieces go, (any empty square), and put it there
5059 {
5060         int i, n=squaresLeft[ANY], j=n-1, k;
5061
5062         k = n*(n-1)/2; // nr of possibilities, not counting permutations
5063         i = seed % k;  // pick one
5064         nrOfShuffles *= k;
5065         seed /= k;
5066         while(i >= j) i -= j--;
5067         j = n - 1 - j; i += j;
5068         put(board, pieceType, rank, j, ANY);
5069         put(board, pieceType, rank, i, ANY);
5070 }
5071
5072 void SetUpShuffle(Board board, int number)
5073 {
5074         int i, p, first=1;
5075
5076         GetPositionNumber(); nrOfShuffles = 1;
5077
5078         squaresLeft[DARK] = (BOARD_RGHT - BOARD_LEFT + 1)/2;
5079         squaresLeft[ANY]  = BOARD_RGHT - BOARD_LEFT;
5080         squaresLeft[LITE] = squaresLeft[ANY] - squaresLeft[DARK];
5081
5082         for(p = 0; p<=(int)WhiteKing; p++) piecesLeft[p] = 0;
5083
5084         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) { // count pieces and clear board
5085             p = (int) board[0][i];
5086             if(p < (int) BlackPawn) piecesLeft[p] ++;
5087             board[0][i] = EmptySquare;
5088         }
5089
5090         if(PosFlags(0) & F_ALL_CASTLE_OK) {
5091             // shuffles restricted to allow normal castling put KRR first
5092             if(piecesLeft[(int)WhiteKing]) // King goes rightish of middle
5093                 put(board, WhiteKing, 0, (gameInfo.boardWidth+1)/2, ANY);
5094             else if(piecesLeft[(int)WhiteUnicorn]) // in Knightmate Unicorn castles
5095                 put(board, WhiteUnicorn, 0, (gameInfo.boardWidth+1)/2, ANY);
5096             if(piecesLeft[(int)WhiteRook]) // First supply a Rook for K-side castling
5097                 put(board, WhiteRook, 0, gameInfo.boardWidth-2, ANY);
5098             if(piecesLeft[(int)WhiteRook]) // Then supply a Rook for Q-side castling
5099                 put(board, WhiteRook, 0, 0, ANY);
5100             // in variants with super-numerary Kings and Rooks, we leave these for the shuffle
5101         }
5102
5103         if(((BOARD_RGHT-BOARD_LEFT) & 1) == 0)
5104             // only for even boards make effort to put pairs of colorbound pieces on opposite colors
5105             for(p = (int) WhiteKing; p > (int) WhitePawn; p--) {
5106                 if(p != (int) WhiteBishop && p != (int) WhiteFerz && p != (int) WhiteAlfil) continue;
5107                 while(piecesLeft[p] >= 2) {
5108                     AddOnePiece(board, p, 0, LITE);
5109                     AddOnePiece(board, p, 0, DARK);
5110                 }
5111                 // Odd color-bound pieces are shuffled with the rest (to not run out of paired squares)
5112             }
5113
5114         for(p = (int) WhiteKing - 2; p > (int) WhitePawn; p--) {
5115             // Remaining pieces (non-colorbound, or odd color bound) can be put anywhere
5116             // but we leave King and Rooks for last, to possibly obey FRC restriction
5117             if(p == (int)WhiteRook) continue;
5118             while(piecesLeft[p] >= 2) AddTwoPieces(board, p, 0); // add in pairs, for not counting permutations
5119             if(piecesLeft[p]) AddOnePiece(board, p, 0, ANY);     // add the odd piece
5120         }
5121
5122         // now everything is placed, except perhaps King (Unicorn) and Rooks
5123
5124         if(PosFlags(0) & F_FRC_TYPE_CASTLING) {
5125             // Last King gets castling rights
5126             while(piecesLeft[(int)WhiteUnicorn]) {
5127                 i = put(board, WhiteUnicorn, 0, piecesLeft[(int)WhiteRook]/2, ANY);
5128                 initialRights[2]  = initialRights[5]  = board[CASTLING][2] = board[CASTLING][5] = i;
5129             }
5130
5131             while(piecesLeft[(int)WhiteKing]) {
5132                 i = put(board, WhiteKing, 0, piecesLeft[(int)WhiteRook]/2, ANY);
5133                 initialRights[2]  = initialRights[5]  = board[CASTLING][2] = board[CASTLING][5] = i;
5134             }
5135
5136
5137         } else {
5138             while(piecesLeft[(int)WhiteKing])    AddOnePiece(board, WhiteKing, 0, ANY);
5139             while(piecesLeft[(int)WhiteUnicorn]) AddOnePiece(board, WhiteUnicorn, 0, ANY);
5140         }
5141
5142         // Only Rooks can be left; simply place them all
5143         while(piecesLeft[(int)WhiteRook]) {
5144                 i = put(board, WhiteRook, 0, 0, ANY);
5145                 if(PosFlags(0) & F_FRC_TYPE_CASTLING) { // first and last Rook get FRC castling rights
5146                         if(first) {
5147                                 first=0;
5148                                 initialRights[1]  = initialRights[4]  = board[CASTLING][1] = board[CASTLING][4] = i;
5149                         }
5150                         initialRights[0]  = initialRights[3]  = board[CASTLING][0] = board[CASTLING][3] = i;
5151                 }
5152         }
5153         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) { // copy black from white
5154             board[BOARD_HEIGHT-1][i] =  (int) board[0][i] < BlackPawn ? WHITE_TO_BLACK board[0][i] : EmptySquare;
5155         }
5156
5157         if(number >= 0) appData.defaultFrcPosition %= nrOfShuffles; // normalize
5158 }
5159
5160 int SetCharTable( char *table, const char * map )
5161 /* [HGM] moved here from winboard.c because of its general usefulness */
5162 /*       Basically a safe strcpy that uses the last character as King */
5163 {
5164     int result = FALSE; int NrPieces;
5165
5166     if( map != NULL && (NrPieces=strlen(map)) <= (int) EmptySquare
5167                     && NrPieces >= 12 && !(NrPieces&1)) {
5168         int i; /* [HGM] Accept even length from 12 to 34 */
5169
5170         for( i=0; i<(int) EmptySquare; i++ ) table[i] = '.';
5171         for( i=0; i<NrPieces/2-1; i++ ) {
5172             table[i] = map[i];
5173             table[i + (int)BlackPawn - (int) WhitePawn] = map[i+NrPieces/2];
5174         }
5175         table[(int) WhiteKing]  = map[NrPieces/2-1];
5176         table[(int) BlackKing]  = map[NrPieces-1];
5177
5178         result = TRUE;
5179     }
5180
5181     return result;
5182 }
5183
5184 void Prelude(Board board)
5185 {       // [HGM] superchess: random selection of exo-pieces
5186         int i, j, k; ChessSquare p;
5187         static ChessSquare exoPieces[4] = { WhiteAngel, WhiteMarshall, WhiteSilver, WhiteLance };
5188
5189         GetPositionNumber(); // use FRC position number
5190
5191         if(appData.pieceToCharTable != NULL) { // select pieces to participate from given char table
5192             SetCharTable(pieceToChar, appData.pieceToCharTable);
5193             for(i=(int)WhiteQueen+1, j=0; i<(int)WhiteKing && j<4; i++)
5194                 if(PieceToChar((ChessSquare)i) != '.') exoPieces[j++] = (ChessSquare) i;
5195         }
5196
5197         j = seed%4;                 seed /= 4;
5198         p = board[0][BOARD_LEFT+j];   board[0][BOARD_LEFT+j] = EmptySquare; k = PieceToNumber(p);
5199         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
5200         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
5201         j = seed%3 + (seed%3 >= j); seed /= 3;
5202         p = board[0][BOARD_LEFT+j];   board[0][BOARD_LEFT+j] = EmptySquare; k = PieceToNumber(p);
5203         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
5204         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
5205         j = seed%3;                 seed /= 3;
5206         p = board[0][BOARD_LEFT+j+5]; board[0][BOARD_LEFT+j+5] = EmptySquare; k = PieceToNumber(p);
5207         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
5208         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
5209         j = seed%2 + (seed%2 >= j); seed /= 2;
5210         p = board[0][BOARD_LEFT+j+5]; board[0][BOARD_LEFT+j+5] = EmptySquare; k = PieceToNumber(p);
5211         board[k][BOARD_WIDTH-1] = p;  board[k][BOARD_WIDTH-2]++;
5212         board[BOARD_HEIGHT-1-k][0] = WHITE_TO_BLACK p;  board[BOARD_HEIGHT-1-k][1]++;
5213         j = seed%4; seed /= 4; put(board, exoPieces[3],    0, j, ANY);
5214         j = seed%3; seed /= 3; put(board, exoPieces[2],   0, j, ANY);
5215         j = seed%2; seed /= 2; put(board, exoPieces[1], 0, j, ANY);
5216         put(board, exoPieces[0],    0, 0, ANY);
5217         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) board[BOARD_HEIGHT-1][i] = WHITE_TO_BLACK board[0][i];
5218 }
5219
5220 void
5221 InitPosition(redraw)
5222      int redraw;
5223 {
5224     ChessSquare (* pieces)[BOARD_FILES];
5225     int i, j, pawnRow, overrule,
5226     oldx = gameInfo.boardWidth,
5227     oldy = gameInfo.boardHeight,
5228     oldh = gameInfo.holdingsWidth,
5229     oldv = gameInfo.variant;
5230
5231     if(appData.icsActive) shuffleOpenings = FALSE; // [HGM] shuffle: in ICS mode, only shuffle on ICS request
5232
5233     /* [AS] Initialize pv info list [HGM] and game status */
5234     {
5235         for( i=0; i<=framePtr; i++ ) { // [HGM] vari: spare saved variations
5236             pvInfoList[i].depth = 0;
5237             boards[i][EP_STATUS] = EP_NONE;
5238             for( j=0; j<BOARD_FILES-2; j++ ) boards[i][CASTLING][j] = NoRights;
5239         }
5240
5241         initialRulePlies = 0; /* 50-move counter start */
5242
5243         castlingRank[0] = castlingRank[1] = castlingRank[2] = 0;
5244         castlingRank[3] = castlingRank[4] = castlingRank[5] = BOARD_HEIGHT-1;
5245     }
5246
5247
5248     /* [HGM] logic here is completely changed. In stead of full positions */
5249     /* the initialized data only consist of the two backranks. The switch */
5250     /* selects which one we will use, which is than copied to the Board   */
5251     /* initialPosition, which for the rest is initialized by Pawns and    */
5252     /* empty squares. This initial position is then copied to boards[0],  */
5253     /* possibly after shuffling, so that it remains available.            */
5254
5255     gameInfo.holdingsWidth = 0; /* default board sizes */
5256     gameInfo.boardWidth    = 8;
5257     gameInfo.boardHeight   = 8;
5258     gameInfo.holdingsSize  = 0;
5259     nrCastlingRights = -1; /* [HGM] Kludge to indicate default should be used */
5260     for(i=0; i<BOARD_FILES-2; i++)
5261       initialPosition[CASTLING][i] = initialRights[i] = NoRights; /* but no rights yet */
5262     initialPosition[EP_STATUS] = EP_NONE;
5263     SetCharTable(pieceToChar, "PNBRQ...........Kpnbrq...........k");
5264
5265     switch (gameInfo.variant) {
5266     case VariantFischeRandom:
5267       shuffleOpenings = TRUE;
5268     default:
5269       pieces = FIDEArray;
5270       break;
5271     case VariantShatranj:
5272       pieces = ShatranjArray;
5273       nrCastlingRights = 0;
5274       SetCharTable(pieceToChar, "PN.R.QB...Kpn.r.qb...k");
5275       break;
5276     case VariantMakruk:
5277       pieces = makrukArray;
5278       nrCastlingRights = 0;
5279       startedFromSetupPosition = TRUE;
5280       SetCharTable(pieceToChar, "PN.R.M....SKpn.r.m....sk");
5281       break;
5282     case VariantTwoKings:
5283       pieces = twoKingsArray;
5284       break;
5285     case VariantCapaRandom:
5286       shuffleOpenings = TRUE;
5287     case VariantCapablanca:
5288       pieces = CapablancaArray;
5289       gameInfo.boardWidth = 10;
5290       SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
5291       break;
5292     case VariantGothic:
5293       pieces = GothicArray;
5294       gameInfo.boardWidth = 10;
5295       SetCharTable(pieceToChar, "PNBRQ..ACKpnbrq..ack");
5296       break;
5297     case VariantJanus:
5298       pieces = JanusArray;
5299       gameInfo.boardWidth = 10;
5300       SetCharTable(pieceToChar, "PNBRQ..JKpnbrq..jk");
5301       nrCastlingRights = 6;
5302         initialPosition[CASTLING][0] = initialRights[0] = BOARD_RGHT-1;
5303         initialPosition[CASTLING][1] = initialRights[1] = BOARD_LEFT;
5304         initialPosition[CASTLING][2] = initialRights[2] =(BOARD_WIDTH-1)>>1;
5305         initialPosition[CASTLING][3] = initialRights[3] = BOARD_RGHT-1;
5306         initialPosition[CASTLING][4] = initialRights[4] = BOARD_LEFT;
5307         initialPosition[CASTLING][5] = initialRights[5] =(BOARD_WIDTH-1)>>1;
5308       break;
5309     case VariantFalcon:
5310       pieces = FalconArray;
5311       gameInfo.boardWidth = 10;
5312       SetCharTable(pieceToChar, "PNBRQ.............FKpnbrq.............fk");
5313       break;
5314     case VariantXiangqi:
5315       pieces = XiangqiArray;
5316       gameInfo.boardWidth  = 9;
5317       gameInfo.boardHeight = 10;
5318       nrCastlingRights = 0;
5319       SetCharTable(pieceToChar, "PH.R.AE..K.C.ph.r.ae..k.c.");
5320       break;
5321     case VariantShogi:
5322       pieces = ShogiArray;
5323       gameInfo.boardWidth  = 9;
5324       gameInfo.boardHeight = 9;
5325       gameInfo.holdingsSize = 7;
5326       nrCastlingRights = 0;
5327       SetCharTable(pieceToChar, "PNBRLS...G.++++++Kpnbrls...g.++++++k");
5328       break;
5329     case VariantCourier:
5330       pieces = CourierArray;
5331       gameInfo.boardWidth  = 12;
5332       nrCastlingRights = 0;
5333       SetCharTable(pieceToChar, "PNBR.FE..WMKpnbr.fe..wmk");
5334       break;
5335     case VariantKnightmate:
5336       pieces = KnightmateArray;
5337       SetCharTable(pieceToChar, "P.BRQ.....M.........K.p.brq.....m.........k.");
5338       break;
5339     case VariantFairy:
5340       pieces = fairyArray;
5341       SetCharTable(pieceToChar, "PNBRQFEACWMOHIJGDVLSUKpnbrqfeacwmohijgdvlsuk");
5342       break;
5343     case VariantGreat:
5344       pieces = GreatArray;
5345       gameInfo.boardWidth = 10;
5346       SetCharTable(pieceToChar, "PN....E...S..HWGMKpn....e...s..hwgmk");
5347       gameInfo.holdingsSize = 8;
5348       break;
5349     case VariantSuper:
5350       pieces = FIDEArray;
5351       SetCharTable(pieceToChar, "PNBRQ..SE.......V.AKpnbrq..se.......v.ak");
5352       gameInfo.holdingsSize = 8;
5353       startedFromSetupPosition = TRUE;
5354       break;
5355     case VariantCrazyhouse:
5356     case VariantBughouse:
5357       pieces = FIDEArray;
5358       SetCharTable(pieceToChar, "PNBRQ.......~~~~Kpnbrq.......~~~~k");
5359       gameInfo.holdingsSize = 5;
5360       break;
5361     case VariantWildCastle:
5362       pieces = FIDEArray;
5363       /* !!?shuffle with kings guaranteed to be on d or e file */
5364       shuffleOpenings = 1;
5365       break;
5366     case VariantNoCastle:
5367       pieces = FIDEArray;
5368       nrCastlingRights = 0;
5369       /* !!?unconstrained back-rank shuffle */
5370       shuffleOpenings = 1;
5371       break;
5372     }
5373
5374     overrule = 0;
5375     if(appData.NrFiles >= 0) {
5376         if(gameInfo.boardWidth != appData.NrFiles) overrule++;
5377         gameInfo.boardWidth = appData.NrFiles;
5378     }
5379     if(appData.NrRanks >= 0) {
5380         gameInfo.boardHeight = appData.NrRanks;
5381     }
5382     if(appData.holdingsSize >= 0) {
5383         i = appData.holdingsSize;
5384         if(i > gameInfo.boardHeight) i = gameInfo.boardHeight;
5385         gameInfo.holdingsSize = i;
5386     }
5387     if(gameInfo.holdingsSize) gameInfo.holdingsWidth = 2;
5388     if(BOARD_HEIGHT > BOARD_RANKS || BOARD_WIDTH > BOARD_FILES)
5389         DisplayFatalError(_("Recompile to support this BOARD_RANKS or BOARD_FILES!"), 0, 2);
5390
5391     pawnRow = gameInfo.boardHeight - 7; /* seems to work in all common variants */
5392     if(pawnRow < 1) pawnRow = 1;
5393     if(gameInfo.variant == VariantMakruk) pawnRow = 2;
5394
5395     /* User pieceToChar list overrules defaults */
5396     if(appData.pieceToCharTable != NULL)
5397         SetCharTable(pieceToChar, appData.pieceToCharTable);
5398
5399     for( j=0; j<BOARD_WIDTH; j++ ) { ChessSquare s = EmptySquare;
5400
5401         if(j==BOARD_LEFT-1 || j==BOARD_RGHT)
5402             s = (ChessSquare) 0; /* account holding counts in guard band */
5403         for( i=0; i<BOARD_HEIGHT; i++ )
5404             initialPosition[i][j] = s;
5405
5406         if(j < BOARD_LEFT || j >= BOARD_RGHT || overrule) continue;
5407         initialPosition[0][j] = pieces[0][j-gameInfo.holdingsWidth];
5408         initialPosition[pawnRow][j] = WhitePawn;
5409         initialPosition[BOARD_HEIGHT-pawnRow-1][j] = BlackPawn;
5410         if(gameInfo.variant == VariantXiangqi) {
5411             if(j&1) {
5412                 initialPosition[pawnRow][j] =
5413                 initialPosition[BOARD_HEIGHT-pawnRow-1][j] = EmptySquare;
5414                 if(j==BOARD_LEFT+1 || j>=BOARD_RGHT-2) {
5415                    initialPosition[2][j] = WhiteCannon;
5416                    initialPosition[BOARD_HEIGHT-3][j] = BlackCannon;
5417                 }
5418             }
5419         }
5420         initialPosition[BOARD_HEIGHT-1][j] =  pieces[1][j-gameInfo.holdingsWidth];
5421     }
5422     if( (gameInfo.variant == VariantShogi) && !overrule ) {
5423
5424             j=BOARD_LEFT+1;
5425             initialPosition[1][j] = WhiteBishop;
5426             initialPosition[BOARD_HEIGHT-2][j] = BlackRook;
5427             j=BOARD_RGHT-2;
5428             initialPosition[1][j] = WhiteRook;
5429             initialPosition[BOARD_HEIGHT-2][j] = BlackBishop;
5430     }
5431
5432     if( nrCastlingRights == -1) {
5433         /* [HGM] Build normal castling rights (must be done after board sizing!) */
5434         /*       This sets default castling rights from none to normal corners   */
5435         /* Variants with other castling rights must set them themselves above    */
5436         nrCastlingRights = 6;
5437
5438         initialPosition[CASTLING][0] = initialRights[0] = BOARD_RGHT-1;
5439         initialPosition[CASTLING][1] = initialRights[1] = BOARD_LEFT;
5440         initialPosition[CASTLING][2] = initialRights[2] = BOARD_WIDTH>>1;
5441         initialPosition[CASTLING][3] = initialRights[3] = BOARD_RGHT-1;
5442         initialPosition[CASTLING][4] = initialRights[4] = BOARD_LEFT;
5443         initialPosition[CASTLING][5] = initialRights[5] = BOARD_WIDTH>>1;
5444      }
5445
5446      if(gameInfo.variant == VariantSuper) Prelude(initialPosition);
5447      if(gameInfo.variant == VariantGreat) { // promotion commoners
5448         initialPosition[PieceToNumber(WhiteMan)][BOARD_WIDTH-1] = WhiteMan;
5449         initialPosition[PieceToNumber(WhiteMan)][BOARD_WIDTH-2] = 9;
5450         initialPosition[BOARD_HEIGHT-1-PieceToNumber(WhiteMan)][0] = BlackMan;
5451         initialPosition[BOARD_HEIGHT-1-PieceToNumber(WhiteMan)][1] = 9;
5452      }
5453   if (appData.debugMode) {
5454     fprintf(debugFP, "shuffleOpenings = %d\n", shuffleOpenings);
5455   }
5456     if(shuffleOpenings) {
5457         SetUpShuffle(initialPosition, appData.defaultFrcPosition);
5458         startedFromSetupPosition = TRUE;
5459     }
5460     if(startedFromPositionFile) {
5461       /* [HGM] loadPos: use PositionFile for every new game */
5462       CopyBoard(initialPosition, filePosition);
5463       for(i=0; i<nrCastlingRights; i++)
5464           initialRights[i] = filePosition[CASTLING][i];
5465       startedFromSetupPosition = TRUE;
5466     }
5467
5468     CopyBoard(boards[0], initialPosition);
5469
5470     if(oldx != gameInfo.boardWidth ||
5471        oldy != gameInfo.boardHeight ||
5472        oldh != gameInfo.holdingsWidth
5473 #ifdef GOTHIC
5474        || oldv == VariantGothic ||        // For licensing popups
5475        gameInfo.variant == VariantGothic
5476 #endif
5477 #ifdef FALCON
5478        || oldv == VariantFalcon ||
5479        gameInfo.variant == VariantFalcon
5480 #endif
5481                                          )
5482             InitDrawingSizes(-2 ,0);
5483
5484     if (redraw)
5485       DrawPosition(TRUE, boards[currentMove]);
5486 }
5487
5488 void
5489 SendBoard(cps, moveNum)
5490      ChessProgramState *cps;
5491      int moveNum;
5492 {
5493     char message[MSG_SIZ];
5494
5495     if (cps->useSetboard) {
5496       char* fen = PositionToFEN(moveNum, cps->fenOverride);
5497       sprintf(message, "setboard %s\n", fen);
5498       SendToProgram(message, cps);
5499       free(fen);
5500
5501     } else {
5502       ChessSquare *bp;
5503       int i, j;
5504       /* Kludge to set black to move, avoiding the troublesome and now
5505        * deprecated "black" command.
5506        */
5507       if (!WhiteOnMove(moveNum)) SendToProgram("a2a3\n", cps);
5508
5509       SendToProgram("edit\n", cps);
5510       SendToProgram("#\n", cps);
5511       for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
5512         bp = &boards[moveNum][i][BOARD_LEFT];
5513         for (j = BOARD_LEFT; j < BOARD_RGHT; j++, bp++) {
5514           if ((int) *bp < (int) BlackPawn) {
5515             sprintf(message, "%c%c%c\n", PieceToChar(*bp),
5516                     AAA + j, ONE + i);
5517             if(message[0] == '+' || message[0] == '~') {
5518                 sprintf(message, "%c%c%c+\n",
5519                         PieceToChar((ChessSquare)(DEMOTED *bp)),
5520                         AAA + j, ONE + i);
5521             }
5522             if(cps->alphaRank) { /* [HGM] shogi: translate coords */
5523                 message[1] = BOARD_RGHT   - 1 - j + '1';
5524                 message[2] = BOARD_HEIGHT - 1 - i + 'a';
5525             }
5526             SendToProgram(message, cps);
5527           }
5528         }
5529       }
5530
5531       SendToProgram("c\n", cps);
5532       for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
5533         bp = &boards[moveNum][i][BOARD_LEFT];
5534         for (j = BOARD_LEFT; j < BOARD_RGHT; j++, bp++) {
5535           if (((int) *bp != (int) EmptySquare)
5536               && ((int) *bp >= (int) BlackPawn)) {
5537             sprintf(message, "%c%c%c\n", ToUpper(PieceToChar(*bp)),
5538                     AAA + j, ONE + i);
5539             if(message[0] == '+' || message[0] == '~') {
5540                 sprintf(message, "%c%c%c+\n",
5541                         PieceToChar((ChessSquare)(DEMOTED *bp)),
5542                         AAA + j, ONE + i);
5543             }
5544             if(cps->alphaRank) { /* [HGM] shogi: translate coords */
5545                 message[1] = BOARD_RGHT   - 1 - j + '1';
5546                 message[2] = BOARD_HEIGHT - 1 - i + 'a';
5547             }
5548             SendToProgram(message, cps);
5549           }
5550         }
5551       }
5552
5553       SendToProgram(".\n", cps);
5554     }
5555     setboardSpoiledMachineBlack = 0; /* [HGM] assume WB 4.2.7 already solves this after sending setboard */
5556 }
5557
5558 static int autoQueen; // [HGM] oneclick
5559
5560 int
5561 HasPromotionChoice(int fromX, int fromY, int toX, int toY, char *promoChoice)
5562 {
5563     /* [HGM] rewritten IsPromotion to only flag promotions that offer a choice */
5564     /* [HGM] add Shogi promotions */
5565     int promotionZoneSize=1, highestPromotingPiece = (int)WhitePawn;
5566     ChessSquare piece;
5567     ChessMove moveType;
5568     Boolean premove;
5569
5570     if(fromX < BOARD_LEFT || fromX >= BOARD_RGHT) return FALSE; // drop
5571     if(toX   < BOARD_LEFT || toX   >= BOARD_RGHT) return FALSE; // move into holdings
5572
5573     if(gameMode == EditPosition || gameInfo.variant == VariantXiangqi || // no promotions
5574       !(fromX >=0 && fromY >= 0 && toX >= 0 && toY >= 0) ) // invalid move
5575         return FALSE;
5576
5577     piece = boards[currentMove][fromY][fromX];
5578     if(gameInfo.variant == VariantShogi) {
5579         promotionZoneSize = 3;
5580         highestPromotingPiece = (int)WhiteFerz;
5581     } else if(gameInfo.variant == VariantMakruk) {
5582         promotionZoneSize = 3;
5583     }
5584
5585     // next weed out all moves that do not touch the promotion zone at all
5586     if((int)piece >= BlackPawn) {
5587         if(toY >= promotionZoneSize && fromY >= promotionZoneSize)
5588              return FALSE;
5589         highestPromotingPiece = WHITE_TO_BLACK highestPromotingPiece;
5590     } else {
5591         if(  toY < BOARD_HEIGHT - promotionZoneSize &&
5592            fromY < BOARD_HEIGHT - promotionZoneSize) return FALSE;
5593     }
5594
5595     if( (int)piece > highestPromotingPiece ) return FALSE; // non-promoting piece
5596
5597     // weed out mandatory Shogi promotions
5598     if(gameInfo.variant == VariantShogi) {
5599         if(piece >= BlackPawn) {
5600             if(toY == 0 && piece == BlackPawn ||
5601                toY == 0 && piece == BlackQueen ||
5602                toY <= 1 && piece == BlackKnight) {
5603                 *promoChoice = '+';
5604                 return FALSE;
5605             }
5606         } else {
5607             if(toY == BOARD_HEIGHT-1 && piece == WhitePawn ||
5608                toY == BOARD_HEIGHT-1 && piece == WhiteQueen ||
5609                toY >= BOARD_HEIGHT-2 && piece == WhiteKnight) {
5610                 *promoChoice = '+';
5611                 return FALSE;
5612             }
5613         }
5614     }
5615
5616     // weed out obviously illegal Pawn moves
5617     if(appData.testLegality  && (piece == WhitePawn || piece == BlackPawn) ) {
5618         if(toX > fromX+1 || toX < fromX-1) return FALSE; // wide
5619         if(piece == WhitePawn && toY != fromY+1) return FALSE; // deep
5620         if(piece == BlackPawn && toY != fromY-1) return FALSE; // deep
5621         if(fromX != toX && gameInfo.variant == VariantShogi) return FALSE;
5622         // note we are not allowed to test for valid (non-)capture, due to premove
5623     }
5624
5625     // we either have a choice what to promote to, or (in Shogi) whether to promote
5626     if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier || gameInfo.variant == VariantMakruk) {
5627         *promoChoice = PieceToChar(BlackFerz);  // no choice
5628         return FALSE;
5629     }
5630     if(autoQueen) { // predetermined
5631         if(gameInfo.variant == VariantSuicide || gameInfo.variant == VariantLosers)
5632              *promoChoice = PieceToChar(BlackKing); // in Suicide Q is the last thing we want
5633         else *promoChoice = PieceToChar(BlackQueen);
5634         return FALSE;
5635     }
5636
5637     // suppress promotion popup on illegal moves that are not premoves
5638     premove = gameMode == IcsPlayingWhite && !WhiteOnMove(currentMove) ||
5639               gameMode == IcsPlayingBlack &&  WhiteOnMove(currentMove);
5640     if(appData.testLegality && !premove) {
5641         moveType = LegalityTest(boards[currentMove], PosFlags(currentMove),
5642                         fromY, fromX, toY, toX, NULLCHAR);
5643         if(moveType != WhitePromotionQueen && moveType  != BlackPromotionQueen &&
5644            moveType != WhitePromotionKnight && moveType != BlackPromotionKnight)
5645             return FALSE;
5646     }
5647
5648     return TRUE;
5649 }
5650
5651 int
5652 InPalace(row, column)
5653      int row, column;
5654 {   /* [HGM] for Xiangqi */
5655     if( (row < 3 || row > BOARD_HEIGHT-4) &&
5656          column < (BOARD_WIDTH + 4)/2 &&
5657          column > (BOARD_WIDTH - 5)/2 ) return TRUE;
5658     return FALSE;
5659 }
5660
5661 int
5662 PieceForSquare (x, y)
5663      int x;
5664      int y;
5665 {
5666   if (x < 0 || x >= BOARD_WIDTH || y < 0 || y >= BOARD_HEIGHT)
5667      return -1;
5668   else
5669      return boards[currentMove][y][x];
5670 }
5671
5672 int
5673 OKToStartUserMove(x, y)
5674      int x, y;
5675 {
5676     ChessSquare from_piece;
5677     int white_piece;
5678
5679     if (matchMode) return FALSE;
5680     if (gameMode == EditPosition) return TRUE;
5681
5682     if (x >= 0 && y >= 0)
5683       from_piece = boards[currentMove][y][x];
5684     else
5685       from_piece = EmptySquare;
5686
5687     if (from_piece == EmptySquare) return FALSE;
5688
5689     white_piece = (int)from_piece >= (int)WhitePawn &&
5690       (int)from_piece < (int)BlackPawn; /* [HGM] can be > King! */
5691
5692     switch (gameMode) {
5693       case PlayFromGameFile:
5694       case AnalyzeFile:
5695       case TwoMachinesPlay:
5696       case EndOfGame:
5697         return FALSE;
5698
5699       case IcsObserving:
5700       case IcsIdle:
5701         return FALSE;
5702
5703       case MachinePlaysWhite:
5704       case IcsPlayingBlack:
5705         if (appData.zippyPlay) return FALSE;
5706         if (white_piece) {
5707             DisplayMoveError(_("You are playing Black"));
5708             return FALSE;
5709         }
5710         break;
5711
5712       case MachinePlaysBlack:
5713       case IcsPlayingWhite:
5714         if (appData.zippyPlay) return FALSE;
5715         if (!white_piece) {
5716             DisplayMoveError(_("You are playing White"));
5717             return FALSE;
5718         }
5719         break;
5720
5721       case EditGame:
5722         if (!white_piece && WhiteOnMove(currentMove)) {
5723             DisplayMoveError(_("It is White's turn"));
5724             return FALSE;
5725         }
5726         if (white_piece && !WhiteOnMove(currentMove)) {
5727             DisplayMoveError(_("It is Black's turn"));
5728             return FALSE;
5729         }
5730         if (cmailMsgLoaded && (currentMove < cmailOldMove)) {
5731             /* Editing correspondence game history */
5732             /* Could disallow this or prompt for confirmation */
5733             cmailOldMove = -1;
5734         }
5735         break;
5736
5737       case BeginningOfGame:
5738         if (appData.icsActive) return FALSE;
5739         if (!appData.noChessProgram) {
5740             if (!white_piece) {
5741                 DisplayMoveError(_("You are playing White"));
5742                 return FALSE;
5743             }
5744         }
5745         break;
5746
5747       case Training:
5748         if (!white_piece && WhiteOnMove(currentMove)) {
5749             DisplayMoveError(_("It is White's turn"));
5750             return FALSE;
5751         }
5752         if (white_piece && !WhiteOnMove(currentMove)) {
5753             DisplayMoveError(_("It is Black's turn"));
5754             return FALSE;
5755         }
5756         break;
5757
5758       default:
5759       case IcsExamining:
5760         break;
5761     }
5762     if (currentMove != forwardMostMove && gameMode != AnalyzeMode
5763         && gameMode != EditGame // [HGM] vari: treat as AnalyzeMode
5764         && gameMode != AnalyzeFile && gameMode != Training) {
5765         DisplayMoveError(_("Displayed position is not current"));
5766         return FALSE;
5767     }
5768     return TRUE;
5769 }
5770
5771 Boolean
5772 OnlyMove(int *x, int *y, Boolean captures) {
5773     DisambiguateClosure cl;
5774     if (appData.zippyPlay) return FALSE;
5775     switch(gameMode) {
5776       case MachinePlaysBlack:
5777       case IcsPlayingWhite:
5778       case BeginningOfGame:
5779         if(!WhiteOnMove(currentMove)) return FALSE;
5780         break;
5781       case MachinePlaysWhite:
5782       case IcsPlayingBlack:
5783         if(WhiteOnMove(currentMove)) return FALSE;
5784         break;
5785       default:
5786         return FALSE;
5787     }
5788     cl.pieceIn = EmptySquare;
5789     cl.rfIn = *y;
5790     cl.ffIn = *x;
5791     cl.rtIn = -1;
5792     cl.ftIn = -1;
5793     cl.promoCharIn = NULLCHAR;
5794     Disambiguate(boards[currentMove], PosFlags(currentMove), &cl);
5795     if( cl.kind == NormalMove ||
5796         cl.kind == AmbiguousMove && captures && cl.captures == 1 ||
5797         cl.kind == WhitePromotionQueen || cl.kind == BlackPromotionQueen ||
5798         cl.kind == WhitePromotionKnight || cl.kind == BlackPromotionKnight ||
5799         cl.kind == WhiteCapturesEnPassant || cl.kind == BlackCapturesEnPassant) {
5800       fromX = cl.ff;
5801       fromY = cl.rf;
5802       *x = cl.ft;
5803       *y = cl.rt;
5804       return TRUE;
5805     }
5806     if(cl.kind != ImpossibleMove) return FALSE;
5807     cl.pieceIn = EmptySquare;
5808     cl.rfIn = -1;
5809     cl.ffIn = -1;
5810     cl.rtIn = *y;
5811     cl.ftIn = *x;
5812     cl.promoCharIn = NULLCHAR;
5813     Disambiguate(boards[currentMove], PosFlags(currentMove), &cl);
5814     if( cl.kind == NormalMove ||
5815         cl.kind == AmbiguousMove && captures && cl.captures == 1 ||
5816         cl.kind == WhitePromotionQueen || cl.kind == BlackPromotionQueen ||
5817         cl.kind == WhitePromotionKnight || cl.kind == BlackPromotionKnight ||
5818         cl.kind == WhiteCapturesEnPassant || cl.kind == BlackCapturesEnPassant) {
5819       fromX = cl.ff;
5820       fromY = cl.rf;
5821       *x = cl.ft;
5822       *y = cl.rt;
5823       autoQueen = TRUE; // act as if autoQueen on when we click to-square
5824       return TRUE;
5825     }
5826     return FALSE;
5827 }
5828
5829 FILE *lastLoadGameFP = NULL, *lastLoadPositionFP = NULL;
5830 int lastLoadGameNumber = 0, lastLoadPositionNumber = 0;
5831 int lastLoadGameUseList = FALSE;
5832 char lastLoadGameTitle[MSG_SIZ], lastLoadPositionTitle[MSG_SIZ];
5833 ChessMove lastLoadGameStart = (ChessMove) 0;
5834
5835 ChessMove
5836 UserMoveTest(fromX, fromY, toX, toY, promoChar, captureOwn)
5837      int fromX, fromY, toX, toY;
5838      int promoChar;
5839      Boolean captureOwn;
5840 {
5841     ChessMove moveType;
5842     ChessSquare pdown, pup;
5843
5844     /* Check if the user is playing in turn.  This is complicated because we
5845        let the user "pick up" a piece before it is his turn.  So the piece he
5846        tried to pick up may have been captured by the time he puts it down!
5847        Therefore we use the color the user is supposed to be playing in this
5848        test, not the color of the piece that is currently on the starting
5849        square---except in EditGame mode, where the user is playing both
5850        sides; fortunately there the capture race can't happen.  (It can
5851        now happen in IcsExamining mode, but that's just too bad.  The user
5852        will get a somewhat confusing message in that case.)
5853        */
5854
5855     switch (gameMode) {
5856       case PlayFromGameFile:
5857       case AnalyzeFile:
5858       case TwoMachinesPlay:
5859       case EndOfGame:
5860       case IcsObserving:
5861       case IcsIdle:
5862         /* We switched into a game mode where moves are not accepted,
5863            perhaps while the mouse button was down. */
5864         return ImpossibleMove;
5865
5866       case MachinePlaysWhite:
5867         /* User is moving for Black */
5868         if (WhiteOnMove(currentMove)) {
5869             DisplayMoveError(_("It is White's turn"));
5870             return ImpossibleMove;
5871         }
5872         break;
5873
5874       case MachinePlaysBlack:
5875         /* User is moving for White */
5876         if (!WhiteOnMove(currentMove)) {
5877             DisplayMoveError(_("It is Black's turn"));
5878             return ImpossibleMove;
5879         }
5880         break;
5881
5882       case EditGame:
5883       case IcsExamining:
5884       case BeginningOfGame:
5885       case AnalyzeMode:
5886       case Training:
5887         if ((int) boards[currentMove][fromY][fromX] >= (int) BlackPawn &&
5888             (int) boards[currentMove][fromY][fromX] < (int) EmptySquare) {
5889             /* User is moving for Black */
5890             if (WhiteOnMove(currentMove)) {
5891                 DisplayMoveError(_("It is White's turn"));
5892                 return ImpossibleMove;
5893             }
5894         } else {
5895             /* User is moving for White */
5896             if (!WhiteOnMove(currentMove)) {
5897                 DisplayMoveError(_("It is Black's turn"));
5898                 return ImpossibleMove;
5899             }
5900         }
5901         break;
5902
5903       case IcsPlayingBlack:
5904         /* User is moving for Black */
5905         if (WhiteOnMove(currentMove)) {
5906             if (!appData.premove) {
5907                 DisplayMoveError(_("It is White's turn"));
5908             } else if (toX >= 0 && toY >= 0) {
5909                 premoveToX = toX;
5910                 premoveToY = toY;
5911                 premoveFromX = fromX;
5912                 premoveFromY = fromY;
5913                 premovePromoChar = promoChar;
5914                 gotPremove = 1;
5915                 if (appData.debugMode)
5916                     fprintf(debugFP, "Got premove: fromX %d,"
5917                             "fromY %d, toX %d, toY %d\n",
5918                             fromX, fromY, toX, toY);
5919             }
5920             return ImpossibleMove;
5921         }
5922         break;
5923
5924       case IcsPlayingWhite:
5925         /* User is moving for White */
5926         if (!WhiteOnMove(currentMove)) {
5927             if (!appData.premove) {
5928                 DisplayMoveError(_("It is Black's turn"));
5929             } else if (toX >= 0 && toY >= 0) {
5930                 premoveToX = toX;
5931                 premoveToY = toY;
5932                 premoveFromX = fromX;
5933                 premoveFromY = fromY;
5934                 premovePromoChar = promoChar;
5935                 gotPremove = 1;
5936                 if (appData.debugMode)
5937                     fprintf(debugFP, "Got premove: fromX %d,"
5938                             "fromY %d, toX %d, toY %d\n",
5939                             fromX, fromY, toX, toY);
5940             }
5941             return ImpossibleMove;
5942         }
5943         break;
5944
5945       default:
5946         break;
5947
5948       case EditPosition:
5949         /* EditPosition, empty square, or different color piece;
5950            click-click move is possible */
5951         if (toX == -2 || toY == -2) {
5952             boards[0][fromY][fromX] = EmptySquare;
5953             return AmbiguousMove;
5954         } else if (toX >= 0 && toY >= 0) {
5955             boards[0][toY][toX] = boards[0][fromY][fromX];
5956             if(fromX == BOARD_LEFT-2) { // handle 'moves' out of holdings
5957                 if(boards[0][fromY][0] != EmptySquare) {
5958                     if(boards[0][fromY][1]) boards[0][fromY][1]--;
5959                     if(boards[0][fromY][1] == 0)  boards[0][fromY][0] = EmptySquare;
5960                 }
5961             } else
5962             if(fromX == BOARD_RGHT+1) {
5963                 if(boards[0][fromY][BOARD_WIDTH-1] != EmptySquare) {
5964                     if(boards[0][fromY][BOARD_WIDTH-2]) boards[0][fromY][BOARD_WIDTH-2]--;
5965                     if(boards[0][fromY][BOARD_WIDTH-2] == 0)  boards[0][fromY][BOARD_WIDTH-1] = EmptySquare;
5966                 }
5967             } else
5968             boards[0][fromY][fromX] = EmptySquare;
5969             return AmbiguousMove;
5970         }
5971         return ImpossibleMove;
5972     }
5973
5974     if(toX < 0 || toY < 0) return ImpossibleMove;
5975     pdown = boards[currentMove][fromY][fromX];
5976     pup = boards[currentMove][toY][toX];
5977
5978     /* [HGM] If move started in holdings, it means a drop */
5979     if( fromX == BOARD_LEFT-2 || fromX == BOARD_RGHT+1) {
5980          if( pup != EmptySquare ) return ImpossibleMove;
5981          if(appData.testLegality) {
5982              /* it would be more logical if LegalityTest() also figured out
5983               * which drops are legal. For now we forbid pawns on back rank.
5984               * Shogi is on its own here...
5985               */
5986              if( (pdown == WhitePawn || pdown == BlackPawn) &&
5987                  (toY == 0 || toY == BOARD_HEIGHT -1 ) )
5988                  return(ImpossibleMove); /* no pawn drops on 1st/8th */
5989          }
5990          return WhiteDrop; /* Not needed to specify white or black yet */
5991     }
5992
5993     /* [HGM] always test for legality, to get promotion info */
5994     moveType = LegalityTest(boards[currentMove], PosFlags(currentMove),
5995                                          fromY, fromX, toY, toX, promoChar);
5996     /* [HGM] but possibly ignore an IllegalMove result */
5997     if (appData.testLegality) {
5998         if (moveType == IllegalMove || moveType == ImpossibleMove) {
5999             DisplayMoveError(_("Illegal move"));
6000             return ImpossibleMove;
6001         }
6002     }
6003
6004     return moveType;
6005     /* [HGM] <popupFix> in stead of calling FinishMove directly, this
6006        function is made into one that returns an OK move type if FinishMove
6007        should be called. This to give the calling driver routine the
6008        opportunity to finish the userMove input with a promotion popup,
6009        without bothering the user with this for invalid or illegal moves */
6010
6011 /*    FinishMove(moveType, fromX, fromY, toX, toY, promoChar); */
6012 }
6013
6014 /* Common tail of UserMoveEvent and DropMenuEvent */
6015 int
6016 FinishMove(moveType, fromX, fromY, toX, toY, promoChar)
6017      ChessMove moveType;
6018      int fromX, fromY, toX, toY;
6019      /*char*/int promoChar;
6020 {
6021     char *bookHit = 0;
6022
6023     if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) && promoChar != NULLCHAR) {
6024         // [HGM] superchess: suppress promotions to non-available piece
6025         int k = PieceToNumber(CharToPiece(ToUpper(promoChar)));
6026         if(WhiteOnMove(currentMove)) {
6027             if(!boards[currentMove][k][BOARD_WIDTH-2]) return 0;
6028         } else {
6029             if(!boards[currentMove][BOARD_HEIGHT-1-k][1]) return 0;
6030         }
6031     }
6032
6033     /* [HGM] <popupFix> kludge to avoid having to know the exact promotion
6034        move type in caller when we know the move is a legal promotion */
6035     if(moveType == NormalMove && promoChar)
6036         moveType = PromoCharToMoveType(WhiteOnMove(currentMove), promoChar);
6037
6038     /* [HGM] convert drag-and-drop piece drops to standard form */
6039     if( (fromX == BOARD_LEFT-2 || fromX == BOARD_RGHT+1) && fromY != DROP_RANK ){
6040          moveType = WhiteOnMove(currentMove) ? WhiteDrop : BlackDrop;
6041            if(appData.debugMode) fprintf(debugFP, "Drop move %d, curr=%d, x=%d,y=%d, p=%d\n",
6042                 moveType, currentMove, fromX, fromY, boards[currentMove][fromY][fromX]);
6043            // holdings might not be sent yet in ICS play; we have to figure out which piece belongs here
6044            if(fromX == 0) fromY = BOARD_HEIGHT-1 - fromY; // black holdings upside-down
6045            fromX = fromX ? WhitePawn : BlackPawn; // first piece type in selected holdings
6046            while(PieceToChar(fromX) == '.' || PieceToNumber(fromX) != fromY && fromX != (int) EmptySquare) fromX++;
6047          fromY = DROP_RANK;
6048     }
6049
6050     /* [HGM] <popupFix> The following if has been moved here from
6051        UserMoveEvent(). Because it seemed to belong here (why not allow
6052        piece drops in training games?), and because it can only be
6053        performed after it is known to what we promote. */
6054     if (gameMode == Training) {
6055       /* compare the move played on the board to the next move in the
6056        * game. If they match, display the move and the opponent's response.
6057        * If they don't match, display an error message.
6058        */
6059       int saveAnimate;
6060       Board testBoard;
6061       CopyBoard(testBoard, boards[currentMove]);
6062       ApplyMove(fromX, fromY, toX, toY, promoChar, testBoard);
6063
6064       if (CompareBoards(testBoard, boards[currentMove+1])) {
6065         ForwardInner(currentMove+1);
6066
6067         /* Autoplay the opponent's response.
6068          * if appData.animate was TRUE when Training mode was entered,
6069          * the response will be animated.
6070          */
6071         saveAnimate = appData.animate;
6072         appData.animate = animateTraining;
6073         ForwardInner(currentMove+1);
6074         appData.animate = saveAnimate;
6075
6076         /* check for the end of the game */
6077         if (currentMove >= forwardMostMove) {
6078           gameMode = PlayFromGameFile;
6079           ModeHighlight();
6080           SetTrainingModeOff();
6081           DisplayInformation(_("End of game"));
6082         }
6083       } else {
6084         DisplayError(_("Incorrect move"), 0);
6085       }
6086       return 1;
6087     }
6088
6089   /* Ok, now we know that the move is good, so we can kill
6090      the previous line in Analysis Mode */
6091   if ((gameMode == AnalyzeMode || gameMode == EditGame)
6092                                 && currentMove < forwardMostMove) {
6093     PushTail(currentMove, forwardMostMove); // [HGM] vari: save tail of game
6094   }
6095
6096   /* If we need the chess program but it's dead, restart it */
6097   ResurrectChessProgram();
6098
6099   /* A user move restarts a paused game*/
6100   if (pausing)
6101     PauseEvent();
6102
6103   thinkOutput[0] = NULLCHAR;
6104
6105   MakeMove(fromX, fromY, toX, toY, promoChar); /*updates forwardMostMove*/
6106
6107   if(Adjudicate(NULL)) return 1; // [HGM] adjudicate: take care of automtic game end
6108
6109   if (gameMode == BeginningOfGame) {
6110     if (appData.noChessProgram) {
6111       gameMode = EditGame;
6112       SetGameInfo();
6113     } else {
6114       char buf[MSG_SIZ];
6115       gameMode = MachinePlaysBlack;
6116       StartClocks();
6117       SetGameInfo();
6118       sprintf(buf, "%s vs. %s", gameInfo.white, gameInfo.black);
6119       DisplayTitle(buf);
6120       if (first.sendName) {
6121         sprintf(buf, "name %s\n", gameInfo.white);
6122         SendToProgram(buf, &first);
6123       }
6124       StartClocks();
6125     }
6126     ModeHighlight();
6127   }
6128
6129   /* Relay move to ICS or chess engine */
6130   if (appData.icsActive) {
6131     if (gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack ||
6132         gameMode == IcsExamining) {
6133       if(userOfferedDraw && (signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
6134         SendToICS(ics_prefix); // [HGM] drawclaim: send caim and move on one line for FICS
6135         SendToICS("draw ");
6136         SendMoveToICS(moveType, fromX, fromY, toX, toY);
6137       }
6138       // also send plain move, in case ICS does not understand atomic claims
6139       SendMoveToICS(moveType, fromX, fromY, toX, toY);
6140       ics_user_moved = 1;
6141     }
6142   } else {
6143     if (first.sendTime && (gameMode == BeginningOfGame ||
6144                            gameMode == MachinePlaysWhite ||
6145                            gameMode == MachinePlaysBlack)) {
6146       SendTimeRemaining(&first, gameMode != MachinePlaysBlack);
6147     }
6148     if (gameMode != EditGame && gameMode != PlayFromGameFile) {
6149          // [HGM] book: if program might be playing, let it use book
6150         bookHit = SendMoveToBookUser(forwardMostMove-1, &first, FALSE);
6151         first.maybeThinking = TRUE;
6152     } else SendMoveToProgram(forwardMostMove-1, &first);
6153     if (currentMove == cmailOldMove + 1) {
6154       cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
6155     }
6156   }
6157
6158   ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6159
6160   switch (gameMode) {
6161   case EditGame:
6162     switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
6163     case MT_NONE:
6164     case MT_CHECK:
6165       break;
6166     case MT_CHECKMATE:
6167     case MT_STAINMATE:
6168       if (WhiteOnMove(currentMove)) {
6169         GameEnds(BlackWins, "Black mates", GE_PLAYER);
6170       } else {
6171         GameEnds(WhiteWins, "White mates", GE_PLAYER);
6172       }
6173       break;
6174     case MT_STALEMATE:
6175       GameEnds(GameIsDrawn, "Stalemate", GE_PLAYER);
6176       break;
6177     }
6178     break;
6179
6180   case MachinePlaysBlack:
6181   case MachinePlaysWhite:
6182     /* disable certain menu options while machine is thinking */
6183     SetMachineThinkingEnables();
6184     break;
6185
6186   default:
6187     break;
6188   }
6189
6190   userOfferedDraw = FALSE; // [HGM] drawclaim: after move made, and tested for claimable draw
6191
6192   if(bookHit) { // [HGM] book: simulate book reply
6193         static char bookMove[MSG_SIZ]; // a bit generous?
6194
6195         programStats.nodes = programStats.depth = programStats.time =
6196         programStats.score = programStats.got_only_move = 0;
6197         sprintf(programStats.movelist, "%s (xbook)", bookHit);
6198
6199         strcpy(bookMove, "move ");
6200         strcat(bookMove, bookHit);
6201         HandleMachineMove(bookMove, &first);
6202   }
6203   return 1;
6204 }
6205
6206 void
6207 UserMoveEvent(fromX, fromY, toX, toY, promoChar)
6208      int fromX, fromY, toX, toY;
6209      int promoChar;
6210 {
6211     /* [HGM] This routine was added to allow calling of its two logical
6212        parts from other modules in the old way. Before, UserMoveEvent()
6213        automatically called FinishMove() if the move was OK, and returned
6214        otherwise. I separated the two, in order to make it possible to
6215        slip a promotion popup in between. But that it always needs two
6216        calls, to the first part, (now called UserMoveTest() ), and to
6217        FinishMove if the first part succeeded. Calls that do not need
6218        to do anything in between, can call this routine the old way.
6219     */
6220     ChessMove moveType = UserMoveTest(fromX, fromY, toX, toY, promoChar, FALSE);
6221 if(appData.debugMode) fprintf(debugFP, "moveType 4 = %d, promochar = %x\n", moveType, promoChar);
6222     if(moveType == AmbiguousMove)
6223         DrawPosition(FALSE, boards[currentMove]);
6224     else if(moveType != ImpossibleMove && moveType != Comment)
6225         FinishMove(moveType, fromX, fromY, toX, toY, promoChar);
6226 }
6227
6228 void
6229 Mark(board, flags, kind, rf, ff, rt, ft, closure)
6230      Board board;
6231      int flags;
6232      ChessMove kind;
6233      int rf, ff, rt, ft;
6234      VOIDSTAR closure;
6235 {
6236     typedef char Markers[BOARD_RANKS][BOARD_FILES];
6237     Markers *m = (Markers *) closure;
6238     if(rf == fromY && ff == fromX)
6239         (*m)[rt][ft] = 1 + (board[rt][ft] != EmptySquare
6240                          || kind == WhiteCapturesEnPassant
6241                          || kind == BlackCapturesEnPassant);
6242     else if(flags & F_MANDATORY_CAPTURE && board[rt][ft] != EmptySquare) (*m)[rt][ft] = 3;
6243 }
6244
6245 void
6246 MarkTargetSquares(int clear)
6247 {
6248   int x, y;
6249   if(!appData.markers || !appData.highlightDragging ||
6250      !appData.testLegality || gameMode == EditPosition) return;
6251   if(clear) {
6252     for(x=0; x<BOARD_WIDTH; x++) for(y=0; y<BOARD_HEIGHT; y++) marker[y][x] = 0;
6253   } else {
6254     int capt = 0;
6255     GenLegal(boards[currentMove], PosFlags(currentMove), Mark, (void*) marker);
6256     if(PosFlags(0) & F_MANDATORY_CAPTURE) {
6257       for(x=0; x<BOARD_WIDTH; x++) for(y=0; y<BOARD_HEIGHT; y++) if(marker[y][x]>1) capt++;
6258       if(capt)
6259       for(x=0; x<BOARD_WIDTH; x++) for(y=0; y<BOARD_HEIGHT; y++) if(marker[y][x] == 1) marker[y][x] = 0;
6260     }
6261   }
6262   DrawPosition(TRUE, NULL);
6263 }
6264
6265 void LeftClick(ClickType clickType, int xPix, int yPix)
6266 {
6267     int x, y;
6268     Boolean saveAnimate;
6269     static int second = 0, promotionChoice = 0, dragging = 0;
6270     char promoChoice = NULLCHAR;
6271
6272     if(appData.seekGraph && appData.icsActive && loggedOn &&
6273         (gameMode == BeginningOfGame || gameMode == IcsIdle)) {
6274         SeekGraphClick(clickType, xPix, yPix, 0);
6275         return;
6276     }
6277
6278     if (clickType == Press) ErrorPopDown();
6279     MarkTargetSquares(1);
6280
6281     x = EventToSquare(xPix, BOARD_WIDTH);
6282     y = EventToSquare(yPix, BOARD_HEIGHT);
6283     if (!flipView && y >= 0) {
6284         y = BOARD_HEIGHT - 1 - y;
6285     }
6286     if (flipView && x >= 0) {
6287         x = BOARD_WIDTH - 1 - x;
6288     }
6289
6290     if(promotionChoice) { // we are waiting for a click to indicate promotion piece
6291         if(clickType == Release) return; // ignore upclick of click-click destination
6292         promotionChoice = FALSE; // only one chance: if click not OK it is interpreted as cancel
6293         if(appData.debugMode) fprintf(debugFP, "promotion click, x=%d, y=%d\n", x, y);
6294         if(gameInfo.holdingsWidth &&
6295                 (WhiteOnMove(currentMove)
6296                         ? x == BOARD_WIDTH-1 && y < gameInfo.holdingsSize && y > 0
6297                         : x == 0 && y >= BOARD_HEIGHT - gameInfo.holdingsSize && y < BOARD_HEIGHT-1) ) {
6298             // click in right holdings, for determining promotion piece
6299             ChessSquare p = boards[currentMove][y][x];
6300             if(appData.debugMode) fprintf(debugFP, "square contains %d\n", (int)p);
6301             if(p != EmptySquare) {
6302                 FinishMove(NormalMove, fromX, fromY, toX, toY, ToLower(PieceToChar(p)));
6303                 fromX = fromY = -1;
6304                 return;
6305             }
6306         }
6307         DrawPosition(FALSE, boards[currentMove]);
6308         return;
6309     }
6310
6311     /* [HGM] holdings: next 5 lines: ignore all clicks between board and holdings */
6312     if(clickType == Press
6313             && ( x == BOARD_LEFT-1 || x == BOARD_RGHT
6314               || x == BOARD_LEFT-2 && y < BOARD_HEIGHT-gameInfo.holdingsSize
6315               || x == BOARD_RGHT+1 && y >= gameInfo.holdingsSize) )
6316         return;
6317
6318     autoQueen = appData.alwaysPromoteToQueen;
6319
6320     if (fromX == -1) {
6321       if(!appData.oneClick || !OnlyMove(&x, &y, FALSE)) {
6322         if (clickType == Press) {
6323             /* First square */
6324             if (OKToStartUserMove(x, y)) {
6325                 fromX = x;
6326                 fromY = y;
6327                 second = 0;
6328                 MarkTargetSquares(0);
6329                 DragPieceBegin(xPix, yPix); dragging = 1;
6330                 if (appData.highlightDragging) {
6331                     SetHighlights(x, y, -1, -1);
6332                 }
6333             }
6334         } else if(dragging); { // [HGM] from-square must have been reset due to game end since last press
6335             DragPieceEnd(xPix, yPix); dragging = 0;
6336             DrawPosition(FALSE, NULL);
6337         }
6338         return;
6339       }
6340     }
6341
6342     /* fromX != -1 */
6343     if (clickType == Press && gameMode != EditPosition) {
6344         ChessSquare fromP;
6345         ChessSquare toP;
6346         int frc;
6347
6348         // ignore off-board to clicks
6349         if(y < 0 || x < 0) return;
6350
6351         /* Check if clicking again on the same color piece */
6352         fromP = boards[currentMove][fromY][fromX];
6353         toP = boards[currentMove][y][x];
6354         frc = gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom;
6355         if ((WhitePawn <= fromP && fromP <= WhiteKing &&
6356              WhitePawn <= toP && toP <= WhiteKing &&
6357              !(fromP == WhiteKing && toP == WhiteRook && frc) &&
6358              !(fromP == WhiteRook && toP == WhiteKing && frc)) ||
6359             (BlackPawn <= fromP && fromP <= BlackKing &&
6360              BlackPawn <= toP && toP <= BlackKing &&
6361              !(fromP == BlackRook && toP == BlackKing && frc) && // allow also RxK as FRC castling
6362              !(fromP == BlackKing && toP == BlackRook && frc))) {
6363             /* Clicked again on same color piece -- changed his mind */
6364             second = (x == fromX && y == fromY);
6365            if(!second || !OnlyMove(&x, &y, TRUE)) {
6366             if (appData.highlightDragging) {
6367                 SetHighlights(x, y, -1, -1);
6368             } else {
6369                 ClearHighlights();
6370             }
6371             if (OKToStartUserMove(x, y)) {
6372                 fromX = x;
6373                 fromY = y; dragging = 1;
6374                 MarkTargetSquares(0);
6375                 DragPieceBegin(xPix, yPix);
6376             }
6377             return;
6378            }
6379         }
6380         // ignore clicks on holdings
6381         if(x < BOARD_LEFT || x >= BOARD_RGHT) return;
6382     }
6383
6384     if (clickType == Release && x == fromX && y == fromY) {
6385         DragPieceEnd(xPix, yPix); dragging = 0;
6386         if (appData.animateDragging) {
6387             /* Undo animation damage if any */
6388             DrawPosition(FALSE, NULL);
6389         }
6390         if (second) {
6391             /* Second up/down in same square; just abort move */
6392             second = 0;
6393             fromX = fromY = -1;
6394             ClearHighlights();
6395             gotPremove = 0;
6396             ClearPremoveHighlights();
6397         } else {
6398             /* First upclick in same square; start click-click mode */
6399             SetHighlights(x, y, -1, -1);
6400         }
6401         return;
6402     }
6403
6404     /* we now have a different from- and (possibly off-board) to-square */
6405     /* Completed move */
6406     toX = x;
6407     toY = y;
6408     saveAnimate = appData.animate;
6409     if (clickType == Press) {
6410         /* Finish clickclick move */
6411         if (appData.animate || appData.highlightLastMove) {
6412             SetHighlights(fromX, fromY, toX, toY);
6413         } else {
6414             ClearHighlights();
6415         }
6416     } else {
6417         /* Finish drag move */
6418         if (appData.highlightLastMove) {
6419             SetHighlights(fromX, fromY, toX, toY);
6420         } else {
6421             ClearHighlights();
6422         }
6423         DragPieceEnd(xPix, yPix); dragging = 0;
6424         /* Don't animate move and drag both */
6425         appData.animate = FALSE;
6426     }
6427
6428     // moves into holding are invalid for now (except in EditPosition, adapting to-square)
6429     if(x >= 0 && x < BOARD_LEFT || x >= BOARD_RGHT) {
6430         ChessSquare piece = boards[currentMove][fromY][fromX];
6431         if(gameMode == EditPosition && piece != EmptySquare &&
6432            fromX >= BOARD_LEFT && fromX < BOARD_RGHT) {
6433             int n;
6434
6435             if(x == BOARD_LEFT-2 && piece >= BlackPawn) {
6436                 n = PieceToNumber(piece - (int)BlackPawn);
6437                 if(n >= gameInfo.holdingsSize) { n = 0; piece = BlackPawn; }
6438                 boards[currentMove][BOARD_HEIGHT-1 - n][0] = piece;
6439                 boards[currentMove][BOARD_HEIGHT-1 - n][1]++;
6440             } else
6441             if(x == BOARD_RGHT+1 && piece < BlackPawn) {
6442                 n = PieceToNumber(piece);
6443                 if(n >= gameInfo.holdingsSize) { n = 0; piece = WhitePawn; }
6444                 boards[currentMove][n][BOARD_WIDTH-1] = piece;
6445                 boards[currentMove][n][BOARD_WIDTH-2]++;
6446             }
6447             boards[currentMove][fromY][fromX] = EmptySquare;
6448         }
6449         ClearHighlights();
6450         fromX = fromY = -1;
6451         DrawPosition(TRUE, boards[currentMove]);
6452         return;
6453     }
6454
6455     // off-board moves should not be highlighted
6456     if(x < 0 || x < 0) ClearHighlights();
6457
6458     if (HasPromotionChoice(fromX, fromY, toX, toY, &promoChoice)) {
6459         SetHighlights(fromX, fromY, toX, toY);
6460         if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
6461             // [HGM] super: promotion to captured piece selected from holdings
6462             ChessSquare p = boards[currentMove][fromY][fromX], q = boards[currentMove][toY][toX];
6463             promotionChoice = TRUE;
6464             // kludge follows to temporarily execute move on display, without promoting yet
6465             boards[currentMove][fromY][fromX] = EmptySquare; // move Pawn to 8th rank
6466             boards[currentMove][toY][toX] = p;
6467             DrawPosition(FALSE, boards[currentMove]);
6468             boards[currentMove][fromY][fromX] = p; // take back, but display stays
6469             boards[currentMove][toY][toX] = q;
6470             DisplayMessage("Click in holdings to choose piece", "");
6471             return;
6472         }
6473         PromotionPopUp();
6474     } else {
6475         UserMoveEvent(fromX, fromY, toX, toY, promoChoice);
6476         if (!appData.highlightLastMove || gotPremove) ClearHighlights();
6477         if (gotPremove) SetPremoveHighlights(fromX, fromY, toX, toY);
6478         fromX = fromY = -1;
6479     }
6480     appData.animate = saveAnimate;
6481     if (appData.animate || appData.animateDragging) {
6482         /* Undo animation damage if needed */
6483         DrawPosition(FALSE, NULL);
6484     }
6485 }
6486
6487 int RightClick(ClickType action, int x, int y, int *fromX, int *fromY)
6488 {   // front-end-free part taken out of PieceMenuPopup
6489     int whichMenu; int xSqr, ySqr;
6490
6491     if(seekGraphUp) { // [HGM] seekgraph
6492         if(action == Press)   SeekGraphClick(Press, x, y, 2); // 2 indicates right-click: no pop-down on miss
6493         if(action == Release) SeekGraphClick(Release, x, y, 2); // and no challenge on hit
6494         return -2;
6495     }
6496
6497     if((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack)
6498          && !appData.zippyPlay && appData.bgObserve) { // [HGM] bughouse: show background game
6499         if(!partnerBoardValid) return -2; // suppress display of uninitialized boards
6500         if( appData.dualBoard) return -2; // [HGM] dual: is already displayed
6501         if(action == Press)   {
6502             originalFlip = flipView;
6503             flipView = !flipView; // temporarily flip board to see game from partners perspective
6504             DrawPosition(TRUE, partnerBoard);
6505             DisplayMessage(partnerStatus, "");
6506             partnerUp = TRUE;
6507         } else if(action == Release) {
6508             flipView = originalFlip;
6509             DrawPosition(TRUE, boards[currentMove]);
6510             partnerUp = FALSE;
6511         }
6512         return -2;
6513     }
6514
6515     xSqr = EventToSquare(x, BOARD_WIDTH);
6516     ySqr = EventToSquare(y, BOARD_HEIGHT);
6517     if (action == Release) UnLoadPV(); // [HGM] pv
6518     if (action != Press) return -2; // return code to be ignored
6519     switch (gameMode) {
6520       case IcsExamining:
6521         if(xSqr < BOARD_LEFT || xSqr >= BOARD_RGHT) return -1;\r
6522       case EditPosition:
6523         if (xSqr == BOARD_LEFT-1 || xSqr == BOARD_RGHT) return -1;\r
6524         if (xSqr < 0 || ySqr < 0) return -1;\r
6525         whichMenu = 0; // edit-position menu
6526         break;
6527       case IcsObserving:
6528         if(!appData.icsEngineAnalyze) return -1;
6529       case IcsPlayingWhite:
6530       case IcsPlayingBlack:
6531         if(!appData.zippyPlay) goto noZip;
6532       case AnalyzeMode:
6533       case AnalyzeFile:
6534       case MachinePlaysWhite:
6535       case MachinePlaysBlack:
6536       case TwoMachinesPlay: // [HGM] pv: use for showing PV
6537         if (!appData.dropMenu) {
6538           LoadPV(x, y);
6539           return 2; // flag front-end to grab mouse events
6540         }
6541         if(gameMode == TwoMachinesPlay || gameMode == AnalyzeMode ||
6542            gameMode == AnalyzeFile || gameMode == IcsObserving) return -1;
6543       case EditGame:
6544       noZip:
6545         if (xSqr < 0 || ySqr < 0) return -1;
6546         if (!appData.dropMenu || appData.testLegality &&
6547             gameInfo.variant != VariantBughouse &&
6548             gameInfo.variant != VariantCrazyhouse) return -1;
6549         whichMenu = 1; // drop menu
6550         break;
6551       default:
6552         return -1;
6553     }
6554
6555     if (((*fromX = xSqr) < 0) ||
6556         ((*fromY = ySqr) < 0)) {
6557         *fromX = *fromY = -1;
6558         return -1;
6559     }
6560     if (flipView)
6561       *fromX = BOARD_WIDTH - 1 - *fromX;
6562     else
6563       *fromY = BOARD_HEIGHT - 1 - *fromY;
6564
6565     return whichMenu;
6566 }
6567
6568 void SendProgramStatsToFrontend( ChessProgramState * cps, ChessProgramStats * cpstats )
6569 {
6570 //    char * hint = lastHint;
6571     FrontEndProgramStats stats;
6572
6573     stats.which = cps == &first ? 0 : 1;
6574     stats.depth = cpstats->depth;
6575     stats.nodes = cpstats->nodes;
6576     stats.score = cpstats->score;
6577     stats.time = cpstats->time;
6578     stats.pv = cpstats->movelist;
6579     stats.hint = lastHint;
6580     stats.an_move_index = 0;
6581     stats.an_move_count = 0;
6582
6583     if( gameMode == AnalyzeMode || gameMode == AnalyzeFile ) {
6584         stats.hint = cpstats->move_name;
6585         stats.an_move_index = cpstats->nr_moves - cpstats->moves_left;
6586         stats.an_move_count = cpstats->nr_moves;
6587     }
6588
6589     if(stats.pv && stats.pv[0]) strcpy(lastPV[stats.which], stats.pv); // [HGM] pv: remember last PV of each
6590
6591     SetProgramStats( &stats );
6592 }
6593
6594 int
6595 Adjudicate(ChessProgramState *cps)
6596 {       // [HGM] some adjudications useful with buggy engines
6597         // [HGM] adjudicate: made into separate routine, which now can be called after every move
6598         //       In any case it determnes if the game is a claimable draw (filling in EP_STATUS).
6599         //       Actually ending the game is now based on the additional internal condition canAdjudicate.
6600         //       Only when the game is ended, and the opponent is a computer, this opponent gets the move relayed.
6601         int k, count = 0; static int bare = 1;
6602         ChessProgramState *engineOpponent = (gameMode == TwoMachinesPlay ? cps->other : (cps ? NULL : &first));
6603         Boolean canAdjudicate = !appData.icsActive;
6604
6605         // most tests only when we understand the game, i.e. legality-checking on, and (for the time being) no piece drops
6606         if(gameInfo.holdingsSize == 0 || gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
6607             if( appData.testLegality )
6608             {   /* [HGM] Some more adjudications for obstinate engines */
6609                 int NrWN=0, NrBN=0, NrWB=0, NrBB=0, NrWR=0, NrBR=0,
6610                     NrWQ=0, NrBQ=0, NrW=0, NrK=0, bishopsColor = 0,
6611                     NrPieces=0, NrPawns=0, PawnAdvance=0, i, j;
6612                 static int moveCount = 6;
6613                 ChessMove result;
6614                 char *reason = NULL;
6615
6616                 /* Count what is on board. */
6617                 for(i=0; i<BOARD_HEIGHT; i++) for(j=BOARD_LEFT; j<BOARD_RGHT; j++)
6618                 {   ChessSquare p = boards[forwardMostMove][i][j];
6619                     int m=i;
6620
6621                     switch((int) p)
6622                     {   /* count B,N,R and other of each side */
6623                         case WhiteKing:
6624                         case BlackKing:
6625                              NrK++; break; // [HGM] atomic: count Kings
6626                         case WhiteKnight:
6627                              NrWN++; break;
6628                         case WhiteBishop:
6629                         case WhiteFerz:    // [HGM] shatranj: kludge to mke it work in shatranj
6630                              bishopsColor |= 1 << ((i^j)&1);
6631                              NrWB++; break;
6632                         case BlackKnight:
6633                              NrBN++; break;
6634                         case BlackBishop:
6635                         case BlackFerz:    // [HGM] shatranj: kludge to mke it work in shatranj
6636                              bishopsColor |= 1 << ((i^j)&1);
6637                              NrBB++; break;
6638                         case WhiteRook:
6639                              NrWR++; break;
6640                         case BlackRook:
6641                              NrBR++; break;
6642                         case WhiteQueen:
6643                              NrWQ++; break;
6644                         case BlackQueen:
6645                              NrBQ++; break;
6646                         case EmptySquare:
6647                              break;
6648                         case BlackPawn:
6649                              m = 7-i;
6650                         case WhitePawn:
6651                              PawnAdvance += m; NrPawns++;
6652                     }
6653                     NrPieces += (p != EmptySquare);
6654                     NrW += ((int)p < (int)BlackPawn);
6655                     if(gameInfo.variant == VariantXiangqi &&
6656                       (p == WhiteFerz || p == WhiteAlfil || p == BlackFerz || p == BlackAlfil)) {
6657                         NrPieces--; // [HGM] XQ: do not count purely defensive pieces
6658                         NrW -= ((int)p < (int)BlackPawn);
6659                     }
6660                 }
6661
6662                 /* Some material-based adjudications that have to be made before stalemate test */
6663                 if(gameInfo.variant == VariantAtomic && NrK < 2) {
6664                     // [HGM] atomic: stm must have lost his King on previous move, as destroying own K is illegal
6665                      boards[forwardMostMove][EP_STATUS] = EP_CHECKMATE; // make claimable as if stm is checkmated
6666                      if(canAdjudicate && appData.checkMates) {
6667                          if(engineOpponent)
6668                            SendMoveToProgram(forwardMostMove-1, engineOpponent); // make sure opponent gets move
6669                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6670                          GameEnds( WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins,
6671                                                         "Xboard adjudication: King destroyed", GE_XBOARD );
6672                          return 1;
6673                      }
6674                 }
6675
6676                 /* Bare King in Shatranj (loses) or Losers (wins) */
6677                 if( NrW == 1 || NrPieces - NrW == 1) {
6678                   if( gameInfo.variant == VariantLosers) { // [HGM] losers: bare King wins (stm must have it first)
6679                      boards[forwardMostMove][EP_STATUS] = EP_WINS;  // mark as win, so it becomes claimable
6680                      if(canAdjudicate && appData.checkMates) {
6681                          if(engineOpponent)
6682                            SendMoveToProgram(forwardMostMove-1, engineOpponent); // make sure opponent gets to see move
6683                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6684                          GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
6685                                                         "Xboard adjudication: Bare king", GE_XBOARD );
6686                          return 1;
6687                      }
6688                   } else
6689                   if( gameInfo.variant == VariantShatranj && --bare < 0)
6690                   {    /* bare King */
6691                         boards[forwardMostMove][EP_STATUS] = EP_WINS; // make claimable as win for stm
6692                         if(canAdjudicate && appData.checkMates) {
6693                             /* but only adjudicate if adjudication enabled */
6694                             if(engineOpponent)
6695                               SendMoveToProgram(forwardMostMove-1, engineOpponent); // make sure opponent gets move
6696                             ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6697                             GameEnds( NrW > 1 ? WhiteWins : NrPieces - NrW > 1 ? BlackWins : GameIsDrawn,
6698                                                         "Xboard adjudication: Bare king", GE_XBOARD );
6699                             return 1;
6700                         }
6701                   }
6702                 } else bare = 1;
6703
6704
6705             // don't wait for engine to announce game end if we can judge ourselves
6706             switch (MateTest(boards[forwardMostMove], PosFlags(forwardMostMove)) ) {
6707               case MT_CHECK:
6708                 if(gameInfo.variant == Variant3Check) { // [HGM] 3check: when in check, test if 3rd time
6709                     int i, checkCnt = 0;    // (should really be done by making nr of checks part of game state)
6710                     for(i=forwardMostMove-2; i>=backwardMostMove; i-=2) {
6711                         if(MateTest(boards[i], PosFlags(i)) == MT_CHECK)
6712                             checkCnt++;
6713                         if(checkCnt >= 2) {
6714                             reason = "Xboard adjudication: 3rd check";
6715                             boards[forwardMostMove][EP_STATUS] = EP_CHECKMATE;
6716                             break;
6717                         }
6718                     }
6719                 }
6720               case MT_NONE:
6721               default:
6722                 break;
6723               case MT_STALEMATE:
6724               case MT_STAINMATE:
6725                 reason = "Xboard adjudication: Stalemate";
6726                 if((signed char)boards[forwardMostMove][EP_STATUS] != EP_CHECKMATE) { // [HGM] don't touch win through baring or K-capt
6727                     boards[forwardMostMove][EP_STATUS] = EP_STALEMATE;   // default result for stalemate is draw
6728                     if(gameInfo.variant == VariantLosers  || gameInfo.variant == VariantGiveaway) // [HGM] losers:
6729                         boards[forwardMostMove][EP_STATUS] = EP_WINS;    // in these variants stalemated is always a win
6730                     else if(gameInfo.variant == VariantSuicide) // in suicide it depends
6731                         boards[forwardMostMove][EP_STATUS] = NrW == NrPieces-NrW ? EP_STALEMATE :
6732                                                    ((NrW < NrPieces-NrW) != WhiteOnMove(forwardMostMove) ?
6733                                                                         EP_CHECKMATE : EP_WINS);
6734                     else if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantXiangqi)
6735                         boards[forwardMostMove][EP_STATUS] = EP_CHECKMATE; // and in these variants being stalemated loses
6736                 }
6737                 break;
6738               case MT_CHECKMATE:
6739                 reason = "Xboard adjudication: Checkmate";
6740                 boards[forwardMostMove][EP_STATUS] = (gameInfo.variant == VariantLosers ? EP_WINS : EP_CHECKMATE);
6741                 break;
6742             }
6743
6744                 switch(i = (signed char)boards[forwardMostMove][EP_STATUS]) {
6745                     case EP_STALEMATE:
6746                         result = GameIsDrawn; break;
6747                     case EP_CHECKMATE:
6748                         result = WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins; break;
6749                     case EP_WINS:
6750                         result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins; break;
6751                     default:
6752                         result = (ChessMove) 0;
6753                 }
6754                 if(canAdjudicate && appData.checkMates && result) { // [HGM] mates: adjudicate finished games if requested
6755                     if(engineOpponent)
6756                       SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
6757                     ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6758                     GameEnds( result, reason, GE_XBOARD );
6759                     return 1;
6760                 }
6761
6762                 /* Next absolutely insufficient mating material. */
6763                 if( NrPieces == 2 || gameInfo.variant != VariantXiangqi &&
6764                                      gameInfo.variant != VariantShatranj && // [HGM] baring will remain possible
6765                         (NrPieces == 3 && NrWN+NrBN+NrWB+NrBB == 1 ||
6766                          NrPieces == NrBB+NrWB+2 && bishopsColor != 3)) // [HGM] all Bishops (Ferz!) same color
6767                 {    /* KBK, KNK, KK of KBKB with like Bishops */
6768
6769                      /* always flag draws, for judging claims */
6770                      boards[forwardMostMove][EP_STATUS] = EP_INSUF_DRAW;
6771
6772                      if(canAdjudicate && appData.materialDraws) {
6773                          /* but only adjudicate them if adjudication enabled */
6774                          if(engineOpponent) {
6775                            SendToProgram("force\n", engineOpponent); // suppress reply
6776                            SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see last move */
6777                          }
6778                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6779                          GameEnds( GameIsDrawn, "Xboard adjudication: Insufficient mating material", GE_XBOARD );
6780                          return 1;
6781                      }
6782                 }
6783
6784                 /* Then some trivial draws (only adjudicate, cannot be claimed) */
6785                 if(NrPieces == 4 &&
6786                    (   NrWR == 1 && NrBR == 1 /* KRKR */
6787                    || NrWQ==1 && NrBQ==1     /* KQKQ */
6788                    || NrWN==2 || NrBN==2     /* KNNK */
6789                    || NrWN+NrWB == 1 && NrBN+NrBB == 1 /* KBKN, KBKB, KNKN */
6790                   ) ) {
6791                      if(--moveCount < 0 && appData.trivialDraws && canAdjudicate)
6792                      {    /* if the first 3 moves do not show a tactical win, declare draw */
6793                           if(engineOpponent) {
6794                             SendToProgram("force\n", engineOpponent); // suppress reply
6795                             SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
6796                           }
6797                           ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6798                           GameEnds( GameIsDrawn, "Xboard adjudication: Trivial draw", GE_XBOARD );
6799                           return 1;
6800                      }
6801                 } else moveCount = 6;
6802             }
6803         }
6804
6805         if (appData.debugMode) { int i;
6806             fprintf(debugFP, "repeat test fmm=%d bmm=%d ep=%d, reps=%d\n",
6807                     forwardMostMove, backwardMostMove, boards[backwardMostMove][EP_STATUS],
6808                     appData.drawRepeats);
6809             for( i=forwardMostMove; i>=backwardMostMove; i-- )
6810               fprintf(debugFP, "%d ep=%d\n", i, (signed char)boards[i][EP_STATUS]);
6811
6812         }
6813
6814         // Repetition draws and 50-move rule can be applied independently of legality testing
6815
6816                 /* Check for rep-draws */
6817                 count = 0;
6818                 for(k = forwardMostMove-2;
6819                     k>=backwardMostMove && k>=forwardMostMove-100 &&
6820                         (signed char)boards[k][EP_STATUS] < EP_UNKNOWN &&
6821                         (signed char)boards[k+2][EP_STATUS] <= EP_NONE && (signed char)boards[k+1][EP_STATUS] <= EP_NONE;
6822                     k-=2)
6823                 {   int rights=0;
6824                     if(CompareBoards(boards[k], boards[forwardMostMove])) {
6825                         /* compare castling rights */
6826                         if( boards[forwardMostMove][CASTLING][2] != boards[k][CASTLING][2] &&
6827                              (boards[k][CASTLING][0] != NoRights || boards[k][CASTLING][1] != NoRights) )
6828                                 rights++; /* King lost rights, while rook still had them */
6829                         if( boards[forwardMostMove][CASTLING][2] != NoRights ) { /* king has rights */
6830                             if( boards[forwardMostMove][CASTLING][0] != boards[k][CASTLING][0] ||
6831                                 boards[forwardMostMove][CASTLING][1] != boards[k][CASTLING][1] )
6832                                    rights++; /* but at least one rook lost them */
6833                         }
6834                         if( boards[forwardMostMove][CASTLING][5] != boards[k][CASTLING][5] &&
6835                              (boards[k][CASTLING][3] != NoRights || boards[k][CASTLING][4] != NoRights) )
6836                                 rights++;
6837                         if( boards[forwardMostMove][CASTLING][5] != NoRights ) {
6838                             if( boards[forwardMostMove][CASTLING][3] != boards[k][CASTLING][3] ||
6839                                 boards[forwardMostMove][CASTLING][4] != boards[k][CASTLING][4] )
6840                                    rights++;
6841                         }
6842                         if( rights == 0 && ++count > appData.drawRepeats-2 && canAdjudicate
6843                             && appData.drawRepeats > 1) {
6844                              /* adjudicate after user-specified nr of repeats */
6845                              int result = GameIsDrawn;
6846                              char *details = "XBoard adjudication: repetition draw";
6847                              if(gameInfo.variant == VariantXiangqi && appData.testLegality) {
6848                                 // [HGM] xiangqi: check for forbidden perpetuals
6849                                 int m, ourPerpetual = 1, hisPerpetual = 1;
6850                                 for(m=forwardMostMove; m>k; m-=2) {
6851                                     if(MateTest(boards[m], PosFlags(m)) != MT_CHECK)
6852                                         ourPerpetual = 0; // the current mover did not always check
6853                                     if(MateTest(boards[m-1], PosFlags(m-1)) != MT_CHECK)
6854                                         hisPerpetual = 0; // the opponent did not always check
6855                                 }
6856                                 if(appData.debugMode) fprintf(debugFP, "XQ perpetual test, our=%d, his=%d\n",
6857                                                                         ourPerpetual, hisPerpetual);
6858                                 if(ourPerpetual && !hisPerpetual) { // we are actively checking him: forfeit
6859                                     result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
6860                                     details = "Xboard adjudication: perpetual checking";
6861                                 } else
6862                                 if(hisPerpetual && !ourPerpetual) { // he is checking us, but did not repeat yet
6863                                     break; // (or we would have caught him before). Abort repetition-checking loop.
6864                                 } else
6865                                 // Now check for perpetual chases
6866                                 if(!ourPerpetual && !hisPerpetual) { // no perpetual check, test for chase
6867                                     hisPerpetual = PerpetualChase(k, forwardMostMove);
6868                                     ourPerpetual = PerpetualChase(k+1, forwardMostMove);
6869                                     if(ourPerpetual && !hisPerpetual) { // we are actively chasing him: forfeit
6870                                         result = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
6871                                         details = "Xboard adjudication: perpetual chasing";
6872                                     } else
6873                                     if(hisPerpetual && !ourPerpetual)   // he is chasing us, but did not repeat yet
6874                                         break; // Abort repetition-checking loop.
6875                                 }
6876                                 // if neither of us is checking or chasing all the time, or both are, it is draw
6877                              }
6878                              if(engineOpponent) {
6879                                SendToProgram("force\n", engineOpponent); // suppress reply
6880                                SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
6881                              }
6882                              ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6883                              GameEnds( result, details, GE_XBOARD );
6884                              return 1;
6885                         }
6886                         if( rights == 0 && count > 1 ) /* occurred 2 or more times before */
6887                              boards[forwardMostMove][EP_STATUS] = EP_REP_DRAW;
6888                     }
6889                 }
6890
6891                 /* Now we test for 50-move draws. Determine ply count */
6892                 count = forwardMostMove;
6893                 /* look for last irreversble move */
6894                 while( (signed char)boards[count][EP_STATUS] <= EP_NONE && count > backwardMostMove )
6895                     count--;
6896                 /* if we hit starting position, add initial plies */
6897                 if( count == backwardMostMove )
6898                     count -= initialRulePlies;
6899                 count = forwardMostMove - count;
6900                 if( count >= 100)
6901                          boards[forwardMostMove][EP_STATUS] = EP_RULE_DRAW;
6902                          /* this is used to judge if draw claims are legal */
6903                 if(canAdjudicate && appData.ruleMoves > 0 && count >= 2*appData.ruleMoves) {
6904                          if(engineOpponent) {
6905                            SendToProgram("force\n", engineOpponent); // suppress reply
6906                            SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
6907                          }
6908                          ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6909                          GameEnds( GameIsDrawn, "Xboard adjudication: 50-move rule", GE_XBOARD );
6910                          return 1;
6911                 }
6912
6913                 /* if draw offer is pending, treat it as a draw claim
6914                  * when draw condition present, to allow engines a way to
6915                  * claim draws before making their move to avoid a race
6916                  * condition occurring after their move
6917                  */
6918                 if((gameMode == TwoMachinesPlay ? second.offeredDraw : userOfferedDraw) || first.offeredDraw ) {
6919                          char *p = NULL;
6920                          if((signed char)boards[forwardMostMove][EP_STATUS] == EP_RULE_DRAW)
6921                              p = "Draw claim: 50-move rule";
6922                          if((signed char)boards[forwardMostMove][EP_STATUS] == EP_REP_DRAW)
6923                              p = "Draw claim: 3-fold repetition";
6924                          if((signed char)boards[forwardMostMove][EP_STATUS] == EP_INSUF_DRAW)
6925                              p = "Draw claim: insufficient mating material";
6926                          if( p != NULL && canAdjudicate) {
6927                              if(engineOpponent) {
6928                                SendToProgram("force\n", engineOpponent); // suppress reply
6929                                SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
6930                              }
6931                              ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6932                              GameEnds( GameIsDrawn, p, GE_XBOARD );
6933                              return 1;
6934                          }
6935                 }
6936
6937                 if( canAdjudicate && appData.adjudicateDrawMoves > 0 && forwardMostMove > (2*appData.adjudicateDrawMoves) ) {
6938                     if(engineOpponent) {
6939                       SendToProgram("force\n", engineOpponent); // suppress reply
6940                       SendMoveToProgram(forwardMostMove-1, engineOpponent); /* make sure opponent gets to see move */
6941                     }
6942                     ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
6943                     GameEnds( GameIsDrawn, "Xboard adjudication: long game", GE_XBOARD );
6944                     return 1;
6945                 }
6946         return 0;
6947 }
6948
6949 char *SendMoveToBookUser(int moveNr, ChessProgramState *cps, int initial)
6950 {   // [HGM] book: this routine intercepts moves to simulate book replies
6951     char *bookHit = NULL;
6952
6953     //first determine if the incoming move brings opponent into his book
6954     if(appData.usePolyglotBook && (cps == &first ? !appData.firstHasOwnBookUCI : !appData.secondHasOwnBookUCI))
6955         bookHit = ProbeBook(moveNr+1, appData.polyglotBook); // returns move
6956     if(appData.debugMode) fprintf(debugFP, "book hit = %s\n", bookHit ? bookHit : "(NULL)");
6957     if(bookHit != NULL && !cps->bookSuspend) {
6958         // make sure opponent is not going to reply after receiving move to book position
6959         SendToProgram("force\n", cps);
6960         cps->bookSuspend = TRUE; // flag indicating it has to be restarted
6961     }
6962     if(!initial) SendMoveToProgram(moveNr, cps); // with hit on initial position there is no move
6963     // now arrange restart after book miss
6964     if(bookHit) {
6965         // after a book hit we never send 'go', and the code after the call to this routine
6966         // has '&& !bookHit' added to suppress potential sending there (based on 'firstMove').
6967         char buf[MSG_SIZ];
6968         sprintf(buf, "%s%s\n", (cps->useUsermove ? "usermove " : ""), bookHit); // force book move into program supposed to play it
6969         SendToProgram(buf, cps);
6970         if(!initial) firstMove = FALSE; // normally we would clear the firstMove condition after return & sending 'go'
6971     } else if(initial) { // 'go' was needed irrespective of firstMove, and it has to be done in this routine
6972         SendToProgram("go\n", cps);
6973         cps->bookSuspend = FALSE; // after a 'go' we are never suspended
6974     } else { // 'go' might be sent based on 'firstMove' after this routine returns
6975         if(cps->bookSuspend && !firstMove) // 'go' needed, and it will not be done after we return
6976             SendToProgram("go\n", cps);
6977         cps->bookSuspend = FALSE; // anyhow, we will not be suspended after a miss
6978     }
6979     return bookHit; // notify caller of hit, so it can take action to send move to opponent
6980 }
6981
6982 char *savedMessage;
6983 ChessProgramState *savedState;
6984 void DeferredBookMove(void)
6985 {
6986         if(savedState->lastPing != savedState->lastPong)
6987                     ScheduleDelayedEvent(DeferredBookMove, 10);
6988         else
6989         HandleMachineMove(savedMessage, savedState);
6990 }
6991
6992 void
6993 HandleMachineMove(message, cps)
6994      char *message;
6995      ChessProgramState *cps;
6996 {
6997     char machineMove[MSG_SIZ], buf1[MSG_SIZ*10], buf2[MSG_SIZ];
6998     char realname[MSG_SIZ];
6999     int fromX, fromY, toX, toY;
7000     ChessMove moveType;
7001     char promoChar;
7002     char *p;
7003     int machineWhite;
7004     char *bookHit;
7005
7006     cps->userError = 0;
7007
7008 FakeBookMove: // [HGM] book: we jump here to simulate machine moves after book hit
7009     /*
7010      * Kludge to ignore BEL characters
7011      */
7012     while (*message == '\007') message++;
7013
7014     /*
7015      * [HGM] engine debug message: ignore lines starting with '#' character
7016      */
7017     if(cps->debug && *message == '#') return;
7018
7019     /*
7020      * Look for book output
7021      */
7022     if (cps == &first && bookRequested) {
7023         if (message[0] == '\t' || message[0] == ' ') {
7024             /* Part of the book output is here; append it */
7025             strcat(bookOutput, message);
7026             strcat(bookOutput, "  \n");
7027             return;
7028         } else if (bookOutput[0] != NULLCHAR) {
7029             /* All of book output has arrived; display it */
7030             char *p = bookOutput;
7031             while (*p != NULLCHAR) {
7032                 if (*p == '\t') *p = ' ';
7033                 p++;
7034             }
7035             DisplayInformation(bookOutput);
7036             bookRequested = FALSE;
7037             /* Fall through to parse the current output */
7038         }
7039     }
7040
7041     /*
7042      * Look for machine move.
7043      */
7044     if ((sscanf(message, "%s %s %s", buf1, buf2, machineMove) == 3 && strcmp(buf2, "...") == 0) ||
7045         (sscanf(message, "%s %s", buf1, machineMove) == 2 && strcmp(buf1, "move") == 0))
7046     {
7047         /* This method is only useful on engines that support ping */
7048         if (cps->lastPing != cps->lastPong) {
7049           if (gameMode == BeginningOfGame) {
7050             /* Extra move from before last new; ignore */
7051             if (appData.debugMode) {
7052                 fprintf(debugFP, "Ignoring extra move from %s\n", cps->which);
7053             }
7054           } else {
7055             if (appData.debugMode) {
7056                 fprintf(debugFP, "Undoing extra move from %s, gameMode %d\n",
7057                         cps->which, gameMode);
7058             }
7059
7060             SendToProgram("undo\n", cps);
7061           }
7062           return;
7063         }
7064
7065         switch (gameMode) {
7066           case BeginningOfGame:
7067             /* Extra move from before last reset; ignore */
7068             if (appData.debugMode) {
7069                 fprintf(debugFP, "Ignoring extra move from %s\n", cps->which);
7070             }
7071             return;
7072
7073           case EndOfGame:
7074           case IcsIdle:
7075           default:
7076             /* Extra move after we tried to stop.  The mode test is
7077                not a reliable way of detecting this problem, but it's
7078                the best we can do on engines that don't support ping.
7079             */
7080             if (appData.debugMode) {
7081                 fprintf(debugFP, "Undoing extra move from %s, gameMode %d\n",
7082                         cps->which, gameMode);
7083             }
7084             SendToProgram("undo\n", cps);
7085             return;
7086
7087           case MachinePlaysWhite:
7088           case IcsPlayingWhite:
7089             machineWhite = TRUE;
7090             break;
7091
7092           case MachinePlaysBlack:
7093           case IcsPlayingBlack:
7094             machineWhite = FALSE;
7095             break;
7096
7097           case TwoMachinesPlay:
7098             machineWhite = (cps->twoMachinesColor[0] == 'w');
7099             break;
7100         }
7101         if (WhiteOnMove(forwardMostMove) != machineWhite) {
7102             if (appData.debugMode) {
7103                 fprintf(debugFP,
7104                         "Ignoring move out of turn by %s, gameMode %d"
7105                         ", forwardMost %d\n",
7106                         cps->which, gameMode, forwardMostMove);
7107             }
7108             return;
7109         }
7110
7111     if (appData.debugMode) { int f = forwardMostMove;
7112         fprintf(debugFP, "machine move %d, castling = %d %d %d %d %d %d\n", f,
7113                 boards[f][CASTLING][0],boards[f][CASTLING][1],boards[f][CASTLING][2],
7114                 boards[f][CASTLING][3],boards[f][CASTLING][4],boards[f][CASTLING][5]);
7115     }
7116         if(cps->alphaRank) AlphaRank(machineMove, 4);
7117         if (!ParseOneMove(machineMove, forwardMostMove, &moveType,
7118                               &fromX, &fromY, &toX, &toY, &promoChar)) {
7119             /* Machine move could not be parsed; ignore it. */
7120             sprintf(buf1, _("Illegal move \"%s\" from %s machine"),
7121                     machineMove, cps->which);
7122             DisplayError(buf1, 0);
7123             sprintf(buf1, "Xboard: Forfeit due to invalid move: %s (%c%c%c%c) res=%d",
7124                     machineMove, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, moveType);
7125             if (gameMode == TwoMachinesPlay) {
7126               GameEnds(machineWhite ? BlackWins : WhiteWins,
7127                        buf1, GE_XBOARD);
7128             }
7129             return;
7130         }
7131
7132         /* [HGM] Apparently legal, but so far only tested with EP_UNKOWN */
7133         /* So we have to redo legality test with true e.p. status here,  */
7134         /* to make sure an illegal e.p. capture does not slip through,   */
7135         /* to cause a forfeit on a justified illegal-move complaint      */
7136         /* of the opponent.                                              */
7137         if( gameMode==TwoMachinesPlay && appData.testLegality
7138             && fromY != DROP_RANK /* [HGM] temporary; should still add legality test for drops */
7139                                                               ) {
7140            ChessMove moveType;
7141            moveType = LegalityTest(boards[forwardMostMove], PosFlags(forwardMostMove),
7142                              fromY, fromX, toY, toX, promoChar);
7143             if (appData.debugMode) {
7144                 int i;
7145                 for(i=0; i< nrCastlingRights; i++) fprintf(debugFP, "(%d,%d) ",
7146                     boards[forwardMostMove][CASTLING][i], castlingRank[i]);
7147                 fprintf(debugFP, "castling rights\n");
7148             }
7149             if(moveType == IllegalMove) {
7150                 sprintf(buf1, "Xboard: Forfeit due to illegal move: %s (%c%c%c%c)%c",
7151                         machineMove, fromX+AAA, fromY+ONE, toX+AAA, toY+ONE, 0);
7152                 GameEnds(machineWhite ? BlackWins : WhiteWins,
7153                            buf1, GE_XBOARD);
7154                 return;
7155            } else if(gameInfo.variant != VariantFischeRandom && gameInfo.variant != VariantCapaRandom)
7156            /* [HGM] Kludge to handle engines that send FRC-style castling
7157               when they shouldn't (like TSCP-Gothic) */
7158            switch(moveType) {
7159              case WhiteASideCastleFR:
7160              case BlackASideCastleFR:
7161                toX+=2;
7162                currentMoveString[2]++;
7163                break;
7164              case WhiteHSideCastleFR:
7165              case BlackHSideCastleFR:
7166                toX--;
7167                currentMoveString[2]--;
7168                break;
7169              default: ; // nothing to do, but suppresses warning of pedantic compilers
7170            }
7171         }
7172         hintRequested = FALSE;
7173         lastHint[0] = NULLCHAR;
7174         bookRequested = FALSE;
7175         /* Program may be pondering now */
7176         cps->maybeThinking = TRUE;
7177         if (cps->sendTime == 2) cps->sendTime = 1;
7178         if (cps->offeredDraw) cps->offeredDraw--;
7179
7180         /* currentMoveString is set as a side-effect of ParseOneMove */
7181         strcpy(machineMove, currentMoveString);
7182         strcat(machineMove, "\n");
7183         strcpy(moveList[forwardMostMove], machineMove);
7184
7185         MakeMove(fromX, fromY, toX, toY, promoChar);/*updates forwardMostMove*/
7186
7187         /* [AS] Adjudicate game if needed (note: remember that forwardMostMove now points past the last move) */
7188         if( gameMode == TwoMachinesPlay && adjudicateLossThreshold != 0 && forwardMostMove >= adjudicateLossPlies ) {
7189             int count = 0;
7190
7191             while( count < adjudicateLossPlies ) {
7192                 int score = pvInfoList[ forwardMostMove - count - 1 ].score;
7193
7194                 if( count & 1 ) {
7195                     score = -score; /* Flip score for winning side */
7196                 }
7197
7198                 if( score > adjudicateLossThreshold ) {
7199                     break;
7200                 }
7201
7202                 count++;
7203             }
7204
7205             if( count >= adjudicateLossPlies ) {
7206                 ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
7207
7208                 GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins,
7209                     "Xboard adjudication",
7210                     GE_XBOARD );
7211
7212                 return;
7213             }
7214         }
7215
7216         if(Adjudicate(cps)) return; // [HGM] adjudicate: for all automatic game ends
7217
7218 #if ZIPPY
7219         if ((gameMode == IcsPlayingWhite || gameMode == IcsPlayingBlack) &&
7220             first.initDone) {
7221           if(cps->offeredDraw && (signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
7222                 SendToICS(ics_prefix); // [HGM] drawclaim: send caim and move on one line for FICS
7223                 SendToICS("draw ");
7224                 SendMoveToICS(moveType, fromX, fromY, toX, toY);
7225           }
7226           SendMoveToICS(moveType, fromX, fromY, toX, toY);
7227           ics_user_moved = 1;
7228           if(appData.autoKibitz && !appData.icsEngineAnalyze ) { /* [HGM] kibitz: send most-recent PV info to ICS */
7229                 char buf[3*MSG_SIZ];
7230
7231                 sprintf(buf, "kibitz !!! %+.2f/%d (%.2f sec, %u nodes, %.0f knps) PV=%s\n",
7232                         programStats.score / 100.,
7233                         programStats.depth,
7234                         programStats.time / 100.,
7235                         (unsigned int)programStats.nodes,
7236                         (unsigned int)programStats.nodes / (10*abs(programStats.time) + 1.),
7237                         programStats.movelist);
7238                 SendToICS(buf);
7239 if(appData.debugMode) fprintf(debugFP, "nodes = %d, %lld\n", (int) programStats.nodes, programStats.nodes);
7240           }
7241         }
7242 #endif
7243
7244         /* [AS] Save move info and clear stats for next move */
7245         pvInfoList[ forwardMostMove-1 ].score = programStats.score;
7246         pvInfoList[ forwardMostMove-1 ].depth = programStats.depth;
7247         pvInfoList[ forwardMostMove-1 ].time =  programStats.time; // [HGM] PGNtime: take time from engine stats
7248         ClearProgramStats();
7249         thinkOutput[0] = NULLCHAR;
7250         hiddenThinkOutputState = 0;
7251
7252         bookHit = NULL;
7253         if (gameMode == TwoMachinesPlay) {
7254             /* [HGM] relaying draw offers moved to after reception of move */
7255             /* and interpreting offer as claim if it brings draw condition */
7256             if (cps->offeredDraw == 1 && cps->other->sendDrawOffers) {
7257                 SendToProgram("draw\n", cps->other);
7258             }
7259             if (cps->other->sendTime) {
7260                 SendTimeRemaining(cps->other,
7261                                   cps->other->twoMachinesColor[0] == 'w');
7262             }
7263             bookHit = SendMoveToBookUser(forwardMostMove-1, cps->other, FALSE);
7264             if (firstMove && !bookHit) {
7265                 firstMove = FALSE;
7266                 if (cps->other->useColors) {
7267                   SendToProgram(cps->other->twoMachinesColor, cps->other);
7268                 }
7269                 SendToProgram("go\n", cps->other);
7270             }
7271             cps->other->maybeThinking = TRUE;
7272         }
7273
7274         ShowMove(fromX, fromY, toX, toY); /*updates currentMove*/
7275
7276         if (!pausing && appData.ringBellAfterMoves) {
7277             RingBell();
7278         }
7279
7280         /*
7281          * Reenable menu items that were disabled while
7282          * machine was thinking
7283          */
7284         if (gameMode != TwoMachinesPlay)
7285             SetUserThinkingEnables();
7286
7287         // [HGM] book: after book hit opponent has received move and is now in force mode
7288         // force the book reply into it, and then fake that it outputted this move by jumping
7289         // back to the beginning of HandleMachineMove, with cps toggled and message set to this move
7290         if(bookHit) {
7291                 static char bookMove[MSG_SIZ]; // a bit generous?
7292
7293                 strcpy(bookMove, "move ");
7294                 strcat(bookMove, bookHit);
7295                 message = bookMove;
7296                 cps = cps->other;
7297                 programStats.nodes = programStats.depth = programStats.time =
7298                 programStats.score = programStats.got_only_move = 0;
7299                 sprintf(programStats.movelist, "%s (xbook)", bookHit);
7300
7301                 if(cps->lastPing != cps->lastPong) {
7302                     savedMessage = message; // args for deferred call
7303                     savedState = cps;
7304                     ScheduleDelayedEvent(DeferredBookMove, 10);
7305                     return;
7306                 }
7307                 goto FakeBookMove;
7308         }
7309
7310         return;
7311     }
7312
7313     /* Set special modes for chess engines.  Later something general
7314      *  could be added here; for now there is just one kludge feature,
7315      *  needed because Crafty 15.10 and earlier don't ignore SIGINT
7316      *  when "xboard" is given as an interactive command.
7317      */
7318     if (strncmp(message, "kibitz Hello from Crafty", 24) == 0) {
7319         cps->useSigint = FALSE;
7320         cps->useSigterm = FALSE;
7321     }
7322     if (strncmp(message, "feature ", 8) == 0) { // [HGM] moved forward to pre-empt non-compliant commands
7323       ParseFeatures(message+8, cps);
7324       return; // [HGM] This return was missing, causing option features to be recognized as non-compliant commands!
7325     }
7326
7327     /* [HGM] Allow engine to set up a position. Don't ask me why one would
7328      * want this, I was asked to put it in, and obliged.
7329      */
7330     if (!strncmp(message, "setboard ", 9)) {
7331         Board initial_position;
7332
7333         GameEnds(GameUnfinished, "Engine aborts game", GE_XBOARD);
7334
7335         if (!ParseFEN(initial_position, &blackPlaysFirst, message + 9)) {
7336             DisplayError(_("Bad FEN received from engine"), 0);
7337             return ;
7338         } else {
7339            Reset(TRUE, FALSE);
7340            CopyBoard(boards[0], initial_position);
7341            initialRulePlies = FENrulePlies;
7342            if(blackPlaysFirst) gameMode = MachinePlaysWhite;
7343            else gameMode = MachinePlaysBlack;
7344            DrawPosition(FALSE, boards[currentMove]);
7345         }
7346         return;
7347     }
7348
7349     /*
7350      * Look for communication commands
7351      */
7352     if (!strncmp(message, "telluser ", 9)) {
7353         EscapeExpand(message+9, message+9); // [HGM] esc: allow escape sequences in popup box
7354         DisplayNote(message + 9);
7355         return;
7356     }
7357     if (!strncmp(message, "tellusererror ", 14)) {
7358         cps->userError = 1;
7359         EscapeExpand(message+14, message+14); // [HGM] esc: allow escape sequences in popup box
7360         DisplayError(message + 14, 0);
7361         return;
7362     }
7363     if (!strncmp(message, "tellopponent ", 13)) {
7364       if (appData.icsActive) {
7365         if (loggedOn) {
7366           snprintf(buf1, sizeof(buf1), "%ssay %s\n", ics_prefix, message + 13);
7367           SendToICS(buf1);
7368         }
7369       } else {
7370         DisplayNote(message + 13);
7371       }
7372       return;
7373     }
7374     if (!strncmp(message, "tellothers ", 11)) {
7375       if (appData.icsActive) {
7376         if (loggedOn) {
7377           snprintf(buf1, sizeof(buf1), "%swhisper %s\n", ics_prefix, message + 11);
7378           SendToICS(buf1);
7379         }
7380       }
7381       return;
7382     }
7383     if (!strncmp(message, "tellall ", 8)) {
7384       if (appData.icsActive) {
7385         if (loggedOn) {
7386           snprintf(buf1, sizeof(buf1), "%skibitz %s\n", ics_prefix, message + 8);
7387           SendToICS(buf1);
7388         }
7389       } else {
7390         DisplayNote(message + 8);
7391       }
7392       return;
7393     }
7394     if (strncmp(message, "warning", 7) == 0) {
7395         /* Undocumented feature, use tellusererror in new code */
7396         DisplayError(message, 0);
7397         return;
7398     }
7399     if (sscanf(message, "askuser %s %[^\n]", buf1, buf2) == 2) {
7400         strcpy(realname, cps->tidy);
7401         strcat(realname, " query");
7402         AskQuestion(realname, buf2, buf1, cps->pr);
7403         return;
7404     }
7405     /* Commands from the engine directly to ICS.  We don't allow these to be
7406      *  sent until we are logged on. Crafty kibitzes have been known to
7407      *  interfere with the login process.
7408      */
7409     if (loggedOn) {
7410         if (!strncmp(message, "tellics ", 8)) {
7411             SendToICS(message + 8);
7412             SendToICS("\n");
7413             return;
7414         }
7415         if (!strncmp(message, "tellicsnoalias ", 15)) {
7416             SendToICS(ics_prefix);
7417             SendToICS(message + 15);
7418             SendToICS("\n");
7419             return;
7420         }
7421         /* The following are for backward compatibility only */
7422         if (!strncmp(message,"whisper",7) || !strncmp(message,"kibitz",6) ||
7423             !strncmp(message,"draw",4) || !strncmp(message,"tell",3)) {
7424             SendToICS(ics_prefix);
7425             SendToICS(message);
7426             SendToICS("\n");
7427             return;
7428         }
7429     }
7430     if (sscanf(message, "pong %d", &cps->lastPong) == 1) {
7431         return;
7432     }
7433     /*
7434      * If the move is illegal, cancel it and redraw the board.
7435      * Also deal with other error cases.  Matching is rather loose
7436      * here to accommodate engines written before the spec.
7437      */
7438     if (strncmp(message + 1, "llegal move", 11) == 0 ||
7439         strncmp(message, "Error", 5) == 0) {
7440         if (StrStr(message, "name") ||
7441             StrStr(message, "rating") || StrStr(message, "?") ||
7442             StrStr(message, "result") || StrStr(message, "board") ||
7443             StrStr(message, "bk") || StrStr(message, "computer") ||
7444             StrStr(message, "variant") || StrStr(message, "hint") ||
7445             StrStr(message, "random") || StrStr(message, "depth") ||
7446             StrStr(message, "accepted")) {
7447             return;
7448         }
7449         if (StrStr(message, "protover")) {
7450           /* Program is responding to input, so it's apparently done
7451              initializing, and this error message indicates it is
7452              protocol version 1.  So we don't need to wait any longer
7453              for it to initialize and send feature commands. */
7454           FeatureDone(cps, 1);
7455           cps->protocolVersion = 1;
7456           return;
7457         }
7458         cps->maybeThinking = FALSE;
7459
7460         if (StrStr(message, "draw")) {
7461             /* Program doesn't have "draw" command */
7462             cps->sendDrawOffers = 0;
7463             return;
7464         }
7465         if (cps->sendTime != 1 &&
7466             (StrStr(message, "time") || StrStr(message, "otim"))) {
7467           /* Program apparently doesn't have "time" or "otim" command */
7468           cps->sendTime = 0;
7469           return;
7470         }
7471         if (StrStr(message, "analyze")) {
7472             cps->analysisSupport = FALSE;
7473             cps->analyzing = FALSE;
7474             Reset(FALSE, TRUE);
7475             sprintf(buf2, _("%s does not support analysis"), cps->tidy);
7476             DisplayError(buf2, 0);
7477             return;
7478         }
7479         if (StrStr(message, "(no matching move)st")) {
7480           /* Special kludge for GNU Chess 4 only */
7481           cps->stKludge = TRUE;
7482           SendTimeControl(cps, movesPerSession, timeControl,
7483                           timeIncrement, appData.searchDepth,
7484                           searchTime);
7485           return;
7486         }
7487         if (StrStr(message, "(no matching move)sd")) {
7488           /* Special kludge for GNU Chess 4 only */
7489           cps->sdKludge = TRUE;
7490           SendTimeControl(cps, movesPerSession, timeControl,
7491                           timeIncrement, appData.searchDepth,
7492                           searchTime);
7493           return;
7494         }
7495         if (!StrStr(message, "llegal")) {
7496             return;
7497         }
7498         if (gameMode == BeginningOfGame || gameMode == EndOfGame ||
7499             gameMode == IcsIdle) return;
7500         if (forwardMostMove <= backwardMostMove) return;
7501         if (pausing) PauseEvent();
7502       if(appData.forceIllegal) {
7503             // [HGM] illegal: machine refused move; force position after move into it
7504           SendToProgram("force\n", cps);
7505           if(!cps->useSetboard) { // hideous kludge on kludge, because SendBoard sucks.
7506                 // we have a real problem now, as SendBoard will use the a2a3 kludge
7507                 // when black is to move, while there might be nothing on a2 or black
7508                 // might already have the move. So send the board as if white has the move.
7509                 // But first we must change the stm of the engine, as it refused the last move
7510                 SendBoard(cps, 0); // always kludgeless, as white is to move on boards[0]
7511                 if(WhiteOnMove(forwardMostMove)) {
7512                     SendToProgram("a7a6\n", cps); // for the engine black still had the move
7513                     SendBoard(cps, forwardMostMove); // kludgeless board
7514                 } else {
7515                     SendToProgram("a2a3\n", cps); // for the engine white still had the move
7516                     CopyBoard(boards[forwardMostMove+1], boards[forwardMostMove]);
7517                     SendBoard(cps, forwardMostMove+1); // kludgeless board
7518                 }
7519           } else SendBoard(cps, forwardMostMove); // FEN case, also sets stm properly
7520             if(gameMode == MachinePlaysWhite || gameMode == MachinePlaysBlack ||
7521                  gameMode == TwoMachinesPlay)
7522               SendToProgram("go\n", cps);
7523             return;
7524       } else
7525         if (gameMode == PlayFromGameFile) {
7526             /* Stop reading this game file */
7527             gameMode = EditGame;
7528             ModeHighlight();
7529         }
7530         currentMove = forwardMostMove-1;
7531         DisplayMove(currentMove-1); /* before DisplayMoveError */
7532         SwitchClocks(forwardMostMove-1); // [HGM] race
7533         DisplayBothClocks();
7534         sprintf(buf1, _("Illegal move \"%s\" (rejected by %s chess program)"),
7535                 parseList[currentMove], cps->which);
7536         DisplayMoveError(buf1);
7537         DrawPosition(FALSE, boards[currentMove]);
7538
7539         /* [HGM] illegal-move claim should forfeit game when Xboard */
7540         /* only passes fully legal moves                            */
7541         if( appData.testLegality && gameMode == TwoMachinesPlay ) {
7542             GameEnds( cps->twoMachinesColor[0] == 'w' ? BlackWins : WhiteWins,
7543                                 "False illegal-move claim", GE_XBOARD );
7544         }
7545         return;
7546     }
7547     if (strncmp(message, "time", 4) == 0 && StrStr(message, "Illegal")) {
7548         /* Program has a broken "time" command that
7549            outputs a string not ending in newline.
7550            Don't use it. */
7551         cps->sendTime = 0;
7552     }
7553
7554     /*
7555      * If chess program startup fails, exit with an error message.
7556      * Attempts to recover here are futile.
7557      */
7558     if ((StrStr(message, "unknown host") != NULL)
7559         || (StrStr(message, "No remote directory") != NULL)
7560         || (StrStr(message, "not found") != NULL)
7561         || (StrStr(message, "No such file") != NULL)
7562         || (StrStr(message, "can't alloc") != NULL)
7563         || (StrStr(message, "Permission denied") != NULL)) {
7564
7565         cps->maybeThinking = FALSE;
7566         snprintf(buf1, sizeof(buf1), _("Failed to start %s chess program %s on %s: %s\n"),
7567                 cps->which, cps->program, cps->host, message);
7568         RemoveInputSource(cps->isr);
7569         DisplayFatalError(buf1, 0, 1);
7570         return;
7571     }
7572
7573     /*
7574      * Look for hint output
7575      */
7576     if (sscanf(message, "Hint: %s", buf1) == 1) {
7577         if (cps == &first && hintRequested) {
7578             hintRequested = FALSE;
7579             if (ParseOneMove(buf1, forwardMostMove, &moveType,
7580                                  &fromX, &fromY, &toX, &toY, &promoChar)) {
7581                 (void) CoordsToAlgebraic(boards[forwardMostMove],
7582                                     PosFlags(forwardMostMove),
7583                                     fromY, fromX, toY, toX, promoChar, buf1);
7584                 snprintf(buf2, sizeof(buf2), _("Hint: %s"), buf1);
7585                 DisplayInformation(buf2);
7586             } else {
7587                 /* Hint move could not be parsed!? */
7588               snprintf(buf2, sizeof(buf2),
7589                         _("Illegal hint move \"%s\"\nfrom %s chess program"),
7590                         buf1, cps->which);
7591                 DisplayError(buf2, 0);
7592             }
7593         } else {
7594             strcpy(lastHint, buf1);
7595         }
7596         return;
7597     }
7598
7599     /*
7600      * Ignore other messages if game is not in progress
7601      */
7602     if (gameMode == BeginningOfGame || gameMode == EndOfGame ||
7603         gameMode == IcsIdle || cps->lastPing != cps->lastPong) return;
7604
7605     /*
7606      * look for win, lose, draw, or draw offer
7607      */
7608     if (strncmp(message, "1-0", 3) == 0) {
7609         char *p, *q, *r = "";
7610         p = strchr(message, '{');
7611         if (p) {
7612             q = strchr(p, '}');
7613             if (q) {
7614                 *q = NULLCHAR;
7615                 r = p + 1;
7616             }
7617         }
7618         GameEnds(WhiteWins, r, GE_ENGINE1 + (cps != &first)); /* [HGM] pass claimer indication for claim test */
7619         return;
7620     } else if (strncmp(message, "0-1", 3) == 0) {
7621         char *p, *q, *r = "";
7622         p = strchr(message, '{');
7623         if (p) {
7624             q = strchr(p, '}');
7625             if (q) {
7626                 *q = NULLCHAR;
7627                 r = p + 1;
7628             }
7629         }
7630         /* Kludge for Arasan 4.1 bug */
7631         if (strcmp(r, "Black resigns") == 0) {
7632             GameEnds(WhiteWins, r, GE_ENGINE1 + (cps != &first));
7633             return;
7634         }
7635         GameEnds(BlackWins, r, GE_ENGINE1 + (cps != &first));
7636         return;
7637     } else if (strncmp(message, "1/2", 3) == 0) {
7638         char *p, *q, *r = "";
7639         p = strchr(message, '{');
7640         if (p) {
7641             q = strchr(p, '}');
7642             if (q) {
7643                 *q = NULLCHAR;
7644                 r = p + 1;
7645             }
7646         }
7647
7648         GameEnds(GameIsDrawn, r, GE_ENGINE1 + (cps != &first));
7649         return;
7650
7651     } else if (strncmp(message, "White resign", 12) == 0) {
7652         GameEnds(BlackWins, "White resigns", GE_ENGINE1 + (cps != &first));
7653         return;
7654     } else if (strncmp(message, "Black resign", 12) == 0) {
7655         GameEnds(WhiteWins, "Black resigns", GE_ENGINE1 + (cps != &first));
7656         return;
7657     } else if (strncmp(message, "White matches", 13) == 0 ||
7658                strncmp(message, "Black matches", 13) == 0   ) {
7659         /* [HGM] ignore GNUShogi noises */
7660         return;
7661     } else if (strncmp(message, "White", 5) == 0 &&
7662                message[5] != '(' &&
7663                StrStr(message, "Black") == NULL) {
7664         GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
7665         return;
7666     } else if (strncmp(message, "Black", 5) == 0 &&
7667                message[5] != '(') {
7668         GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
7669         return;
7670     } else if (strcmp(message, "resign") == 0 ||
7671                strcmp(message, "computer resigns") == 0) {
7672         switch (gameMode) {
7673           case MachinePlaysBlack:
7674           case IcsPlayingBlack:
7675             GameEnds(WhiteWins, "Black resigns", GE_ENGINE);
7676             break;
7677           case MachinePlaysWhite:
7678           case IcsPlayingWhite:
7679             GameEnds(BlackWins, "White resigns", GE_ENGINE);
7680             break;
7681           case TwoMachinesPlay:
7682             if (cps->twoMachinesColor[0] == 'w')
7683               GameEnds(BlackWins, "White resigns", GE_ENGINE1 + (cps != &first));
7684             else
7685               GameEnds(WhiteWins, "Black resigns", GE_ENGINE1 + (cps != &first));
7686             break;
7687           default:
7688             /* can't happen */
7689             break;
7690         }
7691         return;
7692     } else if (strncmp(message, "opponent mates", 14) == 0) {
7693         switch (gameMode) {
7694           case MachinePlaysBlack:
7695           case IcsPlayingBlack:
7696             GameEnds(WhiteWins, "White mates", GE_ENGINE);
7697             break;
7698           case MachinePlaysWhite:
7699           case IcsPlayingWhite:
7700             GameEnds(BlackWins, "Black mates", GE_ENGINE);
7701             break;
7702           case TwoMachinesPlay:
7703             if (cps->twoMachinesColor[0] == 'w')
7704               GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
7705             else
7706               GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
7707             break;
7708           default:
7709             /* can't happen */
7710             break;
7711         }
7712         return;
7713     } else if (strncmp(message, "computer mates", 14) == 0) {
7714         switch (gameMode) {
7715           case MachinePlaysBlack:
7716           case IcsPlayingBlack:
7717             GameEnds(BlackWins, "Black mates", GE_ENGINE1);
7718             break;
7719           case MachinePlaysWhite:
7720           case IcsPlayingWhite:
7721             GameEnds(WhiteWins, "White mates", GE_ENGINE);
7722             break;
7723           case TwoMachinesPlay:
7724             if (cps->twoMachinesColor[0] == 'w')
7725               GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
7726             else
7727               GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
7728             break;
7729           default:
7730             /* can't happen */
7731             break;
7732         }
7733         return;
7734     } else if (strncmp(message, "checkmate", 9) == 0) {
7735         if (WhiteOnMove(forwardMostMove)) {
7736             GameEnds(BlackWins, "Black mates", GE_ENGINE1 + (cps != &first));
7737         } else {
7738             GameEnds(WhiteWins, "White mates", GE_ENGINE1 + (cps != &first));
7739         }
7740         return;
7741     } else if (strstr(message, "Draw") != NULL ||
7742                strstr(message, "game is a draw") != NULL) {
7743         GameEnds(GameIsDrawn, "Draw", GE_ENGINE1 + (cps != &first));
7744         return;
7745     } else if (strstr(message, "offer") != NULL &&
7746                strstr(message, "draw") != NULL) {
7747 #if ZIPPY
7748         if (appData.zippyPlay && first.initDone) {
7749             /* Relay offer to ICS */
7750             SendToICS(ics_prefix);
7751             SendToICS("draw\n");
7752         }
7753 #endif
7754         cps->offeredDraw = 2; /* valid until this engine moves twice */
7755         if (gameMode == TwoMachinesPlay) {
7756             if (cps->other->offeredDraw) {
7757                 GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
7758             /* [HGM] in two-machine mode we delay relaying draw offer      */
7759             /* until after we also have move, to see if it is really claim */
7760             }
7761         } else if (gameMode == MachinePlaysWhite ||
7762                    gameMode == MachinePlaysBlack) {
7763           if (userOfferedDraw) {
7764             DisplayInformation(_("Machine accepts your draw offer"));
7765             GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
7766           } else {
7767             DisplayInformation(_("Machine offers a draw\nSelect Action / Draw to agree"));
7768           }
7769         }
7770     }
7771
7772
7773     /*
7774      * Look for thinking output
7775      */
7776     if ( appData.showThinking // [HGM] thinking: test all options that cause this output
7777           || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp()
7778                                 ) {
7779         int plylev, mvleft, mvtot, curscore, time;
7780         char mvname[MOVE_LEN];
7781         u64 nodes; // [DM]
7782         char plyext;
7783         int ignore = FALSE;
7784         int prefixHint = FALSE;
7785         mvname[0] = NULLCHAR;
7786
7787         switch (gameMode) {
7788           case MachinePlaysBlack:
7789           case IcsPlayingBlack:
7790             if (WhiteOnMove(forwardMostMove)) prefixHint = TRUE;
7791             break;
7792           case MachinePlaysWhite:
7793           case IcsPlayingWhite:
7794             if (!WhiteOnMove(forwardMostMove)) prefixHint = TRUE;
7795             break;
7796           case AnalyzeMode:
7797           case AnalyzeFile:
7798             break;
7799           case IcsObserving: /* [DM] icsEngineAnalyze */
7800             if (!appData.icsEngineAnalyze) ignore = TRUE;
7801             break;
7802           case TwoMachinesPlay:
7803             if ((cps->twoMachinesColor[0] == 'w') != WhiteOnMove(forwardMostMove)) {
7804                 ignore = TRUE;
7805             }
7806             break;
7807           default:
7808             ignore = TRUE;
7809             break;
7810         }
7811
7812         if (!ignore) {
7813             ChessProgramStats tempStats = programStats; // [HGM] info: filter out info lines
7814             buf1[0] = NULLCHAR;
7815             if (sscanf(message, "%d%c %d %d " u64Display " %[^\n]\n",
7816                        &plylev, &plyext, &curscore, &time, &nodes, buf1) >= 5) {
7817
7818                 if (plyext != ' ' && plyext != '\t') {
7819                     time *= 100;
7820                 }
7821
7822                 /* [AS] Negate score if machine is playing black and reporting absolute scores */
7823                 if( cps->scoreIsAbsolute &&
7824                     ( gameMode == MachinePlaysBlack ||
7825                       gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b' ||
7826                       gameMode == IcsPlayingBlack ||     // [HGM] also add other situations where engine should report black POV
7827                      (gameMode == AnalyzeMode || gameMode == AnalyzeFile || gameMode == IcsObserving && appData.icsEngineAnalyze) &&
7828                      !WhiteOnMove(currentMove)
7829                     ) )
7830                 {
7831                     curscore = -curscore;
7832                 }
7833
7834
7835                 tempStats.depth = plylev;
7836                 tempStats.nodes = nodes;
7837                 tempStats.time = time;
7838                 tempStats.score = curscore;
7839                 tempStats.got_only_move = 0;
7840
7841                 if(cps->nps >= 0) { /* [HGM] nps: use engine nodes or time to decrement clock */
7842                         int ticklen;
7843
7844                         if(cps->nps == 0) ticklen = 10*time;                    // use engine reported time
7845                         else ticklen = (1000. * u64ToDouble(nodes)) / cps->nps; // convert node count to time
7846                         if(WhiteOnMove(forwardMostMove) && (gameMode == MachinePlaysWhite ||
7847                                                 gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'w'))
7848                              whiteTimeRemaining = timeRemaining[0][forwardMostMove] - ticklen;
7849                         if(!WhiteOnMove(forwardMostMove) && (gameMode == MachinePlaysBlack ||
7850                                                 gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b'))
7851                              blackTimeRemaining = timeRemaining[1][forwardMostMove] - ticklen;
7852                 }
7853
7854                 /* Buffer overflow protection */
7855                 if (buf1[0] != NULLCHAR) {
7856                     if (strlen(buf1) >= sizeof(tempStats.movelist)
7857                         && appData.debugMode) {
7858                         fprintf(debugFP,
7859                                 "PV is too long; using the first %u bytes.\n",
7860                                 (unsigned) sizeof(tempStats.movelist) - 1);
7861                     }
7862
7863                     safeStrCpy( tempStats.movelist, buf1, sizeof(tempStats.movelist) );
7864                 } else {
7865                     sprintf(tempStats.movelist, " no PV\n");
7866                 }
7867
7868                 if (tempStats.seen_stat) {
7869                     tempStats.ok_to_send = 1;
7870                 }
7871
7872                 if (strchr(tempStats.movelist, '(') != NULL) {
7873                     tempStats.line_is_book = 1;
7874                     tempStats.nr_moves = 0;
7875                     tempStats.moves_left = 0;
7876                 } else {
7877                     tempStats.line_is_book = 0;
7878                 }
7879
7880                     if(tempStats.score != 0 || tempStats.nodes != 0 || tempStats.time != 0)
7881                         programStats = tempStats; // [HGM] info: only set stats if genuine PV and not an info line
7882
7883                 SendProgramStatsToFrontend( cps, &tempStats );
7884
7885                 /*
7886                     [AS] Protect the thinkOutput buffer from overflow... this
7887                     is only useful if buf1 hasn't overflowed first!
7888                 */
7889                 sprintf(thinkOutput, "[%d]%c%+.2f %s%s",
7890                         plylev,
7891                         (gameMode == TwoMachinesPlay ?
7892                          ToUpper(cps->twoMachinesColor[0]) : ' '),
7893                         ((double) curscore) / 100.0,
7894                         prefixHint ? lastHint : "",
7895                         prefixHint ? " " : "" );
7896
7897                 if( buf1[0] != NULLCHAR ) {
7898                     unsigned max_len = sizeof(thinkOutput) - strlen(thinkOutput) - 1;
7899
7900                     if( strlen(buf1) > max_len ) {
7901                         if( appData.debugMode) {
7902                             fprintf(debugFP,"PV is too long for thinkOutput, truncating.\n");
7903                         }
7904                         buf1[max_len+1] = '\0';
7905                     }
7906
7907                     strcat( thinkOutput, buf1 );
7908                 }
7909
7910                 if (currentMove == forwardMostMove || gameMode == AnalyzeMode
7911                         || gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
7912                     DisplayMove(currentMove - 1);
7913                 }
7914                 return;
7915
7916             } else if ((p=StrStr(message, "(only move)")) != NULL) {
7917                 /* crafty (9.25+) says "(only move) <move>"
7918                  * if there is only 1 legal move
7919                  */
7920                 sscanf(p, "(only move) %s", buf1);
7921                 sprintf(thinkOutput, "%s (only move)", buf1);
7922                 sprintf(programStats.movelist, "%s (only move)", buf1);
7923                 programStats.depth = 1;
7924                 programStats.nr_moves = 1;
7925                 programStats.moves_left = 1;
7926                 programStats.nodes = 1;
7927                 programStats.time = 1;
7928                 programStats.got_only_move = 1;
7929
7930                 /* Not really, but we also use this member to
7931                    mean "line isn't going to change" (Crafty
7932                    isn't searching, so stats won't change) */
7933                 programStats.line_is_book = 1;
7934
7935                 SendProgramStatsToFrontend( cps, &programStats );
7936
7937                 if (currentMove == forwardMostMove || gameMode==AnalyzeMode ||
7938                            gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
7939                     DisplayMove(currentMove - 1);
7940                 }
7941                 return;
7942             } else if (sscanf(message,"stat01: %d " u64Display " %d %d %d %s",
7943                               &time, &nodes, &plylev, &mvleft,
7944                               &mvtot, mvname) >= 5) {
7945                 /* The stat01: line is from Crafty (9.29+) in response
7946                    to the "." command */
7947                 programStats.seen_stat = 1;
7948                 cps->maybeThinking = TRUE;
7949
7950                 if (programStats.got_only_move || !appData.periodicUpdates)
7951                   return;
7952
7953                 programStats.depth = plylev;
7954                 programStats.time = time;
7955                 programStats.nodes = nodes;
7956                 programStats.moves_left = mvleft;
7957                 programStats.nr_moves = mvtot;
7958                 strcpy(programStats.move_name, mvname);
7959                 programStats.ok_to_send = 1;
7960                 programStats.movelist[0] = '\0';
7961
7962                 SendProgramStatsToFrontend( cps, &programStats );
7963
7964                 return;
7965
7966             } else if (strncmp(message,"++",2) == 0) {
7967                 /* Crafty 9.29+ outputs this */
7968                 programStats.got_fail = 2;
7969                 return;
7970
7971             } else if (strncmp(message,"--",2) == 0) {
7972                 /* Crafty 9.29+ outputs this */
7973                 programStats.got_fail = 1;
7974                 return;
7975
7976             } else if (thinkOutput[0] != NULLCHAR &&
7977                        strncmp(message, "    ", 4) == 0) {
7978                 unsigned message_len;
7979
7980                 p = message;
7981                 while (*p && *p == ' ') p++;
7982
7983                 message_len = strlen( p );
7984
7985                 /* [AS] Avoid buffer overflow */
7986                 if( sizeof(thinkOutput) - strlen(thinkOutput) - 1 > message_len ) {
7987                     strcat(thinkOutput, " ");
7988                     strcat(thinkOutput, p);
7989                 }
7990
7991                 if( sizeof(programStats.movelist) - strlen(programStats.movelist) - 1 > message_len ) {
7992                     strcat(programStats.movelist, " ");
7993                     strcat(programStats.movelist, p);
7994                 }
7995
7996                 if (currentMove == forwardMostMove || gameMode==AnalyzeMode ||
7997                            gameMode == AnalyzeFile || appData.icsEngineAnalyze) {
7998                     DisplayMove(currentMove - 1);
7999                 }
8000                 return;
8001             }
8002         }
8003         else {
8004             buf1[0] = NULLCHAR;
8005
8006             if (sscanf(message, "%d%c %d %d " u64Display " %[^\n]\n",
8007                        &plylev, &plyext, &curscore, &time, &nodes, buf1) >= 5)
8008             {
8009                 ChessProgramStats cpstats;
8010
8011                 if (plyext != ' ' && plyext != '\t') {
8012                     time *= 100;
8013                 }
8014
8015                 /* [AS] Negate score if machine is playing black and reporting absolute scores */
8016                 if( cps->scoreIsAbsolute && ((gameMode == MachinePlaysBlack) || (gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b')) ) {
8017                     curscore = -curscore;
8018                 }
8019
8020                 cpstats.depth = plylev;
8021                 cpstats.nodes = nodes;
8022                 cpstats.time = time;
8023                 cpstats.score = curscore;
8024                 cpstats.got_only_move = 0;
8025                 cpstats.movelist[0] = '\0';
8026
8027                 if (buf1[0] != NULLCHAR) {
8028                     safeStrCpy( cpstats.movelist, buf1, sizeof(cpstats.movelist) );
8029                 }
8030
8031                 cpstats.ok_to_send = 0;
8032                 cpstats.line_is_book = 0;
8033                 cpstats.nr_moves = 0;
8034                 cpstats.moves_left = 0;
8035
8036                 SendProgramStatsToFrontend( cps, &cpstats );
8037             }
8038         }
8039     }
8040 }
8041
8042
8043 /* Parse a game score from the character string "game", and
8044    record it as the history of the current game.  The game
8045    score is NOT assumed to start from the standard position.
8046    The display is not updated in any way.
8047    */
8048 void
8049 ParseGameHistory(game)
8050      char *game;
8051 {
8052     ChessMove moveType;
8053     int fromX, fromY, toX, toY, boardIndex;
8054     char promoChar;
8055     char *p, *q;
8056     char buf[MSG_SIZ];
8057
8058     if (appData.debugMode)
8059       fprintf(debugFP, "Parsing game history: %s\n", game);
8060
8061     if (gameInfo.event == NULL) gameInfo.event = StrSave("ICS game");
8062     gameInfo.site = StrSave(appData.icsHost);
8063     gameInfo.date = PGNDate();
8064     gameInfo.round = StrSave("-");
8065
8066     /* Parse out names of players */
8067     while (*game == ' ') game++;
8068     p = buf;
8069     while (*game != ' ') *p++ = *game++;
8070     *p = NULLCHAR;
8071     gameInfo.white = StrSave(buf);
8072     while (*game == ' ') game++;
8073     p = buf;
8074     while (*game != ' ' && *game != '\n') *p++ = *game++;
8075     *p = NULLCHAR;
8076     gameInfo.black = StrSave(buf);
8077
8078     /* Parse moves */
8079     boardIndex = blackPlaysFirst ? 1 : 0;
8080     yynewstr(game);
8081     for (;;) {
8082         yyboardindex = boardIndex;
8083         moveType = (ChessMove) yylex();
8084         switch (moveType) {
8085           case IllegalMove:             /* maybe suicide chess, etc. */
8086   if (appData.debugMode) {
8087     fprintf(debugFP, "Illegal move from ICS: '%s'\n", yy_text);
8088     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
8089     setbuf(debugFP, NULL);
8090   }
8091           case WhitePromotionChancellor:
8092           case BlackPromotionChancellor:
8093           case WhitePromotionArchbishop:
8094           case BlackPromotionArchbishop:
8095           case WhitePromotionQueen:
8096           case BlackPromotionQueen:
8097           case WhitePromotionRook:
8098           case BlackPromotionRook:
8099           case WhitePromotionBishop:
8100           case BlackPromotionBishop:
8101           case WhitePromotionKnight:
8102           case BlackPromotionKnight:
8103           case WhitePromotionKing:
8104           case BlackPromotionKing:
8105           case NormalMove:
8106           case WhiteCapturesEnPassant:
8107           case BlackCapturesEnPassant:
8108           case WhiteKingSideCastle:
8109           case WhiteQueenSideCastle:
8110           case BlackKingSideCastle:
8111           case BlackQueenSideCastle:
8112           case WhiteKingSideCastleWild:
8113           case WhiteQueenSideCastleWild:
8114           case BlackKingSideCastleWild:
8115           case BlackQueenSideCastleWild:
8116           /* PUSH Fabien */
8117           case WhiteHSideCastleFR:
8118           case WhiteASideCastleFR:
8119           case BlackHSideCastleFR:
8120           case BlackASideCastleFR:
8121           /* POP Fabien */
8122             fromX = currentMoveString[0] - AAA;
8123             fromY = currentMoveString[1] - ONE;
8124             toX = currentMoveString[2] - AAA;
8125             toY = currentMoveString[3] - ONE;
8126             promoChar = currentMoveString[4];
8127             break;
8128           case WhiteDrop:
8129           case BlackDrop:
8130             fromX = moveType == WhiteDrop ?
8131               (int) CharToPiece(ToUpper(currentMoveString[0])) :
8132             (int) CharToPiece(ToLower(currentMoveString[0]));
8133             fromY = DROP_RANK;
8134             toX = currentMoveString[2] - AAA;
8135             toY = currentMoveString[3] - ONE;
8136             promoChar = NULLCHAR;
8137             break;
8138           case AmbiguousMove:
8139             /* bug? */
8140             sprintf(buf, _("Ambiguous move in ICS output: \"%s\""), yy_text);
8141   if (appData.debugMode) {
8142     fprintf(debugFP, "Ambiguous move from ICS: '%s'\n", yy_text);
8143     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
8144     setbuf(debugFP, NULL);
8145   }
8146             DisplayError(buf, 0);
8147             return;
8148           case ImpossibleMove:
8149             /* bug? */
8150             sprintf(buf, _("Illegal move in ICS output: \"%s\""), yy_text);
8151   if (appData.debugMode) {
8152     fprintf(debugFP, "Impossible move from ICS: '%s'\n", yy_text);
8153     fprintf(debugFP, "board L=%d, R=%d, H=%d, holdings=%d\n", BOARD_LEFT, BOARD_RGHT, BOARD_HEIGHT, gameInfo.holdingsWidth);
8154     setbuf(debugFP, NULL);
8155   }
8156             DisplayError(buf, 0);
8157             return;
8158           case (ChessMove) 0:   /* end of file */
8159             if (boardIndex < backwardMostMove) {
8160                 /* Oops, gap.  How did that happen? */
8161                 DisplayError(_("Gap in move list"), 0);
8162                 return;
8163             }
8164             backwardMostMove =  blackPlaysFirst ? 1 : 0;
8165             if (boardIndex > forwardMostMove) {
8166                 forwardMostMove = boardIndex;
8167             }
8168             return;
8169           case ElapsedTime:
8170             if (boardIndex > (blackPlaysFirst ? 1 : 0)) {
8171                 strcat(parseList[boardIndex-1], " ");
8172                 strcat(parseList[boardIndex-1], yy_text);
8173             }
8174             continue;
8175           case Comment:
8176           case PGNTag:
8177           case NAG:
8178           default:
8179             /* ignore */
8180             continue;
8181           case WhiteWins:
8182           case BlackWins:
8183           case GameIsDrawn:
8184           case GameUnfinished:
8185             if (gameMode == IcsExamining) {
8186                 if (boardIndex < backwardMostMove) {
8187                     /* Oops, gap.  How did that happen? */
8188                     return;
8189                 }
8190                 backwardMostMove = blackPlaysFirst ? 1 : 0;
8191                 return;
8192             }
8193             gameInfo.result = moveType;
8194             p = strchr(yy_text, '{');
8195             if (p == NULL) p = strchr(yy_text, '(');
8196             if (p == NULL) {
8197                 p = yy_text;
8198                 if (p[0] == '0' || p[0] == '1' || p[0] == '*') p = "";
8199             } else {
8200                 q = strchr(p, *p == '{' ? '}' : ')');
8201                 if (q != NULL) *q = NULLCHAR;
8202                 p++;
8203             }
8204             gameInfo.resultDetails = StrSave(p);
8205             continue;
8206         }
8207         if (boardIndex >= forwardMostMove &&
8208             !(gameMode == IcsObserving && ics_gamenum == -1)) {
8209             backwardMostMove = blackPlaysFirst ? 1 : 0;
8210             return;
8211         }
8212         (void) CoordsToAlgebraic(boards[boardIndex], PosFlags(boardIndex),
8213                                  fromY, fromX, toY, toX, promoChar,
8214                                  parseList[boardIndex]);
8215         CopyBoard(boards[boardIndex + 1], boards[boardIndex]);
8216         /* currentMoveString is set as a side-effect of yylex */
8217         strcpy(moveList[boardIndex], currentMoveString);
8218         strcat(moveList[boardIndex], "\n");
8219         boardIndex++;
8220         ApplyMove(fromX, fromY, toX, toY, promoChar, boards[boardIndex]);
8221         switch (MateTest(boards[boardIndex], PosFlags(boardIndex)) ) {
8222           case MT_NONE:
8223           case MT_STALEMATE:
8224           default:
8225             break;
8226           case MT_CHECK:
8227             if(gameInfo.variant != VariantShogi)
8228                 strcat(parseList[boardIndex - 1], "+");
8229             break;
8230           case MT_CHECKMATE:
8231           case MT_STAINMATE:
8232             strcat(parseList[boardIndex - 1], "#");
8233             break;
8234         }
8235     }
8236 }
8237
8238
8239 /* Apply a move to the given board  */
8240 void
8241 ApplyMove(fromX, fromY, toX, toY, promoChar, board)
8242      int fromX, fromY, toX, toY;
8243      int promoChar;
8244      Board board;
8245 {
8246   ChessSquare captured = board[toY][toX], piece, king; int p, oldEP = EP_NONE, berolina = 0;
8247   int promoRank = gameInfo.variant == VariantMakruk ? 3 : 1;
8248
8249     /* [HGM] compute & store e.p. status and castling rights for new position */
8250     /* we can always do that 'in place', now pointers to these rights are passed to ApplyMove */
8251     { int i;
8252
8253       if(gameInfo.variant == VariantBerolina) berolina = EP_BEROLIN_A;
8254       oldEP = (signed char)board[EP_STATUS];
8255       board[EP_STATUS] = EP_NONE;
8256
8257       if( board[toY][toX] != EmptySquare )
8258            board[EP_STATUS] = EP_CAPTURE;
8259
8260       if( board[fromY][fromX] == WhitePawn ) {
8261            if(fromY != toY) // [HGM] Xiangqi sideway Pawn moves should not count as 50-move breakers
8262                board[EP_STATUS] = EP_PAWN_MOVE;
8263            if( toY-fromY==2) {
8264                if(toX>BOARD_LEFT   && board[toY][toX-1] == BlackPawn &&
8265                         gameInfo.variant != VariantBerolina || toX < fromX)
8266                       board[EP_STATUS] = toX | berolina;
8267                if(toX<BOARD_RGHT-1 && board[toY][toX+1] == BlackPawn &&
8268                         gameInfo.variant != VariantBerolina || toX > fromX)
8269                       board[EP_STATUS] = toX;
8270            }
8271       } else
8272       if( board[fromY][fromX] == BlackPawn ) {
8273            if(fromY != toY) // [HGM] Xiangqi sideway Pawn moves should not count as 50-move breakers
8274                board[EP_STATUS] = EP_PAWN_MOVE;
8275            if( toY-fromY== -2) {
8276                if(toX>BOARD_LEFT   && board[toY][toX-1] == WhitePawn &&
8277                         gameInfo.variant != VariantBerolina || toX < fromX)
8278                       board[EP_STATUS] = toX | berolina;
8279                if(toX<BOARD_RGHT-1 && board[toY][toX+1] == WhitePawn &&
8280                         gameInfo.variant != VariantBerolina || toX > fromX)
8281                       board[EP_STATUS] = toX;
8282            }
8283        }
8284
8285        for(i=0; i<nrCastlingRights; i++) {
8286            if(board[CASTLING][i] == fromX && castlingRank[i] == fromY ||
8287               board[CASTLING][i] == toX   && castlingRank[i] == toY
8288              ) board[CASTLING][i] = NoRights; // revoke for moved or captured piece
8289        }
8290
8291     }
8292
8293   /* [HGM] In Shatranj and Courier all promotions are to Ferz */
8294   if((gameInfo.variant==VariantShatranj || gameInfo.variant==VariantCourier || gameInfo.variant == VariantMakruk)
8295        && promoChar != 0) promoChar = PieceToChar(WhiteFerz);
8296
8297   if (fromX == toX && fromY == toY) return;
8298
8299   if (fromY == DROP_RANK) {
8300         /* must be first */
8301         piece = board[toY][toX] = (ChessSquare) fromX;
8302   } else {
8303      piece = board[fromY][fromX]; /* [HGM] remember, for Shogi promotion */
8304      king = piece < (int) BlackPawn ? WhiteKing : BlackKing; /* [HGM] Knightmate simplify testing for castling */
8305      if(gameInfo.variant == VariantKnightmate)
8306          king += (int) WhiteUnicorn - (int) WhiteKing;
8307
8308     /* Code added by Tord: */
8309     /* FRC castling assumed when king captures friendly rook. */
8310     if (board[fromY][fromX] == WhiteKing &&
8311              board[toY][toX] == WhiteRook) {
8312       board[fromY][fromX] = EmptySquare;
8313       board[toY][toX] = EmptySquare;
8314       if(toX > fromX) {
8315         board[0][BOARD_RGHT-2] = WhiteKing; board[0][BOARD_RGHT-3] = WhiteRook;
8316       } else {
8317         board[0][BOARD_LEFT+2] = WhiteKing; board[0][BOARD_LEFT+3] = WhiteRook;
8318       }
8319     } else if (board[fromY][fromX] == BlackKing &&
8320                board[toY][toX] == BlackRook) {
8321       board[fromY][fromX] = EmptySquare;
8322       board[toY][toX] = EmptySquare;
8323       if(toX > fromX) {
8324         board[BOARD_HEIGHT-1][BOARD_RGHT-2] = BlackKing; board[BOARD_HEIGHT-1][BOARD_RGHT-3] = BlackRook;
8325       } else {
8326         board[BOARD_HEIGHT-1][BOARD_LEFT+2] = BlackKing; board[BOARD_HEIGHT-1][BOARD_LEFT+3] = BlackRook;
8327       }
8328     /* End of code added by Tord */
8329
8330     } else if (board[fromY][fromX] == king
8331         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
8332         && toY == fromY && toX > fromX+1) {
8333         board[fromY][fromX] = EmptySquare;
8334         board[toY][toX] = king;
8335         board[toY][toX-1] = board[fromY][BOARD_RGHT-1];
8336         board[fromY][BOARD_RGHT-1] = EmptySquare;
8337     } else if (board[fromY][fromX] == king
8338         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
8339                && toY == fromY && toX < fromX-1) {
8340         board[fromY][fromX] = EmptySquare;
8341         board[toY][toX] = king;
8342         board[toY][toX+1] = board[fromY][BOARD_LEFT];
8343         board[fromY][BOARD_LEFT] = EmptySquare;
8344     } else if (board[fromY][fromX] == WhitePawn
8345                && toY >= BOARD_HEIGHT-promoRank
8346                && gameInfo.variant != VariantXiangqi
8347                ) {
8348         /* white pawn promotion */
8349         board[toY][toX] = CharToPiece(ToUpper(promoChar));
8350         if (board[toY][toX] == EmptySquare) {
8351             board[toY][toX] = WhiteQueen;
8352         }
8353         if(gameInfo.variant==VariantBughouse ||
8354            gameInfo.variant==VariantCrazyhouse) /* [HGM] use shadow piece */
8355             board[toY][toX] = (ChessSquare) (PROMOTED board[toY][toX]);
8356         board[fromY][fromX] = EmptySquare;
8357     } else if ((fromY == BOARD_HEIGHT-4)
8358                && (toX != fromX)
8359                && gameInfo.variant != VariantXiangqi
8360                && gameInfo.variant != VariantBerolina
8361                && (board[fromY][fromX] == WhitePawn)
8362                && (board[toY][toX] == EmptySquare)) {
8363         board[fromY][fromX] = EmptySquare;
8364         board[toY][toX] = WhitePawn;
8365         captured = board[toY - 1][toX];
8366         board[toY - 1][toX] = EmptySquare;
8367     } else if ((fromY == BOARD_HEIGHT-4)
8368                && (toX == fromX)
8369                && gameInfo.variant == VariantBerolina
8370                && (board[fromY][fromX] == WhitePawn)
8371                && (board[toY][toX] == EmptySquare)) {
8372         board[fromY][fromX] = EmptySquare;
8373         board[toY][toX] = WhitePawn;
8374         if(oldEP & EP_BEROLIN_A) {
8375                 captured = board[fromY][fromX-1];
8376                 board[fromY][fromX-1] = EmptySquare;
8377         }else{  captured = board[fromY][fromX+1];
8378                 board[fromY][fromX+1] = EmptySquare;
8379         }
8380     } else if (board[fromY][fromX] == king
8381         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
8382                && toY == fromY && toX > fromX+1) {
8383         board[fromY][fromX] = EmptySquare;
8384         board[toY][toX] = king;
8385         board[toY][toX-1] = board[fromY][BOARD_RGHT-1];
8386         board[fromY][BOARD_RGHT-1] = EmptySquare;
8387     } else if (board[fromY][fromX] == king
8388         && fromX != BOARD_LEFT && fromX != BOARD_RGHT-1 // [HGM] cylinder */
8389                && toY == fromY && toX < fromX-1) {
8390         board[fromY][fromX] = EmptySquare;
8391         board[toY][toX] = king;
8392         board[toY][toX+1] = board[fromY][BOARD_LEFT];
8393         board[fromY][BOARD_LEFT] = EmptySquare;
8394     } else if (fromY == 7 && fromX == 3
8395                && board[fromY][fromX] == BlackKing
8396                && toY == 7 && toX == 5) {
8397         board[fromY][fromX] = EmptySquare;
8398         board[toY][toX] = BlackKing;
8399         board[fromY][7] = EmptySquare;
8400         board[toY][4] = BlackRook;
8401     } else if (fromY == 7 && fromX == 3
8402                && board[fromY][fromX] == BlackKing
8403                && toY == 7 && toX == 1) {
8404         board[fromY][fromX] = EmptySquare;
8405         board[toY][toX] = BlackKing;
8406         board[fromY][0] = EmptySquare;
8407         board[toY][2] = BlackRook;
8408     } else if (board[fromY][fromX] == BlackPawn
8409                && toY < promoRank
8410                && gameInfo.variant != VariantXiangqi
8411                ) {
8412         /* black pawn promotion */
8413         board[toY][toX] = CharToPiece(ToLower(promoChar));
8414         if (board[toY][toX] == EmptySquare) {
8415             board[toY][toX] = BlackQueen;
8416         }
8417         if(gameInfo.variant==VariantBughouse ||
8418            gameInfo.variant==VariantCrazyhouse) /* [HGM] use shadow piece */
8419             board[toY][toX] = (ChessSquare) (PROMOTED board[toY][toX]);
8420         board[fromY][fromX] = EmptySquare;
8421     } else if ((fromY == 3)
8422                && (toX != fromX)
8423                && gameInfo.variant != VariantXiangqi
8424                && gameInfo.variant != VariantBerolina
8425                && (board[fromY][fromX] == BlackPawn)
8426                && (board[toY][toX] == EmptySquare)) {
8427         board[fromY][fromX] = EmptySquare;
8428         board[toY][toX] = BlackPawn;
8429         captured = board[toY + 1][toX];
8430         board[toY + 1][toX] = EmptySquare;
8431     } else if ((fromY == 3)
8432                && (toX == fromX)
8433                && gameInfo.variant == VariantBerolina
8434                && (board[fromY][fromX] == BlackPawn)
8435                && (board[toY][toX] == EmptySquare)) {
8436         board[fromY][fromX] = EmptySquare;
8437         board[toY][toX] = BlackPawn;
8438         if(oldEP & EP_BEROLIN_A) {
8439                 captured = board[fromY][fromX-1];
8440                 board[fromY][fromX-1] = EmptySquare;
8441         }else{  captured = board[fromY][fromX+1];
8442                 board[fromY][fromX+1] = EmptySquare;
8443         }
8444     } else {
8445         board[toY][toX] = board[fromY][fromX];
8446         board[fromY][fromX] = EmptySquare;
8447     }
8448
8449     /* [HGM] now we promote for Shogi, if needed */
8450     if(gameInfo.variant == VariantShogi && promoChar == 'q')
8451         board[toY][toX] = (ChessSquare) (PROMOTED piece);
8452   }
8453
8454     if (gameInfo.holdingsWidth != 0) {
8455
8456       /* !!A lot more code needs to be written to support holdings  */
8457       /* [HGM] OK, so I have written it. Holdings are stored in the */
8458       /* penultimate board files, so they are automaticlly stored   */
8459       /* in the game history.                                       */
8460       if (fromY == DROP_RANK) {
8461         /* Delete from holdings, by decreasing count */
8462         /* and erasing image if necessary            */
8463         p = (int) fromX;
8464         if(p < (int) BlackPawn) { /* white drop */
8465              p -= (int)WhitePawn;
8466                  p = PieceToNumber((ChessSquare)p);
8467              if(p >= gameInfo.holdingsSize) p = 0;
8468              if(--board[p][BOARD_WIDTH-2] <= 0)
8469                   board[p][BOARD_WIDTH-1] = EmptySquare;
8470              if((int)board[p][BOARD_WIDTH-2] < 0)
8471                         board[p][BOARD_WIDTH-2] = 0;
8472         } else {                  /* black drop */
8473              p -= (int)BlackPawn;
8474                  p = PieceToNumber((ChessSquare)p);
8475              if(p >= gameInfo.holdingsSize) p = 0;
8476              if(--board[BOARD_HEIGHT-1-p][1] <= 0)
8477                   board[BOARD_HEIGHT-1-p][0] = EmptySquare;
8478              if((int)board[BOARD_HEIGHT-1-p][1] < 0)
8479                         board[BOARD_HEIGHT-1-p][1] = 0;
8480         }
8481       }
8482       if (captured != EmptySquare && gameInfo.holdingsSize > 0
8483           && gameInfo.variant != VariantBughouse        ) {
8484         /* [HGM] holdings: Add to holdings, if holdings exist */
8485         if(gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat) {
8486                 // [HGM] superchess: suppress flipping color of captured pieces by reverse pre-flip
8487                 captured = (int) captured >= (int) BlackPawn ? BLACK_TO_WHITE captured : WHITE_TO_BLACK captured;
8488         }
8489         p = (int) captured;
8490         if (p >= (int) BlackPawn) {
8491           p -= (int)BlackPawn;
8492           if(gameInfo.variant == VariantShogi && DEMOTED p >= 0) {
8493                   /* in Shogi restore piece to its original  first */
8494                   captured = (ChessSquare) (DEMOTED captured);
8495                   p = DEMOTED p;
8496           }
8497           p = PieceToNumber((ChessSquare)p);
8498           if(p >= gameInfo.holdingsSize) { p = 0; captured = BlackPawn; }
8499           board[p][BOARD_WIDTH-2]++;
8500           board[p][BOARD_WIDTH-1] = BLACK_TO_WHITE captured;
8501         } else {
8502           p -= (int)WhitePawn;
8503           if(gameInfo.variant == VariantShogi && DEMOTED p >= 0) {
8504                   captured = (ChessSquare) (DEMOTED captured);
8505                   p = DEMOTED p;
8506           }
8507           p = PieceToNumber((ChessSquare)p);
8508           if(p >= gameInfo.holdingsSize) { p = 0; captured = WhitePawn; }
8509           board[BOARD_HEIGHT-1-p][1]++;
8510           board[BOARD_HEIGHT-1-p][0] = WHITE_TO_BLACK captured;
8511         }
8512       }
8513     } else if (gameInfo.variant == VariantAtomic) {
8514       if (captured != EmptySquare) {
8515         int y, x;
8516         for (y = toY-1; y <= toY+1; y++) {
8517           for (x = toX-1; x <= toX+1; x++) {
8518             if (y >= 0 && y < BOARD_HEIGHT && x >= BOARD_LEFT && x < BOARD_RGHT &&
8519                 board[y][x] != WhitePawn && board[y][x] != BlackPawn) {
8520               board[y][x] = EmptySquare;
8521             }
8522           }
8523         }
8524         board[toY][toX] = EmptySquare;
8525       }
8526     }
8527     if(gameInfo.variant == VariantShogi && promoChar != NULLCHAR && promoChar != '=') {
8528         /* [HGM] Shogi promotions */
8529         board[toY][toX] = (ChessSquare) (PROMOTED piece);
8530     }
8531
8532     if((gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat)
8533                 && promoChar != NULLCHAR && gameInfo.holdingsSize) {
8534         // [HGM] superchess: take promotion piece out of holdings
8535         int k = PieceToNumber(CharToPiece(ToUpper(promoChar)));
8536         if((int)piece < (int)BlackPawn) { // determine stm from piece color
8537             if(!--board[k][BOARD_WIDTH-2])
8538                 board[k][BOARD_WIDTH-1] = EmptySquare;
8539         } else {
8540             if(!--board[BOARD_HEIGHT-1-k][1])
8541                 board[BOARD_HEIGHT-1-k][0] = EmptySquare;
8542         }
8543     }
8544
8545 }
8546
8547 /* Updates forwardMostMove */
8548 void
8549 MakeMove(fromX, fromY, toX, toY, promoChar)
8550      int fromX, fromY, toX, toY;
8551      int promoChar;
8552 {
8553 //    forwardMostMove++; // [HGM] bare: moved downstream
8554
8555     if(serverMoves != NULL) { /* [HGM] write moves on file for broadcasting (should be separate routine, really) */
8556         int timeLeft; static int lastLoadFlag=0; int king, piece;
8557         piece = boards[forwardMostMove][fromY][fromX];
8558         king = piece < (int) BlackPawn ? WhiteKing : BlackKing;
8559         if(gameInfo.variant == VariantKnightmate)
8560             king += (int) WhiteUnicorn - (int) WhiteKing;
8561         if(forwardMostMove == 0) {
8562             if(blackPlaysFirst)
8563                 fprintf(serverMoves, "%s;", second.tidy);
8564             fprintf(serverMoves, "%s;", first.tidy);
8565             if(!blackPlaysFirst)
8566                 fprintf(serverMoves, "%s;", second.tidy);
8567         } else fprintf(serverMoves, loadFlag|lastLoadFlag ? ":" : ";");
8568         lastLoadFlag = loadFlag;
8569         // print base move
8570         fprintf(serverMoves, "%c%c:%c%c", AAA+fromX, ONE+fromY, AAA+toX, ONE+toY);
8571         // print castling suffix
8572         if( toY == fromY && piece == king ) {
8573             if(toX-fromX > 1)
8574                 fprintf(serverMoves, ":%c%c:%c%c", AAA+BOARD_RGHT-1, ONE+fromY, AAA+toX-1,ONE+toY);
8575             if(fromX-toX >1)
8576                 fprintf(serverMoves, ":%c%c:%c%c", AAA+BOARD_LEFT, ONE+fromY, AAA+toX+1,ONE+toY);
8577         }
8578         // e.p. suffix
8579         if( (boards[forwardMostMove][fromY][fromX] == WhitePawn ||
8580              boards[forwardMostMove][fromY][fromX] == BlackPawn   ) &&
8581              boards[forwardMostMove][toY][toX] == EmptySquare
8582              && fromX != toX )
8583                 fprintf(serverMoves, ":%c%c:%c%c", AAA+fromX, ONE+fromY, AAA+toX, ONE+fromY);
8584         // promotion suffix
8585         if(promoChar != NULLCHAR)
8586                 fprintf(serverMoves, ":%c:%c%c", promoChar, AAA+toX, ONE+toY);
8587         if(!loadFlag) {
8588             fprintf(serverMoves, "/%d/%d",
8589                pvInfoList[forwardMostMove].depth, pvInfoList[forwardMostMove].score);
8590             if(forwardMostMove+1 & 1) timeLeft = whiteTimeRemaining/1000;
8591             else                      timeLeft = blackTimeRemaining/1000;
8592             fprintf(serverMoves, "/%d", timeLeft);
8593         }
8594         fflush(serverMoves);
8595     }
8596
8597     if (forwardMostMove+1 > framePtr) { // [HGM] vari: do not run into saved variations
8598       DisplayFatalError(_("Game too long; increase MAX_MOVES and recompile"),
8599                         0, 1);
8600       return;
8601     }
8602     UnLoadPV(); // [HGM] pv: if we are looking at a PV, abort this
8603     if (commentList[forwardMostMove+1] != NULL) {
8604         free(commentList[forwardMostMove+1]);
8605         commentList[forwardMostMove+1] = NULL;
8606     }
8607     CopyBoard(boards[forwardMostMove+1], boards[forwardMostMove]);
8608     ApplyMove(fromX, fromY, toX, toY, promoChar, boards[forwardMostMove+1]);
8609     // forwardMostMove++; // [HGM] bare: moved to after ApplyMove, to make sure clock interrupt finds complete board
8610     SwitchClocks(forwardMostMove+1); // [HGM] race: incrementing move nr inside
8611     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
8612     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
8613     gameInfo.result = GameUnfinished;
8614     if (gameInfo.resultDetails != NULL) {
8615         free(gameInfo.resultDetails);
8616         gameInfo.resultDetails = NULL;
8617     }
8618     CoordsToComputerAlgebraic(fromY, fromX, toY, toX, promoChar,
8619                               moveList[forwardMostMove - 1]);
8620     (void) CoordsToAlgebraic(boards[forwardMostMove - 1],
8621                              PosFlags(forwardMostMove - 1),
8622                              fromY, fromX, toY, toX, promoChar,
8623                              parseList[forwardMostMove - 1]);
8624     switch (MateTest(boards[forwardMostMove], PosFlags(forwardMostMove)) ) {
8625       case MT_NONE:
8626       case MT_STALEMATE:
8627       default:
8628         break;
8629       case MT_CHECK:
8630         if(gameInfo.variant != VariantShogi)
8631             strcat(parseList[forwardMostMove - 1], "+");
8632         break;
8633       case MT_CHECKMATE:
8634       case MT_STAINMATE:
8635         strcat(parseList[forwardMostMove - 1], "#");
8636         break;
8637     }
8638     if (appData.debugMode) {
8639         fprintf(debugFP, "move: %s, parse: %s (%c)\n", moveList[forwardMostMove-1], parseList[forwardMostMove-1], moveList[forwardMostMove-1][4]);
8640     }
8641
8642 }
8643
8644 /* Updates currentMove if not pausing */
8645 void
8646 ShowMove(fromX, fromY, toX, toY)
8647 {
8648     int instant = (gameMode == PlayFromGameFile) ?
8649         (matchMode || (appData.timeDelay == 0 && !pausing)) : pausing;
8650     if(appData.noGUI) return;
8651     if (!pausing || gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
8652         if (!instant) {
8653             if (forwardMostMove == currentMove + 1) {
8654                 AnimateMove(boards[forwardMostMove - 1],
8655                             fromX, fromY, toX, toY);
8656             }
8657             if (appData.highlightLastMove) {
8658                 SetHighlights(fromX, fromY, toX, toY);
8659             }
8660         }
8661         currentMove = forwardMostMove;
8662     }
8663
8664     if (instant) return;
8665
8666     DisplayMove(currentMove - 1);
8667     DrawPosition(FALSE, boards[currentMove]);
8668     DisplayBothClocks();
8669     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
8670 }
8671
8672 void SendEgtPath(ChessProgramState *cps)
8673 {       /* [HGM] EGT: match formats given in feature with those given by user, and send info for each match */
8674         char buf[MSG_SIZ], name[MSG_SIZ], *p;
8675
8676         if((p = cps->egtFormats) == NULL || appData.egtFormats == NULL) return;
8677
8678         while(*p) {
8679             char c, *q = name+1, *r, *s;
8680
8681             name[0] = ','; // extract next format name from feature and copy with prefixed ','
8682             while(*p && *p != ',') *q++ = *p++;
8683             *q++ = ':'; *q = 0;
8684             if( appData.defaultPathEGTB && appData.defaultPathEGTB[0] &&
8685                 strcmp(name, ",nalimov:") == 0 ) {
8686                 // take nalimov path from the menu-changeable option first, if it is defined
8687                 sprintf(buf, "egtpath nalimov %s\n", appData.defaultPathEGTB);
8688                 SendToProgram(buf,cps);     // send egtbpath command for nalimov
8689             } else
8690             if( (s = StrStr(appData.egtFormats, name+1)) == appData.egtFormats ||
8691                 (s = StrStr(appData.egtFormats, name)) != NULL) {
8692                 // format name occurs amongst user-supplied formats, at beginning or immediately after comma
8693                 s = r = StrStr(s, ":") + 1; // beginning of path info
8694                 while(*r && *r != ',') r++; // path info is everything upto next ';' or end of string
8695                 c = *r; *r = 0;             // temporarily null-terminate path info
8696                     *--q = 0;               // strip of trailig ':' from name
8697                     sprintf(buf, "egtpath %s %s\n", name+1, s);
8698                 *r = c;
8699                 SendToProgram(buf,cps);     // send egtbpath command for this format
8700             }
8701             if(*p == ',') p++; // read away comma to position for next format name
8702         }
8703 }
8704
8705 void
8706 InitChessProgram(cps, setup)
8707      ChessProgramState *cps;
8708      int setup; /* [HGM] needed to setup FRC opening position */
8709 {
8710     char buf[MSG_SIZ], b[MSG_SIZ]; int overruled;
8711     if (appData.noChessProgram) return;
8712     hintRequested = FALSE;
8713     bookRequested = FALSE;
8714
8715     /* [HGM] some new WB protocol commands to configure engine are sent now, if engine supports them */
8716     /*       moved to before sending initstring in 4.3.15, so Polyglot can delay UCI 'isready' to recepton of 'new' */
8717     if(cps->memSize) { /* [HGM] memory */
8718         sprintf(buf, "memory %d\n", appData.defaultHashSize + appData.defaultCacheSizeEGTB);
8719         SendToProgram(buf, cps);
8720     }
8721     SendEgtPath(cps); /* [HGM] EGT */
8722     if(cps->maxCores) { /* [HGM] SMP: (protocol specified must be last settings command before new!) */
8723         sprintf(buf, "cores %d\n", appData.smpCores);
8724         SendToProgram(buf, cps);
8725     }
8726
8727     SendToProgram(cps->initString, cps);
8728     if (gameInfo.variant != VariantNormal &&
8729         gameInfo.variant != VariantLoadable
8730         /* [HGM] also send variant if board size non-standard */
8731         || gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0
8732                                             ) {
8733       char *v = VariantName(gameInfo.variant);
8734       if (cps->protocolVersion != 1 && StrStr(cps->variants, v) == NULL) {
8735         /* [HGM] in protocol 1 we have to assume all variants valid */
8736         sprintf(buf, _("Variant %s not supported by %s"), v, cps->tidy);
8737         DisplayFatalError(buf, 0, 1);
8738         return;
8739       }
8740
8741       /* [HGM] make prefix for non-standard board size. Awkward testing... */
8742       overruled = gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0;
8743       if( gameInfo.variant == VariantXiangqi )
8744            overruled = gameInfo.boardWidth != 9 || gameInfo.boardHeight != 10 || gameInfo.holdingsSize != 0;
8745       if( gameInfo.variant == VariantShogi )
8746            overruled = gameInfo.boardWidth != 9 || gameInfo.boardHeight != 9 || gameInfo.holdingsSize != 7;
8747       if( gameInfo.variant == VariantBughouse || gameInfo.variant == VariantCrazyhouse )
8748            overruled = gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 5;
8749       if( gameInfo.variant == VariantCapablanca || gameInfo.variant == VariantCapaRandom ||
8750                                gameInfo.variant == VariantGothic  || gameInfo.variant == VariantFalcon )
8751            overruled = gameInfo.boardWidth != 10 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0;
8752       if( gameInfo.variant == VariantCourier )
8753            overruled = gameInfo.boardWidth != 12 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 0;
8754       if( gameInfo.variant == VariantSuper )
8755            overruled = gameInfo.boardWidth != 8 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 8;
8756       if( gameInfo.variant == VariantGreat )
8757            overruled = gameInfo.boardWidth != 10 || gameInfo.boardHeight != 8 || gameInfo.holdingsSize != 8;
8758
8759       if(overruled) {
8760            sprintf(b, "%dx%d+%d_%s", gameInfo.boardWidth, gameInfo.boardHeight,
8761                                gameInfo.holdingsSize, VariantName(gameInfo.variant)); // cook up sized variant name
8762            /* [HGM] varsize: try first if this defiant size variant is specifically known */
8763            if(StrStr(cps->variants, b) == NULL) {
8764                // specific sized variant not known, check if general sizing allowed
8765                if (cps->protocolVersion != 1) { // for protocol 1 we cannot check and hope for the best
8766                    if(StrStr(cps->variants, "boardsize") == NULL) {
8767                        sprintf(buf, "Board size %dx%d+%d not supported by %s",
8768                             gameInfo.boardWidth, gameInfo.boardHeight, gameInfo.holdingsSize, cps->tidy);
8769                        DisplayFatalError(buf, 0, 1);
8770                        return;
8771                    }
8772                    /* [HGM] here we really should compare with the maximum supported board size */
8773                }
8774            }
8775       } else sprintf(b, "%s", VariantName(gameInfo.variant));
8776       sprintf(buf, "variant %s\n", b);
8777       SendToProgram(buf, cps);
8778     }
8779     currentlyInitializedVariant = gameInfo.variant;
8780
8781     /* [HGM] send opening position in FRC to first engine */
8782     if(setup) {
8783           SendToProgram("force\n", cps);
8784           SendBoard(cps, 0);
8785           /* engine is now in force mode! Set flag to wake it up after first move. */
8786           setboardSpoiledMachineBlack = 1;
8787     }
8788
8789     if (cps->sendICS) {
8790       snprintf(buf, sizeof(buf), "ics %s\n", appData.icsActive ? appData.icsHost : "-");
8791       SendToProgram(buf, cps);
8792     }
8793     cps->maybeThinking = FALSE;
8794     cps->offeredDraw = 0;
8795     if (!appData.icsActive) {
8796         SendTimeControl(cps, movesPerSession, timeControl,
8797                         timeIncrement, appData.searchDepth,
8798                         searchTime);
8799     }
8800     if (appData.showThinking
8801         // [HGM] thinking: four options require thinking output to be sent
8802         || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp()
8803                                 ) {
8804         SendToProgram("post\n", cps);
8805     }
8806     SendToProgram("hard\n", cps);
8807     if (!appData.ponderNextMove) {
8808         /* Warning: "easy" is a toggle in GNU Chess, so don't send
8809            it without being sure what state we are in first.  "hard"
8810            is not a toggle, so that one is OK.
8811          */
8812         SendToProgram("easy\n", cps);
8813     }
8814     if (cps->usePing) {
8815       sprintf(buf, "ping %d\n", ++cps->lastPing);
8816       SendToProgram(buf, cps);
8817     }
8818     cps->initDone = TRUE;
8819 }
8820
8821
8822 void
8823 StartChessProgram(cps)
8824      ChessProgramState *cps;
8825 {
8826     char buf[MSG_SIZ];
8827     int err;
8828
8829     if (appData.noChessProgram) return;
8830     cps->initDone = FALSE;
8831
8832     if (strcmp(cps->host, "localhost") == 0) {
8833         err = StartChildProcess(cps->program, cps->dir, &cps->pr);
8834     } else if (*appData.remoteShell == NULLCHAR) {
8835         err = OpenRcmd(cps->host, appData.remoteUser, cps->program, &cps->pr);
8836     } else {
8837         if (*appData.remoteUser == NULLCHAR) {
8838           snprintf(buf, sizeof(buf), "%s %s %s", appData.remoteShell, cps->host,
8839                     cps->program);
8840         } else {
8841           snprintf(buf, sizeof(buf), "%s %s -l %s %s", appData.remoteShell,
8842                     cps->host, appData.remoteUser, cps->program);
8843         }
8844         err = StartChildProcess(buf, "", &cps->pr);
8845     }
8846
8847     if (err != 0) {
8848         sprintf(buf, _("Startup failure on '%s'"), cps->program);
8849         DisplayFatalError(buf, err, 1);
8850         cps->pr = NoProc;
8851         cps->isr = NULL;
8852         return;
8853     }
8854
8855     cps->isr = AddInputSource(cps->pr, TRUE, ReceiveFromProgram, cps);
8856     if (cps->protocolVersion > 1) {
8857       sprintf(buf, "xboard\nprotover %d\n", cps->protocolVersion);
8858       cps->nrOptions = 0; // [HGM] options: clear all engine-specific options
8859       cps->comboCnt = 0;  //                and values of combo boxes
8860       SendToProgram(buf, cps);
8861     } else {
8862       SendToProgram("xboard\n", cps);
8863     }
8864 }
8865
8866
8867 void
8868 TwoMachinesEventIfReady P((void))
8869 {
8870   if (first.lastPing != first.lastPong) {
8871     DisplayMessage("", _("Waiting for first chess program"));
8872     ScheduleDelayedEvent(TwoMachinesEventIfReady, 10); // [HGM] fast: lowered from 1000
8873     return;
8874   }
8875   if (second.lastPing != second.lastPong) {
8876     DisplayMessage("", _("Waiting for second chess program"));
8877     ScheduleDelayedEvent(TwoMachinesEventIfReady, 10); // [HGM] fast: lowered from 1000
8878     return;
8879   }
8880   ThawUI();
8881   TwoMachinesEvent();
8882 }
8883
8884 void
8885 NextMatchGame P((void))
8886 {
8887     int index; /* [HGM] autoinc: step load index during match */
8888     Reset(FALSE, TRUE);
8889     if (*appData.loadGameFile != NULLCHAR) {
8890         index = appData.loadGameIndex;
8891         if(index < 0) { // [HGM] autoinc
8892             lastIndex = index = (index == -2 && first.twoMachinesColor[0] == 'b') ? lastIndex : lastIndex+1;
8893             if(appData.rewindIndex > 0 && index > appData.rewindIndex) lastIndex = index = 1;
8894         }
8895         LoadGameFromFile(appData.loadGameFile,
8896                          index,
8897                          appData.loadGameFile, FALSE);
8898     } else if (*appData.loadPositionFile != NULLCHAR) {
8899         index = appData.loadPositionIndex;
8900         if(index < 0) { // [HGM] autoinc
8901             lastIndex = index = (index == -2 && first.twoMachinesColor[0] == 'b') ? lastIndex : lastIndex+1;
8902             if(appData.rewindIndex > 0 && index > appData.rewindIndex) lastIndex = index = 1;
8903         }
8904         LoadPositionFromFile(appData.loadPositionFile,
8905                              index,
8906                              appData.loadPositionFile);
8907     }
8908     TwoMachinesEventIfReady();
8909 }
8910
8911 void UserAdjudicationEvent( int result )
8912 {
8913     ChessMove gameResult = GameIsDrawn;
8914
8915     if( result > 0 ) {
8916         gameResult = WhiteWins;
8917     }
8918     else if( result < 0 ) {
8919         gameResult = BlackWins;
8920     }
8921
8922     if( gameMode == TwoMachinesPlay ) {
8923         GameEnds( gameResult, "User adjudication", GE_XBOARD );
8924     }
8925 }
8926
8927
8928 // [HGM] save: calculate checksum of game to make games easily identifiable
8929 int StringCheckSum(char *s)
8930 {
8931         int i = 0;
8932         if(s==NULL) return 0;
8933         while(*s) i = i*259 + *s++;
8934         return i;
8935 }
8936
8937 int GameCheckSum()
8938 {
8939         int i, sum=0;
8940         for(i=backwardMostMove; i<forwardMostMove; i++) {
8941                 sum += pvInfoList[i].depth;
8942                 sum += StringCheckSum(parseList[i]);
8943                 sum += StringCheckSum(commentList[i]);
8944                 sum *= 261;
8945         }
8946         if(i>1 && sum==0) sum++; // make sure never zero for non-empty game
8947         return sum + StringCheckSum(commentList[i]);
8948 } // end of save patch
8949
8950 void
8951 GameEnds(result, resultDetails, whosays)
8952      ChessMove result;
8953      char *resultDetails;
8954      int whosays;
8955 {
8956     GameMode nextGameMode;
8957     int isIcsGame;
8958     char buf[MSG_SIZ];
8959
8960     if(endingGame) return; /* [HGM] crash: forbid recursion */
8961     endingGame = 1;
8962     if(twoBoards) { // [HGM] dual: switch back to one board
8963         twoBoards = partnerUp = 0; InitDrawingSizes(-2, 0);
8964         DrawPosition(TRUE, partnerBoard); // observed game becomes foreground
8965     }
8966     if (appData.debugMode) {
8967       fprintf(debugFP, "GameEnds(%d, %s, %d)\n",
8968               result, resultDetails ? resultDetails : "(null)", whosays);
8969     }
8970
8971     fromX = fromY = -1; // [HGM] abort any move the user is entering.
8972
8973     if (appData.icsActive && (whosays == GE_ENGINE || whosays >= GE_ENGINE1)) {
8974         /* If we are playing on ICS, the server decides when the
8975            game is over, but the engine can offer to draw, claim
8976            a draw, or resign.
8977          */
8978 #if ZIPPY
8979         if (appData.zippyPlay && first.initDone) {
8980             if (result == GameIsDrawn) {
8981                 /* In case draw still needs to be claimed */
8982                 SendToICS(ics_prefix);
8983                 SendToICS("draw\n");
8984             } else if (StrCaseStr(resultDetails, "resign")) {
8985                 SendToICS(ics_prefix);
8986                 SendToICS("resign\n");
8987             }
8988         }
8989 #endif
8990         endingGame = 0; /* [HGM] crash */
8991         return;
8992     }
8993
8994     /* If we're loading the game from a file, stop */
8995     if (whosays == GE_FILE) {
8996       (void) StopLoadGameTimer();
8997       gameFileFP = NULL;
8998     }
8999
9000     /* Cancel draw offers */
9001     first.offeredDraw = second.offeredDraw = 0;
9002
9003     /* If this is an ICS game, only ICS can really say it's done;
9004        if not, anyone can. */
9005     isIcsGame = (gameMode == IcsPlayingWhite ||
9006                  gameMode == IcsPlayingBlack ||
9007                  gameMode == IcsObserving    ||
9008                  gameMode == IcsExamining);
9009
9010     if (!isIcsGame || whosays == GE_ICS) {
9011         /* OK -- not an ICS game, or ICS said it was done */
9012         StopClocks();
9013         if (!isIcsGame && !appData.noChessProgram)
9014           SetUserThinkingEnables();
9015
9016         /* [HGM] if a machine claims the game end we verify this claim */
9017         if(gameMode == TwoMachinesPlay && appData.testClaims) {
9018             if(appData.testLegality && whosays >= GE_ENGINE1 ) {
9019                 char claimer;
9020                 ChessMove trueResult = (ChessMove) -1;
9021
9022                 claimer = whosays == GE_ENGINE1 ?      /* color of claimer */
9023                                             first.twoMachinesColor[0] :
9024                                             second.twoMachinesColor[0] ;
9025
9026                 // [HGM] losers: because the logic is becoming a bit hairy, determine true result first
9027                 if((signed char)boards[forwardMostMove][EP_STATUS] == EP_CHECKMATE) {
9028                     /* [HGM] verify: engine mate claims accepted if they were flagged */
9029                     trueResult = WhiteOnMove(forwardMostMove) ? BlackWins : WhiteWins;
9030                 } else
9031                 if((signed char)boards[forwardMostMove][EP_STATUS] == EP_WINS) { // added code for games where being mated is a win
9032                     /* [HGM] verify: engine mate claims accepted if they were flagged */
9033                     trueResult = WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins;
9034                 } else
9035                 if((signed char)boards[forwardMostMove][EP_STATUS] == EP_STALEMATE) { // only used to indicate draws now
9036                     trueResult = GameIsDrawn; // default; in variants where stalemate loses, Status is CHECKMATE
9037                 }
9038
9039                 // now verify win claims, but not in drop games, as we don't understand those yet
9040                 if( (gameInfo.holdingsWidth == 0 || gameInfo.variant == VariantSuper
9041                                                  || gameInfo.variant == VariantGreat) &&
9042                     (result == WhiteWins && claimer == 'w' ||
9043                      result == BlackWins && claimer == 'b'   ) ) { // case to verify: engine claims own win
9044                       if (appData.debugMode) {
9045                         fprintf(debugFP, "result=%d sp=%d move=%d\n",
9046                                 result, (signed char)boards[forwardMostMove][EP_STATUS], forwardMostMove);
9047                       }
9048                       if(result != trueResult) {
9049                               sprintf(buf, "False win claim: '%s'", resultDetails);
9050                               result = claimer == 'w' ? BlackWins : WhiteWins;
9051                               resultDetails = buf;
9052                       }
9053                 } else
9054                 if( result == GameIsDrawn && (signed char)boards[forwardMostMove][EP_STATUS] > EP_DRAWS
9055                     && (forwardMostMove <= backwardMostMove ||
9056                         (signed char)boards[forwardMostMove-1][EP_STATUS] > EP_DRAWS ||
9057                         (claimer=='b')==(forwardMostMove&1))
9058                                                                                   ) {
9059                       /* [HGM] verify: draws that were not flagged are false claims */
9060                       sprintf(buf, "False draw claim: '%s'", resultDetails);
9061                       result = claimer == 'w' ? BlackWins : WhiteWins;
9062                       resultDetails = buf;
9063                 }
9064                 /* (Claiming a loss is accepted no questions asked!) */
9065             }
9066             /* [HGM] bare: don't allow bare King to win */
9067             if((gameInfo.holdingsWidth == 0 || gameInfo.variant == VariantSuper || gameInfo.variant == VariantGreat)
9068                && gameInfo.variant != VariantLosers && gameInfo.variant != VariantGiveaway
9069                && gameInfo.variant != VariantSuicide // [HGM] losers: except in losers, of course...
9070                && result != GameIsDrawn)
9071             {   int i, j, k=0, color = (result==WhiteWins ? (int)WhitePawn : (int)BlackPawn);
9072                 for(j=BOARD_LEFT; j<BOARD_RGHT; j++) for(i=0; i<BOARD_HEIGHT; i++) {
9073                         int p = (signed char)boards[forwardMostMove][i][j] - color;
9074                         if(p >= 0 && p <= (int)WhiteKing) k++;
9075                 }
9076                 if (appData.debugMode) {
9077                      fprintf(debugFP, "GE(%d, %s, %d) bare king k=%d color=%d\n",
9078                         result, resultDetails ? resultDetails : "(null)", whosays, k, color);
9079                 }
9080                 if(k <= 1) {
9081                         result = GameIsDrawn;
9082                         sprintf(buf, "%s but bare king", resultDetails);
9083                         resultDetails = buf;
9084                 }
9085             }
9086         }
9087
9088
9089         if(serverMoves != NULL && !loadFlag) { char c = '=';
9090             if(result==WhiteWins) c = '+';
9091             if(result==BlackWins) c = '-';
9092             if(resultDetails != NULL)
9093                 fprintf(serverMoves, ";%c;%s\n", c, resultDetails);
9094         }
9095         if (resultDetails != NULL) {
9096             gameInfo.result = result;
9097             gameInfo.resultDetails = StrSave(resultDetails);
9098
9099             /* display last move only if game was not loaded from file */
9100             if ((whosays != GE_FILE) && (currentMove == forwardMostMove))
9101                 DisplayMove(currentMove - 1);
9102
9103             if (forwardMostMove != 0) {
9104                 if (gameMode != PlayFromGameFile && gameMode != EditGame
9105                     && lastSavedGame != GameCheckSum() // [HGM] save: suppress duplicates
9106                                                                 ) {
9107                     if (*appData.saveGameFile != NULLCHAR) {
9108                         SaveGameToFile(appData.saveGameFile, TRUE);
9109                     } else if (appData.autoSaveGames) {
9110                         AutoSaveGame();
9111                     }
9112                     if (*appData.savePositionFile != NULLCHAR) {
9113                         SavePositionToFile(appData.savePositionFile);
9114                     }
9115                 }
9116             }
9117
9118             /* Tell program how game ended in case it is learning */
9119             /* [HGM] Moved this to after saving the PGN, just in case */
9120             /* engine died and we got here through time loss. In that */
9121             /* case we will get a fatal error writing the pipe, which */
9122             /* would otherwise lose us the PGN.                       */
9123             /* [HGM] crash: not needed anymore, but doesn't hurt;     */
9124             /* output during GameEnds should never be fatal anymore   */
9125             if (gameMode == MachinePlaysWhite ||
9126                 gameMode == MachinePlaysBlack ||
9127                 gameMode == TwoMachinesPlay ||
9128                 gameMode == IcsPlayingWhite ||
9129                 gameMode == IcsPlayingBlack ||
9130                 gameMode == BeginningOfGame) {
9131                 char buf[MSG_SIZ];
9132                 sprintf(buf, "result %s {%s}\n", PGNResult(result),
9133                         resultDetails);
9134                 if (first.pr != NoProc) {
9135                     SendToProgram(buf, &first);
9136                 }
9137                 if (second.pr != NoProc &&
9138                     gameMode == TwoMachinesPlay) {
9139                     SendToProgram(buf, &second);
9140                 }
9141             }
9142         }
9143
9144         if (appData.icsActive) {
9145             if (appData.quietPlay &&
9146                 (gameMode == IcsPlayingWhite ||
9147                  gameMode == IcsPlayingBlack)) {
9148                 SendToICS(ics_prefix);
9149                 SendToICS("set shout 1\n");
9150             }
9151             nextGameMode = IcsIdle;
9152             ics_user_moved = FALSE;
9153             /* clean up premove.  It's ugly when the game has ended and the
9154              * premove highlights are still on the board.
9155              */
9156             if (gotPremove) {
9157               gotPremove = FALSE;
9158               ClearPremoveHighlights();
9159               DrawPosition(FALSE, boards[currentMove]);
9160             }
9161             if (whosays == GE_ICS) {
9162                 switch (result) {
9163                 case WhiteWins:
9164                     if (gameMode == IcsPlayingWhite)
9165                         PlayIcsWinSound();
9166                     else if(gameMode == IcsPlayingBlack)
9167                         PlayIcsLossSound();
9168                     break;
9169                 case BlackWins:
9170                     if (gameMode == IcsPlayingBlack)
9171                         PlayIcsWinSound();
9172                     else if(gameMode == IcsPlayingWhite)
9173                         PlayIcsLossSound();
9174                     break;
9175                 case GameIsDrawn:
9176                     PlayIcsDrawSound();
9177                     break;
9178                 default:
9179                     PlayIcsUnfinishedSound();
9180                 }
9181             }
9182         } else if (gameMode == EditGame ||
9183                    gameMode == PlayFromGameFile ||
9184                    gameMode == AnalyzeMode ||
9185                    gameMode == AnalyzeFile) {
9186             nextGameMode = gameMode;
9187         } else {
9188             nextGameMode = EndOfGame;
9189         }
9190         pausing = FALSE;
9191         ModeHighlight();
9192     } else {
9193         nextGameMode = gameMode;
9194     }
9195
9196     if (appData.noChessProgram) {
9197         gameMode = nextGameMode;
9198         ModeHighlight();
9199         endingGame = 0; /* [HGM] crash */
9200         return;
9201     }
9202
9203     if (first.reuse) {
9204         /* Put first chess program into idle state */
9205         if (first.pr != NoProc &&
9206             (gameMode == MachinePlaysWhite ||
9207              gameMode == MachinePlaysBlack ||
9208              gameMode == TwoMachinesPlay ||
9209              gameMode == IcsPlayingWhite ||
9210              gameMode == IcsPlayingBlack ||
9211              gameMode == BeginningOfGame)) {
9212             SendToProgram("force\n", &first);
9213             if (first.usePing) {
9214               char buf[MSG_SIZ];
9215               sprintf(buf, "ping %d\n", ++first.lastPing);
9216               SendToProgram(buf, &first);
9217             }
9218         }
9219     } else if (result != GameUnfinished || nextGameMode == IcsIdle) {
9220         /* Kill off first chess program */
9221         if (first.isr != NULL)
9222           RemoveInputSource(first.isr);
9223         first.isr = NULL;
9224
9225         if (first.pr != NoProc) {
9226             ExitAnalyzeMode();
9227             DoSleep( appData.delayBeforeQuit );
9228             SendToProgram("quit\n", &first);
9229             DoSleep( appData.delayAfterQuit );
9230             DestroyChildProcess(first.pr, first.useSigterm);
9231         }
9232         first.pr = NoProc;
9233     }
9234     if (second.reuse) {
9235         /* Put second chess program into idle state */
9236         if (second.pr != NoProc &&
9237             gameMode == TwoMachinesPlay) {
9238             SendToProgram("force\n", &second);
9239             if (second.usePing) {
9240               char buf[MSG_SIZ];
9241               sprintf(buf, "ping %d\n", ++second.lastPing);
9242               SendToProgram(buf, &second);
9243             }
9244         }
9245     } else if (result != GameUnfinished || nextGameMode == IcsIdle) {
9246         /* Kill off second chess program */
9247         if (second.isr != NULL)
9248           RemoveInputSource(second.isr);
9249         second.isr = NULL;
9250
9251         if (second.pr != NoProc) {
9252             DoSleep( appData.delayBeforeQuit );
9253             SendToProgram("quit\n", &second);
9254             DoSleep( appData.delayAfterQuit );
9255             DestroyChildProcess(second.pr, second.useSigterm);
9256         }
9257         second.pr = NoProc;
9258     }
9259
9260     if (matchMode && gameMode == TwoMachinesPlay) {
9261         switch (result) {
9262         case WhiteWins:
9263           if (first.twoMachinesColor[0] == 'w') {
9264             first.matchWins++;
9265           } else {
9266             second.matchWins++;
9267           }
9268           break;
9269         case BlackWins:
9270           if (first.twoMachinesColor[0] == 'b') {
9271             first.matchWins++;
9272           } else {
9273             second.matchWins++;
9274           }
9275           break;
9276         default:
9277           break;
9278         }
9279         if (matchGame < appData.matchGames) {
9280             char *tmp;
9281             if(appData.sameColorGames <= 1) { /* [HGM] alternate: suppress color swap */
9282                 tmp = first.twoMachinesColor;
9283                 first.twoMachinesColor = second.twoMachinesColor;
9284                 second.twoMachinesColor = tmp;
9285             }
9286             gameMode = nextGameMode;
9287             matchGame++;
9288             if(appData.matchPause>10000 || appData.matchPause<10)
9289                 appData.matchPause = 10000; /* [HGM] make pause adjustable */
9290             ScheduleDelayedEvent(NextMatchGame, appData.matchPause);
9291             endingGame = 0; /* [HGM] crash */
9292             return;
9293         } else {
9294             char buf[MSG_SIZ];
9295             gameMode = nextGameMode;
9296             sprintf(buf, _("Match %s vs. %s: final score %d-%d-%d"),
9297                     first.tidy, second.tidy,
9298                     first.matchWins, second.matchWins,
9299                     appData.matchGames - (first.matchWins + second.matchWins));
9300             DisplayFatalError(buf, 0, 0);
9301         }
9302     }
9303     if ((gameMode == AnalyzeMode || gameMode == AnalyzeFile) &&
9304         !(nextGameMode == AnalyzeMode || nextGameMode == AnalyzeFile))
9305       ExitAnalyzeMode();
9306     gameMode = nextGameMode;
9307     ModeHighlight();
9308     endingGame = 0;  /* [HGM] crash */
9309 }
9310
9311 /* Assumes program was just initialized (initString sent).
9312    Leaves program in force mode. */
9313 void
9314 FeedMovesToProgram(cps, upto)
9315      ChessProgramState *cps;
9316      int upto;
9317 {
9318     int i;
9319
9320     if (appData.debugMode)
9321       fprintf(debugFP, "Feeding %smoves %d through %d to %s chess program\n",
9322               startedFromSetupPosition ? "position and " : "",
9323               backwardMostMove, upto, cps->which);
9324     if(currentlyInitializedVariant != gameInfo.variant) { char buf[MSG_SIZ];
9325         // [HGM] variantswitch: make engine aware of new variant
9326         if(cps->protocolVersion > 1 && StrStr(cps->variants, VariantName(gameInfo.variant)) == NULL)
9327                 return; // [HGM] refrain from feeding moves altogether if variant is unsupported!
9328         sprintf(buf, "variant %s\n", VariantName(gameInfo.variant));
9329         SendToProgram(buf, cps);
9330         currentlyInitializedVariant = gameInfo.variant;
9331     }
9332     SendToProgram("force\n", cps);
9333     if (startedFromSetupPosition) {
9334         SendBoard(cps, backwardMostMove);
9335     if (appData.debugMode) {
9336         fprintf(debugFP, "feedMoves\n");
9337     }
9338     }
9339     for (i = backwardMostMove; i < upto; i++) {
9340         SendMoveToProgram(i, cps);
9341     }
9342 }
9343
9344
9345 void
9346 ResurrectChessProgram()
9347 {
9348      /* The chess program may have exited.
9349         If so, restart it and feed it all the moves made so far. */
9350
9351     if (appData.noChessProgram || first.pr != NoProc) return;
9352
9353     StartChessProgram(&first);
9354     InitChessProgram(&first, FALSE);
9355     FeedMovesToProgram(&first, currentMove);
9356
9357     if (!first.sendTime) {
9358         /* can't tell gnuchess what its clock should read,
9359            so we bow to its notion. */
9360         ResetClocks();
9361         timeRemaining[0][currentMove] = whiteTimeRemaining;
9362         timeRemaining[1][currentMove] = blackTimeRemaining;
9363     }
9364
9365     if ((gameMode == AnalyzeMode || gameMode == AnalyzeFile ||
9366                 appData.icsEngineAnalyze) && first.analysisSupport) {
9367       SendToProgram("analyze\n", &first);
9368       first.analyzing = TRUE;
9369     }
9370 }
9371
9372 /*
9373  * Button procedures
9374  */
9375 void
9376 Reset(redraw, init)
9377      int redraw, init;
9378 {
9379     int i;
9380
9381     if (appData.debugMode) {
9382         fprintf(debugFP, "Reset(%d, %d) from gameMode %d\n",
9383                 redraw, init, gameMode);
9384     }
9385     CleanupTail(); // [HGM] vari: delete any stored variations
9386     pausing = pauseExamInvalid = FALSE;
9387     startedFromSetupPosition = blackPlaysFirst = FALSE;
9388     firstMove = TRUE;
9389     whiteFlag = blackFlag = FALSE;
9390     userOfferedDraw = FALSE;
9391     hintRequested = bookRequested = FALSE;
9392     first.maybeThinking = FALSE;
9393     second.maybeThinking = FALSE;
9394     first.bookSuspend = FALSE; // [HGM] book
9395     second.bookSuspend = FALSE;
9396     thinkOutput[0] = NULLCHAR;
9397     lastHint[0] = NULLCHAR;
9398     ClearGameInfo(&gameInfo);
9399     gameInfo.variant = StringToVariant(appData.variant);
9400     ics_user_moved = ics_clock_paused = FALSE;
9401     ics_getting_history = H_FALSE;
9402     ics_gamenum = -1;
9403     white_holding[0] = black_holding[0] = NULLCHAR;
9404     ClearProgramStats();
9405     opponentKibitzes = FALSE; // [HGM] kibitz: do not reserve space in engine-output window in zippy mode
9406
9407     ResetFrontEnd();
9408     ClearHighlights();
9409     flipView = appData.flipView;
9410     ClearPremoveHighlights();
9411     gotPremove = FALSE;
9412     alarmSounded = FALSE;
9413
9414     GameEnds((ChessMove) 0, NULL, GE_PLAYER);
9415     if(appData.serverMovesName != NULL) {
9416         /* [HGM] prepare to make moves file for broadcasting */
9417         clock_t t = clock();
9418         if(serverMoves != NULL) fclose(serverMoves);
9419         serverMoves = fopen(appData.serverMovesName, "r");
9420         if(serverMoves != NULL) {
9421             fclose(serverMoves);
9422             /* delay 15 sec before overwriting, so all clients can see end */
9423             while(clock()-t < appData.serverPause*CLOCKS_PER_SEC);
9424         }
9425         serverMoves = fopen(appData.serverMovesName, "w");
9426     }
9427
9428     ExitAnalyzeMode();
9429     gameMode = BeginningOfGame;
9430     ModeHighlight();
9431     if(appData.icsActive) gameInfo.variant = VariantNormal;
9432     currentMove = forwardMostMove = backwardMostMove = 0;
9433     InitPosition(redraw);
9434     for (i = 0; i < MAX_MOVES; i++) {
9435         if (commentList[i] != NULL) {
9436             free(commentList[i]);
9437             commentList[i] = NULL;
9438         }
9439     }
9440     ResetClocks();
9441     timeRemaining[0][0] = whiteTimeRemaining;
9442     timeRemaining[1][0] = blackTimeRemaining;
9443     if (first.pr == NULL) {
9444         StartChessProgram(&first);
9445     }
9446     if (init) {
9447             InitChessProgram(&first, startedFromSetupPosition);
9448     }
9449     DisplayTitle("");
9450     DisplayMessage("", "");
9451     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
9452     lastSavedGame = 0; // [HGM] save: make sure next game counts as unsaved
9453 }
9454
9455 void
9456 AutoPlayGameLoop()
9457 {
9458     for (;;) {
9459         if (!AutoPlayOneMove())
9460           return;
9461         if (matchMode || appData.timeDelay == 0)
9462           continue;
9463         if (appData.timeDelay < 0 || gameMode == AnalyzeFile)
9464           return;
9465         StartLoadGameTimer((long)(1000.0 * appData.timeDelay));
9466         break;
9467     }
9468 }
9469
9470
9471 int
9472 AutoPlayOneMove()
9473 {
9474     int fromX, fromY, toX, toY;
9475
9476     if (appData.debugMode) {
9477       fprintf(debugFP, "AutoPlayOneMove(): current %d\n", currentMove);
9478     }
9479
9480     if (gameMode != PlayFromGameFile)
9481       return FALSE;
9482
9483     if (currentMove >= forwardMostMove) {
9484       gameMode = EditGame;
9485       ModeHighlight();
9486
9487       /* [AS] Clear current move marker at the end of a game */
9488       /* HistorySet(parseList, backwardMostMove, forwardMostMove, -1); */
9489
9490       return FALSE;
9491     }
9492
9493     toX = moveList[currentMove][2] - AAA;
9494     toY = moveList[currentMove][3] - ONE;
9495
9496     if (moveList[currentMove][1] == '@') {
9497         if (appData.highlightLastMove) {
9498             SetHighlights(-1, -1, toX, toY);
9499         }
9500     } else {
9501         fromX = moveList[currentMove][0] - AAA;
9502         fromY = moveList[currentMove][1] - ONE;
9503
9504         HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove); /* [AS] */
9505
9506         AnimateMove(boards[currentMove], fromX, fromY, toX, toY);
9507
9508         if (appData.highlightLastMove) {
9509             SetHighlights(fromX, fromY, toX, toY);
9510         }
9511     }
9512     DisplayMove(currentMove);
9513     SendMoveToProgram(currentMove++, &first);
9514     DisplayBothClocks();
9515     DrawPosition(FALSE, boards[currentMove]);
9516     // [HGM] PV info: always display, routine tests if empty
9517     DisplayComment(currentMove - 1, commentList[currentMove]);
9518     return TRUE;
9519 }
9520
9521
9522 int
9523 LoadGameOneMove(readAhead)
9524      ChessMove readAhead;
9525 {
9526     int fromX = 0, fromY = 0, toX = 0, toY = 0, done;
9527     char promoChar = NULLCHAR;
9528     ChessMove moveType;
9529     char move[MSG_SIZ];
9530     char *p, *q;
9531
9532     if (gameMode != PlayFromGameFile && gameMode != AnalyzeFile &&
9533         gameMode != AnalyzeMode && gameMode != Training) {
9534         gameFileFP = NULL;
9535         return FALSE;
9536     }
9537
9538     yyboardindex = forwardMostMove;
9539     if (readAhead != (ChessMove)0) {
9540       moveType = readAhead;
9541     } else {
9542       if (gameFileFP == NULL)
9543           return FALSE;
9544       moveType = (ChessMove) yylex();
9545     }
9546
9547     done = FALSE;
9548     switch (moveType) {
9549       case Comment:
9550         if (appData.debugMode)
9551           fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
9552         p = yy_text;
9553
9554         /* append the comment but don't display it */
9555         AppendComment(currentMove, p, FALSE);
9556         return TRUE;
9557
9558       case WhiteCapturesEnPassant:
9559       case BlackCapturesEnPassant:
9560       case WhitePromotionChancellor:
9561       case BlackPromotionChancellor:
9562       case WhitePromotionArchbishop:
9563       case BlackPromotionArchbishop:
9564       case WhitePromotionCentaur:
9565       case BlackPromotionCentaur:
9566       case WhitePromotionQueen:
9567       case BlackPromotionQueen:
9568       case WhitePromotionRook:
9569       case BlackPromotionRook:
9570       case WhitePromotionBishop:
9571       case BlackPromotionBishop:
9572       case WhitePromotionKnight:
9573       case BlackPromotionKnight:
9574       case WhitePromotionKing:
9575       case BlackPromotionKing:
9576       case NormalMove:
9577       case WhiteKingSideCastle:
9578       case WhiteQueenSideCastle:
9579       case BlackKingSideCastle:
9580       case BlackQueenSideCastle:
9581       case WhiteKingSideCastleWild:
9582       case WhiteQueenSideCastleWild:
9583       case BlackKingSideCastleWild:
9584       case BlackQueenSideCastleWild:
9585       /* PUSH Fabien */
9586       case WhiteHSideCastleFR:
9587       case WhiteASideCastleFR:
9588       case BlackHSideCastleFR:
9589       case BlackASideCastleFR:
9590       /* POP Fabien */
9591         if (appData.debugMode)
9592           fprintf(debugFP, "Parsed %s into %s\n", yy_text, currentMoveString);
9593         fromX = currentMoveString[0] - AAA;
9594         fromY = currentMoveString[1] - ONE;
9595         toX = currentMoveString[2] - AAA;
9596         toY = currentMoveString[3] - ONE;
9597         promoChar = currentMoveString[4];
9598         break;
9599
9600       case WhiteDrop:
9601       case BlackDrop:
9602         if (appData.debugMode)
9603           fprintf(debugFP, "Parsed %s into %s\n", yy_text, currentMoveString);
9604         fromX = moveType == WhiteDrop ?
9605           (int) CharToPiece(ToUpper(currentMoveString[0])) :
9606         (int) CharToPiece(ToLower(currentMoveString[0]));
9607         fromY = DROP_RANK;
9608         toX = currentMoveString[2] - AAA;
9609         toY = currentMoveString[3] - ONE;
9610         break;
9611
9612       case WhiteWins:
9613       case BlackWins:
9614       case GameIsDrawn:
9615       case GameUnfinished:
9616         if (appData.debugMode)
9617           fprintf(debugFP, "Parsed game end: %s\n", yy_text);
9618         p = strchr(yy_text, '{');
9619         if (p == NULL) p = strchr(yy_text, '(');
9620         if (p == NULL) {
9621             p = yy_text;
9622             if (p[0] == '0' || p[0] == '1' || p[0] == '*') p = "";
9623         } else {
9624             q = strchr(p, *p == '{' ? '}' : ')');
9625             if (q != NULL) *q = NULLCHAR;
9626             p++;
9627         }
9628         GameEnds(moveType, p, GE_FILE);
9629         done = TRUE;
9630         if (cmailMsgLoaded) {
9631             ClearHighlights();
9632             flipView = WhiteOnMove(currentMove);
9633             if (moveType == GameUnfinished) flipView = !flipView;
9634             if (appData.debugMode)
9635               fprintf(debugFP, "Setting flipView to %d\n", flipView) ;
9636         }
9637         break;
9638
9639       case (ChessMove) 0:       /* end of file */
9640         if (appData.debugMode)
9641           fprintf(debugFP, "Parser hit end of file\n");
9642         switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
9643           case MT_NONE:
9644           case MT_CHECK:
9645             break;
9646           case MT_CHECKMATE:
9647           case MT_STAINMATE:
9648             if (WhiteOnMove(currentMove)) {
9649                 GameEnds(BlackWins, "Black mates", GE_FILE);
9650             } else {
9651                 GameEnds(WhiteWins, "White mates", GE_FILE);
9652             }
9653             break;
9654           case MT_STALEMATE:
9655             GameEnds(GameIsDrawn, "Stalemate", GE_FILE);
9656             break;
9657         }
9658         done = TRUE;
9659         break;
9660
9661       case MoveNumberOne:
9662         if (lastLoadGameStart == GNUChessGame) {
9663             /* GNUChessGames have numbers, but they aren't move numbers */
9664             if (appData.debugMode)
9665               fprintf(debugFP, "Parser ignoring: '%s' (%d)\n",
9666                       yy_text, (int) moveType);
9667             return LoadGameOneMove((ChessMove)0); /* tail recursion */
9668         }
9669         /* else fall thru */
9670
9671       case XBoardGame:
9672       case GNUChessGame:
9673       case PGNTag:
9674         /* Reached start of next game in file */
9675         if (appData.debugMode)
9676           fprintf(debugFP, "Parsed start of next game: %s\n", yy_text);
9677         switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
9678           case MT_NONE:
9679           case MT_CHECK:
9680             break;
9681           case MT_CHECKMATE:
9682           case MT_STAINMATE:
9683             if (WhiteOnMove(currentMove)) {
9684                 GameEnds(BlackWins, "Black mates", GE_FILE);
9685             } else {
9686                 GameEnds(WhiteWins, "White mates", GE_FILE);
9687             }
9688             break;
9689           case MT_STALEMATE:
9690             GameEnds(GameIsDrawn, "Stalemate", GE_FILE);
9691             break;
9692         }
9693         done = TRUE;
9694         break;
9695
9696       case PositionDiagram:     /* should not happen; ignore */
9697       case ElapsedTime:         /* ignore */
9698       case NAG:                 /* ignore */
9699         if (appData.debugMode)
9700           fprintf(debugFP, "Parser ignoring: '%s' (%d)\n",
9701                   yy_text, (int) moveType);
9702         return LoadGameOneMove((ChessMove)0); /* tail recursion */
9703
9704       case IllegalMove:
9705         if (appData.testLegality) {
9706             if (appData.debugMode)
9707               fprintf(debugFP, "Parsed IllegalMove: %s\n", yy_text);
9708             sprintf(move, _("Illegal move: %d.%s%s"),
9709                     (forwardMostMove / 2) + 1,
9710                     WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
9711             DisplayError(move, 0);
9712             done = TRUE;
9713         } else {
9714             if (appData.debugMode)
9715               fprintf(debugFP, "Parsed %s into IllegalMove %s\n",
9716                       yy_text, currentMoveString);
9717             fromX = currentMoveString[0] - AAA;
9718             fromY = currentMoveString[1] - ONE;
9719             toX = currentMoveString[2] - AAA;
9720             toY = currentMoveString[3] - ONE;
9721             promoChar = currentMoveString[4];
9722         }
9723         break;
9724
9725       case AmbiguousMove:
9726         if (appData.debugMode)
9727           fprintf(debugFP, "Parsed AmbiguousMove: %s\n", yy_text);
9728         sprintf(move, _("Ambiguous move: %d.%s%s"),
9729                 (forwardMostMove / 2) + 1,
9730                 WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
9731         DisplayError(move, 0);
9732         done = TRUE;
9733         break;
9734
9735       default:
9736       case ImpossibleMove:
9737         if (appData.debugMode)
9738           fprintf(debugFP, "Parsed ImpossibleMove (type = %d): %s\n", moveType, yy_text);
9739         sprintf(move, _("Illegal move: %d.%s%s"),
9740                 (forwardMostMove / 2) + 1,
9741                 WhiteOnMove(forwardMostMove) ? " " : ".. ", yy_text);
9742         DisplayError(move, 0);
9743         done = TRUE;
9744         break;
9745     }
9746
9747     if (done) {
9748         if (appData.matchMode || (appData.timeDelay == 0 && !pausing)) {
9749             DrawPosition(FALSE, boards[currentMove]);
9750             DisplayBothClocks();
9751             if (!appData.matchMode) // [HGM] PV info: routine tests if empty
9752               DisplayComment(currentMove - 1, commentList[currentMove]);
9753         }
9754         (void) StopLoadGameTimer();
9755         gameFileFP = NULL;
9756         cmailOldMove = forwardMostMove;
9757         return FALSE;
9758     } else {
9759         /* currentMoveString is set as a side-effect of yylex */
9760         strcat(currentMoveString, "\n");
9761         strcpy(moveList[forwardMostMove], currentMoveString);
9762
9763         thinkOutput[0] = NULLCHAR;
9764         MakeMove(fromX, fromY, toX, toY, promoChar);
9765         currentMove = forwardMostMove;
9766         return TRUE;
9767     }
9768 }
9769
9770 /* Load the nth game from the given file */
9771 int
9772 LoadGameFromFile(filename, n, title, useList)
9773      char *filename;
9774      int n;
9775      char *title;
9776      /*Boolean*/ int useList;
9777 {
9778     FILE *f;
9779     char buf[MSG_SIZ];
9780
9781     if (strcmp(filename, "-") == 0) {
9782         f = stdin;
9783         title = "stdin";
9784     } else {
9785         f = fopen(filename, "rb");
9786         if (f == NULL) {
9787           snprintf(buf, sizeof(buf),  _("Can't open \"%s\""), filename);
9788             DisplayError(buf, errno);
9789             return FALSE;
9790         }
9791     }
9792     if (fseek(f, 0, 0) == -1) {
9793         /* f is not seekable; probably a pipe */
9794         useList = FALSE;
9795     }
9796     if (useList && n == 0) {
9797         int error = GameListBuild(f);
9798         if (error) {
9799             DisplayError(_("Cannot build game list"), error);
9800         } else if (!ListEmpty(&gameList) &&
9801                    ((ListGame *) gameList.tailPred)->number > 1) {
9802             GameListPopUp(f, title);
9803             return TRUE;
9804         }
9805         GameListDestroy();
9806         n = 1;
9807     }
9808     if (n == 0) n = 1;
9809     return LoadGame(f, n, title, FALSE);
9810 }
9811
9812
9813 void
9814 MakeRegisteredMove()
9815 {
9816     int fromX, fromY, toX, toY;
9817     char promoChar;
9818     if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
9819         switch (cmailMoveType[lastLoadGameNumber - 1]) {
9820           case CMAIL_MOVE:
9821           case CMAIL_DRAW:
9822             if (appData.debugMode)
9823               fprintf(debugFP, "Restoring %s for game %d\n",
9824                       cmailMove[lastLoadGameNumber - 1], lastLoadGameNumber);
9825
9826             thinkOutput[0] = NULLCHAR;
9827             strcpy(moveList[currentMove], cmailMove[lastLoadGameNumber - 1]);
9828             fromX = cmailMove[lastLoadGameNumber - 1][0] - AAA;
9829             fromY = cmailMove[lastLoadGameNumber - 1][1] - ONE;
9830             toX = cmailMove[lastLoadGameNumber - 1][2] - AAA;
9831             toY = cmailMove[lastLoadGameNumber - 1][3] - ONE;
9832             promoChar = cmailMove[lastLoadGameNumber - 1][4];
9833             MakeMove(fromX, fromY, toX, toY, promoChar);
9834             ShowMove(fromX, fromY, toX, toY);
9835
9836             switch (MateTest(boards[currentMove], PosFlags(currentMove)) ) {
9837               case MT_NONE:
9838               case MT_CHECK:
9839                 break;
9840
9841               case MT_CHECKMATE:
9842               case MT_STAINMATE:
9843                 if (WhiteOnMove(currentMove)) {
9844                     GameEnds(BlackWins, "Black mates", GE_PLAYER);
9845                 } else {
9846                     GameEnds(WhiteWins, "White mates", GE_PLAYER);
9847                 }
9848                 break;
9849
9850               case MT_STALEMATE:
9851                 GameEnds(GameIsDrawn, "Stalemate", GE_PLAYER);
9852                 break;
9853             }
9854
9855             break;
9856
9857           case CMAIL_RESIGN:
9858             if (WhiteOnMove(currentMove)) {
9859                 GameEnds(BlackWins, "White resigns", GE_PLAYER);
9860             } else {
9861                 GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
9862             }
9863             break;
9864
9865           case CMAIL_ACCEPT:
9866             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
9867             break;
9868
9869           default:
9870             break;
9871         }
9872     }
9873
9874     return;
9875 }
9876
9877 /* Wrapper around LoadGame for use when a Cmail message is loaded */
9878 int
9879 CmailLoadGame(f, gameNumber, title, useList)
9880      FILE *f;
9881      int gameNumber;
9882      char *title;
9883      int useList;
9884 {
9885     int retVal;
9886
9887     if (gameNumber > nCmailGames) {
9888         DisplayError(_("No more games in this message"), 0);
9889         return FALSE;
9890     }
9891     if (f == lastLoadGameFP) {
9892         int offset = gameNumber - lastLoadGameNumber;
9893         if (offset == 0) {
9894             cmailMsg[0] = NULLCHAR;
9895             if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
9896                 cmailMoveRegistered[lastLoadGameNumber - 1] = FALSE;
9897                 nCmailMovesRegistered--;
9898             }
9899             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
9900             if (cmailResult[lastLoadGameNumber - 1] == CMAIL_NEW_RESULT) {
9901                 cmailResult[lastLoadGameNumber - 1] = CMAIL_NOT_RESULT;
9902             }
9903         } else {
9904             if (! RegisterMove()) return FALSE;
9905         }
9906     }
9907
9908     retVal = LoadGame(f, gameNumber, title, useList);
9909
9910     /* Make move registered during previous look at this game, if any */
9911     MakeRegisteredMove();
9912
9913     if (cmailCommentList[lastLoadGameNumber - 1] != NULL) {
9914         commentList[currentMove]
9915           = StrSave(cmailCommentList[lastLoadGameNumber - 1]);
9916         DisplayComment(currentMove - 1, commentList[currentMove]);
9917     }
9918
9919     return retVal;
9920 }
9921
9922 /* Support for LoadNextGame, LoadPreviousGame, ReloadSameGame */
9923 int
9924 ReloadGame(offset)
9925      int offset;
9926 {
9927     int gameNumber = lastLoadGameNumber + offset;
9928     if (lastLoadGameFP == NULL) {
9929         DisplayError(_("No game has been loaded yet"), 0);
9930         return FALSE;
9931     }
9932     if (gameNumber <= 0) {
9933         DisplayError(_("Can't back up any further"), 0);
9934         return FALSE;
9935     }
9936     if (cmailMsgLoaded) {
9937         return CmailLoadGame(lastLoadGameFP, gameNumber,
9938                              lastLoadGameTitle, lastLoadGameUseList);
9939     } else {
9940         return LoadGame(lastLoadGameFP, gameNumber,
9941                         lastLoadGameTitle, lastLoadGameUseList);
9942     }
9943 }
9944
9945
9946
9947 /* Load the nth game from open file f */
9948 int
9949 LoadGame(f, gameNumber, title, useList)
9950      FILE *f;
9951      int gameNumber;
9952      char *title;
9953      int useList;
9954 {
9955     ChessMove cm;
9956     char buf[MSG_SIZ];
9957     int gn = gameNumber;
9958     ListGame *lg = NULL;
9959     int numPGNTags = 0;
9960     int err;
9961     GameMode oldGameMode;
9962     VariantClass oldVariant = gameInfo.variant; /* [HGM] PGNvariant */
9963
9964     if (appData.debugMode)
9965         fprintf(debugFP, "LoadGame(): on entry, gameMode %d\n", gameMode);
9966
9967     if (gameMode == Training )
9968         SetTrainingModeOff();
9969
9970     oldGameMode = gameMode;
9971     if (gameMode != BeginningOfGame) {
9972       Reset(FALSE, TRUE);
9973     }
9974
9975     gameFileFP = f;
9976     if (lastLoadGameFP != NULL && lastLoadGameFP != f) {
9977         fclose(lastLoadGameFP);
9978     }
9979
9980     if (useList) {
9981         lg = (ListGame *) ListElem(&gameList, gameNumber-1);
9982
9983         if (lg) {
9984             fseek(f, lg->offset, 0);
9985             GameListHighlight(gameNumber);
9986             gn = 1;
9987         }
9988         else {
9989             DisplayError(_("Game number out of range"), 0);
9990             return FALSE;
9991         }
9992     } else {
9993         GameListDestroy();
9994         if (fseek(f, 0, 0) == -1) {
9995             if (f == lastLoadGameFP ?
9996                 gameNumber == lastLoadGameNumber + 1 :
9997                 gameNumber == 1) {
9998                 gn = 1;
9999             } else {
10000                 DisplayError(_("Can't seek on game file"), 0);
10001                 return FALSE;
10002             }
10003         }
10004     }
10005     lastLoadGameFP = f;
10006     lastLoadGameNumber = gameNumber;
10007     strcpy(lastLoadGameTitle, title);
10008     lastLoadGameUseList = useList;
10009
10010     yynewfile(f);
10011
10012     if (lg && lg->gameInfo.white && lg->gameInfo.black) {
10013       snprintf(buf, sizeof(buf), "%s vs. %s", lg->gameInfo.white,
10014                 lg->gameInfo.black);
10015             DisplayTitle(buf);
10016     } else if (*title != NULLCHAR) {
10017         if (gameNumber > 1) {
10018             sprintf(buf, "%s %d", title, gameNumber);
10019             DisplayTitle(buf);
10020         } else {
10021             DisplayTitle(title);
10022         }
10023     }
10024
10025     if (gameMode != AnalyzeFile && gameMode != AnalyzeMode) {
10026         gameMode = PlayFromGameFile;
10027         ModeHighlight();
10028     }
10029
10030     currentMove = forwardMostMove = backwardMostMove = 0;
10031     CopyBoard(boards[0], initialPosition);
10032     StopClocks();
10033
10034     /*
10035      * Skip the first gn-1 games in the file.
10036      * Also skip over anything that precedes an identifiable
10037      * start of game marker, to avoid being confused by
10038      * garbage at the start of the file.  Currently
10039      * recognized start of game markers are the move number "1",
10040      * the pattern "gnuchess .* game", the pattern
10041      * "^[#;%] [^ ]* game file", and a PGN tag block.
10042      * A game that starts with one of the latter two patterns
10043      * will also have a move number 1, possibly
10044      * following a position diagram.
10045      * 5-4-02: Let's try being more lenient and allowing a game to
10046      * start with an unnumbered move.  Does that break anything?
10047      */
10048     cm = lastLoadGameStart = (ChessMove) 0;
10049     while (gn > 0) {
10050         yyboardindex = forwardMostMove;
10051         cm = (ChessMove) yylex();
10052         switch (cm) {
10053           case (ChessMove) 0:
10054             if (cmailMsgLoaded) {
10055                 nCmailGames = CMAIL_MAX_GAMES - gn;
10056             } else {
10057                 Reset(TRUE, TRUE);
10058                 DisplayError(_("Game not found in file"), 0);
10059             }
10060             return FALSE;
10061
10062           case GNUChessGame:
10063           case XBoardGame:
10064             gn--;
10065             lastLoadGameStart = cm;
10066             break;
10067
10068           case MoveNumberOne:
10069             switch (lastLoadGameStart) {
10070               case GNUChessGame:
10071               case XBoardGame:
10072               case PGNTag:
10073                 break;
10074               case MoveNumberOne:
10075               case (ChessMove) 0:
10076                 gn--;           /* count this game */
10077                 lastLoadGameStart = cm;
10078                 break;
10079               default:
10080                 /* impossible */
10081                 break;
10082             }
10083             break;
10084
10085           case PGNTag:
10086             switch (lastLoadGameStart) {
10087               case GNUChessGame:
10088               case PGNTag:
10089               case MoveNumberOne:
10090               case (ChessMove) 0:
10091                 gn--;           /* count this game */
10092                 lastLoadGameStart = cm;
10093                 break;
10094               case XBoardGame:
10095                 lastLoadGameStart = cm; /* game counted already */
10096                 break;
10097               default:
10098                 /* impossible */
10099                 break;
10100             }
10101             if (gn > 0) {
10102                 do {
10103                     yyboardindex = forwardMostMove;
10104                     cm = (ChessMove) yylex();
10105                 } while (cm == PGNTag || cm == Comment);
10106             }
10107             break;
10108
10109           case WhiteWins:
10110           case BlackWins:
10111           case GameIsDrawn:
10112             if (cmailMsgLoaded && (CMAIL_MAX_GAMES == lastLoadGameNumber)) {
10113                 if (   cmailResult[CMAIL_MAX_GAMES - gn - 1]
10114                     != CMAIL_OLD_RESULT) {
10115                     nCmailResults ++ ;
10116                     cmailResult[  CMAIL_MAX_GAMES
10117                                 - gn - 1] = CMAIL_OLD_RESULT;
10118                 }
10119             }
10120             break;
10121
10122           case NormalMove:
10123             /* Only a NormalMove can be at the start of a game
10124              * without a position diagram. */
10125             if (lastLoadGameStart == (ChessMove) 0) {
10126               gn--;
10127               lastLoadGameStart = MoveNumberOne;
10128             }
10129             break;
10130
10131           default:
10132             break;
10133         }
10134     }
10135
10136     if (appData.debugMode)
10137       fprintf(debugFP, "Parsed game start '%s' (%d)\n", yy_text, (int) cm);
10138
10139     if (cm == XBoardGame) {
10140         /* Skip any header junk before position diagram and/or move 1 */
10141         for (;;) {
10142             yyboardindex = forwardMostMove;
10143             cm = (ChessMove) yylex();
10144
10145             if (cm == (ChessMove) 0 ||
10146                 cm == GNUChessGame || cm == XBoardGame) {
10147                 /* Empty game; pretend end-of-file and handle later */
10148                 cm = (ChessMove) 0;
10149                 break;
10150             }
10151
10152             if (cm == MoveNumberOne || cm == PositionDiagram ||
10153                 cm == PGNTag || cm == Comment)
10154               break;
10155         }
10156     } else if (cm == GNUChessGame) {
10157         if (gameInfo.event != NULL) {
10158             free(gameInfo.event);
10159         }
10160         gameInfo.event = StrSave(yy_text);
10161     }
10162
10163     startedFromSetupPosition = FALSE;
10164     while (cm == PGNTag) {
10165         if (appData.debugMode)
10166           fprintf(debugFP, "Parsed PGNTag: %s\n", yy_text);
10167         err = ParsePGNTag(yy_text, &gameInfo);
10168         if (!err) numPGNTags++;
10169
10170         /* [HGM] PGNvariant: automatically switch to variant given in PGN tag */
10171         if(gameInfo.variant != oldVariant) {
10172             startedFromPositionFile = FALSE; /* [HGM] loadPos: variant switch likely makes position invalid */
10173             InitPosition(TRUE);
10174             oldVariant = gameInfo.variant;
10175             if (appData.debugMode)
10176               fprintf(debugFP, "New variant %d\n", (int) oldVariant);
10177         }
10178
10179
10180         if (gameInfo.fen != NULL) {
10181           Board initial_position;
10182           startedFromSetupPosition = TRUE;
10183           if (!ParseFEN(initial_position, &blackPlaysFirst, gameInfo.fen)) {
10184             Reset(TRUE, TRUE);
10185             DisplayError(_("Bad FEN position in file"), 0);
10186             return FALSE;
10187           }
10188           CopyBoard(boards[0], initial_position);
10189           if (blackPlaysFirst) {
10190             currentMove = forwardMostMove = backwardMostMove = 1;
10191             CopyBoard(boards[1], initial_position);
10192             strcpy(moveList[0], "");
10193             strcpy(parseList[0], "");
10194             timeRemaining[0][1] = whiteTimeRemaining;
10195             timeRemaining[1][1] = blackTimeRemaining;
10196             if (commentList[0] != NULL) {
10197               commentList[1] = commentList[0];
10198               commentList[0] = NULL;
10199             }
10200           } else {
10201             currentMove = forwardMostMove = backwardMostMove = 0;
10202           }
10203           /* [HGM] copy FEN attributes as well. Bugfix 4.3.14m and 4.3.15e: moved to after 'blackPlaysFirst' */
10204           {   int i;
10205               initialRulePlies = FENrulePlies;
10206               for( i=0; i< nrCastlingRights; i++ )
10207                   initialRights[i] = initial_position[CASTLING][i];
10208           }
10209           yyboardindex = forwardMostMove;
10210           free(gameInfo.fen);
10211           gameInfo.fen = NULL;
10212         }
10213
10214         yyboardindex = forwardMostMove;
10215         cm = (ChessMove) yylex();
10216
10217         /* Handle comments interspersed among the tags */
10218         while (cm == Comment) {
10219             char *p;
10220             if (appData.debugMode)
10221               fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
10222             p = yy_text;
10223             AppendComment(currentMove, p, FALSE);
10224             yyboardindex = forwardMostMove;
10225             cm = (ChessMove) yylex();
10226         }
10227     }
10228
10229     /* don't rely on existence of Event tag since if game was
10230      * pasted from clipboard the Event tag may not exist
10231      */
10232     if (numPGNTags > 0){
10233         char *tags;
10234         if (gameInfo.variant == VariantNormal) {
10235           VariantClass v = StringToVariant(gameInfo.event);
10236           // [HGM] do not recognize variants from event tag that were introduced after supporting variant tag
10237           if(v < VariantShogi) gameInfo.variant = v;
10238         }
10239         if (!matchMode) {
10240           if( appData.autoDisplayTags ) {
10241             tags = PGNTags(&gameInfo);
10242             TagsPopUp(tags, CmailMsg());
10243             free(tags);
10244           }
10245         }
10246     } else {
10247         /* Make something up, but don't display it now */
10248         SetGameInfo();
10249         TagsPopDown();
10250     }
10251
10252     if (cm == PositionDiagram) {
10253         int i, j;
10254         char *p;
10255         Board initial_position;
10256
10257         if (appData.debugMode)
10258           fprintf(debugFP, "Parsed PositionDiagram: %s\n", yy_text);
10259
10260         if (!startedFromSetupPosition) {
10261             p = yy_text;
10262             for (i = BOARD_HEIGHT - 1; i >= 0; i--)
10263               for (j = BOARD_LEFT; j < BOARD_RGHT; p++)
10264                 switch (*p) {
10265                   case '[':
10266                   case '-':
10267                   case ' ':
10268                   case '\t':
10269                   case '\n':
10270                   case '\r':
10271                     break;
10272                   default:
10273                     initial_position[i][j++] = CharToPiece(*p);
10274                     break;
10275                 }
10276             while (*p == ' ' || *p == '\t' ||
10277                    *p == '\n' || *p == '\r') p++;
10278
10279             if (strncmp(p, "black", strlen("black"))==0)
10280               blackPlaysFirst = TRUE;
10281             else
10282               blackPlaysFirst = FALSE;
10283             startedFromSetupPosition = TRUE;
10284
10285             CopyBoard(boards[0], initial_position);
10286             if (blackPlaysFirst) {
10287                 currentMove = forwardMostMove = backwardMostMove = 1;
10288                 CopyBoard(boards[1], initial_position);
10289                 strcpy(moveList[0], "");
10290                 strcpy(parseList[0], "");
10291                 timeRemaining[0][1] = whiteTimeRemaining;
10292                 timeRemaining[1][1] = blackTimeRemaining;
10293                 if (commentList[0] != NULL) {
10294                     commentList[1] = commentList[0];
10295                     commentList[0] = NULL;
10296                 }
10297             } else {
10298                 currentMove = forwardMostMove = backwardMostMove = 0;
10299             }
10300         }
10301         yyboardindex = forwardMostMove;
10302         cm = (ChessMove) yylex();
10303     }
10304
10305     if (first.pr == NoProc) {
10306         StartChessProgram(&first);
10307     }
10308     InitChessProgram(&first, FALSE);
10309     SendToProgram("force\n", &first);
10310     if (startedFromSetupPosition) {
10311         SendBoard(&first, forwardMostMove);
10312     if (appData.debugMode) {
10313         fprintf(debugFP, "Load Game\n");
10314     }
10315         DisplayBothClocks();
10316     }
10317
10318     /* [HGM] server: flag to write setup moves in broadcast file as one */
10319     loadFlag = appData.suppressLoadMoves;
10320
10321     while (cm == Comment) {
10322         char *p;
10323         if (appData.debugMode)
10324           fprintf(debugFP, "Parsed Comment: %s\n", yy_text);
10325         p = yy_text;
10326         AppendComment(currentMove, p, FALSE);
10327         yyboardindex = forwardMostMove;
10328         cm = (ChessMove) yylex();
10329     }
10330
10331     if ((cm == (ChessMove) 0 && lastLoadGameStart != (ChessMove) 0) ||
10332         cm == WhiteWins || cm == BlackWins ||
10333         cm == GameIsDrawn || cm == GameUnfinished) {
10334         DisplayMessage("", _("No moves in game"));
10335         if (cmailMsgLoaded) {
10336             if (appData.debugMode)
10337               fprintf(debugFP, "Setting flipView to %d.\n", FALSE);
10338             ClearHighlights();
10339             flipView = FALSE;
10340         }
10341         DrawPosition(FALSE, boards[currentMove]);
10342         DisplayBothClocks();
10343         gameMode = EditGame;
10344         ModeHighlight();
10345         gameFileFP = NULL;
10346         cmailOldMove = 0;
10347         return TRUE;
10348     }
10349
10350     // [HGM] PV info: routine tests if comment empty
10351     if (!matchMode && (pausing || appData.timeDelay != 0)) {
10352         DisplayComment(currentMove - 1, commentList[currentMove]);
10353     }
10354     if (!matchMode && appData.timeDelay != 0)
10355       DrawPosition(FALSE, boards[currentMove]);
10356
10357     if (gameMode == AnalyzeFile || gameMode == AnalyzeMode) {
10358       programStats.ok_to_send = 1;
10359     }
10360
10361     /* if the first token after the PGN tags is a move
10362      * and not move number 1, retrieve it from the parser
10363      */
10364     if (cm != MoveNumberOne)
10365         LoadGameOneMove(cm);
10366
10367     /* load the remaining moves from the file */
10368     while (LoadGameOneMove((ChessMove)0)) {
10369       timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
10370       timeRemaining[1][forwardMostMove] = blackTimeRemaining;
10371     }
10372
10373     /* rewind to the start of the game */
10374     currentMove = backwardMostMove;
10375
10376     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
10377
10378     if (oldGameMode == AnalyzeFile ||
10379         oldGameMode == AnalyzeMode) {
10380       AnalyzeFileEvent();
10381     }
10382
10383     if (matchMode || appData.timeDelay == 0) {
10384       ToEndEvent();
10385       gameMode = EditGame;
10386       ModeHighlight();
10387     } else if (appData.timeDelay > 0) {
10388       AutoPlayGameLoop();
10389     }
10390
10391     if (appData.debugMode)
10392         fprintf(debugFP, "LoadGame(): on exit, gameMode %d\n", gameMode);
10393
10394     loadFlag = 0; /* [HGM] true game starts */
10395     return TRUE;
10396 }
10397
10398 /* Support for LoadNextPosition, LoadPreviousPosition, ReloadSamePosition */
10399 int
10400 ReloadPosition(offset)
10401      int offset;
10402 {
10403     int positionNumber = lastLoadPositionNumber + offset;
10404     if (lastLoadPositionFP == NULL) {
10405         DisplayError(_("No position has been loaded yet"), 0);
10406         return FALSE;
10407     }
10408     if (positionNumber <= 0) {
10409         DisplayError(_("Can't back up any further"), 0);
10410         return FALSE;
10411     }
10412     return LoadPosition(lastLoadPositionFP, positionNumber,
10413                         lastLoadPositionTitle);
10414 }
10415
10416 /* Load the nth position from the given file */
10417 int
10418 LoadPositionFromFile(filename, n, title)
10419      char *filename;
10420      int n;
10421      char *title;
10422 {
10423     FILE *f;
10424     char buf[MSG_SIZ];
10425
10426     if (strcmp(filename, "-") == 0) {
10427         return LoadPosition(stdin, n, "stdin");
10428     } else {
10429         f = fopen(filename, "rb");
10430         if (f == NULL) {
10431             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
10432             DisplayError(buf, errno);
10433             return FALSE;
10434         } else {
10435             return LoadPosition(f, n, title);
10436         }
10437     }
10438 }
10439
10440 /* Load the nth position from the given open file, and close it */
10441 int
10442 LoadPosition(f, positionNumber, title)
10443      FILE *f;
10444      int positionNumber;
10445      char *title;
10446 {
10447     char *p, line[MSG_SIZ];
10448     Board initial_position;
10449     int i, j, fenMode, pn;
10450
10451     if (gameMode == Training )
10452         SetTrainingModeOff();
10453
10454     if (gameMode != BeginningOfGame) {
10455         Reset(FALSE, TRUE);
10456     }
10457     if (lastLoadPositionFP != NULL && lastLoadPositionFP != f) {
10458         fclose(lastLoadPositionFP);
10459     }
10460     if (positionNumber == 0) positionNumber = 1;
10461     lastLoadPositionFP = f;
10462     lastLoadPositionNumber = positionNumber;
10463     strcpy(lastLoadPositionTitle, title);
10464     if (first.pr == NoProc) {
10465       StartChessProgram(&first);
10466       InitChessProgram(&first, FALSE);
10467     }
10468     pn = positionNumber;
10469     if (positionNumber < 0) {
10470         /* Negative position number means to seek to that byte offset */
10471         if (fseek(f, -positionNumber, 0) == -1) {
10472             DisplayError(_("Can't seek on position file"), 0);
10473             return FALSE;
10474         };
10475         pn = 1;
10476     } else {
10477         if (fseek(f, 0, 0) == -1) {
10478             if (f == lastLoadPositionFP ?
10479                 positionNumber == lastLoadPositionNumber + 1 :
10480                 positionNumber == 1) {
10481                 pn = 1;
10482             } else {
10483                 DisplayError(_("Can't seek on position file"), 0);
10484                 return FALSE;
10485             }
10486         }
10487     }
10488     /* See if this file is FEN or old-style xboard */
10489     if (fgets(line, MSG_SIZ, f) == NULL) {
10490         DisplayError(_("Position not found in file"), 0);
10491         return FALSE;
10492     }
10493     // [HGM] FEN can begin with digit, any piece letter valid in this variant, or a + for Shogi promoted pieces
10494     fenMode = line[0] >= '0' && line[0] <= '9' || line[0] == '+' || CharToPiece(line[0]) != EmptySquare;
10495
10496     if (pn >= 2) {
10497         if (fenMode || line[0] == '#') pn--;
10498         while (pn > 0) {
10499             /* skip positions before number pn */
10500             if (fgets(line, MSG_SIZ, f) == NULL) {
10501                 Reset(TRUE, TRUE);
10502                 DisplayError(_("Position not found in file"), 0);
10503                 return FALSE;
10504             }
10505             if (fenMode || line[0] == '#') pn--;
10506         }
10507     }
10508
10509     if (fenMode) {
10510         if (!ParseFEN(initial_position, &blackPlaysFirst, line)) {
10511             DisplayError(_("Bad FEN position in file"), 0);
10512             return FALSE;
10513         }
10514     } else {
10515         (void) fgets(line, MSG_SIZ, f);
10516         (void) fgets(line, MSG_SIZ, f);
10517
10518         for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
10519             (void) fgets(line, MSG_SIZ, f);
10520             for (p = line, j = BOARD_LEFT; j < BOARD_RGHT; p++) {
10521                 if (*p == ' ')
10522                   continue;
10523                 initial_position[i][j++] = CharToPiece(*p);
10524             }
10525         }
10526
10527         blackPlaysFirst = FALSE;
10528         if (!feof(f)) {
10529             (void) fgets(line, MSG_SIZ, f);
10530             if (strncmp(line, "black", strlen("black"))==0)
10531               blackPlaysFirst = TRUE;
10532         }
10533     }
10534     startedFromSetupPosition = TRUE;
10535
10536     SendToProgram("force\n", &first);
10537     CopyBoard(boards[0], initial_position);
10538     if (blackPlaysFirst) {
10539         currentMove = forwardMostMove = backwardMostMove = 1;
10540         strcpy(moveList[0], "");
10541         strcpy(parseList[0], "");
10542         CopyBoard(boards[1], initial_position);
10543         DisplayMessage("", _("Black to play"));
10544     } else {
10545         currentMove = forwardMostMove = backwardMostMove = 0;
10546         DisplayMessage("", _("White to play"));
10547     }
10548     initialRulePlies = FENrulePlies; /* [HGM] copy FEN attributes as well */
10549     SendBoard(&first, forwardMostMove);
10550     if (appData.debugMode) {
10551 int i, j;
10552   for(i=0;i<2;i++){for(j=0;j<6;j++)fprintf(debugFP, " %d", boards[i][CASTLING][j]);fprintf(debugFP,"\n");}
10553   for(j=0;j<6;j++)fprintf(debugFP, " %d", initialRights[j]);fprintf(debugFP,"\n");
10554         fprintf(debugFP, "Load Position\n");
10555     }
10556
10557     if (positionNumber > 1) {
10558         sprintf(line, "%s %d", title, positionNumber);
10559         DisplayTitle(line);
10560     } else {
10561         DisplayTitle(title);
10562     }
10563     gameMode = EditGame;
10564     ModeHighlight();
10565     ResetClocks();
10566     timeRemaining[0][1] = whiteTimeRemaining;
10567     timeRemaining[1][1] = blackTimeRemaining;
10568     DrawPosition(FALSE, boards[currentMove]);
10569
10570     return TRUE;
10571 }
10572
10573
10574 void
10575 CopyPlayerNameIntoFileName(dest, src)
10576      char **dest, *src;
10577 {
10578     while (*src != NULLCHAR && *src != ',') {
10579         if (*src == ' ') {
10580             *(*dest)++ = '_';
10581             src++;
10582         } else {
10583             *(*dest)++ = *src++;
10584         }
10585     }
10586 }
10587
10588 char *DefaultFileName(ext)
10589      char *ext;
10590 {
10591     static char def[MSG_SIZ];
10592     char *p;
10593
10594     if (gameInfo.white != NULL && gameInfo.white[0] != '-') {
10595         p = def;
10596         CopyPlayerNameIntoFileName(&p, gameInfo.white);
10597         *p++ = '-';
10598         CopyPlayerNameIntoFileName(&p, gameInfo.black);
10599         *p++ = '.';
10600         strcpy(p, ext);
10601     } else {
10602         def[0] = NULLCHAR;
10603     }
10604     return def;
10605 }
10606
10607 /* Save the current game to the given file */
10608 int
10609 SaveGameToFile(filename, append)
10610      char *filename;
10611      int append;
10612 {
10613     FILE *f;
10614     char buf[MSG_SIZ];
10615
10616     if (strcmp(filename, "-") == 0) {
10617         return SaveGame(stdout, 0, NULL);
10618     } else {
10619         f = fopen(filename, append ? "a" : "w");
10620         if (f == NULL) {
10621             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
10622             DisplayError(buf, errno);
10623             return FALSE;
10624         } else {
10625             return SaveGame(f, 0, NULL);
10626         }
10627     }
10628 }
10629
10630 char *
10631 SavePart(str)
10632      char *str;
10633 {
10634     static char buf[MSG_SIZ];
10635     char *p;
10636
10637     p = strchr(str, ' ');
10638     if (p == NULL) return str;
10639     strncpy(buf, str, p - str);
10640     buf[p - str] = NULLCHAR;
10641     return buf;
10642 }
10643
10644 #define PGN_MAX_LINE 75
10645
10646 #define PGN_SIDE_WHITE  0
10647 #define PGN_SIDE_BLACK  1
10648
10649 /* [AS] */
10650 static int FindFirstMoveOutOfBook( int side )
10651 {
10652     int result = -1;
10653
10654     if( backwardMostMove == 0 && ! startedFromSetupPosition) {
10655         int index = backwardMostMove;
10656         int has_book_hit = 0;
10657
10658         if( (index % 2) != side ) {
10659             index++;
10660         }
10661
10662         while( index < forwardMostMove ) {
10663             /* Check to see if engine is in book */
10664             int depth = pvInfoList[index].depth;
10665             int score = pvInfoList[index].score;
10666             int in_book = 0;
10667
10668             if( depth <= 2 ) {
10669                 in_book = 1;
10670             }
10671             else if( score == 0 && depth == 63 ) {
10672                 in_book = 1; /* Zappa */
10673             }
10674             else if( score == 2 && depth == 99 ) {
10675                 in_book = 1; /* Abrok */
10676             }
10677
10678             has_book_hit += in_book;
10679
10680             if( ! in_book ) {
10681                 result = index;
10682
10683                 break;
10684             }
10685
10686             index += 2;
10687         }
10688     }
10689
10690     return result;
10691 }
10692
10693 /* [AS] */
10694 void GetOutOfBookInfo( char * buf )
10695 {
10696     int oob[2];
10697     int i;
10698     int offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
10699
10700     oob[0] = FindFirstMoveOutOfBook( PGN_SIDE_WHITE );
10701     oob[1] = FindFirstMoveOutOfBook( PGN_SIDE_BLACK );
10702
10703     *buf = '\0';
10704
10705     if( oob[0] >= 0 || oob[1] >= 0 ) {
10706         for( i=0; i<2; i++ ) {
10707             int idx = oob[i];
10708
10709             if( idx >= 0 ) {
10710                 if( i > 0 && oob[0] >= 0 ) {
10711                     strcat( buf, "   " );
10712                 }
10713
10714                 sprintf( buf+strlen(buf), "%d%s. ", (idx - offset)/2 + 1, idx & 1 ? ".." : "" );
10715                 sprintf( buf+strlen(buf), "%s%.2f",
10716                     pvInfoList[idx].score >= 0 ? "+" : "",
10717                     pvInfoList[idx].score / 100.0 );
10718             }
10719         }
10720     }
10721 }
10722
10723 /* Save game in PGN style and close the file */
10724 int
10725 SaveGamePGN(f)
10726      FILE *f;
10727 {
10728     int i, offset, linelen, newblock;
10729     time_t tm;
10730 //    char *movetext;
10731     char numtext[32];
10732     int movelen, numlen, blank;
10733     char move_buffer[100]; /* [AS] Buffer for move+PV info */
10734
10735     offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
10736
10737     tm = time((time_t *) NULL);
10738
10739     PrintPGNTags(f, &gameInfo);
10740
10741     if (backwardMostMove > 0 || startedFromSetupPosition) {
10742         char *fen = PositionToFEN(backwardMostMove, NULL);
10743         fprintf(f, "[FEN \"%s\"]\n[SetUp \"1\"]\n", fen);
10744         fprintf(f, "\n{--------------\n");
10745         PrintPosition(f, backwardMostMove);
10746         fprintf(f, "--------------}\n");
10747         free(fen);
10748     }
10749     else {
10750         /* [AS] Out of book annotation */
10751         if( appData.saveOutOfBookInfo ) {
10752             char buf[64];
10753
10754             GetOutOfBookInfo( buf );
10755
10756             if( buf[0] != '\0' ) {
10757                 fprintf( f, "[%s \"%s\"]\n", PGN_OUT_OF_BOOK, buf );
10758             }
10759         }
10760
10761         fprintf(f, "\n");
10762     }
10763
10764     i = backwardMostMove;
10765     linelen = 0;
10766     newblock = TRUE;
10767
10768     while (i < forwardMostMove) {
10769         /* Print comments preceding this move */
10770         if (commentList[i] != NULL) {
10771             if (linelen > 0) fprintf(f, "\n");
10772             fprintf(f, "%s", commentList[i]);
10773             linelen = 0;
10774             newblock = TRUE;
10775         }
10776
10777         /* Format move number */
10778         if ((i % 2) == 0) {
10779             sprintf(numtext, "%d.", (i - offset)/2 + 1);
10780         } else {
10781             if (newblock) {
10782                 sprintf(numtext, "%d...", (i - offset)/2 + 1);
10783             } else {
10784                 numtext[0] = NULLCHAR;
10785             }
10786         }
10787         numlen = strlen(numtext);
10788         newblock = FALSE;
10789
10790         /* Print move number */
10791         blank = linelen > 0 && numlen > 0;
10792         if (linelen + (blank ? 1 : 0) + numlen > PGN_MAX_LINE) {
10793             fprintf(f, "\n");
10794             linelen = 0;
10795             blank = 0;
10796         }
10797         if (blank) {
10798             fprintf(f, " ");
10799             linelen++;
10800         }
10801         fprintf(f, "%s", numtext);
10802         linelen += numlen;
10803
10804         /* Get move */
10805         strcpy(move_buffer, SavePart(parseList[i])); // [HGM] pgn: print move via buffer, so it can be edited
10806         movelen = strlen(move_buffer); /* [HGM] pgn: line-break point before move */
10807
10808         /* Print move */
10809         blank = linelen > 0 && movelen > 0;
10810         if (linelen + (blank ? 1 : 0) + movelen > PGN_MAX_LINE) {
10811             fprintf(f, "\n");
10812             linelen = 0;
10813             blank = 0;
10814         }
10815         if (blank) {
10816             fprintf(f, " ");
10817             linelen++;
10818         }
10819         fprintf(f, "%s", move_buffer);
10820         linelen += movelen;
10821
10822         /* [AS] Add PV info if present */
10823         if( i >= 0 && appData.saveExtendedInfoInPGN && pvInfoList[i].depth > 0 ) {
10824             /* [HGM] add time */
10825             char buf[MSG_SIZ]; int seconds;
10826
10827             seconds = (pvInfoList[i].time+5)/10; // deci-seconds, rounded to nearest
10828
10829             if( seconds <= 0) buf[0] = 0; else
10830             if( seconds < 30 ) sprintf(buf, " %3.1f%c", seconds/10., 0); else {
10831                 seconds = (seconds + 4)/10; // round to full seconds
10832                 if( seconds < 60 ) sprintf(buf, " %d%c", seconds, 0); else
10833                                    sprintf(buf, " %d:%02d%c", seconds/60, seconds%60, 0);
10834             }
10835
10836             sprintf( move_buffer, "{%s%.2f/%d%s}",
10837                 pvInfoList[i].score >= 0 ? "+" : "",
10838                 pvInfoList[i].score / 100.0,
10839                 pvInfoList[i].depth,
10840                 buf );
10841
10842             movelen = strlen(move_buffer); /* [HGM] pgn: line-break point after move */
10843
10844             /* Print score/depth */
10845             blank = linelen > 0 && movelen > 0;
10846             if (linelen + (blank ? 1 : 0) + movelen > PGN_MAX_LINE) {
10847                 fprintf(f, "\n");
10848                 linelen = 0;
10849                 blank = 0;
10850             }
10851             if (blank) {
10852                 fprintf(f, " ");
10853                 linelen++;
10854             }
10855             fprintf(f, "%s", move_buffer);
10856             linelen += movelen;
10857         }
10858
10859         i++;
10860     }
10861
10862     /* Start a new line */
10863     if (linelen > 0) fprintf(f, "\n");
10864
10865     /* Print comments after last move */
10866     if (commentList[i] != NULL) {
10867         fprintf(f, "%s\n", commentList[i]);
10868     }
10869
10870     /* Print result */
10871     if (gameInfo.resultDetails != NULL &&
10872         gameInfo.resultDetails[0] != NULLCHAR) {
10873         fprintf(f, "{%s} %s\n\n", gameInfo.resultDetails,
10874                 PGNResult(gameInfo.result));
10875     } else {
10876         fprintf(f, "%s\n\n", PGNResult(gameInfo.result));
10877     }
10878
10879     fclose(f);
10880     lastSavedGame = GameCheckSum(); // [HGM] save: remember ID of last saved game to prevent double saving
10881     return TRUE;
10882 }
10883
10884 /* Save game in old style and close the file */
10885 int
10886 SaveGameOldStyle(f)
10887      FILE *f;
10888 {
10889     int i, offset;
10890     time_t tm;
10891
10892     tm = time((time_t *) NULL);
10893
10894     fprintf(f, "# %s game file -- %s", programName, ctime(&tm));
10895     PrintOpponents(f);
10896
10897     if (backwardMostMove > 0 || startedFromSetupPosition) {
10898         fprintf(f, "\n[--------------\n");
10899         PrintPosition(f, backwardMostMove);
10900         fprintf(f, "--------------]\n");
10901     } else {
10902         fprintf(f, "\n");
10903     }
10904
10905     i = backwardMostMove;
10906     offset = backwardMostMove & (~1L); /* output move numbers start at 1 */
10907
10908     while (i < forwardMostMove) {
10909         if (commentList[i] != NULL) {
10910             fprintf(f, "[%s]\n", commentList[i]);
10911         }
10912
10913         if ((i % 2) == 1) {
10914             fprintf(f, "%d. ...  %s\n", (i - offset)/2 + 1, parseList[i]);
10915             i++;
10916         } else {
10917             fprintf(f, "%d. %s  ", (i - offset)/2 + 1, parseList[i]);
10918             i++;
10919             if (commentList[i] != NULL) {
10920                 fprintf(f, "\n");
10921                 continue;
10922             }
10923             if (i >= forwardMostMove) {
10924                 fprintf(f, "\n");
10925                 break;
10926             }
10927             fprintf(f, "%s\n", parseList[i]);
10928             i++;
10929         }
10930     }
10931
10932     if (commentList[i] != NULL) {
10933         fprintf(f, "[%s]\n", commentList[i]);
10934     }
10935
10936     /* This isn't really the old style, but it's close enough */
10937     if (gameInfo.resultDetails != NULL &&
10938         gameInfo.resultDetails[0] != NULLCHAR) {
10939         fprintf(f, "%s (%s)\n\n", PGNResult(gameInfo.result),
10940                 gameInfo.resultDetails);
10941     } else {
10942         fprintf(f, "%s\n\n", PGNResult(gameInfo.result));
10943     }
10944
10945     fclose(f);
10946     return TRUE;
10947 }
10948
10949 /* Save the current game to open file f and close the file */
10950 int
10951 SaveGame(f, dummy, dummy2)
10952      FILE *f;
10953      int dummy;
10954      char *dummy2;
10955 {
10956     if (gameMode == EditPosition) EditPositionDone(TRUE);
10957     lastSavedGame = GameCheckSum(); // [HGM] save: remember ID of last saved game to prevent double saving
10958     if (appData.oldSaveStyle)
10959       return SaveGameOldStyle(f);
10960     else
10961       return SaveGamePGN(f);
10962 }
10963
10964 /* Save the current position to the given file */
10965 int
10966 SavePositionToFile(filename)
10967      char *filename;
10968 {
10969     FILE *f;
10970     char buf[MSG_SIZ];
10971
10972     if (strcmp(filename, "-") == 0) {
10973         return SavePosition(stdout, 0, NULL);
10974     } else {
10975         f = fopen(filename, "a");
10976         if (f == NULL) {
10977             snprintf(buf, sizeof(buf), _("Can't open \"%s\""), filename);
10978             DisplayError(buf, errno);
10979             return FALSE;
10980         } else {
10981             SavePosition(f, 0, NULL);
10982             return TRUE;
10983         }
10984     }
10985 }
10986
10987 /* Save the current position to the given open file and close the file */
10988 int
10989 SavePosition(f, dummy, dummy2)
10990      FILE *f;
10991      int dummy;
10992      char *dummy2;
10993 {
10994     time_t tm;
10995     char *fen;
10996
10997     if (gameMode == EditPosition) EditPositionDone(TRUE);
10998     if (appData.oldSaveStyle) {
10999         tm = time((time_t *) NULL);
11000
11001         fprintf(f, "# %s position file -- %s", programName, ctime(&tm));
11002         PrintOpponents(f);
11003         fprintf(f, "[--------------\n");
11004         PrintPosition(f, currentMove);
11005         fprintf(f, "--------------]\n");
11006     } else {
11007         fen = PositionToFEN(currentMove, NULL);
11008         fprintf(f, "%s\n", fen);
11009         free(fen);
11010     }
11011     fclose(f);
11012     return TRUE;
11013 }
11014
11015 void
11016 ReloadCmailMsgEvent(unregister)
11017      int unregister;
11018 {
11019 #if !WIN32
11020     static char *inFilename = NULL;
11021     static char *outFilename;
11022     int i;
11023     struct stat inbuf, outbuf;
11024     int status;
11025
11026     /* Any registered moves are unregistered if unregister is set, */
11027     /* i.e. invoked by the signal handler */
11028     if (unregister) {
11029         for (i = 0; i < CMAIL_MAX_GAMES; i ++) {
11030             cmailMoveRegistered[i] = FALSE;
11031             if (cmailCommentList[i] != NULL) {
11032                 free(cmailCommentList[i]);
11033                 cmailCommentList[i] = NULL;
11034             }
11035         }
11036         nCmailMovesRegistered = 0;
11037     }
11038
11039     for (i = 0; i < CMAIL_MAX_GAMES; i ++) {
11040         cmailResult[i] = CMAIL_NOT_RESULT;
11041     }
11042     nCmailResults = 0;
11043
11044     if (inFilename == NULL) {
11045         /* Because the filenames are static they only get malloced once  */
11046         /* and they never get freed                                      */
11047         inFilename = (char *) malloc(strlen(appData.cmailGameName) + 9);
11048         sprintf(inFilename, "%s.game.in", appData.cmailGameName);
11049
11050         outFilename = (char *) malloc(strlen(appData.cmailGameName) + 5);
11051         sprintf(outFilename, "%s.out", appData.cmailGameName);
11052     }
11053
11054     status = stat(outFilename, &outbuf);
11055     if (status < 0) {
11056         cmailMailedMove = FALSE;
11057     } else {
11058         status = stat(inFilename, &inbuf);
11059         cmailMailedMove = (inbuf.st_mtime < outbuf.st_mtime);
11060     }
11061
11062     /* LoadGameFromFile(CMAIL_MAX_GAMES) with cmailMsgLoaded == TRUE
11063        counts the games, notes how each one terminated, etc.
11064
11065        It would be nice to remove this kludge and instead gather all
11066        the information while building the game list.  (And to keep it
11067        in the game list nodes instead of having a bunch of fixed-size
11068        parallel arrays.)  Note this will require getting each game's
11069        termination from the PGN tags, as the game list builder does
11070        not process the game moves.  --mann
11071        */
11072     cmailMsgLoaded = TRUE;
11073     LoadGameFromFile(inFilename, CMAIL_MAX_GAMES, "", FALSE);
11074
11075     /* Load first game in the file or popup game menu */
11076     LoadGameFromFile(inFilename, 0, appData.cmailGameName, TRUE);
11077
11078 #endif /* !WIN32 */
11079     return;
11080 }
11081
11082 int
11083 RegisterMove()
11084 {
11085     FILE *f;
11086     char string[MSG_SIZ];
11087
11088     if (   cmailMailedMove
11089         || (cmailResult[lastLoadGameNumber - 1] == CMAIL_OLD_RESULT)) {
11090         return TRUE;            /* Allow free viewing  */
11091     }
11092
11093     /* Unregister move to ensure that we don't leave RegisterMove        */
11094     /* with the move registered when the conditions for registering no   */
11095     /* longer hold                                                       */
11096     if (cmailMoveRegistered[lastLoadGameNumber - 1]) {
11097         cmailMoveRegistered[lastLoadGameNumber - 1] = FALSE;
11098         nCmailMovesRegistered --;
11099
11100         if (cmailCommentList[lastLoadGameNumber - 1] != NULL)
11101           {
11102               free(cmailCommentList[lastLoadGameNumber - 1]);
11103               cmailCommentList[lastLoadGameNumber - 1] = NULL;
11104           }
11105     }
11106
11107     if (cmailOldMove == -1) {
11108         DisplayError(_("You have edited the game history.\nUse Reload Same Game and make your move again."), 0);
11109         return FALSE;
11110     }
11111
11112     if (currentMove > cmailOldMove + 1) {
11113         DisplayError(_("You have entered too many moves.\nBack up to the correct position and try again."), 0);
11114         return FALSE;
11115     }
11116
11117     if (currentMove < cmailOldMove) {
11118         DisplayError(_("Displayed position is not current.\nStep forward to the correct position and try again."), 0);
11119         return FALSE;
11120     }
11121
11122     if (forwardMostMove > currentMove) {
11123         /* Silently truncate extra moves */
11124         TruncateGame();
11125     }
11126
11127     if (   (currentMove == cmailOldMove + 1)
11128         || (   (currentMove == cmailOldMove)
11129             && (   (cmailMoveType[lastLoadGameNumber - 1] == CMAIL_ACCEPT)
11130                 || (cmailMoveType[lastLoadGameNumber - 1] == CMAIL_RESIGN)))) {
11131         if (gameInfo.result != GameUnfinished) {
11132             cmailResult[lastLoadGameNumber - 1] = CMAIL_NEW_RESULT;
11133         }
11134
11135         if (commentList[currentMove] != NULL) {
11136             cmailCommentList[lastLoadGameNumber - 1]
11137               = StrSave(commentList[currentMove]);
11138         }
11139         strcpy(cmailMove[lastLoadGameNumber - 1], moveList[currentMove - 1]);
11140
11141         if (appData.debugMode)
11142           fprintf(debugFP, "Saving %s for game %d\n",
11143                   cmailMove[lastLoadGameNumber - 1], lastLoadGameNumber);
11144
11145         sprintf(string,
11146                 "%s.game.out.%d", appData.cmailGameName, lastLoadGameNumber);
11147
11148         f = fopen(string, "w");
11149         if (appData.oldSaveStyle) {
11150             SaveGameOldStyle(f); /* also closes the file */
11151
11152             sprintf(string, "%s.pos.out", appData.cmailGameName);
11153             f = fopen(string, "w");
11154             SavePosition(f, 0, NULL); /* also closes the file */
11155         } else {
11156             fprintf(f, "{--------------\n");
11157             PrintPosition(f, currentMove);
11158             fprintf(f, "--------------}\n\n");
11159
11160             SaveGame(f, 0, NULL); /* also closes the file*/
11161         }
11162
11163         cmailMoveRegistered[lastLoadGameNumber - 1] = TRUE;
11164         nCmailMovesRegistered ++;
11165     } else if (nCmailGames == 1) {
11166         DisplayError(_("You have not made a move yet"), 0);
11167         return FALSE;
11168     }
11169
11170     return TRUE;
11171 }
11172
11173 void
11174 MailMoveEvent()
11175 {
11176 #if !WIN32
11177     static char *partCommandString = "cmail -xv%s -remail -game %s 2>&1";
11178     FILE *commandOutput;
11179     char buffer[MSG_SIZ], msg[MSG_SIZ], string[MSG_SIZ];
11180     int nBytes = 0;             /*  Suppress warnings on uninitialized variables    */
11181     int nBuffers;
11182     int i;
11183     int archived;
11184     char *arcDir;
11185
11186     if (! cmailMsgLoaded) {
11187         DisplayError(_("The cmail message is not loaded.\nUse Reload CMail Message and make your move again."), 0);
11188         return;
11189     }
11190
11191     if (nCmailGames == nCmailResults) {
11192         DisplayError(_("No unfinished games"), 0);
11193         return;
11194     }
11195
11196 #if CMAIL_PROHIBIT_REMAIL
11197     if (cmailMailedMove) {
11198         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);
11199         DisplayError(msg, 0);
11200         return;
11201     }
11202 #endif
11203
11204     if (! (cmailMailedMove || RegisterMove())) return;
11205
11206     if (   cmailMailedMove
11207         || (nCmailMovesRegistered + nCmailResults == nCmailGames)) {
11208         sprintf(string, partCommandString,
11209                 appData.debugMode ? " -v" : "", appData.cmailGameName);
11210         commandOutput = popen(string, "r");
11211
11212         if (commandOutput == NULL) {
11213             DisplayError(_("Failed to invoke cmail"), 0);
11214         } else {
11215             for (nBuffers = 0; (! feof(commandOutput)); nBuffers ++) {
11216                 nBytes = fread(buffer, 1, MSG_SIZ - 1, commandOutput);
11217             }
11218             if (nBuffers > 1) {
11219                 (void) memcpy(msg, buffer + nBytes, MSG_SIZ - nBytes - 1);
11220                 (void) memcpy(msg + MSG_SIZ - nBytes - 1, buffer, nBytes);
11221                 nBytes = MSG_SIZ - 1;
11222             } else {
11223                 (void) memcpy(msg, buffer, nBytes);
11224             }
11225             *(msg + nBytes) = '\0'; /* \0 for end-of-string*/
11226
11227             if(StrStr(msg, "Mailed cmail message to ") != NULL) {
11228                 cmailMailedMove = TRUE; /* Prevent >1 moves    */
11229
11230                 archived = TRUE;
11231                 for (i = 0; i < nCmailGames; i ++) {
11232                     if (cmailResult[i] == CMAIL_NOT_RESULT) {
11233                         archived = FALSE;
11234                     }
11235                 }
11236                 if (   archived
11237                     && (   (arcDir = (char *) getenv("CMAIL_ARCDIR"))
11238                         != NULL)) {
11239                     sprintf(buffer, "%s/%s.%s.archive",
11240                             arcDir,
11241                             appData.cmailGameName,
11242                             gameInfo.date);
11243                     LoadGameFromFile(buffer, 1, buffer, FALSE);
11244                     cmailMsgLoaded = FALSE;
11245                 }
11246             }
11247
11248             DisplayInformation(msg);
11249             pclose(commandOutput);
11250         }
11251     } else {
11252         if ((*cmailMsg) != '\0') {
11253             DisplayInformation(cmailMsg);
11254         }
11255     }
11256
11257     return;
11258 #endif /* !WIN32 */
11259 }
11260
11261 char *
11262 CmailMsg()
11263 {
11264 #if WIN32
11265     return NULL;
11266 #else
11267     int  prependComma = 0;
11268     char number[5];
11269     char string[MSG_SIZ];       /* Space for game-list */
11270     int  i;
11271
11272     if (!cmailMsgLoaded) return "";
11273
11274     if (cmailMailedMove) {
11275         sprintf(cmailMsg, _("Waiting for reply from opponent\n"));
11276     } else {
11277         /* Create a list of games left */
11278         sprintf(string, "[");
11279         for (i = 0; i < nCmailGames; i ++) {
11280             if (! (   cmailMoveRegistered[i]
11281                    || (cmailResult[i] == CMAIL_OLD_RESULT))) {
11282                 if (prependComma) {
11283                     sprintf(number, ",%d", i + 1);
11284                 } else {
11285                     sprintf(number, "%d", i + 1);
11286                     prependComma = 1;
11287                 }
11288
11289                 strcat(string, number);
11290             }
11291         }
11292         strcat(string, "]");
11293
11294         if (nCmailMovesRegistered + nCmailResults == 0) {
11295             switch (nCmailGames) {
11296               case 1:
11297                 sprintf(cmailMsg,
11298                         _("Still need to make move for game\n"));
11299                 break;
11300
11301               case 2:
11302                 sprintf(cmailMsg,
11303                         _("Still need to make moves for both games\n"));
11304                 break;
11305
11306               default:
11307                 sprintf(cmailMsg,
11308                         _("Still need to make moves for all %d games\n"),
11309                         nCmailGames);
11310                 break;
11311             }
11312         } else {
11313             switch (nCmailGames - nCmailMovesRegistered - nCmailResults) {
11314               case 1:
11315                 sprintf(cmailMsg,
11316                         _("Still need to make a move for game %s\n"),
11317                         string);
11318                 break;
11319
11320               case 0:
11321                 if (nCmailResults == nCmailGames) {
11322                     sprintf(cmailMsg, _("No unfinished games\n"));
11323                 } else {
11324                     sprintf(cmailMsg, _("Ready to send mail\n"));
11325                 }
11326                 break;
11327
11328               default:
11329                 sprintf(cmailMsg,
11330                         _("Still need to make moves for games %s\n"),
11331                         string);
11332             }
11333         }
11334     }
11335     return cmailMsg;
11336 #endif /* WIN32 */
11337 }
11338
11339 void
11340 ResetGameEvent()
11341 {
11342     if (gameMode == Training)
11343       SetTrainingModeOff();
11344
11345     Reset(TRUE, TRUE);
11346     cmailMsgLoaded = FALSE;
11347     if (appData.icsActive) {
11348       SendToICS(ics_prefix);
11349       SendToICS("refresh\n");
11350     }
11351 }
11352
11353 void
11354 ExitEvent(status)
11355      int status;
11356 {
11357     exiting++;
11358     if (exiting > 2) {
11359       /* Give up on clean exit */
11360       exit(status);
11361     }
11362     if (exiting > 1) {
11363       /* Keep trying for clean exit */
11364       return;
11365     }
11366
11367     if (appData.icsActive && appData.colorize) Colorize(ColorNone, FALSE);
11368
11369     if (telnetISR != NULL) {
11370       RemoveInputSource(telnetISR);
11371     }
11372     if (icsPR != NoProc) {
11373       DestroyChildProcess(icsPR, TRUE);
11374     }
11375
11376     /* [HGM] crash: leave writing PGN and position entirely to GameEnds() */
11377     GameEnds(gameInfo.result, gameInfo.resultDetails==NULL ? "xboard exit" : gameInfo.resultDetails, GE_PLAYER);
11378
11379     /* [HGM] crash: the above GameEnds() is a dud if another one was running */
11380     /* make sure this other one finishes before killing it!                  */
11381     if(endingGame) { int count = 0;
11382         if(appData.debugMode) fprintf(debugFP, "ExitEvent() during GameEnds(), wait\n");
11383         while(endingGame && count++ < 10) DoSleep(1);
11384         if(appData.debugMode && endingGame) fprintf(debugFP, "GameEnds() seems stuck, proceed exiting\n");
11385     }
11386
11387     /* Kill off chess programs */
11388     if (first.pr != NoProc) {
11389         ExitAnalyzeMode();
11390
11391         DoSleep( appData.delayBeforeQuit );
11392         SendToProgram("quit\n", &first);
11393         DoSleep( appData.delayAfterQuit );
11394         DestroyChildProcess(first.pr, 10 /* [AS] first.useSigterm */ );
11395     }
11396     if (second.pr != NoProc) {
11397         DoSleep( appData.delayBeforeQuit );
11398         SendToProgram("quit\n", &second);
11399         DoSleep( appData.delayAfterQuit );
11400         DestroyChildProcess(second.pr, 10 /* [AS] second.useSigterm */ );
11401     }
11402     if (first.isr != NULL) {
11403         RemoveInputSource(first.isr);
11404     }
11405     if (second.isr != NULL) {
11406         RemoveInputSource(second.isr);
11407     }
11408
11409     ShutDownFrontEnd();
11410     exit(status);
11411 }
11412
11413 void
11414 PauseEvent()
11415 {
11416     if (appData.debugMode)
11417         fprintf(debugFP, "PauseEvent(): pausing %d\n", pausing);
11418     if (pausing) {
11419         pausing = FALSE;
11420         ModeHighlight();
11421         if (gameMode == MachinePlaysWhite ||
11422             gameMode == MachinePlaysBlack) {
11423             StartClocks();
11424         } else {
11425             DisplayBothClocks();
11426         }
11427         if (gameMode == PlayFromGameFile) {
11428             if (appData.timeDelay >= 0)
11429                 AutoPlayGameLoop();
11430         } else if (gameMode == IcsExamining && pauseExamInvalid) {
11431             Reset(FALSE, TRUE);
11432             SendToICS(ics_prefix);
11433             SendToICS("refresh\n");
11434         } else if (currentMove < forwardMostMove) {
11435             ForwardInner(forwardMostMove);
11436         }
11437         pauseExamInvalid = FALSE;
11438     } else {
11439         switch (gameMode) {
11440           default:
11441             return;
11442           case IcsExamining:
11443             pauseExamForwardMostMove = forwardMostMove;
11444             pauseExamInvalid = FALSE;
11445             /* fall through */
11446           case IcsObserving:
11447           case IcsPlayingWhite:
11448           case IcsPlayingBlack:
11449             pausing = TRUE;
11450             ModeHighlight();
11451             return;
11452           case PlayFromGameFile:
11453             (void) StopLoadGameTimer();
11454             pausing = TRUE;
11455             ModeHighlight();
11456             break;
11457           case BeginningOfGame:
11458             if (appData.icsActive) return;
11459             /* else fall through */
11460           case MachinePlaysWhite:
11461           case MachinePlaysBlack:
11462           case TwoMachinesPlay:
11463             if (forwardMostMove == 0)
11464               return;           /* don't pause if no one has moved */
11465             if ((gameMode == MachinePlaysWhite &&
11466                  !WhiteOnMove(forwardMostMove)) ||
11467                 (gameMode == MachinePlaysBlack &&
11468                  WhiteOnMove(forwardMostMove))) {
11469                 StopClocks();
11470             }
11471             pausing = TRUE;
11472             ModeHighlight();
11473             break;
11474         }
11475     }
11476 }
11477
11478 void
11479 EditCommentEvent()
11480 {
11481     char title[MSG_SIZ];
11482
11483     if (currentMove < 1 || parseList[currentMove - 1][0] == NULLCHAR) {
11484         strcpy(title, _("Edit comment"));
11485     } else {
11486         sprintf(title, _("Edit comment on %d.%s%s"), (currentMove - 1) / 2 + 1,
11487                 WhiteOnMove(currentMove - 1) ? " " : ".. ",
11488                 parseList[currentMove - 1]);
11489     }
11490
11491     EditCommentPopUp(currentMove, title, commentList[currentMove]);
11492 }
11493
11494
11495 void
11496 EditTagsEvent()
11497 {
11498     char *tags = PGNTags(&gameInfo);
11499     EditTagsPopUp(tags);
11500     free(tags);
11501 }
11502
11503 void
11504 AnalyzeModeEvent()
11505 {
11506     if (appData.noChessProgram || gameMode == AnalyzeMode)
11507       return;
11508
11509     if (gameMode != AnalyzeFile) {
11510         if (!appData.icsEngineAnalyze) {
11511                EditGameEvent();
11512                if (gameMode != EditGame) return;
11513         }
11514         ResurrectChessProgram();
11515         SendToProgram("analyze\n", &first);
11516         first.analyzing = TRUE;
11517         /*first.maybeThinking = TRUE;*/
11518         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
11519         EngineOutputPopUp();
11520     }
11521     if (!appData.icsEngineAnalyze) gameMode = AnalyzeMode;
11522     pausing = FALSE;
11523     ModeHighlight();
11524     SetGameInfo();
11525
11526     StartAnalysisClock();
11527     GetTimeMark(&lastNodeCountTime);
11528     lastNodeCount = 0;
11529 }
11530
11531 void
11532 AnalyzeFileEvent()
11533 {
11534     if (appData.noChessProgram || gameMode == AnalyzeFile)
11535       return;
11536
11537     if (gameMode != AnalyzeMode) {
11538         EditGameEvent();
11539         if (gameMode != EditGame) return;
11540         ResurrectChessProgram();
11541         SendToProgram("analyze\n", &first);
11542         first.analyzing = TRUE;
11543         /*first.maybeThinking = TRUE;*/
11544         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
11545         EngineOutputPopUp();
11546     }
11547     gameMode = AnalyzeFile;
11548     pausing = FALSE;
11549     ModeHighlight();
11550     SetGameInfo();
11551
11552     StartAnalysisClock();
11553     GetTimeMark(&lastNodeCountTime);
11554     lastNodeCount = 0;
11555 }
11556
11557 void
11558 MachineWhiteEvent()
11559 {
11560     char buf[MSG_SIZ];
11561     char *bookHit = NULL;
11562
11563     if (appData.noChessProgram || (gameMode == MachinePlaysWhite))
11564       return;
11565
11566
11567     if (gameMode == PlayFromGameFile ||
11568         gameMode == TwoMachinesPlay  ||
11569         gameMode == Training         ||
11570         gameMode == AnalyzeMode      ||
11571         gameMode == EndOfGame)
11572         EditGameEvent();
11573
11574     if (gameMode == EditPosition)
11575         EditPositionDone(TRUE);
11576
11577     if (!WhiteOnMove(currentMove)) {
11578         DisplayError(_("It is not White's turn"), 0);
11579         return;
11580     }
11581
11582     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile)
11583       ExitAnalyzeMode();
11584
11585     if (gameMode == EditGame || gameMode == AnalyzeMode ||
11586         gameMode == AnalyzeFile)
11587         TruncateGame();
11588
11589     ResurrectChessProgram();    /* in case it isn't running */
11590     if(gameMode == BeginningOfGame) { /* [HGM] time odds: to get right odds in human mode */
11591         gameMode = MachinePlaysWhite;
11592         ResetClocks();
11593     } else
11594     gameMode = MachinePlaysWhite;
11595     pausing = FALSE;
11596     ModeHighlight();
11597     SetGameInfo();
11598     sprintf(buf, "%s vs. %s", gameInfo.white, gameInfo.black);
11599     DisplayTitle(buf);
11600     if (first.sendName) {
11601       sprintf(buf, "name %s\n", gameInfo.black);
11602       SendToProgram(buf, &first);
11603     }
11604     if (first.sendTime) {
11605       if (first.useColors) {
11606         SendToProgram("black\n", &first); /*gnu kludge*/
11607       }
11608       SendTimeRemaining(&first, TRUE);
11609     }
11610     if (first.useColors) {
11611       SendToProgram("white\n", &first); // [HGM] book: send 'go' separately
11612     }
11613     bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: send go or retrieve book move
11614     SetMachineThinkingEnables();
11615     first.maybeThinking = TRUE;
11616     StartClocks();
11617     firstMove = FALSE;
11618
11619     if (appData.autoFlipView && !flipView) {
11620       flipView = !flipView;
11621       DrawPosition(FALSE, NULL);
11622       DisplayBothClocks();       // [HGM] logo: clocks might have to be exchanged;
11623     }
11624
11625     if(bookHit) { // [HGM] book: simulate book reply
11626         static char bookMove[MSG_SIZ]; // a bit generous?
11627
11628         programStats.nodes = programStats.depth = programStats.time =
11629         programStats.score = programStats.got_only_move = 0;
11630         sprintf(programStats.movelist, "%s (xbook)", bookHit);
11631
11632         strcpy(bookMove, "move ");
11633         strcat(bookMove, bookHit);
11634         HandleMachineMove(bookMove, &first);
11635     }
11636 }
11637
11638 void
11639 MachineBlackEvent()
11640 {
11641     char buf[MSG_SIZ];
11642    char *bookHit = NULL;
11643
11644     if (appData.noChessProgram || (gameMode == MachinePlaysBlack))
11645         return;
11646
11647
11648     if (gameMode == PlayFromGameFile ||
11649         gameMode == TwoMachinesPlay  ||
11650         gameMode == Training         ||
11651         gameMode == AnalyzeMode      ||
11652         gameMode == EndOfGame)
11653         EditGameEvent();
11654
11655     if (gameMode == EditPosition)
11656         EditPositionDone(TRUE);
11657
11658     if (WhiteOnMove(currentMove)) {
11659         DisplayError(_("It is not Black's turn"), 0);
11660         return;
11661     }
11662
11663     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile)
11664       ExitAnalyzeMode();
11665
11666     if (gameMode == EditGame || gameMode == AnalyzeMode ||
11667         gameMode == AnalyzeFile)
11668         TruncateGame();
11669
11670     ResurrectChessProgram();    /* in case it isn't running */
11671     gameMode = MachinePlaysBlack;
11672     pausing = FALSE;
11673     ModeHighlight();
11674     SetGameInfo();
11675     sprintf(buf, "%s vs. %s", gameInfo.white, gameInfo.black);
11676     DisplayTitle(buf);
11677     if (first.sendName) {
11678       sprintf(buf, "name %s\n", gameInfo.white);
11679       SendToProgram(buf, &first);
11680     }
11681     if (first.sendTime) {
11682       if (first.useColors) {
11683         SendToProgram("white\n", &first); /*gnu kludge*/
11684       }
11685       SendTimeRemaining(&first, FALSE);
11686     }
11687     if (first.useColors) {
11688       SendToProgram("black\n", &first); // [HGM] book: 'go' sent separately
11689     }
11690     bookHit = SendMoveToBookUser(forwardMostMove-1, &first, TRUE); // [HGM] book: send go or retrieve book move
11691     SetMachineThinkingEnables();
11692     first.maybeThinking = TRUE;
11693     StartClocks();
11694
11695     if (appData.autoFlipView && flipView) {
11696       flipView = !flipView;
11697       DrawPosition(FALSE, NULL);
11698       DisplayBothClocks();       // [HGM] logo: clocks might have to be exchanged;
11699     }
11700     if(bookHit) { // [HGM] book: simulate book reply
11701         static char bookMove[MSG_SIZ]; // a bit generous?
11702
11703         programStats.nodes = programStats.depth = programStats.time =
11704         programStats.score = programStats.got_only_move = 0;
11705         sprintf(programStats.movelist, "%s (xbook)", bookHit);
11706
11707         strcpy(bookMove, "move ");
11708         strcat(bookMove, bookHit);
11709         HandleMachineMove(bookMove, &first);
11710     }
11711 }
11712
11713
11714 void
11715 DisplayTwoMachinesTitle()
11716 {
11717     char buf[MSG_SIZ];
11718     if (appData.matchGames > 0) {
11719         if (first.twoMachinesColor[0] == 'w') {
11720             sprintf(buf, "%s vs. %s (%d-%d-%d)",
11721                     gameInfo.white, gameInfo.black,
11722                     first.matchWins, second.matchWins,
11723                     matchGame - 1 - (first.matchWins + second.matchWins));
11724         } else {
11725             sprintf(buf, "%s vs. %s (%d-%d-%d)",
11726                     gameInfo.white, gameInfo.black,
11727                     second.matchWins, first.matchWins,
11728                     matchGame - 1 - (first.matchWins + second.matchWins));
11729         }
11730     } else {
11731         sprintf(buf, "%s vs. %s", gameInfo.white, gameInfo.black);
11732     }
11733     DisplayTitle(buf);
11734 }
11735
11736 void
11737 TwoMachinesEvent P((void))
11738 {
11739     int i;
11740     char buf[MSG_SIZ];
11741     ChessProgramState *onmove;
11742     char *bookHit = NULL;
11743
11744     if (appData.noChessProgram) return;
11745
11746     switch (gameMode) {
11747       case TwoMachinesPlay:
11748         return;
11749       case MachinePlaysWhite:
11750       case MachinePlaysBlack:
11751         if (WhiteOnMove(forwardMostMove) == (gameMode == MachinePlaysWhite)) {
11752             DisplayError(_("Wait until your turn,\nor select Move Now"), 0);
11753             return;
11754         }
11755         /* fall through */
11756       case BeginningOfGame:
11757       case PlayFromGameFile:
11758       case EndOfGame:
11759         EditGameEvent();
11760         if (gameMode != EditGame) return;
11761         break;
11762       case EditPosition:
11763         EditPositionDone(TRUE);
11764         break;
11765       case AnalyzeMode:
11766       case AnalyzeFile:
11767         ExitAnalyzeMode();
11768         break;
11769       case EditGame:
11770       default:
11771         break;
11772     }
11773
11774 //    forwardMostMove = currentMove;
11775     TruncateGame(); // [HGM] vari: MachineWhite and MachineBlack do this...
11776     ResurrectChessProgram();    /* in case first program isn't running */
11777
11778     if (second.pr == NULL) {
11779         StartChessProgram(&second);
11780         if (second.protocolVersion == 1) {
11781           TwoMachinesEventIfReady();
11782         } else {
11783           /* kludge: allow timeout for initial "feature" command */
11784           FreezeUI();
11785           DisplayMessage("", _("Starting second chess program"));
11786           ScheduleDelayedEvent(TwoMachinesEventIfReady, FEATURE_TIMEOUT);
11787         }
11788         return;
11789     }
11790     DisplayMessage("", "");
11791     InitChessProgram(&second, FALSE);
11792     SendToProgram("force\n", &second);
11793     if (startedFromSetupPosition) {
11794         SendBoard(&second, backwardMostMove);
11795     if (appData.debugMode) {
11796         fprintf(debugFP, "Two Machines\n");
11797     }
11798     }
11799     for (i = backwardMostMove; i < forwardMostMove; i++) {
11800         SendMoveToProgram(i, &second);
11801     }
11802
11803     gameMode = TwoMachinesPlay;
11804     pausing = FALSE;
11805     ModeHighlight();
11806     SetGameInfo();
11807     DisplayTwoMachinesTitle();
11808     firstMove = TRUE;
11809     if ((first.twoMachinesColor[0] == 'w') == WhiteOnMove(forwardMostMove)) {
11810         onmove = &first;
11811     } else {
11812         onmove = &second;
11813     }
11814
11815     SendToProgram(first.computerString, &first);
11816     if (first.sendName) {
11817       sprintf(buf, "name %s\n", second.tidy);
11818       SendToProgram(buf, &first);
11819     }
11820     SendToProgram(second.computerString, &second);
11821     if (second.sendName) {
11822       sprintf(buf, "name %s\n", first.tidy);
11823       SendToProgram(buf, &second);
11824     }
11825
11826     ResetClocks();
11827     if (!first.sendTime || !second.sendTime) {
11828         timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
11829         timeRemaining[1][forwardMostMove] = blackTimeRemaining;
11830     }
11831     if (onmove->sendTime) {
11832       if (onmove->useColors) {
11833         SendToProgram(onmove->other->twoMachinesColor, onmove); /*gnu kludge*/
11834       }
11835       SendTimeRemaining(onmove, WhiteOnMove(forwardMostMove));
11836     }
11837     if (onmove->useColors) {
11838       SendToProgram(onmove->twoMachinesColor, onmove);
11839     }
11840     bookHit = SendMoveToBookUser(forwardMostMove-1, onmove, TRUE); // [HGM] book: send go or retrieve book move
11841 //    SendToProgram("go\n", onmove);
11842     onmove->maybeThinking = TRUE;
11843     SetMachineThinkingEnables();
11844
11845     StartClocks();
11846
11847     if(bookHit) { // [HGM] book: simulate book reply
11848         static char bookMove[MSG_SIZ]; // a bit generous?
11849
11850         programStats.nodes = programStats.depth = programStats.time =
11851         programStats.score = programStats.got_only_move = 0;
11852         sprintf(programStats.movelist, "%s (xbook)", bookHit);
11853
11854         strcpy(bookMove, "move ");
11855         strcat(bookMove, bookHit);
11856         savedMessage = bookMove; // args for deferred call
11857         savedState = onmove;
11858         ScheduleDelayedEvent(DeferredBookMove, 1);
11859     }
11860 }
11861
11862 void
11863 TrainingEvent()
11864 {
11865     if (gameMode == Training) {
11866       SetTrainingModeOff();
11867       gameMode = PlayFromGameFile;
11868       DisplayMessage("", _("Training mode off"));
11869     } else {
11870       gameMode = Training;
11871       animateTraining = appData.animate;
11872
11873       /* make sure we are not already at the end of the game */
11874       if (currentMove < forwardMostMove) {
11875         SetTrainingModeOn();
11876         DisplayMessage("", _("Training mode on"));
11877       } else {
11878         gameMode = PlayFromGameFile;
11879         DisplayError(_("Already at end of game"), 0);
11880       }
11881     }
11882     ModeHighlight();
11883 }
11884
11885 void
11886 IcsClientEvent()
11887 {
11888     if (!appData.icsActive) return;
11889     switch (gameMode) {
11890       case IcsPlayingWhite:
11891       case IcsPlayingBlack:
11892       case IcsObserving:
11893       case IcsIdle:
11894       case BeginningOfGame:
11895       case IcsExamining:
11896         return;
11897
11898       case EditGame:
11899         break;
11900
11901       case EditPosition:
11902         EditPositionDone(TRUE);
11903         break;
11904
11905       case AnalyzeMode:
11906       case AnalyzeFile:
11907         ExitAnalyzeMode();
11908         break;
11909
11910       default:
11911         EditGameEvent();
11912         break;
11913     }
11914
11915     gameMode = IcsIdle;
11916     ModeHighlight();
11917     return;
11918 }
11919
11920
11921 void
11922 EditGameEvent()
11923 {
11924     int i;
11925
11926     switch (gameMode) {
11927       case Training:
11928         SetTrainingModeOff();
11929         break;
11930       case MachinePlaysWhite:
11931       case MachinePlaysBlack:
11932       case BeginningOfGame:
11933         SendToProgram("force\n", &first);
11934         SetUserThinkingEnables();
11935         break;
11936       case PlayFromGameFile:
11937         (void) StopLoadGameTimer();
11938         if (gameFileFP != NULL) {
11939             gameFileFP = NULL;
11940         }
11941         break;
11942       case EditPosition:
11943         EditPositionDone(TRUE);
11944         break;
11945       case AnalyzeMode:
11946       case AnalyzeFile:
11947         ExitAnalyzeMode();
11948         SendToProgram("force\n", &first);
11949         break;
11950       case TwoMachinesPlay:
11951         GameEnds((ChessMove) 0, NULL, GE_PLAYER);
11952         ResurrectChessProgram();
11953         SetUserThinkingEnables();
11954         break;
11955       case EndOfGame:
11956         ResurrectChessProgram();
11957         break;
11958       case IcsPlayingBlack:
11959       case IcsPlayingWhite:
11960         DisplayError(_("Warning: You are still playing a game"), 0);
11961         break;
11962       case IcsObserving:
11963         DisplayError(_("Warning: You are still observing a game"), 0);
11964         break;
11965       case IcsExamining:
11966         DisplayError(_("Warning: You are still examining a game"), 0);
11967         break;
11968       case IcsIdle:
11969         break;
11970       case EditGame:
11971       default:
11972         return;
11973     }
11974
11975     pausing = FALSE;
11976     StopClocks();
11977     first.offeredDraw = second.offeredDraw = 0;
11978
11979     if (gameMode == PlayFromGameFile) {
11980         whiteTimeRemaining = timeRemaining[0][currentMove];
11981         blackTimeRemaining = timeRemaining[1][currentMove];
11982         DisplayTitle("");
11983     }
11984
11985     if (gameMode == MachinePlaysWhite ||
11986         gameMode == MachinePlaysBlack ||
11987         gameMode == TwoMachinesPlay ||
11988         gameMode == EndOfGame) {
11989         i = forwardMostMove;
11990         while (i > currentMove) {
11991             SendToProgram("undo\n", &first);
11992             i--;
11993         }
11994         whiteTimeRemaining = timeRemaining[0][currentMove];
11995         blackTimeRemaining = timeRemaining[1][currentMove];
11996         DisplayBothClocks();
11997         if (whiteFlag || blackFlag) {
11998             whiteFlag = blackFlag = 0;
11999         }
12000         DisplayTitle("");
12001     }
12002
12003     gameMode = EditGame;
12004     ModeHighlight();
12005     SetGameInfo();
12006 }
12007
12008
12009 void
12010 EditPositionEvent()
12011 {
12012     if (gameMode == EditPosition) {
12013         EditGameEvent();
12014         return;
12015     }
12016
12017     EditGameEvent();
12018     if (gameMode != EditGame) return;
12019
12020     gameMode = EditPosition;
12021     ModeHighlight();
12022     SetGameInfo();
12023     if (currentMove > 0)
12024       CopyBoard(boards[0], boards[currentMove]);
12025
12026     blackPlaysFirst = !WhiteOnMove(currentMove);
12027     ResetClocks();
12028     currentMove = forwardMostMove = backwardMostMove = 0;
12029     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
12030     DisplayMove(-1);
12031 }
12032
12033 void
12034 ExitAnalyzeMode()
12035 {
12036     /* [DM] icsEngineAnalyze - possible call from other functions */
12037     if (appData.icsEngineAnalyze) {
12038         appData.icsEngineAnalyze = FALSE;
12039
12040         DisplayMessage("",_("Close ICS engine analyze..."));
12041     }
12042     if (first.analysisSupport && first.analyzing) {
12043       SendToProgram("exit\n", &first);
12044       first.analyzing = FALSE;
12045     }
12046     thinkOutput[0] = NULLCHAR;
12047 }
12048
12049 void
12050 EditPositionDone(Boolean fakeRights)
12051 {
12052     int king = gameInfo.variant == VariantKnightmate ? WhiteUnicorn : WhiteKing;
12053
12054     startedFromSetupPosition = TRUE;
12055     InitChessProgram(&first, FALSE);
12056     if(fakeRights) { // [HGM] suppress this if we just pasted a FEN.
12057       boards[0][EP_STATUS] = EP_NONE;
12058       boards[0][CASTLING][2] = boards[0][CASTLING][5] = BOARD_WIDTH>>1;
12059     if(boards[0][0][BOARD_WIDTH>>1] == king) {
12060         boards[0][CASTLING][1] = boards[0][0][BOARD_LEFT] == WhiteRook ? 0 : NoRights;
12061         boards[0][CASTLING][0] = boards[0][0][BOARD_RGHT-1] == WhiteRook ? BOARD_RGHT-1 : NoRights;
12062       } else boards[0][CASTLING][2] = NoRights;
12063     if(boards[0][BOARD_HEIGHT-1][BOARD_WIDTH>>1] == WHITE_TO_BLACK king) {
12064         boards[0][CASTLING][4] = boards[0][BOARD_HEIGHT-1][BOARD_LEFT] == BlackRook ? 0 : NoRights;
12065         boards[0][CASTLING][3] = boards[0][BOARD_HEIGHT-1][BOARD_RGHT-1] == BlackRook ? BOARD_RGHT-1 : NoRights;
12066       } else boards[0][CASTLING][5] = NoRights;
12067     }
12068     SendToProgram("force\n", &first);
12069     if (blackPlaysFirst) {
12070         strcpy(moveList[0], "");
12071         strcpy(parseList[0], "");
12072         currentMove = forwardMostMove = backwardMostMove = 1;
12073         CopyBoard(boards[1], boards[0]);
12074     } else {
12075         currentMove = forwardMostMove = backwardMostMove = 0;
12076     }
12077     SendBoard(&first, forwardMostMove);
12078     if (appData.debugMode) {
12079         fprintf(debugFP, "EditPosDone\n");
12080     }
12081     DisplayTitle("");
12082     timeRemaining[0][forwardMostMove] = whiteTimeRemaining;
12083     timeRemaining[1][forwardMostMove] = blackTimeRemaining;
12084     gameMode = EditGame;
12085     ModeHighlight();
12086     HistorySet(parseList, backwardMostMove, forwardMostMove, currentMove-1);
12087     ClearHighlights(); /* [AS] */
12088 }
12089
12090 /* Pause for `ms' milliseconds */
12091 /* !! Ugh, this is a kludge. Fix it sometime. --tpm */
12092 void
12093 TimeDelay(ms)
12094      long ms;
12095 {
12096     TimeMark m1, m2;
12097
12098     GetTimeMark(&m1);
12099     do {
12100         GetTimeMark(&m2);
12101     } while (SubtractTimeMarks(&m2, &m1) < ms);
12102 }
12103
12104 /* !! Ugh, this is a kludge. Fix it sometime. --tpm */
12105 void
12106 SendMultiLineToICS(buf)
12107      char *buf;
12108 {
12109     char temp[MSG_SIZ+1], *p;
12110     int len;
12111
12112     len = strlen(buf);
12113     if (len > MSG_SIZ)
12114       len = MSG_SIZ;
12115
12116     strncpy(temp, buf, len);
12117     temp[len] = 0;
12118
12119     p = temp;
12120     while (*p) {
12121         if (*p == '\n' || *p == '\r')
12122           *p = ' ';
12123         ++p;
12124     }
12125
12126     strcat(temp, "\n");
12127     SendToICS(temp);
12128     SendToPlayer(temp, strlen(temp));
12129 }
12130
12131 void
12132 SetWhiteToPlayEvent()
12133 {
12134     if (gameMode == EditPosition) {
12135         blackPlaysFirst = FALSE;
12136         DisplayBothClocks();    /* works because currentMove is 0 */
12137     } else if (gameMode == IcsExamining) {
12138         SendToICS(ics_prefix);
12139         SendToICS("tomove white\n");
12140     }
12141 }
12142
12143 void
12144 SetBlackToPlayEvent()
12145 {
12146     if (gameMode == EditPosition) {
12147         blackPlaysFirst = TRUE;
12148         currentMove = 1;        /* kludge */
12149         DisplayBothClocks();
12150         currentMove = 0;
12151     } else if (gameMode == IcsExamining) {
12152         SendToICS(ics_prefix);
12153         SendToICS("tomove black\n");
12154     }
12155 }
12156
12157 void
12158 EditPositionMenuEvent(selection, x, y)
12159      ChessSquare selection;
12160      int x, y;
12161 {
12162     char buf[MSG_SIZ];
12163     ChessSquare piece = boards[0][y][x];
12164
12165     if (gameMode != EditPosition && gameMode != IcsExamining) return;
12166
12167     switch (selection) {
12168       case ClearBoard:
12169         if (gameMode == IcsExamining && ics_type == ICS_FICS) {
12170             SendToICS(ics_prefix);
12171             SendToICS("bsetup clear\n");
12172         } else if (gameMode == IcsExamining && ics_type == ICS_ICC) {
12173             SendToICS(ics_prefix);
12174             SendToICS("clearboard\n");
12175         } else {
12176             for (x = 0; x < BOARD_WIDTH; x++) { ChessSquare p = EmptySquare;
12177                 if(x == BOARD_LEFT-1 || x == BOARD_RGHT) p = (ChessSquare) 0; /* [HGM] holdings */
12178                 for (y = 0; y < BOARD_HEIGHT; y++) {
12179                     if (gameMode == IcsExamining) {
12180                         if (boards[currentMove][y][x] != EmptySquare) {
12181                             sprintf(buf, "%sx@%c%c\n", ics_prefix,
12182                                     AAA + x, ONE + y);
12183                             SendToICS(buf);
12184                         }
12185                     } else {
12186                         boards[0][y][x] = p;
12187                     }
12188                 }
12189             }
12190         }
12191         if (gameMode == EditPosition) {
12192             DrawPosition(FALSE, boards[0]);
12193         }
12194         break;
12195
12196       case WhitePlay:
12197         SetWhiteToPlayEvent();
12198         break;
12199
12200       case BlackPlay:
12201         SetBlackToPlayEvent();
12202         break;
12203
12204       case EmptySquare:
12205         if (gameMode == IcsExamining) {
12206             if (x < BOARD_LEFT || x >= BOARD_RGHT) break; // [HGM] holdings
12207             sprintf(buf, "%sx@%c%c\n", ics_prefix, AAA + x, ONE + y);
12208             SendToICS(buf);
12209         } else {
12210             if(x < BOARD_LEFT || x >= BOARD_RGHT) {
12211                 if(x == BOARD_LEFT-2) {
12212                     if(y < BOARD_HEIGHT-1-gameInfo.holdingsSize) break;
12213                     boards[0][y][1] = 0;
12214                 } else
12215                 if(x == BOARD_RGHT+1) {
12216                     if(y >= gameInfo.holdingsSize) break;
12217                     boards[0][y][BOARD_WIDTH-2] = 0;
12218                 } else break;
12219             }
12220             boards[0][y][x] = EmptySquare;
12221             DrawPosition(FALSE, boards[0]);
12222         }
12223         break;
12224
12225       case PromotePiece:
12226         if(piece >= (int)WhitePawn && piece < (int)WhiteMan ||
12227            piece >= (int)BlackPawn && piece < (int)BlackMan   ) {
12228             selection = (ChessSquare) (PROMOTED piece);
12229         } else if(piece == EmptySquare) selection = WhiteSilver;
12230         else selection = (ChessSquare)((int)piece - 1);
12231         goto defaultlabel;
12232
12233       case DemotePiece:
12234         if(piece > (int)WhiteMan && piece <= (int)WhiteKing ||
12235            piece > (int)BlackMan && piece <= (int)BlackKing   ) {
12236             selection = (ChessSquare) (DEMOTED piece);
12237         } else if(piece == EmptySquare) selection = BlackSilver;
12238         else selection = (ChessSquare)((int)piece + 1);
12239         goto defaultlabel;
12240
12241       case WhiteQueen:
12242       case BlackQueen:
12243         if(gameInfo.variant == VariantShatranj ||
12244            gameInfo.variant == VariantXiangqi  ||
12245            gameInfo.variant == VariantCourier  ||
12246            gameInfo.variant == VariantMakruk     )
12247             selection = (ChessSquare)((int)selection - (int)WhiteQueen + (int)WhiteFerz);
12248         goto defaultlabel;
12249
12250       case WhiteKing:
12251       case BlackKing:
12252         if(gameInfo.variant == VariantXiangqi)
12253             selection = (ChessSquare)((int)selection - (int)WhiteKing + (int)WhiteWazir);
12254         if(gameInfo.variant == VariantKnightmate)
12255             selection = (ChessSquare)((int)selection - (int)WhiteKing + (int)WhiteUnicorn);
12256       default:
12257         defaultlabel:
12258         if (gameMode == IcsExamining) {
12259             if (x < BOARD_LEFT || x >= BOARD_RGHT) break; // [HGM] holdings
12260             sprintf(buf, "%s%c@%c%c\n", ics_prefix,
12261                     PieceToChar(selection), AAA + x, ONE + y);
12262             SendToICS(buf);
12263         } else {
12264             if(x < BOARD_LEFT || x >= BOARD_RGHT) {
12265                 int n;
12266                 if(x == BOARD_LEFT-2 && selection >= BlackPawn) {
12267                     n = PieceToNumber(selection - BlackPawn);
12268                     if(n >= gameInfo.holdingsSize) { n = 0; selection = BlackPawn; }
12269                     boards[0][BOARD_HEIGHT-1-n][0] = selection;
12270                     boards[0][BOARD_HEIGHT-1-n][1]++;
12271                 } else
12272                 if(x == BOARD_RGHT+1 && selection < BlackPawn) {
12273                     n = PieceToNumber(selection);
12274                     if(n >= gameInfo.holdingsSize) { n = 0; selection = WhitePawn; }
12275                     boards[0][n][BOARD_WIDTH-1] = selection;
12276                     boards[0][n][BOARD_WIDTH-2]++;
12277                 }
12278             } else
12279             boards[0][y][x] = selection;
12280             DrawPosition(TRUE, boards[0]);
12281         }
12282         break;
12283     }
12284 }
12285
12286
12287 void
12288 DropMenuEvent(selection, x, y)
12289      ChessSquare selection;
12290      int x, y;
12291 {
12292     ChessMove moveType;
12293
12294     switch (gameMode) {
12295       case IcsPlayingWhite:
12296       case MachinePlaysBlack:
12297         if (!WhiteOnMove(currentMove)) {
12298             DisplayMoveError(_("It is Black's turn"));
12299             return;
12300         }
12301         moveType = WhiteDrop;
12302         break;
12303       case IcsPlayingBlack:
12304       case MachinePlaysWhite:
12305         if (WhiteOnMove(currentMove)) {
12306             DisplayMoveError(_("It is White's turn"));
12307             return;
12308         }
12309         moveType = BlackDrop;
12310         break;
12311       case EditGame:
12312         moveType = WhiteOnMove(currentMove) ? WhiteDrop : BlackDrop;
12313         break;
12314       default:
12315         return;
12316     }
12317
12318     if (moveType == BlackDrop && selection < BlackPawn) {
12319       selection = (ChessSquare) ((int) selection
12320                                  + (int) BlackPawn - (int) WhitePawn);
12321     }
12322     if (boards[currentMove][y][x] != EmptySquare) {
12323         DisplayMoveError(_("That square is occupied"));
12324         return;
12325     }
12326
12327     FinishMove(moveType, (int) selection, DROP_RANK, x, y, NULLCHAR);
12328 }
12329
12330 void
12331 AcceptEvent()
12332 {
12333     /* Accept a pending offer of any kind from opponent */
12334
12335     if (appData.icsActive) {
12336         SendToICS(ics_prefix);
12337         SendToICS("accept\n");
12338     } else if (cmailMsgLoaded) {
12339         if (currentMove == cmailOldMove &&
12340             commentList[cmailOldMove] != NULL &&
12341             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
12342                    "Black offers a draw" : "White offers a draw")) {
12343             TruncateGame();
12344             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
12345             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_ACCEPT;
12346         } else {
12347             DisplayError(_("There is no pending offer on this move"), 0);
12348             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
12349         }
12350     } else {
12351         /* Not used for offers from chess program */
12352     }
12353 }
12354
12355 void
12356 DeclineEvent()
12357 {
12358     /* Decline a pending offer of any kind from opponent */
12359
12360     if (appData.icsActive) {
12361         SendToICS(ics_prefix);
12362         SendToICS("decline\n");
12363     } else if (cmailMsgLoaded) {
12364         if (currentMove == cmailOldMove &&
12365             commentList[cmailOldMove] != NULL &&
12366             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
12367                    "Black offers a draw" : "White offers a draw")) {
12368 #ifdef NOTDEF
12369             AppendComment(cmailOldMove, "Draw declined", TRUE);
12370             DisplayComment(cmailOldMove - 1, "Draw declined");
12371 #endif /*NOTDEF*/
12372         } else {
12373             DisplayError(_("There is no pending offer on this move"), 0);
12374         }
12375     } else {
12376         /* Not used for offers from chess program */
12377     }
12378 }
12379
12380 void
12381 RematchEvent()
12382 {
12383     /* Issue ICS rematch command */
12384     if (appData.icsActive) {
12385         SendToICS(ics_prefix);
12386         SendToICS("rematch\n");
12387     }
12388 }
12389
12390 void
12391 CallFlagEvent()
12392 {
12393     /* Call your opponent's flag (claim a win on time) */
12394     if (appData.icsActive) {
12395         SendToICS(ics_prefix);
12396         SendToICS("flag\n");
12397     } else {
12398         switch (gameMode) {
12399           default:
12400             return;
12401           case MachinePlaysWhite:
12402             if (whiteFlag) {
12403                 if (blackFlag)
12404                   GameEnds(GameIsDrawn, "Both players ran out of time",
12405                            GE_PLAYER);
12406                 else
12407                   GameEnds(BlackWins, "Black wins on time", GE_PLAYER);
12408             } else {
12409                 DisplayError(_("Your opponent is not out of time"), 0);
12410             }
12411             break;
12412           case MachinePlaysBlack:
12413             if (blackFlag) {
12414                 if (whiteFlag)
12415                   GameEnds(GameIsDrawn, "Both players ran out of time",
12416                            GE_PLAYER);
12417                 else
12418                   GameEnds(WhiteWins, "White wins on time", GE_PLAYER);
12419             } else {
12420                 DisplayError(_("Your opponent is not out of time"), 0);
12421             }
12422             break;
12423         }
12424     }
12425 }
12426
12427 void
12428 DrawEvent()
12429 {
12430     /* Offer draw or accept pending draw offer from opponent */
12431
12432     if (appData.icsActive) {
12433         /* Note: tournament rules require draw offers to be
12434            made after you make your move but before you punch
12435            your clock.  Currently ICS doesn't let you do that;
12436            instead, you immediately punch your clock after making
12437            a move, but you can offer a draw at any time. */
12438
12439         SendToICS(ics_prefix);
12440         SendToICS("draw\n");
12441         userOfferedDraw = TRUE; // [HGM] drawclaim: also set flag in ICS play
12442     } else if (cmailMsgLoaded) {
12443         if (currentMove == cmailOldMove &&
12444             commentList[cmailOldMove] != NULL &&
12445             StrStr(commentList[cmailOldMove], WhiteOnMove(cmailOldMove) ?
12446                    "Black offers a draw" : "White offers a draw")) {
12447             GameEnds(GameIsDrawn, "Draw agreed", GE_PLAYER);
12448             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_ACCEPT;
12449         } else if (currentMove == cmailOldMove + 1) {
12450             char *offer = WhiteOnMove(cmailOldMove) ?
12451               "White offers a draw" : "Black offers a draw";
12452             AppendComment(currentMove, offer, TRUE);
12453             DisplayComment(currentMove - 1, offer);
12454             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_DRAW;
12455         } else {
12456             DisplayError(_("You must make your move before offering a draw"), 0);
12457             cmailMoveType[lastLoadGameNumber - 1] = CMAIL_MOVE;
12458         }
12459     } else if (first.offeredDraw) {
12460         GameEnds(GameIsDrawn, "Draw agreed", GE_XBOARD);
12461     } else {
12462         if (first.sendDrawOffers) {
12463             SendToProgram("draw\n", &first);
12464             userOfferedDraw = TRUE;
12465         }
12466     }
12467 }
12468
12469 void
12470 AdjournEvent()
12471 {
12472     /* Offer Adjourn or accept pending Adjourn offer from opponent */
12473
12474     if (appData.icsActive) {
12475         SendToICS(ics_prefix);
12476         SendToICS("adjourn\n");
12477     } else {
12478         /* Currently GNU Chess doesn't offer or accept Adjourns */
12479     }
12480 }
12481
12482
12483 void
12484 AbortEvent()
12485 {
12486     /* Offer Abort or accept pending Abort offer from opponent */
12487
12488     if (appData.icsActive) {
12489         SendToICS(ics_prefix);
12490         SendToICS("abort\n");
12491     } else {
12492         GameEnds(GameUnfinished, "Game aborted", GE_PLAYER);
12493     }
12494 }
12495
12496 void
12497 ResignEvent()
12498 {
12499     /* Resign.  You can do this even if it's not your turn. */
12500
12501     if (appData.icsActive) {
12502         SendToICS(ics_prefix);
12503         SendToICS("resign\n");
12504     } else {
12505         switch (gameMode) {
12506           case MachinePlaysWhite:
12507             GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
12508             break;
12509           case MachinePlaysBlack:
12510             GameEnds(BlackWins, "White resigns", GE_PLAYER);
12511             break;
12512           case EditGame:
12513             if (cmailMsgLoaded) {
12514                 TruncateGame();
12515                 if (WhiteOnMove(cmailOldMove)) {
12516                     GameEnds(BlackWins, "White resigns", GE_PLAYER);
12517                 } else {
12518                     GameEnds(WhiteWins, "Black resigns", GE_PLAYER);
12519                 }
12520                 cmailMoveType[lastLoadGameNumber - 1] = CMAIL_RESIGN;
12521             }
12522             break;
12523           default:
12524             break;
12525         }
12526     }
12527 }
12528
12529
12530 void
12531 StopObservingEvent()
12532 {
12533     /* Stop observing current games */
12534     SendToICS(ics_prefix);
12535     SendToICS("unobserve\n");
12536 }
12537
12538 void
12539 StopExaminingEvent()
12540 {
12541     /* Stop observing current game */
12542     SendToICS(ics_prefix);
12543     SendToICS("unexamine\n");
12544 }
12545
12546 void
12547 ForwardInner(target)
12548      int target;
12549 {
12550     int limit;
12551
12552     if (appData.debugMode)
12553         fprintf(debugFP, "ForwardInner(%d), current %d, forward %d\n",
12554                 target, currentMove, forwardMostMove);
12555
12556     if (gameMode == EditPosition)
12557       return;
12558
12559     if (gameMode == PlayFromGameFile && !pausing)
12560       PauseEvent();
12561
12562     if (gameMode == IcsExamining && pausing)
12563       limit = pauseExamForwardMostMove;
12564     else
12565       limit = forwardMostMove;
12566
12567     if (target > limit) target = limit;
12568
12569     if (target > 0 && moveList[target - 1][0]) {
12570         int fromX, fromY, toX, toY;
12571         toX = moveList[target - 1][2] - AAA;
12572         toY = moveList[target - 1][3] - ONE;
12573         if (moveList[target - 1][1] == '@') {
12574             if (appData.highlightLastMove) {
12575                 SetHighlights(-1, -1, toX, toY);
12576             }
12577         } else {
12578             fromX = moveList[target - 1][0] - AAA;
12579             fromY = moveList[target - 1][1] - ONE;
12580             if (target == currentMove + 1) {
12581                 AnimateMove(boards[currentMove], fromX, fromY, toX, toY);
12582             }
12583             if (appData.highlightLastMove) {
12584                 SetHighlights(fromX, fromY, toX, toY);
12585             }
12586         }
12587     }
12588     if (gameMode == EditGame || gameMode == AnalyzeMode ||
12589         gameMode == Training || gameMode == PlayFromGameFile ||
12590         gameMode == AnalyzeFile) {
12591         while (currentMove < target) {
12592             SendMoveToProgram(currentMove++, &first);
12593         }
12594     } else {
12595         currentMove = target;
12596     }
12597
12598     if (gameMode == EditGame || gameMode == EndOfGame) {
12599         whiteTimeRemaining = timeRemaining[0][currentMove];
12600         blackTimeRemaining = timeRemaining[1][currentMove];
12601     }
12602     DisplayBothClocks();
12603     DisplayMove(currentMove - 1);
12604     DrawPosition(FALSE, boards[currentMove]);
12605     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
12606     if ( !matchMode && gameMode != Training) { // [HGM] PV info: routine tests if empty
12607         DisplayComment(currentMove - 1, commentList[currentMove]);
12608     }
12609 }
12610
12611
12612 void
12613 ForwardEvent()
12614 {
12615     if (gameMode == IcsExamining && !pausing) {
12616         SendToICS(ics_prefix);
12617         SendToICS("forward\n");
12618     } else {
12619         ForwardInner(currentMove + 1);
12620     }
12621 }
12622
12623 void
12624 ToEndEvent()
12625 {
12626     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
12627         /* to optimze, we temporarily turn off analysis mode while we feed
12628          * the remaining moves to the engine. Otherwise we get analysis output
12629          * after each move.
12630          */
12631         if (first.analysisSupport) {
12632           SendToProgram("exit\nforce\n", &first);
12633           first.analyzing = FALSE;
12634         }
12635     }
12636
12637     if (gameMode == IcsExamining && !pausing) {
12638         SendToICS(ics_prefix);
12639         SendToICS("forward 999999\n");
12640     } else {
12641         ForwardInner(forwardMostMove);
12642     }
12643
12644     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
12645         /* we have fed all the moves, so reactivate analysis mode */
12646         SendToProgram("analyze\n", &first);
12647         first.analyzing = TRUE;
12648         /*first.maybeThinking = TRUE;*/
12649         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
12650     }
12651 }
12652
12653 void
12654 BackwardInner(target)
12655      int target;
12656 {
12657     int full_redraw = TRUE; /* [AS] Was FALSE, had to change it! */
12658
12659     if (appData.debugMode)
12660         fprintf(debugFP, "BackwardInner(%d), current %d, forward %d\n",
12661                 target, currentMove, forwardMostMove);
12662
12663     if (gameMode == EditPosition) return;
12664     if (currentMove <= backwardMostMove) {
12665         ClearHighlights();
12666         DrawPosition(full_redraw, boards[currentMove]);
12667         return;
12668     }
12669     if (gameMode == PlayFromGameFile && !pausing)
12670       PauseEvent();
12671
12672     if (moveList[target][0]) {
12673         int fromX, fromY, toX, toY;
12674         toX = moveList[target][2] - AAA;
12675         toY = moveList[target][3] - ONE;
12676         if (moveList[target][1] == '@') {
12677             if (appData.highlightLastMove) {
12678                 SetHighlights(-1, -1, toX, toY);
12679             }
12680         } else {
12681             fromX = moveList[target][0] - AAA;
12682             fromY = moveList[target][1] - ONE;
12683             if (target == currentMove - 1) {
12684                 AnimateMove(boards[currentMove], toX, toY, fromX, fromY);
12685             }
12686             if (appData.highlightLastMove) {
12687                 SetHighlights(fromX, fromY, toX, toY);
12688             }
12689         }
12690     }
12691     if (gameMode == EditGame || gameMode==AnalyzeMode ||
12692         gameMode == PlayFromGameFile || gameMode == AnalyzeFile) {
12693         while (currentMove > target) {
12694             SendToProgram("undo\n", &first);
12695             currentMove--;
12696         }
12697     } else {
12698         currentMove = target;
12699     }
12700
12701     if (gameMode == EditGame || gameMode == EndOfGame) {
12702         whiteTimeRemaining = timeRemaining[0][currentMove];
12703         blackTimeRemaining = timeRemaining[1][currentMove];
12704     }
12705     DisplayBothClocks();
12706     DisplayMove(currentMove - 1);
12707     DrawPosition(full_redraw, boards[currentMove]);
12708     HistorySet(parseList,backwardMostMove,forwardMostMove,currentMove-1);
12709     // [HGM] PV info: routine tests if comment empty
12710     DisplayComment(currentMove - 1, commentList[currentMove]);
12711 }
12712
12713 void
12714 BackwardEvent()
12715 {
12716     if (gameMode == IcsExamining && !pausing) {
12717         SendToICS(ics_prefix);
12718         SendToICS("backward\n");
12719     } else {
12720         BackwardInner(currentMove - 1);
12721     }
12722 }
12723
12724 void
12725 ToStartEvent()
12726 {
12727     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
12728         /* to optimize, we temporarily turn off analysis mode while we undo
12729          * all the moves. Otherwise we get analysis output after each undo.
12730          */
12731         if (first.analysisSupport) {
12732           SendToProgram("exit\nforce\n", &first);
12733           first.analyzing = FALSE;
12734         }
12735     }
12736
12737     if (gameMode == IcsExamining && !pausing) {
12738         SendToICS(ics_prefix);
12739         SendToICS("backward 999999\n");
12740     } else {
12741         BackwardInner(backwardMostMove);
12742     }
12743
12744     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
12745         /* we have fed all the moves, so reactivate analysis mode */
12746         SendToProgram("analyze\n", &first);
12747         first.analyzing = TRUE;
12748         /*first.maybeThinking = TRUE;*/
12749         first.maybeThinking = FALSE; /* avoid killing GNU Chess */
12750     }
12751 }
12752
12753 void
12754 ToNrEvent(int to)
12755 {
12756   if (gameMode == PlayFromGameFile && !pausing) PauseEvent();
12757   if (to >= forwardMostMove) to = forwardMostMove;
12758   if (to <= backwardMostMove) to = backwardMostMove;
12759   if (to < currentMove) {
12760     BackwardInner(to);
12761   } else {
12762     ForwardInner(to);
12763   }
12764 }
12765
12766 void
12767 RevertEvent(Boolean annotate)
12768 {
12769     if(PopTail(annotate)) { // [HGM] vari: restore old game tail
12770         return;
12771     }
12772     if (gameMode != IcsExamining) {
12773         DisplayError(_("You are not examining a game"), 0);
12774         return;
12775     }
12776     if (pausing) {
12777         DisplayError(_("You can't revert while pausing"), 0);
12778         return;
12779     }
12780     SendToICS(ics_prefix);
12781     SendToICS("revert\n");
12782 }
12783
12784 void
12785 RetractMoveEvent()
12786 {
12787     switch (gameMode) {
12788       case MachinePlaysWhite:
12789       case MachinePlaysBlack:
12790         if (WhiteOnMove(forwardMostMove) == (gameMode == MachinePlaysWhite)) {
12791             DisplayError(_("Wait until your turn,\nor select Move Now"), 0);
12792             return;
12793         }
12794         if (forwardMostMove < 2) return;
12795         currentMove = forwardMostMove = forwardMostMove - 2;
12796         whiteTimeRemaining = timeRemaining[0][currentMove];
12797         blackTimeRemaining = timeRemaining[1][currentMove];
12798         DisplayBothClocks();
12799         DisplayMove(currentMove - 1);
12800         ClearHighlights();/*!! could figure this out*/
12801         DrawPosition(TRUE, boards[currentMove]); /* [AS] Changed to full redraw! */
12802         SendToProgram("remove\n", &first);
12803         /*first.maybeThinking = TRUE;*/ /* GNU Chess does not ponder here */
12804         break;
12805
12806       case BeginningOfGame:
12807       default:
12808         break;
12809
12810       case IcsPlayingWhite:
12811       case IcsPlayingBlack:
12812         if (WhiteOnMove(forwardMostMove) == (gameMode == IcsPlayingWhite)) {
12813             SendToICS(ics_prefix);
12814             SendToICS("takeback 2\n");
12815         } else {
12816             SendToICS(ics_prefix);
12817             SendToICS("takeback 1\n");
12818         }
12819         break;
12820     }
12821 }
12822
12823 void
12824 MoveNowEvent()
12825 {
12826     ChessProgramState *cps;
12827
12828     switch (gameMode) {
12829       case MachinePlaysWhite:
12830         if (!WhiteOnMove(forwardMostMove)) {
12831             DisplayError(_("It is your turn"), 0);
12832             return;
12833         }
12834         cps = &first;
12835         break;
12836       case MachinePlaysBlack:
12837         if (WhiteOnMove(forwardMostMove)) {
12838             DisplayError(_("It is your turn"), 0);
12839             return;
12840         }
12841         cps = &first;
12842         break;
12843       case TwoMachinesPlay:
12844         if (WhiteOnMove(forwardMostMove) ==
12845             (first.twoMachinesColor[0] == 'w')) {
12846             cps = &first;
12847         } else {
12848             cps = &second;
12849         }
12850         break;
12851       case BeginningOfGame:
12852       default:
12853         return;
12854     }
12855     SendToProgram("?\n", cps);
12856 }
12857
12858 void
12859 TruncateGameEvent()
12860 {
12861     EditGameEvent();
12862     if (gameMode != EditGame) return;
12863     TruncateGame();
12864 }
12865
12866 void
12867 TruncateGame()
12868 {
12869     CleanupTail(); // [HGM] vari: only keep current variation if we explicitly truncate
12870     if (forwardMostMove > currentMove) {
12871         if (gameInfo.resultDetails != NULL) {
12872             free(gameInfo.resultDetails);
12873             gameInfo.resultDetails = NULL;
12874             gameInfo.result = GameUnfinished;
12875         }
12876         forwardMostMove = currentMove;
12877         HistorySet(parseList, backwardMostMove, forwardMostMove,
12878                    currentMove-1);
12879     }
12880 }
12881
12882 void
12883 HintEvent()
12884 {
12885     if (appData.noChessProgram) return;
12886     switch (gameMode) {
12887       case MachinePlaysWhite:
12888         if (WhiteOnMove(forwardMostMove)) {
12889             DisplayError(_("Wait until your turn"), 0);
12890             return;
12891         }
12892         break;
12893       case BeginningOfGame:
12894       case MachinePlaysBlack:
12895         if (!WhiteOnMove(forwardMostMove)) {
12896             DisplayError(_("Wait until your turn"), 0);
12897             return;
12898         }
12899         break;
12900       default:
12901         DisplayError(_("No hint available"), 0);
12902         return;
12903     }
12904     SendToProgram("hint\n", &first);
12905     hintRequested = TRUE;
12906 }
12907
12908 void
12909 BookEvent()
12910 {
12911     if (appData.noChessProgram) return;
12912     switch (gameMode) {
12913       case MachinePlaysWhite:
12914         if (WhiteOnMove(forwardMostMove)) {
12915             DisplayError(_("Wait until your turn"), 0);
12916             return;
12917         }
12918         break;
12919       case BeginningOfGame:
12920       case MachinePlaysBlack:
12921         if (!WhiteOnMove(forwardMostMove)) {
12922             DisplayError(_("Wait until your turn"), 0);
12923             return;
12924         }
12925         break;
12926       case EditPosition:
12927         EditPositionDone(TRUE);
12928         break;
12929       case TwoMachinesPlay:
12930         return;
12931       default:
12932         break;
12933     }
12934     SendToProgram("bk\n", &first);
12935     bookOutput[0] = NULLCHAR;
12936     bookRequested = TRUE;
12937 }
12938
12939 void
12940 AboutGameEvent()
12941 {
12942     char *tags = PGNTags(&gameInfo);
12943     TagsPopUp(tags, CmailMsg());
12944     free(tags);
12945 }
12946
12947 /* end button procedures */
12948
12949 void
12950 PrintPosition(fp, move)
12951      FILE *fp;
12952      int move;
12953 {
12954     int i, j;
12955
12956     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
12957         for (j = BOARD_LEFT; j < BOARD_RGHT; j++) {
12958             char c = PieceToChar(boards[move][i][j]);
12959             fputc(c == 'x' ? '.' : c, fp);
12960             fputc(j == BOARD_RGHT - 1 ? '\n' : ' ', fp);
12961         }
12962     }
12963     if ((gameMode == EditPosition) ? !blackPlaysFirst : (move % 2 == 0))
12964       fprintf(fp, "white to play\n");
12965     else
12966       fprintf(fp, "black to play\n");
12967 }
12968
12969 void
12970 PrintOpponents(fp)
12971      FILE *fp;
12972 {
12973     if (gameInfo.white != NULL) {
12974         fprintf(fp, "\t%s vs. %s\n", gameInfo.white, gameInfo.black);
12975     } else {
12976         fprintf(fp, "\n");
12977     }
12978 }
12979
12980 /* Find last component of program's own name, using some heuristics */
12981 void
12982 TidyProgramName(prog, host, buf)
12983      char *prog, *host, buf[MSG_SIZ];
12984 {
12985     char *p, *q;
12986     int local = (strcmp(host, "localhost") == 0);
12987     while (!local && (p = strchr(prog, ';')) != NULL) {
12988         p++;
12989         while (*p == ' ') p++;
12990         prog = p;
12991     }
12992     if (*prog == '"' || *prog == '\'') {
12993         q = strchr(prog + 1, *prog);
12994     } else {
12995         q = strchr(prog, ' ');
12996     }
12997     if (q == NULL) q = prog + strlen(prog);
12998     p = q;
12999     while (p >= prog && *p != '/' && *p != '\\') p--;
13000     p++;
13001     if(p == prog && *p == '"') p++;
13002     if (q - p >= 4 && StrCaseCmp(q - 4, ".exe") == 0) q -= 4;
13003     memcpy(buf, p, q - p);
13004     buf[q - p] = NULLCHAR;
13005     if (!local) {
13006         strcat(buf, "@");
13007         strcat(buf, host);
13008     }
13009 }
13010
13011 char *
13012 TimeControlTagValue()
13013 {
13014     char buf[MSG_SIZ];
13015     if (!appData.clockMode) {
13016         strcpy(buf, "-");
13017     } else if (movesPerSession > 0) {
13018         sprintf(buf, "%d/%ld", movesPerSession, timeControl/1000);
13019     } else if (timeIncrement == 0) {
13020         sprintf(buf, "%ld", timeControl/1000);
13021     } else {
13022         sprintf(buf, "%ld+%ld", timeControl/1000, timeIncrement/1000);
13023     }
13024     return StrSave(buf);
13025 }
13026
13027 void
13028 SetGameInfo()
13029 {
13030     /* This routine is used only for certain modes */
13031     VariantClass v = gameInfo.variant;
13032     ChessMove r = GameUnfinished;
13033     char *p = NULL;
13034
13035     if(gameMode == EditGame) { // [HGM] vari: do not erase result on EditGame
13036         r = gameInfo.result;
13037         p = gameInfo.resultDetails;
13038         gameInfo.resultDetails = NULL;
13039     }
13040     ClearGameInfo(&gameInfo);
13041     gameInfo.variant = v;
13042
13043     switch (gameMode) {
13044       case MachinePlaysWhite:
13045         gameInfo.event = StrSave( appData.pgnEventHeader );
13046         gameInfo.site = StrSave(HostName());
13047         gameInfo.date = PGNDate();
13048         gameInfo.round = StrSave("-");
13049         gameInfo.white = StrSave(first.tidy);
13050         gameInfo.black = StrSave(UserName());
13051         gameInfo.timeControl = TimeControlTagValue();
13052         break;
13053
13054       case MachinePlaysBlack:
13055         gameInfo.event = StrSave( appData.pgnEventHeader );
13056         gameInfo.site = StrSave(HostName());
13057         gameInfo.date = PGNDate();
13058         gameInfo.round = StrSave("-");
13059         gameInfo.white = StrSave(UserName());
13060         gameInfo.black = StrSave(first.tidy);
13061         gameInfo.timeControl = TimeControlTagValue();
13062         break;
13063
13064       case TwoMachinesPlay:
13065         gameInfo.event = StrSave( appData.pgnEventHeader );
13066         gameInfo.site = StrSave(HostName());
13067         gameInfo.date = PGNDate();
13068         if (matchGame > 0) {
13069             char buf[MSG_SIZ];
13070             sprintf(buf, "%d", matchGame);
13071             gameInfo.round = StrSave(buf);
13072         } else {
13073             gameInfo.round = StrSave("-");
13074         }
13075         if (first.twoMachinesColor[0] == 'w') {
13076             gameInfo.white = StrSave(first.tidy);
13077             gameInfo.black = StrSave(second.tidy);
13078         } else {
13079             gameInfo.white = StrSave(second.tidy);
13080             gameInfo.black = StrSave(first.tidy);
13081         }
13082         gameInfo.timeControl = TimeControlTagValue();
13083         break;
13084
13085       case EditGame:
13086         gameInfo.event = StrSave("Edited game");
13087         gameInfo.site = StrSave(HostName());
13088         gameInfo.date = PGNDate();
13089         gameInfo.round = StrSave("-");
13090         gameInfo.white = StrSave("-");
13091         gameInfo.black = StrSave("-");
13092         gameInfo.result = r;
13093         gameInfo.resultDetails = p;
13094         break;
13095
13096       case EditPosition:
13097         gameInfo.event = StrSave("Edited position");
13098         gameInfo.site = StrSave(HostName());
13099         gameInfo.date = PGNDate();
13100         gameInfo.round = StrSave("-");
13101         gameInfo.white = StrSave("-");
13102         gameInfo.black = StrSave("-");
13103         break;
13104
13105       case IcsPlayingWhite:
13106       case IcsPlayingBlack:
13107       case IcsObserving:
13108       case IcsExamining:
13109         break;
13110
13111       case PlayFromGameFile:
13112         gameInfo.event = StrSave("Game from non-PGN file");
13113         gameInfo.site = StrSave(HostName());
13114         gameInfo.date = PGNDate();
13115         gameInfo.round = StrSave("-");
13116         gameInfo.white = StrSave("?");
13117         gameInfo.black = StrSave("?");
13118         break;
13119
13120       default:
13121         break;
13122     }
13123 }
13124
13125 void
13126 ReplaceComment(index, text)
13127      int index;
13128      char *text;
13129 {
13130     int len;
13131
13132     while (*text == '\n') text++;
13133     len = strlen(text);
13134     while (len > 0 && text[len - 1] == '\n') len--;
13135
13136     if (commentList[index] != NULL)
13137       free(commentList[index]);
13138
13139     if (len == 0) {
13140         commentList[index] = NULL;
13141         return;
13142     }
13143   if( *text == '{' && strchr(text, '}') || // [HGM] braces: if certainy malformed, put braces
13144       *text == '[' && strchr(text, ']') || // otherwise hope the user knows what he is doing
13145       *text == '(' && strchr(text, ')')) { // (perhaps check if this parses as comment-only?)
13146     commentList[index] = (char *) malloc(len + 2);
13147     strncpy(commentList[index], text, len);
13148     commentList[index][len] = '\n';
13149     commentList[index][len + 1] = NULLCHAR;
13150   } else {
13151     // [HGM] braces: if text does not start with known OK delimiter, put braces around it.
13152     char *p;
13153     commentList[index] = (char *) malloc(len + 6);
13154     strcpy(commentList[index], "{\n");
13155     strncpy(commentList[index]+2, text, len);
13156     commentList[index][len+2] = NULLCHAR;
13157     while(p = strchr(commentList[index], '}')) *p = ')'; // kill all } to make it one comment
13158     strcat(commentList[index], "\n}\n");
13159   }
13160 }
13161
13162 void
13163 CrushCRs(text)
13164      char *text;
13165 {
13166   char *p = text;
13167   char *q = text;
13168   char ch;
13169
13170   do {
13171     ch = *p++;
13172     if (ch == '\r') continue;
13173     *q++ = ch;
13174   } while (ch != '\0');
13175 }
13176
13177 void
13178 AppendComment(index, text, addBraces)
13179      int index;
13180      char *text;
13181      Boolean addBraces; // [HGM] braces: tells if we should add {}
13182 {
13183     int oldlen, len;
13184     char *old;
13185
13186 if(appData.debugMode) fprintf(debugFP, "Append: in='%s' %d\n", text, addBraces); fflush(debugFP);
13187     text = GetInfoFromComment( index, text ); /* [HGM] PV time: strip PV info from comment */
13188
13189     CrushCRs(text);
13190     while (*text == '\n') text++;
13191     len = strlen(text);
13192     while (len > 0 && text[len - 1] == '\n') len--;
13193
13194     if (len == 0) return;
13195
13196     if (commentList[index] != NULL) {
13197         old = commentList[index];
13198         oldlen = strlen(old);
13199         while(commentList[index][oldlen-1] ==  '\n')
13200           commentList[index][--oldlen] = NULLCHAR;
13201         commentList[index] = (char *) malloc(oldlen + len + 6); // might waste 4
13202         strcpy(commentList[index], old);
13203         free(old);
13204         // [HGM] braces: join "{A\n}\n" + "{\nB}" as "{A\nB\n}"
13205         if(commentList[index][oldlen-1] == '}' && (text[0] == '{' || addBraces)) {
13206           if(addBraces) addBraces = FALSE; else { text++; len--; }
13207           while (*text == '\n') { text++; len--; }
13208           commentList[index][--oldlen] = NULLCHAR;
13209       }
13210         if(addBraces) strcat(commentList[index], "\n{\n");
13211         else          strcat(commentList[index], "\n");
13212         strcat(commentList[index], text);
13213         if(addBraces) strcat(commentList[index], "\n}\n");
13214         else          strcat(commentList[index], "\n");
13215     } else {
13216         commentList[index] = (char *) malloc(len + 6); // perhaps wastes 4...
13217         if(addBraces)
13218              strcpy(commentList[index], "{\n");
13219         else commentList[index][0] = NULLCHAR;
13220         strcat(commentList[index], text);
13221         strcat(commentList[index], "\n");
13222         if(addBraces) strcat(commentList[index], "}\n");
13223     }
13224 }
13225
13226 static char * FindStr( char * text, char * sub_text )
13227 {
13228     char * result = strstr( text, sub_text );
13229
13230     if( result != NULL ) {
13231         result += strlen( sub_text );
13232     }
13233
13234     return result;
13235 }
13236
13237 /* [AS] Try to extract PV info from PGN comment */
13238 /* [HGM] PV time: and then remove it, to prevent it appearing twice */
13239 char *GetInfoFromComment( int index, char * text )
13240 {
13241     char * sep = text;
13242
13243     if( text != NULL && index > 0 ) {
13244         int score = 0;
13245         int depth = 0;
13246         int time = -1, sec = 0, deci;
13247         char * s_eval = FindStr( text, "[%eval " );
13248         char * s_emt = FindStr( text, "[%emt " );
13249
13250         if( s_eval != NULL || s_emt != NULL ) {
13251             /* New style */
13252             char delim;
13253
13254             if( s_eval != NULL ) {
13255                 if( sscanf( s_eval, "%d,%d%c", &score, &depth, &delim ) != 3 ) {
13256                     return text;
13257                 }
13258
13259                 if( delim != ']' ) {
13260                     return text;
13261                 }
13262             }
13263
13264             if( s_emt != NULL ) {
13265             }
13266                 return text;
13267         }
13268         else {
13269             /* We expect something like: [+|-]nnn.nn/dd */
13270             int score_lo = 0;
13271
13272             if(*text != '{') return text; // [HGM] braces: must be normal comment
13273
13274             sep = strchr( text, '/' );
13275             if( sep == NULL || sep < (text+4) ) {
13276                 return text;
13277             }
13278
13279             time = -1; sec = -1; deci = -1;
13280             if( sscanf( text+1, "%d.%d/%d %d:%d", &score, &score_lo, &depth, &time, &sec ) != 5 &&
13281                 sscanf( text+1, "%d.%d/%d %d.%d", &score, &score_lo, &depth, &time, &deci ) != 5 &&
13282                 sscanf( text+1, "%d.%d/%d %d", &score, &score_lo, &depth, &time ) != 4 &&
13283                 sscanf( text+1, "%d.%d/%d", &score, &score_lo, &depth ) != 3   ) {
13284                 return text;
13285             }
13286
13287             if( score_lo < 0 || score_lo >= 100 ) {
13288                 return text;
13289             }
13290
13291             if(sec >= 0) time = 600*time + 10*sec; else
13292             if(deci >= 0) time = 10*time + deci; else time *= 10; // deci-sec
13293
13294             score = score >= 0 ? score*100 + score_lo : score*100 - score_lo;
13295
13296             /* [HGM] PV time: now locate end of PV info */
13297             while( *++sep >= '0' && *sep <= '9'); // strip depth
13298             if(time >= 0)
13299             while( *++sep >= '0' && *sep <= '9'); // strip time
13300             if(sec >= 0)
13301             while( *++sep >= '0' && *sep <= '9'); // strip seconds
13302             if(deci >= 0)
13303             while( *++sep >= '0' && *sep <= '9'); // strip fractional seconds
13304             while(*sep == ' ') sep++;
13305         }
13306
13307         if( depth <= 0 ) {
13308             return text;
13309         }
13310
13311         if( time < 0 ) {
13312             time = -1;
13313         }
13314
13315         pvInfoList[index-1].depth = depth;
13316         pvInfoList[index-1].score = score;
13317         pvInfoList[index-1].time  = 10*time; // centi-sec
13318         if(*sep == '}') *sep = 0; else *--sep = '{';
13319     }
13320     return sep;
13321 }
13322
13323 void
13324 SendToProgram(message, cps)
13325      char *message;
13326      ChessProgramState *cps;
13327 {
13328     int count, outCount, error;
13329     char buf[MSG_SIZ];
13330
13331     if (cps->pr == NULL) return;
13332     Attention(cps);
13333
13334     if (appData.debugMode) {
13335         TimeMark now;
13336         GetTimeMark(&now);
13337         fprintf(debugFP, "%ld >%-6s: %s",
13338                 SubtractTimeMarks(&now, &programStartTime),
13339                 cps->which, message);
13340     }
13341
13342     count = strlen(message);
13343     outCount = OutputToProcess(cps->pr, message, count, &error);
13344     if (outCount < count && !exiting
13345                          && !endingGame) { /* [HGM] crash: to not hang GameEnds() writing to deceased engines */
13346         sprintf(buf, _("Error writing to %s chess program"), cps->which);
13347         if(gameInfo.resultDetails==NULL) { /* [HGM] crash: if game in progress, give reason for abort */
13348             if((signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
13349                 gameInfo.result = GameIsDrawn; /* [HGM] accept exit as draw claim */
13350                 sprintf(buf, "%s program exits in draw position (%s)", cps->which, cps->program);
13351             } else {
13352                 gameInfo.result = cps->twoMachinesColor[0]=='w' ? BlackWins : WhiteWins;
13353             }
13354             gameInfo.resultDetails = StrSave(buf);
13355         }
13356         if(!cps->userError || !appData.popupExitMessage) DisplayFatalError(buf, error, 1); else errorExitStatus = 1;
13357     }
13358 }
13359
13360 void
13361 ReceiveFromProgram(isr, closure, message, count, error)
13362      InputSourceRef isr;
13363      VOIDSTAR closure;
13364      char *message;
13365      int count;
13366      int error;
13367 {
13368     char *end_str;
13369     char buf[MSG_SIZ];
13370     ChessProgramState *cps = (ChessProgramState *)closure;
13371
13372     if (isr != cps->isr) return; /* Killed intentionally */
13373     if (count <= 0) {
13374         if (count == 0) {
13375             sprintf(buf,
13376                     _("Error: %s chess program (%s) exited unexpectedly"),
13377                     cps->which, cps->program);
13378         if(gameInfo.resultDetails==NULL) { /* [HGM] crash: if game in progress, give reason for abort */
13379                 if((signed char)boards[forwardMostMove][EP_STATUS] <= EP_DRAWS) {
13380                     gameInfo.result = GameIsDrawn; /* [HGM] accept exit as draw claim */
13381                     sprintf(buf, _("%s program exits in draw position (%s)"), cps->which, cps->program);
13382                 } else {
13383                     gameInfo.result = cps->twoMachinesColor[0]=='w' ? BlackWins : WhiteWins;
13384                 }
13385                 gameInfo.resultDetails = StrSave(buf);
13386             }
13387             RemoveInputSource(cps->isr);
13388             if(!cps->userError || !appData.popupExitMessage) DisplayFatalError(buf, 0, 1); else errorExitStatus = 1;
13389         } else {
13390             sprintf(buf,
13391                     _("Error reading from %s chess program (%s)"),
13392                     cps->which, cps->program);
13393             RemoveInputSource(cps->isr);
13394
13395             /* [AS] Program is misbehaving badly... kill it */
13396             if( count == -2 ) {
13397                 DestroyChildProcess( cps->pr, 9 );
13398                 cps->pr = NoProc;
13399             }
13400
13401             if(!cps->userError || !appData.popupExitMessage) DisplayFatalError(buf, error, 1); else errorExitStatus = 1;
13402         }
13403         return;
13404     }
13405
13406     if ((end_str = strchr(message, '\r')) != NULL)
13407       *end_str = NULLCHAR;
13408     if ((end_str = strchr(message, '\n')) != NULL)
13409       *end_str = NULLCHAR;
13410
13411     if (appData.debugMode) {
13412         TimeMark now; int print = 1;
13413         char *quote = ""; char c; int i;
13414
13415         if(appData.engineComments != 1) { /* [HGM] debug: decide if protocol-violating output is written */
13416                 char start = message[0];
13417                 if(start >='A' && start <= 'Z') start += 'a' - 'A'; // be tolerant to capitalizing
13418                 if(sscanf(message, "%d%c%d%d%d", &i, &c, &i, &i, &i) != 5 &&
13419                    sscanf(message, "move %c", &c)!=1  && sscanf(message, "offer%c", &c)!=1 &&
13420                    sscanf(message, "resign%c", &c)!=1 && sscanf(message, "feature %c", &c)!=1 &&
13421                    sscanf(message, "error %c", &c)!=1 && sscanf(message, "illegal %c", &c)!=1 &&
13422                    sscanf(message, "tell%c", &c)!=1   && sscanf(message, "0-1 %c", &c)!=1 &&
13423                    sscanf(message, "1-0 %c", &c)!=1   && sscanf(message, "1/2-1/2 %c", &c)!=1 &&
13424                    sscanf(message, "pong %c", &c)!=1   && start != '#') {
13425                     quote = appData.engineComments == 2 ? "# " : "### NON-COMPLIANT! ### ";
13426                     print = (appData.engineComments >= 2);
13427                 }
13428                 message[0] = start; // restore original message
13429         }
13430         if(print) {
13431                 GetTimeMark(&now);
13432                 fprintf(debugFP, "%ld <%-6s: %s%s\n",
13433                         SubtractTimeMarks(&now, &programStartTime), cps->which,
13434                         quote,
13435                         message);
13436         }
13437     }
13438
13439     /* [DM] if icsEngineAnalyze is active we block all whisper and kibitz output, because nobody want to see this */
13440     if (appData.icsEngineAnalyze) {
13441         if (strstr(message, "whisper") != NULL ||
13442              strstr(message, "kibitz") != NULL ||
13443             strstr(message, "tellics") != NULL) return;
13444     }
13445
13446     HandleMachineMove(message, cps);
13447 }
13448
13449
13450 void
13451 SendTimeControl(cps, mps, tc, inc, sd, st)
13452      ChessProgramState *cps;
13453      int mps, inc, sd, st;
13454      long tc;
13455 {
13456     char buf[MSG_SIZ];
13457     int seconds;
13458
13459     if( timeControl_2 > 0 ) {
13460         if( (gameMode == MachinePlaysBlack) || (gameMode == TwoMachinesPlay && cps->twoMachinesColor[0] == 'b') ) {
13461             tc = timeControl_2;
13462         }
13463     }
13464     tc  /= cps->timeOdds; /* [HGM] time odds: apply before telling engine */
13465     inc /= cps->timeOdds;
13466     st  /= cps->timeOdds;
13467
13468     seconds = (tc / 1000) % 60; /* [HGM] displaced to after applying odds */
13469
13470     if (st > 0) {
13471       /* Set exact time per move, normally using st command */
13472       if (cps->stKludge) {
13473         /* GNU Chess 4 has no st command; uses level in a nonstandard way */
13474         seconds = st % 60;
13475         if (seconds == 0) {
13476           sprintf(buf, "level 1 %d\n", st/60);
13477         } else {
13478           sprintf(buf, "level 1 %d:%02d\n", st/60, seconds);
13479         }
13480       } else {
13481         sprintf(buf, "st %d\n", st);
13482       }
13483     } else {
13484       /* Set conventional or incremental time control, using level command */
13485       if (seconds == 0) {
13486         /* Note old gnuchess bug -- minutes:seconds used to not work.
13487            Fixed in later versions, but still avoid :seconds
13488            when seconds is 0. */
13489         sprintf(buf, "level %d %ld %d\n", mps, tc/60000, inc/1000);
13490       } else {
13491         sprintf(buf, "level %d %ld:%02d %d\n", mps, tc/60000,
13492                 seconds, inc/1000);
13493       }
13494     }
13495     SendToProgram(buf, cps);
13496
13497     /* Orthoganally (except for GNU Chess 4), limit time to st seconds */
13498     /* Orthogonally, limit search to given depth */
13499     if (sd > 0) {
13500       if (cps->sdKludge) {
13501         sprintf(buf, "depth\n%d\n", sd);
13502       } else {
13503         sprintf(buf, "sd %d\n", sd);
13504       }
13505       SendToProgram(buf, cps);
13506     }
13507
13508     if(cps->nps > 0) { /* [HGM] nps */
13509         if(cps->supportsNPS == FALSE) cps->nps = -1; // don't use if engine explicitly says not supported!
13510         else {
13511                 sprintf(buf, "nps %d\n", cps->nps);
13512               SendToProgram(buf, cps);
13513         }
13514     }
13515 }
13516
13517 ChessProgramState *WhitePlayer()
13518 /* [HGM] return pointer to 'first' or 'second', depending on who plays white */
13519 {
13520     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b' ||
13521        gameMode == BeginningOfGame || gameMode == MachinePlaysBlack)
13522         return &second;
13523     return &first;
13524 }
13525
13526 void
13527 SendTimeRemaining(cps, machineWhite)
13528      ChessProgramState *cps;
13529      int /*boolean*/ machineWhite;
13530 {
13531     char message[MSG_SIZ];
13532     long time, otime;
13533
13534     /* Note: this routine must be called when the clocks are stopped
13535        or when they have *just* been set or switched; otherwise
13536        it will be off by the time since the current tick started.
13537     */
13538     if (machineWhite) {
13539         time = whiteTimeRemaining / 10;
13540         otime = blackTimeRemaining / 10;
13541     } else {
13542         time = blackTimeRemaining / 10;
13543         otime = whiteTimeRemaining / 10;
13544     }
13545     /* [HGM] translate opponent's time by time-odds factor */
13546     otime = (otime * cps->other->timeOdds) / cps->timeOdds;
13547     if (appData.debugMode) {
13548         fprintf(debugFP, "time odds: %f %f \n", cps->timeOdds, cps->other->timeOdds);
13549     }
13550
13551     if (time <= 0) time = 1;
13552     if (otime <= 0) otime = 1;
13553
13554     sprintf(message, "time %ld\n", time);
13555     SendToProgram(message, cps);
13556
13557     sprintf(message, "otim %ld\n", otime);
13558     SendToProgram(message, cps);
13559 }
13560
13561 int
13562 BoolFeature(p, name, loc, cps)
13563      char **p;
13564      char *name;
13565      int *loc;
13566      ChessProgramState *cps;
13567 {
13568   char buf[MSG_SIZ];
13569   int len = strlen(name);
13570   int val;
13571   if (strncmp((*p), name, len) == 0 && (*p)[len] == '=') {
13572     (*p) += len + 1;
13573     sscanf(*p, "%d", &val);
13574     *loc = (val != 0);
13575     while (**p && **p != ' ') (*p)++;
13576     sprintf(buf, "accepted %s\n", name);
13577     SendToProgram(buf, cps);
13578     return TRUE;
13579   }
13580   return FALSE;
13581 }
13582
13583 int
13584 IntFeature(p, name, loc, cps)
13585      char **p;
13586      char *name;
13587      int *loc;
13588      ChessProgramState *cps;
13589 {
13590   char buf[MSG_SIZ];
13591   int len = strlen(name);
13592   if (strncmp((*p), name, len) == 0 && (*p)[len] == '=') {
13593     (*p) += len + 1;
13594     sscanf(*p, "%d", loc);
13595     while (**p && **p != ' ') (*p)++;
13596     sprintf(buf, "accepted %s\n", name);
13597     SendToProgram(buf, cps);
13598     return TRUE;
13599   }
13600   return FALSE;
13601 }
13602
13603 int
13604 StringFeature(p, name, loc, cps)
13605      char **p;
13606      char *name;
13607      char loc[];
13608      ChessProgramState *cps;
13609 {
13610   char buf[MSG_SIZ];
13611   int len = strlen(name);
13612   if (strncmp((*p), name, len) == 0
13613       && (*p)[len] == '=' && (*p)[len+1] == '\"') {
13614     (*p) += len + 2;
13615     sscanf(*p, "%[^\"]", loc);
13616     while (**p && **p != '\"') (*p)++;
13617     if (**p == '\"') (*p)++;
13618     sprintf(buf, "accepted %s\n", name);
13619     SendToProgram(buf, cps);
13620     return TRUE;
13621   }
13622   return FALSE;
13623 }
13624
13625 int
13626 ParseOption(Option *opt, ChessProgramState *cps)
13627 // [HGM] options: process the string that defines an engine option, and determine
13628 // name, type, default value, and allowed value range
13629 {
13630         char *p, *q, buf[MSG_SIZ];
13631         int n, min = (-1)<<31, max = 1<<31, def;
13632
13633         if(p = strstr(opt->name, " -spin ")) {
13634             if((n = sscanf(p, " -spin %d %d %d", &def, &min, &max)) < 3 ) return FALSE;
13635             if(max < min) max = min; // enforce consistency
13636             if(def < min) def = min;
13637             if(def > max) def = max;
13638             opt->value = def;
13639             opt->min = min;
13640             opt->max = max;
13641             opt->type = Spin;
13642         } else if((p = strstr(opt->name, " -slider "))) {
13643             // for now -slider is a synonym for -spin, to already provide compatibility with future polyglots
13644             if((n = sscanf(p, " -slider %d %d %d", &def, &min, &max)) < 3 ) return FALSE;
13645             if(max < min) max = min; // enforce consistency
13646             if(def < min) def = min;
13647             if(def > max) def = max;
13648             opt->value = def;
13649             opt->min = min;
13650             opt->max = max;
13651             opt->type = Spin; // Slider;
13652         } else if((p = strstr(opt->name, " -string "))) {
13653             opt->textValue = p+9;
13654             opt->type = TextBox;
13655         } else if((p = strstr(opt->name, " -file "))) {
13656             // for now -file is a synonym for -string, to already provide compatibility with future polyglots
13657             opt->textValue = p+7;
13658             opt->type = TextBox; // FileName;
13659         } else if((p = strstr(opt->name, " -path "))) {
13660             // for now -file is a synonym for -string, to already provide compatibility with future polyglots
13661             opt->textValue = p+7;
13662             opt->type = TextBox; // PathName;
13663         } else if(p = strstr(opt->name, " -check ")) {
13664             if(sscanf(p, " -check %d", &def) < 1) return FALSE;
13665             opt->value = (def != 0);
13666             opt->type = CheckBox;
13667         } else if(p = strstr(opt->name, " -combo ")) {
13668             opt->textValue = (char*) (&cps->comboList[cps->comboCnt]); // cheat with pointer type
13669             cps->comboList[cps->comboCnt++] = q = p+8; // holds possible choices
13670             if(*q == '*') cps->comboList[cps->comboCnt-1]++;
13671             opt->value = n = 0;
13672             while(q = StrStr(q, " /// ")) {
13673                 n++; *q = 0;    // count choices, and null-terminate each of them
13674                 q += 5;
13675                 if(*q == '*') { // remember default, which is marked with * prefix
13676                     q++;
13677                     opt->value = n;
13678                 }
13679                 cps->comboList[cps->comboCnt++] = q;
13680             }
13681             cps->comboList[cps->comboCnt++] = NULL;
13682             opt->max = n + 1;
13683             opt->type = ComboBox;
13684         } else if(p = strstr(opt->name, " -button")) {
13685             opt->type = Button;
13686         } else if(p = strstr(opt->name, " -save")) {
13687             opt->type = SaveButton;
13688         } else return FALSE;
13689         *p = 0; // terminate option name
13690         // now look if the command-line options define a setting for this engine option.
13691         if(cps->optionSettings && cps->optionSettings[0])
13692             p = strstr(cps->optionSettings, opt->name); else p = NULL;
13693         if(p && (p == cps->optionSettings || p[-1] == ',')) {
13694                 sprintf(buf, "option %s", p);
13695                 if(p = strstr(buf, ",")) *p = 0;
13696                 strcat(buf, "\n");
13697                 SendToProgram(buf, cps);
13698         }
13699         return TRUE;
13700 }
13701
13702 void
13703 FeatureDone(cps, val)
13704      ChessProgramState* cps;
13705      int val;
13706 {
13707   DelayedEventCallback cb = GetDelayedEvent();
13708   if ((cb == InitBackEnd3 && cps == &first) ||
13709       (cb == TwoMachinesEventIfReady && cps == &second)) {
13710     CancelDelayedEvent();
13711     ScheduleDelayedEvent(cb, val ? 1 : 3600000);
13712   }
13713   cps->initDone = val;
13714 }
13715
13716 /* Parse feature command from engine */
13717 void
13718 ParseFeatures(args, cps)
13719      char* args;
13720      ChessProgramState *cps;
13721 {
13722   char *p = args;
13723   char *q;
13724   int val;
13725   char buf[MSG_SIZ];
13726
13727   for (;;) {
13728     while (*p == ' ') p++;
13729     if (*p == NULLCHAR) return;
13730
13731     if (BoolFeature(&p, "setboard", &cps->useSetboard, cps)) continue;
13732     if (BoolFeature(&p, "time", &cps->sendTime, cps)) continue;
13733     if (BoolFeature(&p, "draw", &cps->sendDrawOffers, cps)) continue;
13734     if (BoolFeature(&p, "sigint", &cps->useSigint, cps)) continue;
13735     if (BoolFeature(&p, "sigterm", &cps->useSigterm, cps)) continue;
13736     if (BoolFeature(&p, "reuse", &val, cps)) {
13737       /* Engine can disable reuse, but can't enable it if user said no */
13738       if (!val) cps->reuse = FALSE;
13739       continue;
13740     }
13741     if (BoolFeature(&p, "analyze", &cps->analysisSupport, cps)) continue;
13742     if (StringFeature(&p, "myname", &cps->tidy, cps)) {
13743       if (gameMode == TwoMachinesPlay) {
13744         DisplayTwoMachinesTitle();
13745       } else {
13746         DisplayTitle("");
13747       }
13748       continue;
13749     }
13750     if (StringFeature(&p, "variants", &cps->variants, cps)) continue;
13751     if (BoolFeature(&p, "san", &cps->useSAN, cps)) continue;
13752     if (BoolFeature(&p, "ping", &cps->usePing, cps)) continue;
13753     if (BoolFeature(&p, "playother", &cps->usePlayother, cps)) continue;
13754     if (BoolFeature(&p, "colors", &cps->useColors, cps)) continue;
13755     if (BoolFeature(&p, "usermove", &cps->useUsermove, cps)) continue;
13756     if (BoolFeature(&p, "ics", &cps->sendICS, cps)) continue;
13757     if (BoolFeature(&p, "name", &cps->sendName, cps)) continue;
13758     if (BoolFeature(&p, "pause", &val, cps)) continue; /* unused at present */
13759     if (IntFeature(&p, "done", &val, cps)) {
13760       FeatureDone(cps, val);
13761       continue;
13762     }
13763     /* Added by Tord: */
13764     if (BoolFeature(&p, "fen960", &cps->useFEN960, cps)) continue;
13765     if (BoolFeature(&p, "oocastle", &cps->useOOCastle, cps)) continue;
13766     /* End of additions by Tord */
13767
13768     /* [HGM] added features: */
13769     if (BoolFeature(&p, "debug", &cps->debug, cps)) continue;
13770     if (BoolFeature(&p, "nps", &cps->supportsNPS, cps)) continue;
13771     if (IntFeature(&p, "level", &cps->maxNrOfSessions, cps)) continue;
13772     if (BoolFeature(&p, "memory", &cps->memSize, cps)) continue;
13773     if (BoolFeature(&p, "smp", &cps->maxCores, cps)) continue;
13774     if (StringFeature(&p, "egt", &cps->egtFormats, cps)) continue;
13775     if (StringFeature(&p, "option", &(cps->option[cps->nrOptions].name), cps)) {
13776         if(!ParseOption(&(cps->option[cps->nrOptions++]), cps)) { // [HGM] options: add option feature
13777             sprintf(buf, "rejected option %s\n", cps->option[--cps->nrOptions].name);
13778             SendToProgram(buf, cps);
13779             continue;
13780         }
13781         if(cps->nrOptions >= MAX_OPTIONS) {
13782             cps->nrOptions--;
13783             sprintf(buf, "%s engine has too many options\n", cps->which);
13784             DisplayError(buf, 0);
13785         }
13786         continue;
13787     }
13788     if (BoolFeature(&p, "smp", &cps->maxCores, cps)) continue;
13789     /* End of additions by HGM */
13790
13791     /* unknown feature: complain and skip */
13792     q = p;
13793     while (*q && *q != '=') q++;
13794     sprintf(buf, "rejected %.*s\n", (int)(q-p), p);
13795     SendToProgram(buf, cps);
13796     p = q;
13797     if (*p == '=') {
13798       p++;
13799       if (*p == '\"') {
13800         p++;
13801         while (*p && *p != '\"') p++;
13802         if (*p == '\"') p++;
13803       } else {
13804         while (*p && *p != ' ') p++;
13805       }
13806     }
13807   }
13808
13809 }
13810
13811 void
13812 PeriodicUpdatesEvent(newState)
13813      int newState;
13814 {
13815     if (newState == appData.periodicUpdates)
13816       return;
13817
13818     appData.periodicUpdates=newState;
13819
13820     /* Display type changes, so update it now */
13821 //    DisplayAnalysis();
13822
13823     /* Get the ball rolling again... */
13824     if (newState) {
13825         AnalysisPeriodicEvent(1);
13826         StartAnalysisClock();
13827     }
13828 }
13829
13830 void
13831 PonderNextMoveEvent(newState)
13832      int newState;
13833 {
13834     if (newState == appData.ponderNextMove) return;
13835     if (gameMode == EditPosition) EditPositionDone(TRUE);
13836     if (newState) {
13837         SendToProgram("hard\n", &first);
13838         if (gameMode == TwoMachinesPlay) {
13839             SendToProgram("hard\n", &second);
13840         }
13841     } else {
13842         SendToProgram("easy\n", &first);
13843         thinkOutput[0] = NULLCHAR;
13844         if (gameMode == TwoMachinesPlay) {
13845             SendToProgram("easy\n", &second);
13846         }
13847     }
13848     appData.ponderNextMove = newState;
13849 }
13850
13851 void
13852 NewSettingEvent(option, command, value)
13853      char *command;
13854      int option, value;
13855 {
13856     char buf[MSG_SIZ];
13857
13858     if (gameMode == EditPosition) EditPositionDone(TRUE);
13859     sprintf(buf, "%s%s %d\n", (option ? "option ": ""), command, value);
13860     SendToProgram(buf, &first);
13861     if (gameMode == TwoMachinesPlay) {
13862         SendToProgram(buf, &second);
13863     }
13864 }
13865
13866 void
13867 ShowThinkingEvent()
13868 // [HGM] thinking: this routine is now also called from "Options -> Engine..." popup
13869 {
13870     static int oldState = 2; // kludge alert! Neither true nor fals, so first time oldState is always updated
13871     int newState = appData.showThinking
13872         // [HGM] thinking: other features now need thinking output as well
13873         || !appData.hideThinkingFromHuman || appData.adjudicateLossThreshold != 0 || EngineOutputIsUp();
13874
13875     if (oldState == newState) return;
13876     oldState = newState;
13877     if (gameMode == EditPosition) EditPositionDone(TRUE);
13878     if (oldState) {
13879         SendToProgram("post\n", &first);
13880         if (gameMode == TwoMachinesPlay) {
13881             SendToProgram("post\n", &second);
13882         }
13883     } else {
13884         SendToProgram("nopost\n", &first);
13885         thinkOutput[0] = NULLCHAR;
13886         if (gameMode == TwoMachinesPlay) {
13887             SendToProgram("nopost\n", &second);
13888         }
13889     }
13890 //    appData.showThinking = newState; // [HGM] thinking: responsible option should already have be changed when calling this routine!
13891 }
13892
13893 void
13894 AskQuestionEvent(title, question, replyPrefix, which)
13895      char *title; char *question; char *replyPrefix; char *which;
13896 {
13897   ProcRef pr = (which[0] == '1') ? first.pr : second.pr;
13898   if (pr == NoProc) return;
13899   AskQuestion(title, question, replyPrefix, pr);
13900 }
13901
13902 void
13903 DisplayMove(moveNumber)
13904      int moveNumber;
13905 {
13906     char message[MSG_SIZ];
13907     char res[MSG_SIZ];
13908     char cpThinkOutput[MSG_SIZ];
13909
13910     if(appData.noGUI) return; // [HGM] fast: suppress display of moves
13911
13912     if (moveNumber == forwardMostMove - 1 ||
13913         gameMode == AnalyzeMode || gameMode == AnalyzeFile) {
13914
13915         safeStrCpy(cpThinkOutput, thinkOutput, sizeof(cpThinkOutput));
13916
13917         if (strchr(cpThinkOutput, '\n')) {
13918             *strchr(cpThinkOutput, '\n') = NULLCHAR;
13919         }
13920     } else {
13921         *cpThinkOutput = NULLCHAR;
13922     }
13923
13924     /* [AS] Hide thinking from human user */
13925     if( appData.hideThinkingFromHuman && gameMode != TwoMachinesPlay ) {
13926         *cpThinkOutput = NULLCHAR;
13927         if( thinkOutput[0] != NULLCHAR ) {
13928             int i;
13929
13930             for( i=0; i<=hiddenThinkOutputState; i++ ) {
13931                 cpThinkOutput[i] = '.';
13932             }
13933             cpThinkOutput[i] = NULLCHAR;
13934             hiddenThinkOutputState = (hiddenThinkOutputState + 1) % 3;
13935         }
13936     }
13937
13938     if (moveNumber == forwardMostMove - 1 &&
13939         gameInfo.resultDetails != NULL) {
13940         if (gameInfo.resultDetails[0] == NULLCHAR) {
13941             sprintf(res, " %s", PGNResult(gameInfo.result));
13942         } else {
13943             sprintf(res, " {%s} %s",
13944                     gameInfo.resultDetails, PGNResult(gameInfo.result));
13945         }
13946     } else {
13947         res[0] = NULLCHAR;
13948     }
13949
13950     if (moveNumber < 0 || parseList[moveNumber][0] == NULLCHAR) {
13951         DisplayMessage(res, cpThinkOutput);
13952     } else {
13953         sprintf(message, "%d.%s%s%s", moveNumber / 2 + 1,
13954                 WhiteOnMove(moveNumber) ? " " : ".. ",
13955                 parseList[moveNumber], res);
13956         DisplayMessage(message, cpThinkOutput);
13957     }
13958 }
13959
13960 void
13961 DisplayComment(moveNumber, text)
13962      int moveNumber;
13963      char *text;
13964 {
13965     char title[MSG_SIZ];
13966     char buf[8000]; // comment can be long!
13967     int score, depth;
13968
13969     if (moveNumber < 0 || parseList[moveNumber][0] == NULLCHAR) {
13970       strcpy(title, "Comment");
13971     } else {
13972       sprintf(title, "Comment on %d.%s%s", moveNumber / 2 + 1,
13973               WhiteOnMove(moveNumber) ? " " : ".. ",
13974               parseList[moveNumber]);
13975     }
13976     // [HGM] PV info: display PV info together with (or as) comment
13977     if(moveNumber >= 0 && (depth = pvInfoList[moveNumber].depth) > 0) {
13978       if(text == NULL) text = "";
13979       score = pvInfoList[moveNumber].score;
13980       sprintf(buf, "%s%.2f/%d %d\n%s", score>0 ? "+" : "", score/100.,
13981               depth, (pvInfoList[moveNumber].time+50)/100, text);
13982       text = buf;
13983     }
13984     if (text != NULL && (appData.autoDisplayComment || commentUp))
13985         CommentPopUp(title, text);
13986 }
13987
13988 /* This routine sends a ^C interrupt to gnuchess, to awaken it if it
13989  * might be busy thinking or pondering.  It can be omitted if your
13990  * gnuchess is configured to stop thinking immediately on any user
13991  * input.  However, that gnuchess feature depends on the FIONREAD
13992  * ioctl, which does not work properly on some flavors of Unix.
13993  */
13994 void
13995 Attention(cps)
13996      ChessProgramState *cps;
13997 {
13998 #if ATTENTION
13999     if (!cps->useSigint) return;
14000     if (appData.noChessProgram || (cps->pr == NoProc)) return;
14001     switch (gameMode) {
14002       case MachinePlaysWhite:
14003       case MachinePlaysBlack:
14004       case TwoMachinesPlay:
14005       case IcsPlayingWhite:
14006       case IcsPlayingBlack:
14007       case AnalyzeMode:
14008       case AnalyzeFile:
14009         /* Skip if we know it isn't thinking */
14010         if (!cps->maybeThinking) return;
14011         if (appData.debugMode)
14012           fprintf(debugFP, "Interrupting %s\n", cps->which);
14013         InterruptChildProcess(cps->pr);
14014         cps->maybeThinking = FALSE;
14015         break;
14016       default:
14017         break;
14018     }
14019 #endif /*ATTENTION*/
14020 }
14021
14022 int
14023 CheckFlags()
14024 {
14025     if (whiteTimeRemaining <= 0) {
14026         if (!whiteFlag) {
14027             whiteFlag = TRUE;
14028             if (appData.icsActive) {
14029                 if (appData.autoCallFlag &&
14030                     gameMode == IcsPlayingBlack && !blackFlag) {
14031                   SendToICS(ics_prefix);
14032                   SendToICS("flag\n");
14033                 }
14034             } else {
14035                 if (blackFlag) {
14036                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Both flags fell"));
14037                 } else {
14038                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("White's flag fell"));
14039                     if (appData.autoCallFlag) {
14040                         GameEnds(BlackWins, "Black wins on time", GE_XBOARD);
14041                         return TRUE;
14042                     }
14043                 }
14044             }
14045         }
14046     }
14047     if (blackTimeRemaining <= 0) {
14048         if (!blackFlag) {
14049             blackFlag = TRUE;
14050             if (appData.icsActive) {
14051                 if (appData.autoCallFlag &&
14052                     gameMode == IcsPlayingWhite && !whiteFlag) {
14053                   SendToICS(ics_prefix);
14054                   SendToICS("flag\n");
14055                 }
14056             } else {
14057                 if (whiteFlag) {
14058                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Both flags fell"));
14059                 } else {
14060                     if(gameMode != TwoMachinesPlay) DisplayTitle(_("Black's flag fell"));
14061                     if (appData.autoCallFlag) {
14062                         GameEnds(WhiteWins, "White wins on time", GE_XBOARD);
14063                         return TRUE;
14064                     }
14065                 }
14066             }
14067         }
14068     }
14069     return FALSE;
14070 }
14071
14072 void
14073 CheckTimeControl()
14074 {
14075     if (!appData.clockMode || appData.icsActive || searchTime || // [HGM] st: no inc in st mode
14076         gameMode == PlayFromGameFile || forwardMostMove == 0) return;
14077
14078     /*
14079      * add time to clocks when time control is achieved ([HGM] now also used for increment)
14080      */
14081     if ( !WhiteOnMove(forwardMostMove) )
14082         /* White made time control */
14083         whiteTimeRemaining += GetTimeQuota((forwardMostMove-1)/2)
14084         /* [HGM] time odds: correct new time quota for time odds! */
14085                                             / WhitePlayer()->timeOdds;
14086       else
14087         /* Black made time control */
14088         blackTimeRemaining += GetTimeQuota((forwardMostMove-1)/2)
14089                                             / WhitePlayer()->other->timeOdds;
14090 }
14091
14092 void
14093 DisplayBothClocks()
14094 {
14095     int wom = gameMode == EditPosition ?
14096       !blackPlaysFirst : WhiteOnMove(currentMove);
14097     DisplayWhiteClock(whiteTimeRemaining, wom);
14098     DisplayBlackClock(blackTimeRemaining, !wom);
14099 }
14100
14101
14102 /* Timekeeping seems to be a portability nightmare.  I think everyone
14103    has ftime(), but I'm really not sure, so I'm including some ifdefs
14104    to use other calls if you don't.  Clocks will be less accurate if
14105    you have neither ftime nor gettimeofday.
14106 */
14107
14108 /* VS 2008 requires the #include outside of the function */
14109 #if !HAVE_GETTIMEOFDAY && HAVE_FTIME
14110 #include <sys/timeb.h>
14111 #endif
14112
14113 /* Get the current time as a TimeMark */
14114 void
14115 GetTimeMark(tm)
14116      TimeMark *tm;
14117 {
14118 #if HAVE_GETTIMEOFDAY
14119
14120     struct timeval timeVal;
14121     struct timezone timeZone;
14122
14123     gettimeofday(&timeVal, &timeZone);
14124     tm->sec = (long) timeVal.tv_sec;
14125     tm->ms = (int) (timeVal.tv_usec / 1000L);
14126
14127 #else /*!HAVE_GETTIMEOFDAY*/
14128 #if HAVE_FTIME
14129
14130 // include <sys/timeb.h> / moved to just above start of function
14131     struct timeb timeB;
14132
14133     ftime(&timeB);
14134     tm->sec = (long) timeB.time;
14135     tm->ms = (int) timeB.millitm;
14136
14137 #else /*!HAVE_FTIME && !HAVE_GETTIMEOFDAY*/
14138     tm->sec = (long) time(NULL);
14139     tm->ms = 0;
14140 #endif
14141 #endif
14142 }
14143
14144 /* Return the difference in milliseconds between two
14145    time marks.  We assume the difference will fit in a long!
14146 */
14147 long
14148 SubtractTimeMarks(tm2, tm1)
14149      TimeMark *tm2, *tm1;
14150 {
14151     return 1000L*(tm2->sec - tm1->sec) +
14152            (long) (tm2->ms - tm1->ms);
14153 }
14154
14155
14156 /*
14157  * Code to manage the game clocks.
14158  *
14159  * In tournament play, black starts the clock and then white makes a move.
14160  * We give the human user a slight advantage if he is playing white---the
14161  * clocks don't run until he makes his first move, so it takes zero time.
14162  * Also, we don't account for network lag, so we could get out of sync
14163  * with GNU Chess's clock -- but then, referees are always right.
14164  */
14165
14166 static TimeMark tickStartTM;
14167 static long intendedTickLength;
14168
14169 long
14170 NextTickLength(timeRemaining)
14171      long timeRemaining;
14172 {
14173     long nominalTickLength, nextTickLength;
14174
14175     if (timeRemaining > 0L && timeRemaining <= 10000L)
14176       nominalTickLength = 100L;
14177     else
14178       nominalTickLength = 1000L;
14179     nextTickLength = timeRemaining % nominalTickLength;
14180     if (nextTickLength <= 0) nextTickLength += nominalTickLength;
14181
14182     return nextTickLength;
14183 }
14184
14185 /* Adjust clock one minute up or down */
14186 void
14187 AdjustClock(Boolean which, int dir)
14188 {
14189     if(which) blackTimeRemaining += 60000*dir;
14190     else      whiteTimeRemaining += 60000*dir;
14191     DisplayBothClocks();
14192 }
14193
14194 /* Stop clocks and reset to a fresh time control */
14195 void
14196 ResetClocks()
14197 {
14198     (void) StopClockTimer();
14199     if (appData.icsActive) {
14200         whiteTimeRemaining = blackTimeRemaining = 0;
14201     } else if (searchTime) {
14202         whiteTimeRemaining = 1000*searchTime / WhitePlayer()->timeOdds;
14203         blackTimeRemaining = 1000*searchTime / WhitePlayer()->other->timeOdds;
14204     } else { /* [HGM] correct new time quote for time odds */
14205         whiteTimeRemaining = GetTimeQuota(-1) / WhitePlayer()->timeOdds;
14206         blackTimeRemaining = GetTimeQuota(-1) / WhitePlayer()->other->timeOdds;
14207     }
14208     if (whiteFlag || blackFlag) {
14209         DisplayTitle("");
14210         whiteFlag = blackFlag = FALSE;
14211     }
14212     DisplayBothClocks();
14213 }
14214
14215 #define FUDGE 25 /* 25ms = 1/40 sec; should be plenty even for 50 Hz clocks */
14216
14217 /* Decrement running clock by amount of time that has passed */
14218 void
14219 DecrementClocks()
14220 {
14221     long timeRemaining;
14222     long lastTickLength, fudge;
14223     TimeMark now;
14224
14225     if (!appData.clockMode) return;
14226     if (gameMode==AnalyzeMode || gameMode == AnalyzeFile) return;
14227
14228     GetTimeMark(&now);
14229
14230     lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
14231
14232     /* Fudge if we woke up a little too soon */
14233     fudge = intendedTickLength - lastTickLength;
14234     if (fudge < 0 || fudge > FUDGE) fudge = 0;
14235
14236     if (WhiteOnMove(forwardMostMove)) {
14237         if(whiteNPS >= 0) lastTickLength = 0;
14238         timeRemaining = whiteTimeRemaining -= lastTickLength;
14239         DisplayWhiteClock(whiteTimeRemaining - fudge,
14240                           WhiteOnMove(currentMove < forwardMostMove ? currentMove : forwardMostMove));
14241     } else {
14242         if(blackNPS >= 0) lastTickLength = 0;
14243         timeRemaining = blackTimeRemaining -= lastTickLength;
14244         DisplayBlackClock(blackTimeRemaining - fudge,
14245                           !WhiteOnMove(currentMove < forwardMostMove ? currentMove : forwardMostMove));
14246     }
14247
14248     if (CheckFlags()) return;
14249
14250     tickStartTM = now;
14251     intendedTickLength = NextTickLength(timeRemaining - fudge) + fudge;
14252     StartClockTimer(intendedTickLength);
14253
14254     /* if the time remaining has fallen below the alarm threshold, sound the
14255      * alarm. if the alarm has sounded and (due to a takeback or time control
14256      * with increment) the time remaining has increased to a level above the
14257      * threshold, reset the alarm so it can sound again.
14258      */
14259
14260     if (appData.icsActive && appData.icsAlarm) {
14261
14262         /* make sure we are dealing with the user's clock */
14263         if (!( ((gameMode == IcsPlayingWhite) && WhiteOnMove(currentMove)) ||
14264                ((gameMode == IcsPlayingBlack) && !WhiteOnMove(currentMove))
14265            )) return;
14266
14267         if (alarmSounded && (timeRemaining > appData.icsAlarmTime)) {
14268             alarmSounded = FALSE;
14269         } else if (!alarmSounded && (timeRemaining <= appData.icsAlarmTime)) {
14270             PlayAlarmSound();
14271             alarmSounded = TRUE;
14272         }
14273     }
14274 }
14275
14276
14277 /* A player has just moved, so stop the previously running
14278    clock and (if in clock mode) start the other one.
14279    We redisplay both clocks in case we're in ICS mode, because
14280    ICS gives us an update to both clocks after every move.
14281    Note that this routine is called *after* forwardMostMove
14282    is updated, so the last fractional tick must be subtracted
14283    from the color that is *not* on move now.
14284 */
14285 void
14286 SwitchClocks(int newMoveNr)
14287 {
14288     long lastTickLength;
14289     TimeMark now;
14290     int flagged = FALSE;
14291
14292     GetTimeMark(&now);
14293
14294     if (StopClockTimer() && appData.clockMode) {
14295         lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
14296         if (!WhiteOnMove(forwardMostMove)) {
14297             if(blackNPS >= 0) lastTickLength = 0;
14298             blackTimeRemaining -= lastTickLength;
14299            /* [HGM] PGNtime: save time for PGN file if engine did not give it */
14300 //         if(pvInfoList[forwardMostMove-1].time == -1)
14301                  pvInfoList[forwardMostMove-1].time =               // use GUI time
14302                       (timeRemaining[1][forwardMostMove-1] - blackTimeRemaining)/10;
14303         } else {
14304            if(whiteNPS >= 0) lastTickLength = 0;
14305            whiteTimeRemaining -= lastTickLength;
14306            /* [HGM] PGNtime: save time for PGN file if engine did not give it */
14307 //         if(pvInfoList[forwardMostMove-1].time == -1)
14308                  pvInfoList[forwardMostMove-1].time =
14309                       (timeRemaining[0][forwardMostMove-1] - whiteTimeRemaining)/10;
14310         }
14311         flagged = CheckFlags();
14312     }
14313     forwardMostMove = newMoveNr; // [HGM] race: change stm when no timer interrupt scheduled
14314     CheckTimeControl();
14315
14316     if (flagged || !appData.clockMode) return;
14317
14318     switch (gameMode) {
14319       case MachinePlaysBlack:
14320       case MachinePlaysWhite:
14321       case BeginningOfGame:
14322         if (pausing) return;
14323         break;
14324
14325       case EditGame:
14326       case PlayFromGameFile:
14327       case IcsExamining:
14328         return;
14329
14330       default:
14331         break;
14332     }
14333
14334     if (searchTime) { // [HGM] st: set clock of player that has to move to max time
14335         if(WhiteOnMove(forwardMostMove))
14336              whiteTimeRemaining = 1000*searchTime / WhitePlayer()->timeOdds;
14337         else blackTimeRemaining = 1000*searchTime / WhitePlayer()->other->timeOdds;
14338     }
14339
14340     tickStartTM = now;
14341     intendedTickLength = NextTickLength(WhiteOnMove(forwardMostMove) ?
14342       whiteTimeRemaining : blackTimeRemaining);
14343     StartClockTimer(intendedTickLength);
14344 }
14345
14346
14347 /* Stop both clocks */
14348 void
14349 StopClocks()
14350 {
14351     long lastTickLength;
14352     TimeMark now;
14353
14354     if (!StopClockTimer()) return;
14355     if (!appData.clockMode) return;
14356
14357     GetTimeMark(&now);
14358
14359     lastTickLength = SubtractTimeMarks(&now, &tickStartTM);
14360     if (WhiteOnMove(forwardMostMove)) {
14361         if(whiteNPS >= 0) lastTickLength = 0;
14362         whiteTimeRemaining -= lastTickLength;
14363         DisplayWhiteClock(whiteTimeRemaining, WhiteOnMove(currentMove));
14364     } else {
14365         if(blackNPS >= 0) lastTickLength = 0;
14366         blackTimeRemaining -= lastTickLength;
14367         DisplayBlackClock(blackTimeRemaining, !WhiteOnMove(currentMove));
14368     }
14369     CheckFlags();
14370 }
14371
14372 /* Start clock of player on move.  Time may have been reset, so
14373    if clock is already running, stop and restart it. */
14374 void
14375 StartClocks()
14376 {
14377     (void) StopClockTimer(); /* in case it was running already */
14378     DisplayBothClocks();
14379     if (CheckFlags()) return;
14380
14381     if (!appData.clockMode) return;
14382     if (gameMode == AnalyzeMode || gameMode == AnalyzeFile) return;
14383
14384     GetTimeMark(&tickStartTM);
14385     intendedTickLength = NextTickLength(WhiteOnMove(forwardMostMove) ?
14386       whiteTimeRemaining : blackTimeRemaining);
14387
14388    /* [HGM] nps: figure out nps factors, by determining which engine plays white and/or black once and for all */
14389     whiteNPS = blackNPS = -1;
14390     if(gameMode == MachinePlaysWhite || gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'w'
14391        || appData.zippyPlay && gameMode == IcsPlayingBlack) // first (perhaps only) engine has white
14392         whiteNPS = first.nps;
14393     if(gameMode == MachinePlaysBlack || gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b'
14394        || appData.zippyPlay && gameMode == IcsPlayingWhite) // first (perhaps only) engine has black
14395         blackNPS = first.nps;
14396     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'b') // second only used in Two-Machines mode
14397         whiteNPS = second.nps;
14398     if(gameMode == TwoMachinesPlay && first.twoMachinesColor[0] == 'w')
14399         blackNPS = second.nps;
14400     if(appData.debugMode) fprintf(debugFP, "nps: w=%d, b=%d\n", whiteNPS, blackNPS);
14401
14402     StartClockTimer(intendedTickLength);
14403 }
14404
14405 char *
14406 TimeString(ms)
14407      long ms;
14408 {
14409     long second, minute, hour, day;
14410     char *sign = "";
14411     static char buf[32];
14412
14413     if (ms > 0 && ms <= 9900) {
14414       /* convert milliseconds to tenths, rounding up */
14415       double tenths = floor( ((double)(ms + 99L)) / 100.00 );
14416
14417       sprintf(buf, " %03.1f ", tenths/10.0);
14418       return buf;
14419     }
14420
14421     /* convert milliseconds to seconds, rounding up */
14422     /* use floating point to avoid strangeness of integer division
14423        with negative dividends on many machines */
14424     second = (long) floor(((double) (ms + 999L)) / 1000.0);
14425
14426     if (second < 0) {
14427         sign = "-";
14428         second = -second;
14429     }
14430
14431     day = second / (60 * 60 * 24);
14432     second = second % (60 * 60 * 24);
14433     hour = second / (60 * 60);
14434     second = second % (60 * 60);
14435     minute = second / 60;
14436     second = second % 60;
14437
14438     if (day > 0)
14439       sprintf(buf, " %s%ld:%02ld:%02ld:%02ld ",
14440               sign, day, hour, minute, second);
14441     else if (hour > 0)
14442       sprintf(buf, " %s%ld:%02ld:%02ld ", sign, hour, minute, second);
14443     else
14444       sprintf(buf, " %s%2ld:%02ld ", sign, minute, second);
14445
14446     return buf;
14447 }
14448
14449
14450 /*
14451  * This is necessary because some C libraries aren't ANSI C compliant yet.
14452  */
14453 char *
14454 StrStr(string, match)
14455      char *string, *match;
14456 {
14457     int i, length;
14458
14459     length = strlen(match);
14460
14461     for (i = strlen(string) - length; i >= 0; i--, string++)
14462       if (!strncmp(match, string, length))
14463         return string;
14464
14465     return NULL;
14466 }
14467
14468 char *
14469 StrCaseStr(string, match)
14470      char *string, *match;
14471 {
14472     int i, j, length;
14473
14474     length = strlen(match);
14475
14476     for (i = strlen(string) - length; i >= 0; i--, string++) {
14477         for (j = 0; j < length; j++) {
14478             if (ToLower(match[j]) != ToLower(string[j]))
14479               break;
14480         }
14481         if (j == length) return string;
14482     }
14483
14484     return NULL;
14485 }
14486
14487 #ifndef _amigados
14488 int
14489 StrCaseCmp(s1, s2)
14490      char *s1, *s2;
14491 {
14492     char c1, c2;
14493
14494     for (;;) {
14495         c1 = ToLower(*s1++);
14496         c2 = ToLower(*s2++);
14497         if (c1 > c2) return 1;
14498         if (c1 < c2) return -1;
14499         if (c1 == NULLCHAR) return 0;
14500     }
14501 }
14502
14503
14504 int
14505 ToLower(c)
14506      int c;
14507 {
14508     return isupper(c) ? tolower(c) : c;
14509 }
14510
14511
14512 int
14513 ToUpper(c)
14514      int c;
14515 {
14516     return islower(c) ? toupper(c) : c;
14517 }
14518 #endif /* !_amigados    */
14519
14520 char *
14521 StrSave(s)
14522      char *s;
14523 {
14524     char *ret;
14525
14526     if ((ret = (char *) malloc(strlen(s) + 1))) {
14527         strcpy(ret, s);
14528     }
14529     return ret;
14530 }
14531
14532 char *
14533 StrSavePtr(s, savePtr)
14534      char *s, **savePtr;
14535 {
14536     if (*savePtr) {
14537         free(*savePtr);
14538     }
14539     if ((*savePtr = (char *) malloc(strlen(s) + 1))) {
14540         strcpy(*savePtr, s);
14541     }
14542     return(*savePtr);
14543 }
14544
14545 char *
14546 PGNDate()
14547 {
14548     time_t clock;
14549     struct tm *tm;
14550     char buf[MSG_SIZ];
14551
14552     clock = time((time_t *)NULL);
14553     tm = localtime(&clock);
14554     sprintf(buf, "%04d.%02d.%02d",
14555             tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday);
14556     return StrSave(buf);
14557 }
14558
14559
14560 char *
14561 PositionToFEN(move, overrideCastling)
14562      int move;
14563      char *overrideCastling;
14564 {
14565     int i, j, fromX, fromY, toX, toY;
14566     int whiteToPlay;
14567     char buf[128];
14568     char *p, *q;
14569     int emptycount;
14570     ChessSquare piece;
14571
14572     whiteToPlay = (gameMode == EditPosition) ?
14573       !blackPlaysFirst : (move % 2 == 0);
14574     p = buf;
14575
14576     /* Piece placement data */
14577     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
14578         emptycount = 0;
14579         for (j = BOARD_LEFT; j < BOARD_RGHT; j++) {
14580             if (boards[move][i][j] == EmptySquare) {
14581                 emptycount++;
14582             } else { ChessSquare piece = boards[move][i][j];
14583                 if (emptycount > 0) {
14584                     if(emptycount<10) /* [HGM] can be >= 10 */
14585                         *p++ = '0' + emptycount;
14586                     else { *p++ = '0' + emptycount/10; *p++ = '0' + emptycount%10; }
14587                     emptycount = 0;
14588                 }
14589                 if(PieceToChar(piece) == '+') {
14590                     /* [HGM] write promoted pieces as '+<unpromoted>' (Shogi) */
14591                     *p++ = '+';
14592                     piece = (ChessSquare)(DEMOTED piece);
14593                 }
14594                 *p++ = PieceToChar(piece);
14595                 if(p[-1] == '~') {
14596                     /* [HGM] flag promoted pieces as '<promoted>~' (Crazyhouse) */
14597                     p[-1] = PieceToChar((ChessSquare)(DEMOTED piece));
14598                     *p++ = '~';
14599                 }
14600             }
14601         }
14602         if (emptycount > 0) {
14603             if(emptycount<10) /* [HGM] can be >= 10 */
14604                 *p++ = '0' + emptycount;
14605             else { *p++ = '0' + emptycount/10; *p++ = '0' + emptycount%10; }
14606             emptycount = 0;
14607         }
14608         *p++ = '/';
14609     }
14610     *(p - 1) = ' ';
14611
14612     /* [HGM] print Crazyhouse or Shogi holdings */
14613     if( gameInfo.holdingsWidth ) {
14614         *(p-1) = '['; /* if we wanted to support BFEN, this could be '/' */
14615         q = p;
14616         for(i=0; i<gameInfo.holdingsSize; i++) { /* white holdings */
14617             piece = boards[move][i][BOARD_WIDTH-1];
14618             if( piece != EmptySquare )
14619               for(j=0; j<(int) boards[move][i][BOARD_WIDTH-2]; j++)
14620                   *p++ = PieceToChar(piece);
14621         }
14622         for(i=0; i<gameInfo.holdingsSize; i++) { /* black holdings */
14623             piece = boards[move][BOARD_HEIGHT-i-1][0];
14624             if( piece != EmptySquare )
14625               for(j=0; j<(int) boards[move][BOARD_HEIGHT-i-1][1]; j++)
14626                   *p++ = PieceToChar(piece);
14627         }
14628
14629         if( q == p ) *p++ = '-';
14630         *p++ = ']';
14631         *p++ = ' ';
14632     }
14633
14634     /* Active color */
14635     *p++ = whiteToPlay ? 'w' : 'b';
14636     *p++ = ' ';
14637
14638   if(q = overrideCastling) { // [HGM] FRC: override castling & e.p fields for non-compliant engines
14639     while(*p++ = *q++); if(q != overrideCastling+1) p[-1] = ' '; else --p;
14640   } else {
14641   if(nrCastlingRights) {
14642      q = p;
14643      if(gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom) {
14644        /* [HGM] write directly from rights */
14645            if(boards[move][CASTLING][2] != NoRights &&
14646               boards[move][CASTLING][0] != NoRights   )
14647                 *p++ = boards[move][CASTLING][0] + AAA + 'A' - 'a';
14648            if(boards[move][CASTLING][2] != NoRights &&
14649               boards[move][CASTLING][1] != NoRights   )
14650                 *p++ = boards[move][CASTLING][1] + AAA + 'A' - 'a';
14651            if(boards[move][CASTLING][5] != NoRights &&
14652               boards[move][CASTLING][3] != NoRights   )
14653                 *p++ = boards[move][CASTLING][3] + AAA;
14654            if(boards[move][CASTLING][5] != NoRights &&
14655               boards[move][CASTLING][4] != NoRights   )
14656                 *p++ = boards[move][CASTLING][4] + AAA;
14657      } else {
14658
14659         /* [HGM] write true castling rights */
14660         if( nrCastlingRights == 6 ) {
14661             if(boards[move][CASTLING][0] == BOARD_RGHT-1 &&
14662                boards[move][CASTLING][2] != NoRights  ) *p++ = 'K';
14663             if(boards[move][CASTLING][1] == BOARD_LEFT &&
14664                boards[move][CASTLING][2] != NoRights  ) *p++ = 'Q';
14665             if(boards[move][CASTLING][3] == BOARD_RGHT-1 &&
14666                boards[move][CASTLING][5] != NoRights  ) *p++ = 'k';
14667             if(boards[move][CASTLING][4] == BOARD_LEFT &&
14668                boards[move][CASTLING][5] != NoRights  ) *p++ = 'q';
14669         }
14670      }
14671      if (q == p) *p++ = '-'; /* No castling rights */
14672      *p++ = ' ';
14673   }
14674
14675   if(gameInfo.variant != VariantShogi    && gameInfo.variant != VariantXiangqi &&
14676      gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier && gameInfo.variant != VariantMakruk ) {
14677     /* En passant target square */
14678     if (move > backwardMostMove) {
14679         fromX = moveList[move - 1][0] - AAA;
14680         fromY = moveList[move - 1][1] - ONE;
14681         toX = moveList[move - 1][2] - AAA;
14682         toY = moveList[move - 1][3] - ONE;
14683         if (fromY == (whiteToPlay ? BOARD_HEIGHT-2 : 1) &&
14684             toY == (whiteToPlay ? BOARD_HEIGHT-4 : 3) &&
14685             boards[move][toY][toX] == (whiteToPlay ? BlackPawn : WhitePawn) &&
14686             fromX == toX) {
14687             /* 2-square pawn move just happened */
14688             *p++ = toX + AAA;
14689             *p++ = whiteToPlay ? '6'+BOARD_HEIGHT-8 : '3';
14690         } else {
14691             *p++ = '-';
14692         }
14693     } else if(move == backwardMostMove) {
14694         // [HGM] perhaps we should always do it like this, and forget the above?
14695         if((signed char)boards[move][EP_STATUS] >= 0) {
14696             *p++ = boards[move][EP_STATUS] + AAA;
14697             *p++ = whiteToPlay ? '6'+BOARD_HEIGHT-8 : '3';
14698         } else {
14699             *p++ = '-';
14700         }
14701     } else {
14702         *p++ = '-';
14703     }
14704     *p++ = ' ';
14705   }
14706   }
14707
14708     /* [HGM] find reversible plies */
14709     {   int i = 0, j=move;
14710
14711         if (appData.debugMode) { int k;
14712             fprintf(debugFP, "write FEN 50-move: %d %d %d\n", initialRulePlies, forwardMostMove, backwardMostMove);
14713             for(k=backwardMostMove; k<=forwardMostMove; k++)
14714                 fprintf(debugFP, "e%d. p=%d\n", k, (signed char)boards[k][EP_STATUS]);
14715
14716         }
14717
14718         while(j > backwardMostMove && (signed char)boards[j][EP_STATUS] <= EP_NONE) j--,i++;
14719         if( j == backwardMostMove ) i += initialRulePlies;
14720         sprintf(p, "%d ", i);
14721         p += i>=100 ? 4 : i >= 10 ? 3 : 2;
14722     }
14723     /* Fullmove number */
14724     sprintf(p, "%d", (move / 2) + 1);
14725
14726     return StrSave(buf);
14727 }
14728
14729 Boolean
14730 ParseFEN(board, blackPlaysFirst, fen)
14731     Board board;
14732      int *blackPlaysFirst;
14733      char *fen;
14734 {
14735     int i, j;
14736     char *p;
14737     int emptycount;
14738     ChessSquare piece;
14739
14740     p = fen;
14741
14742     /* [HGM] by default clear Crazyhouse holdings, if present */
14743     if(gameInfo.holdingsWidth) {
14744        for(i=0; i<BOARD_HEIGHT; i++) {
14745            board[i][0]             = EmptySquare; /* black holdings */
14746            board[i][BOARD_WIDTH-1] = EmptySquare; /* white holdings */
14747            board[i][1]             = (ChessSquare) 0; /* black counts */
14748            board[i][BOARD_WIDTH-2] = (ChessSquare) 0; /* white counts */
14749        }
14750     }
14751
14752     /* Piece placement data */
14753     for (i = BOARD_HEIGHT - 1; i >= 0; i--) {
14754         j = 0;
14755         for (;;) {
14756             if (*p == '/' || *p == ' ' || (*p == '[' && i == 0) ) {
14757                 if (*p == '/') p++;
14758                 emptycount = gameInfo.boardWidth - j;
14759                 while (emptycount--)
14760                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
14761                 break;
14762 #if(BOARD_FILES >= 10)
14763             } else if(*p=='x' || *p=='X') { /* [HGM] X means 10 */
14764                 p++; emptycount=10;
14765                 if (j + emptycount > gameInfo.boardWidth) return FALSE;
14766                 while (emptycount--)
14767                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
14768 #endif
14769             } else if (isdigit(*p)) {
14770                 emptycount = *p++ - '0';
14771                 while(isdigit(*p)) emptycount = 10*emptycount + *p++ - '0'; /* [HGM] allow > 9 */
14772                 if (j + emptycount > gameInfo.boardWidth) return FALSE;
14773                 while (emptycount--)
14774                         board[i][(j++)+gameInfo.holdingsWidth] = EmptySquare;
14775             } else if (*p == '+' || isalpha(*p)) {
14776                 if (j >= gameInfo.boardWidth) return FALSE;
14777                 if(*p=='+') {
14778                     piece = CharToPiece(*++p);
14779                     if(piece == EmptySquare) return FALSE; /* unknown piece */
14780                     piece = (ChessSquare) (PROMOTED piece ); p++;
14781                     if(PieceToChar(piece) != '+') return FALSE; /* unpromotable piece */
14782                 } else piece = CharToPiece(*p++);
14783
14784                 if(piece==EmptySquare) return FALSE; /* unknown piece */
14785                 if(*p == '~') { /* [HGM] make it a promoted piece for Crazyhouse */
14786                     piece = (ChessSquare) (PROMOTED piece);
14787                     if(PieceToChar(piece) != '~') return FALSE; /* cannot be a promoted piece */
14788                     p++;
14789                 }
14790                 board[i][(j++)+gameInfo.holdingsWidth] = piece;
14791             } else {
14792                 return FALSE;
14793             }
14794         }
14795     }
14796     while (*p == '/' || *p == ' ') p++;
14797
14798     /* [HGM] look for Crazyhouse holdings here */
14799     while(*p==' ') p++;
14800     if( gameInfo.holdingsWidth && p[-1] == '/' || *p == '[') {
14801         if(*p == '[') p++;
14802         if(*p == '-' ) *p++; /* empty holdings */ else {
14803             if( !gameInfo.holdingsWidth ) return FALSE; /* no room to put holdings! */
14804             /* if we would allow FEN reading to set board size, we would   */
14805             /* have to add holdings and shift the board read so far here   */
14806             while( (piece = CharToPiece(*p) ) != EmptySquare ) {
14807                 *p++;
14808                 if((int) piece >= (int) BlackPawn ) {
14809                     i = (int)piece - (int)BlackPawn;
14810                     i = PieceToNumber((ChessSquare)i);
14811                     if( i >= gameInfo.holdingsSize ) return FALSE;
14812                     board[BOARD_HEIGHT-1-i][0] = piece; /* black holdings */
14813                     board[BOARD_HEIGHT-1-i][1]++;       /* black counts   */
14814                 } else {
14815                     i = (int)piece - (int)WhitePawn;
14816                     i = PieceToNumber((ChessSquare)i);
14817                     if( i >= gameInfo.holdingsSize ) return FALSE;
14818                     board[i][BOARD_WIDTH-1] = piece;    /* white holdings */
14819                     board[i][BOARD_WIDTH-2]++;          /* black holdings */
14820                 }
14821             }
14822         }
14823         if(*p == ']') *p++;
14824     }
14825
14826     while(*p == ' ') p++;
14827
14828     /* Active color */
14829     switch (*p++) {
14830       case 'w':
14831         *blackPlaysFirst = FALSE;
14832         break;
14833       case 'b':
14834         *blackPlaysFirst = TRUE;
14835         break;
14836       default:
14837         return FALSE;
14838     }
14839
14840     /* [HGM] We NO LONGER ignore the rest of the FEN notation */
14841     /* return the extra info in global variiables             */
14842
14843     /* set defaults in case FEN is incomplete */
14844     board[EP_STATUS] = EP_UNKNOWN;
14845     for(i=0; i<nrCastlingRights; i++ ) {
14846         board[CASTLING][i] =
14847             gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom ? NoRights : initialRights[i];
14848     }   /* assume possible unless obviously impossible */
14849     if(initialRights[0]!=NoRights && board[castlingRank[0]][initialRights[0]] != WhiteRook) board[CASTLING][0] = NoRights;
14850     if(initialRights[1]!=NoRights && board[castlingRank[1]][initialRights[1]] != WhiteRook) board[CASTLING][1] = NoRights;
14851     if(initialRights[2]!=NoRights && board[castlingRank[2]][initialRights[2]] != WhiteUnicorn
14852                                   && board[castlingRank[2]][initialRights[2]] != WhiteKing) board[CASTLING][2] = NoRights;
14853     if(initialRights[3]!=NoRights && board[castlingRank[3]][initialRights[3]] != BlackRook) board[CASTLING][3] = NoRights;
14854     if(initialRights[4]!=NoRights && board[castlingRank[4]][initialRights[4]] != BlackRook) board[CASTLING][4] = NoRights;
14855     if(initialRights[5]!=NoRights && board[castlingRank[5]][initialRights[5]] != BlackUnicorn
14856                                   && board[castlingRank[5]][initialRights[5]] != BlackKing) board[CASTLING][5] = NoRights;
14857     FENrulePlies = 0;
14858
14859     while(*p==' ') p++;
14860     if(nrCastlingRights) {
14861       if(*p=='K' || *p=='Q' || *p=='k' || *p=='q' || *p=='-') {
14862           /* castling indicator present, so default becomes no castlings */
14863           for(i=0; i<nrCastlingRights; i++ ) {
14864                  board[CASTLING][i] = NoRights;
14865           }
14866       }
14867       while(*p=='K' || *p=='Q' || *p=='k' || *p=='q' || *p=='-' ||
14868              (gameInfo.variant == VariantFischeRandom || gameInfo.variant == VariantCapaRandom) &&
14869              ( *p >= 'a' && *p < 'a' + gameInfo.boardWidth) ||
14870              ( *p >= 'A' && *p < 'A' + gameInfo.boardWidth)   ) {
14871         char c = *p++; int whiteKingFile=NoRights, blackKingFile=NoRights;
14872
14873         for(i=BOARD_LEFT; i<BOARD_RGHT; i++) {
14874             if(board[BOARD_HEIGHT-1][i] == BlackKing) blackKingFile = i;
14875             if(board[0             ][i] == WhiteKing) whiteKingFile = i;
14876         }
14877         if(gameInfo.variant == VariantTwoKings || gameInfo.variant == VariantKnightmate)
14878             whiteKingFile = blackKingFile = BOARD_WIDTH >> 1; // for these variant scanning fails
14879         if(whiteKingFile == NoRights || board[0][whiteKingFile] != WhiteUnicorn
14880                                      && board[0][whiteKingFile] != WhiteKing) whiteKingFile = NoRights;
14881         if(blackKingFile == NoRights || board[BOARD_HEIGHT-1][blackKingFile] != BlackUnicorn
14882                                      && board[BOARD_HEIGHT-1][blackKingFile] != BlackKing) blackKingFile = NoRights;
14883         switch(c) {
14884           case'K':
14885               for(i=BOARD_RGHT-1; board[0][i]!=WhiteRook && i>whiteKingFile; i--);
14886               board[CASTLING][0] = i != whiteKingFile ? i : NoRights;
14887               board[CASTLING][2] = whiteKingFile;
14888               break;
14889           case'Q':
14890               for(i=BOARD_LEFT;  i<BOARD_RGHT && board[0][i]!=WhiteRook && i<whiteKingFile; i++);
14891               board[CASTLING][1] = i != whiteKingFile ? i : NoRights;
14892               board[CASTLING][2] = whiteKingFile;
14893               break;
14894           case'k':
14895               for(i=BOARD_RGHT-1; board[BOARD_HEIGHT-1][i]!=BlackRook && i>blackKingFile; i--);
14896               board[CASTLING][3] = i != blackKingFile ? i : NoRights;
14897               board[CASTLING][5] = blackKingFile;
14898               break;
14899           case'q':
14900               for(i=BOARD_LEFT; i<BOARD_RGHT && board[BOARD_HEIGHT-1][i]!=BlackRook && i<blackKingFile; i++);
14901               board[CASTLING][4] = i != blackKingFile ? i : NoRights;
14902               board[CASTLING][5] = blackKingFile;
14903           case '-':
14904               break;
14905           default: /* FRC castlings */
14906               if(c >= 'a') { /* black rights */
14907                   for(i=BOARD_LEFT; i<BOARD_RGHT; i++)
14908                     if(board[BOARD_HEIGHT-1][i] == BlackKing) break;
14909                   if(i == BOARD_RGHT) break;
14910                   board[CASTLING][5] = i;
14911                   c -= AAA;
14912                   if(board[BOARD_HEIGHT-1][c] <  BlackPawn ||
14913                      board[BOARD_HEIGHT-1][c] >= BlackKing   ) break;
14914                   if(c > i)
14915                       board[CASTLING][3] = c;
14916                   else
14917                       board[CASTLING][4] = c;
14918               } else { /* white rights */
14919                   for(i=BOARD_LEFT; i<BOARD_RGHT; i++)
14920                     if(board[0][i] == WhiteKing) break;
14921                   if(i == BOARD_RGHT) break;
14922                   board[CASTLING][2] = i;
14923                   c -= AAA - 'a' + 'A';
14924                   if(board[0][c] >= WhiteKing) break;
14925                   if(c > i)
14926                       board[CASTLING][0] = c;
14927                   else
14928                       board[CASTLING][1] = c;
14929               }
14930         }
14931       }
14932       for(i=0; i<nrCastlingRights; i++)
14933         if(board[CASTLING][i] != NoRights) initialRights[i] = board[CASTLING][i];
14934     if (appData.debugMode) {
14935         fprintf(debugFP, "FEN castling rights:");
14936         for(i=0; i<nrCastlingRights; i++)
14937         fprintf(debugFP, " %d", board[CASTLING][i]);
14938         fprintf(debugFP, "\n");
14939     }
14940
14941       while(*p==' ') p++;
14942     }
14943
14944     /* read e.p. field in games that know e.p. capture */
14945     if(gameInfo.variant != VariantShogi    && gameInfo.variant != VariantXiangqi &&
14946        gameInfo.variant != VariantShatranj && gameInfo.variant != VariantCourier && gameInfo.variant != VariantMakruk ) {
14947       if(*p=='-') {
14948         p++; board[EP_STATUS] = EP_NONE;
14949       } else {
14950          char c = *p++ - AAA;
14951
14952          if(c < BOARD_LEFT || c >= BOARD_RGHT) return TRUE;
14953          if(*p >= '0' && *p <='9') *p++;
14954          board[EP_STATUS] = c;
14955       }
14956     }
14957
14958
14959     if(sscanf(p, "%d", &i) == 1) {
14960         FENrulePlies = i; /* 50-move ply counter */
14961         /* (The move number is still ignored)    */
14962     }
14963
14964     return TRUE;
14965 }
14966
14967 void
14968 EditPositionPasteFEN(char *fen)
14969 {
14970   if (fen != NULL) {
14971     Board initial_position;
14972
14973     if (!ParseFEN(initial_position, &blackPlaysFirst, fen)) {
14974       DisplayError(_("Bad FEN position in clipboard"), 0);
14975       return ;
14976     } else {
14977       int savedBlackPlaysFirst = blackPlaysFirst;
14978       EditPositionEvent();
14979       blackPlaysFirst = savedBlackPlaysFirst;
14980       CopyBoard(boards[0], initial_position);
14981       initialRulePlies = FENrulePlies; /* [HGM] copy FEN attributes as well */
14982       EditPositionDone(FALSE); // [HGM] fake: do not fake rights if we had FEN
14983       DisplayBothClocks();
14984       DrawPosition(FALSE, boards[currentMove]);
14985     }
14986   }
14987 }
14988
14989 static char cseq[12] = "\\   ";
14990
14991 Boolean set_cont_sequence(char *new_seq)
14992 {
14993     int len;
14994     Boolean ret;
14995
14996     // handle bad attempts to set the sequence
14997         if (!new_seq)
14998                 return 0; // acceptable error - no debug
14999
15000     len = strlen(new_seq);
15001     ret = (len > 0) && (len < sizeof(cseq));
15002     if (ret)
15003         strcpy(cseq, new_seq);
15004     else if (appData.debugMode)
15005         fprintf(debugFP, "Invalid continuation sequence \"%s\"  (maximum length is: %u)\n", new_seq, (unsigned) sizeof(cseq)-1);
15006     return ret;
15007 }
15008
15009 /*
15010     reformat a source message so words don't cross the width boundary.  internal
15011     newlines are not removed.  returns the wrapped size (no null character unless
15012     included in source message).  If dest is NULL, only calculate the size required
15013     for the dest buffer.  lp argument indicats line position upon entry, and it's
15014     passed back upon exit.
15015 */
15016 int wrap(char *dest, char *src, int count, int width, int *lp)
15017 {
15018     int len, i, ansi, cseq_len, line, old_line, old_i, old_len, clen;
15019
15020     cseq_len = strlen(cseq);
15021     old_line = line = *lp;
15022     ansi = len = clen = 0;
15023
15024     for (i=0; i < count; i++)
15025     {
15026         if (src[i] == '\033')
15027             ansi = 1;
15028
15029         // if we hit the width, back up
15030         if (!ansi && (line >= width) && src[i] != '\n' && src[i] != ' ')
15031         {
15032             // store i & len in case the word is too long
15033             old_i = i, old_len = len;
15034
15035             // find the end of the last word
15036             while (i && src[i] != ' ' && src[i] != '\n')
15037             {
15038                 i--;
15039                 len--;
15040             }
15041
15042             // word too long?  restore i & len before splitting it
15043             if ((old_i-i+clen) >= width)
15044             {
15045                 i = old_i;
15046                 len = old_len;
15047             }
15048
15049             // extra space?
15050             if (i && src[i-1] == ' ')
15051                 len--;
15052
15053             if (src[i] != ' ' && src[i] != '\n')
15054             {
15055                 i--;
15056                 if (len)
15057                     len--;
15058             }
15059
15060             // now append the newline and continuation sequence
15061             if (dest)
15062                 dest[len] = '\n';
15063             len++;
15064             if (dest)
15065                 strncpy(dest+len, cseq, cseq_len);
15066             len += cseq_len;
15067             line = cseq_len;
15068             clen = cseq_len;
15069             continue;
15070         }
15071
15072         if (dest)
15073             dest[len] = src[i];
15074         len++;
15075         if (!ansi)
15076             line++;
15077         if (src[i] == '\n')
15078             line = 0;
15079         if (src[i] == 'm')
15080             ansi = 0;
15081     }
15082     if (dest && appData.debugMode)
15083     {
15084         fprintf(debugFP, "wrap(count:%d,width:%d,line:%d,len:%d,*lp:%d,src: ",
15085             count, width, line, len, *lp);
15086         show_bytes(debugFP, src, count);
15087         fprintf(debugFP, "\ndest: ");
15088         show_bytes(debugFP, dest, len);
15089         fprintf(debugFP, "\n");
15090     }
15091     *lp = dest ? line : old_line;
15092
15093     return len;
15094 }
15095
15096 // [HGM] vari: routines for shelving variations
15097
15098 void
15099 PushTail(int firstMove, int lastMove)
15100 {
15101         int i, j, nrMoves = lastMove - firstMove;
15102
15103         if(appData.icsActive) { // only in local mode
15104                 forwardMostMove = currentMove; // mimic old ICS behavior
15105                 return;
15106         }
15107         if(storedGames >= MAX_VARIATIONS-1) return;
15108
15109         // push current tail of game on stack
15110         savedResult[storedGames] = gameInfo.result;
15111         savedDetails[storedGames] = gameInfo.resultDetails;
15112         gameInfo.resultDetails = NULL;
15113         savedFirst[storedGames] = firstMove;
15114         savedLast [storedGames] = lastMove;
15115         savedFramePtr[storedGames] = framePtr;
15116         framePtr -= nrMoves; // reserve space for the boards
15117         for(i=nrMoves; i>=1; i--) { // copy boards to stack, working downwards, in case of overlap
15118             CopyBoard(boards[framePtr+i], boards[firstMove+i]);
15119             for(j=0; j<MOVE_LEN; j++)
15120                 moveList[framePtr+i][j] = moveList[firstMove+i-1][j];
15121             for(j=0; j<2*MOVE_LEN; j++)
15122                 parseList[framePtr+i][j] = parseList[firstMove+i-1][j];
15123             timeRemaining[0][framePtr+i] = timeRemaining[0][firstMove+i];
15124             timeRemaining[1][framePtr+i] = timeRemaining[1][firstMove+i];
15125             pvInfoList[framePtr+i] = pvInfoList[firstMove+i-1];
15126             pvInfoList[firstMove+i-1].depth = 0;
15127             commentList[framePtr+i] = commentList[firstMove+i];
15128             commentList[firstMove+i] = NULL;
15129         }
15130
15131         storedGames++;
15132         forwardMostMove = firstMove; // truncate game so we can start variation
15133         if(storedGames == 1) GreyRevert(FALSE);
15134 }
15135
15136 Boolean
15137 PopTail(Boolean annotate)
15138 {
15139         int i, j, nrMoves;
15140         char buf[8000], moveBuf[20];
15141
15142         if(appData.icsActive) return FALSE; // only in local mode
15143         if(!storedGames) return FALSE; // sanity
15144         CommentPopDown(); // make sure no stale variation comments to the destroyed line can remain open
15145
15146         storedGames--;
15147         ToNrEvent(savedFirst[storedGames]); // sets currentMove
15148         nrMoves = savedLast[storedGames] - currentMove;
15149         if(annotate) {
15150                 int cnt = 10;
15151                 if(!WhiteOnMove(currentMove)) sprintf(buf, "(%d...", currentMove+2>>1);
15152                 else strcpy(buf, "(");
15153                 for(i=currentMove; i<forwardMostMove; i++) {
15154                         if(WhiteOnMove(i))
15155                              sprintf(moveBuf, " %d. %s", i+2>>1, SavePart(parseList[i]));
15156                         else sprintf(moveBuf, " %s", SavePart(parseList[i]));
15157                         strcat(buf, moveBuf);
15158                         if(commentList[i]) { strcat(buf, " "); strcat(buf, commentList[i]); }
15159                         if(!--cnt) { strcat(buf, "\n"); cnt = 10; }
15160                 }
15161                 strcat(buf, ")");
15162         }
15163         for(i=1; i<=nrMoves; i++) { // copy last variation back
15164             CopyBoard(boards[currentMove+i], boards[framePtr+i]);
15165             for(j=0; j<MOVE_LEN; j++)
15166                 moveList[currentMove+i-1][j] = moveList[framePtr+i][j];
15167             for(j=0; j<2*MOVE_LEN; j++)
15168                 parseList[currentMove+i-1][j] = parseList[framePtr+i][j];
15169             timeRemaining[0][currentMove+i] = timeRemaining[0][framePtr+i];
15170             timeRemaining[1][currentMove+i] = timeRemaining[1][framePtr+i];
15171             pvInfoList[currentMove+i-1] = pvInfoList[framePtr+i];
15172             if(commentList[currentMove+i]) free(commentList[currentMove+i]);
15173             commentList[currentMove+i] = commentList[framePtr+i];
15174             commentList[framePtr+i] = NULL;
15175         }
15176         if(annotate) AppendComment(currentMove+1, buf, FALSE);
15177         framePtr = savedFramePtr[storedGames];
15178         gameInfo.result = savedResult[storedGames];
15179         if(gameInfo.resultDetails != NULL) {
15180             free(gameInfo.resultDetails);
15181       }
15182         gameInfo.resultDetails = savedDetails[storedGames];
15183         forwardMostMove = currentMove + nrMoves;
15184         if(storedGames == 0) GreyRevert(TRUE);
15185         return TRUE;
15186 }
15187
15188 void
15189 CleanupTail()
15190 {       // remove all shelved variations
15191         int i;
15192         for(i=0; i<storedGames; i++) {
15193             if(savedDetails[i])
15194                 free(savedDetails[i]);
15195             savedDetails[i] = NULL;
15196         }
15197         for(i=framePtr; i<MAX_MOVES; i++) {
15198                 if(commentList[i]) free(commentList[i]);
15199                 commentList[i] = NULL;
15200         }
15201         framePtr = MAX_MOVES-1;
15202         storedGames = 0;
15203 }
15204
15205 void
15206 LoadVariation(int index, char *text)
15207 {       // [HGM] vari: shelve previous line and load new variation, parsed from text around text[index]
15208         char *p = text, *start = NULL, *end = NULL, wait = NULLCHAR;
15209         int level = 0, move;
15210
15211         if(gameMode != EditGame && gameMode != AnalyzeMode) return;
15212         // first find outermost bracketing variation
15213         while(*p) { // hope I got this right... Non-nesting {} and [] can screen each other and nesting ()
15214             if(!wait) { // while inside [] pr {}, ignore everyting except matching closing ]}
15215                 if(*p == '{') wait = '}'; else
15216                 if(*p == '[') wait = ']'; else
15217                 if(*p == '(' && level++ == 0 && p-text < index) start = p+1;
15218                 if(*p == ')' && level > 0 && --level == 0 && p-text > index && end == NULL) end = p-1;
15219             }
15220             if(*p == wait) wait = NULLCHAR; // closing ]} found
15221             p++;
15222         }
15223         if(!start || !end) return; // no variation found, or syntax error in PGN: ignore click
15224         if(appData.debugMode) fprintf(debugFP, "at move %d load variation '%s'\n", currentMove, start);
15225         end[1] = NULLCHAR; // clip off comment beyond variation
15226         ToNrEvent(currentMove-1);
15227         PushTail(currentMove, forwardMostMove); // shelve main variation. This truncates game
15228         // kludge: use ParsePV() to append variation to game
15229         move = currentMove;
15230         ParsePV(start, TRUE);
15231         forwardMostMove = endPV; endPV = -1; currentMove = move; // cleanup what ParsePV did
15232         ClearPremoveHighlights();
15233         CommentPopDown();
15234         ToNrEvent(currentMove+1);
15235 }
15236